String s2 = new String(" ¡Hola desde Java!
");
char cl[] = {'H', 'o', '1'. 'a', ' ', 'a', 'hp, tír);
String s3 = new String (cl) ;
double doublel = 1.23456789;
String s4 = String valueOf(doub1el):
Además, se puede asignar un objeto a otro, como se puede ver aquí:
public class app
t
public static void main(String[] args)
{
String SI;
s1 = new String("iHo1a desde Java!");
String s2 = new String("iHo1a desde Java!");
char cl[] = {'H', 'o', 'l', 'a', ' ', 'a', 'h', 'í');
String s3 = new Stringícl);
double doublel = 1.23456789;
String s4 = [Link](doublel);
String 85;
s5 = al;
C:\>java app
¡Hola desde Java!
¡Hola desde Java!
Hola ahí
1.23456789
;Hola desde Java!
Declarar y definir clases
[access] class nombre de clase [extends . . . ] [implernents . . . 1
i
//aquí va la definición de la clase.
1
access class nombre de clase [extends . . . ] [implements . . . 1
{
[accessl [staticl tipo variable-de-instancial;
[access] [staticl tipo variable-de-instanciaN;
[accessl [staticl tipo método1 (lista-deqarámetros)
(
[accessl [staticl tipo métodoN (lista-deparámetros)
(
class printer
(
public void print0
C
[Link](~ola desde Java!);
1
>
(
public void print0
(
[Link] .println(" ¡Hola desde Java! " ) ;
1
1
public class app
(
public static void main(String[ 1 args)
C
printer printerl = new printer( );
Ahora se pone este código en un fichero, [Link], se compila y se ejecuta como
sigue:
C:\>java app
¡Hola desde Java!
class printer
(
public void print0
I
[Link]("iHola desde Java! ");
1
1
Y este es el nuevo [Link] (observe que se tiene que importar la clase printer
para poder utilizarla; para más detalles sobre la importación de clases, ver el
capítulo 1):
import printert
public class app
(
public static void main(String[l args)
(
printer printerl = new printer0;
Crear variables de instancia
access class nombre de clase [extends ...] [implements ... 1
(
[access] tipo variable-de-inctancial;
[access] tipo variable-de-instanciaN;
)
clasci Data
c
public String data-etring = wyHola desde Javalm;
1
class Data
(
public String data-string = "iHola desde Java!";
)
public class app
(
public static void main(String[l args)
{
Data data = new Data();
String etring - [Link]-etring;
access class nombre de clase [extends ... ] [implements ... 1
I
[access] [static] tipo variable-de-instancial;
[access] [static] tipo variable-de-instanciaN;
1
class Data
I
private String data-string = -1Hola desde Javalm;
>
public class app
{
public static void main(String11 args)
{
Data data = new Data();
String string = [Link]-string;
Ahora, si se intenta acceder a la variable de instancia data-string desde otra clase,
como se hizo anteriormente en la clase app, el compilador de Java devolverá:
C: \>javac app. java -deprecation
[Link]:lZ: Variable data-string in class Data not accessible
from class app.
String string = [Link]-string;
Crear variables de clase
"
access class nombre de clase [extends ... ] [implements ... 1
I
[access] static tipo variable-de-instancial;
[access] static tipo variable-de-instanciaN;
1
Esto es un ejemplo en el que se crea una clase llamada data con una variable de
datos de clase llamada intdata:
class data
(
public static int intdata = 0;
1
class data
(
public static int intdata = 0;
1
public class app
(
public static void main(String[] args)
I
data a, b;
a = new data01
b = new data0;
System.o~[Link](~E1 valor de b-intdata = " + [Link]);
1
1
Este es el resultado del código:
C:\>java app
El valor de [Link] = 1
class data
{
public static int intdata = 1;
public static int doubledintdata;
static
c
doubledintdata = 2 * intdata;
1
1
public class app
{
public static void main(String[] args)
{
data a;
a = new data0 ;
[Link](E1 valor de [Link] = " i [Link]);
1
1
Este es el resultado del código:
C:\>java app
El valor de [Link] = 2
access class nombre de clase [extends . . .1 [implements . . . 1
{
[access] [static] tipo método1 (lista de parámetros)
{
[accessl [staticl tipo métodoN (lista de parámetros)
{
'
class printer
í
public void print()
[Link](Vola desde Java!");
1
1
public class app
(
public static void mainíString[] args)
{
printer printerl = new printer();
printerl .print ( ;
1
1
C:\>java app
¡Hola desde Java!
Establecer el acceso a los métodos
"
access class nombre de clase [extends ...] [implements ... 1
{
[access] [static] tipo método1 (lista de parámetros)
I
[access] [static] tipo métodoN (lista de parámetros)
{
public void print ( )
{
internal-use-only();
}
private void internal-use-only ()
I
System.~[Link](~;Hola desde Javalm);
1
1
public class app
{
public static void main(String[] args)
{
printer printerl = new printero;
C:\>java app
¡Hola desde Java!
Pasar parámetros a los métodos
[accessl [staticl nombre-deqarámetro2. tipo método1 ([tipo nombre-degarámetrol
[, tipo ..111
class printer
(
public void print(String s)
{
class printer
{
public void print(String S)
{
[Link](s);
)
1
public class app
I
public static void main(String[l args)
{
(new printer()).print(" ¡Hola otra vez desde Java!");
1
Este es el resultado del código:
C:\>java app
¡Hola otra vez desde Java!
Si hay que pasar más de un parámetro, se pueden especificar en la lista,
separados por comas:
class calculator
int addenn(int 091, int 092)
int result = opl + op2;
}
1
Se puede llamar a los métodos con literales, variables, arrays u objetos, como
sigue:
[Link]í1, intl, arrayl, objl)
Argumentos de la línea de comandos pasados a rnain
c:\>java app Ya es la hora -
public class app
I
public static void main(String[] args)
I
[Link]("Argumentos de la línea de comandos...");
for(int loop-index = 0; loop-index < [Link]; loop-index++) {
[Link]("Argumento " + loop-index t 8, - S, - + args [ loop-
indexl ) ;
1
1
1
Así es como funcionaría la aplicación:
C:\>java app Ya es la hora
Argumentos de la línea de comandos ...
Argumento O = Ya
Argumento 1 = es
Argumento 2 = la
Argumento 3 = hora
Devolver valores desde los métodos
[accessl [staticl tipo método1 ([tipo nombreqarámetrol [, tipo nombreqarámetro2 ...
1)
class calculator
I
int addem(int opl, int op2)
{
Así se devuelve la suma de los valores pasados aaddem, usando la sentencia
return:
class calculator
(
int addem(int opl, int op2)
{
return opl + op2;
1
Así funciona la clase calculator en un programa:
class calculator
{
int addem(int opl, int op2)
(
return opl + op2;
1
)
public class app
public static void main(String[l args)
(
calculator calc = new calculator();
System.o~[Link](~addem(2, 2) = " + [Link](2, 2));
1
Este es el resultado de la aplicación:
C:\>java app
addem(2, 21 = 4
Crear métodos de clase
class calculator
(
static int addem(int opl, int op2)
{
return opl + op2;
>
1
public class app
(
public static void main(String[l args)
(
system.o~[Link](~addem(2.2) = + [Link]í2,2));
1
Este es el resultado del código:
C:\>java app
addem(2, 2) = 4
Además se puede usar un método de clase de la forma usual, como un
método de un objeto:
class calculator
(
static int addem(int opl, int op2)
(
return opl + op2;
3
1
public class app
I
public static void rnain(String[] args)
I
calculator calc = new calculator0;
[Link]("addem(2, 2) = m + [Link](2, 2));
Crear métodos de acceso a datos "
I
private String data-string = "iHola desde Java!";
class data
(
private String data-string = "¡Hola desde Java!";
public String getData0
i
return data-string;
1
1
class data
{
private String data-string = "¡Hola desde Java!";
public String getData0
t
return data-string;
1
public void setData(String S)
i
if (a.length0 * 100) {
data-string = S;
1
1
1
public class app
(
public static void main (String [ 1 args)
I
[Link]((new dataO).getDataO);
1
1
Este es el resultado del código:
C:\>java app
;Hola desde Java!
Crear constructores "
{
private String data-string;
data ( )
c
data-string = "iHola desde Java!";
1
public String getData0
{
return data-string;
1
1
public class app
(
public static void main(String[l args)
I
[Link]((new data0 ).getDataO );
1
1
Esto es lo que se verá al ejecutar el programa:
C:\>java app
¡Hola desde Java!
pasar parámetros a constructores
"
printer:
class data
I
private String data-string;
data(String S)
{
data-string = S;
1
public String getData0
(
return data-string;
1
1
public class app
I
public static void main(Stringi1 args)
(
[Link]((new data("iHo1a desde Java!") ).getDataO );
1
1
Este es el resultado del código:
C:\zjava app
¡Hola desde Java!
Un ejemplo completo de clase
class stack {
private int stack-data[];
private int stackgtr; // stackqtr = -1 -> la pila
est6 vacía
stack(int size)
I
stack-data = new int[sizel;
stackqtr = -1;
1
public int pop ( )
I
if(stackgtr == -1) // Pila vacía -
devuelve error return O;
else // Si no, devuelve datos return
stack-datalstackqtr-1;
1
public int push(int push-this)
{
if (stackgtr >= 99) // La pila está llena -
devuelve error return O;
else ( // Si no, almacena datos stack-data[+
+stackqtr] = push-this; return 1;
public class stacker
{
public static void main(String args[l) (
int popped-value;
stack stackl = new stack(100);
[Link]("AÍiadiendo valores ahora...") ;
for(int loop-index = 0; loop-index i 10; loop-index++) (
[Link](loop-index);
[Link]("~alor añadido-> " + loop-index);
1
[Link]("Quitando valores ahora...");
for(int loop-index = 0; loop-index < 10; loop-index++)I
popped-value = stackl.pop0;
[Link]("Valor quitado-> " + popped-value);
1
1
1
Así funciona el programa:
~:\>java stacker
Añadiendo valores ahora..
Valor añadido-> O
Valor añadido-> 1
Valor añadido-> 2
Valor añadido-> 3
Valor añadido-> 4
Valor añadido-) 5
Valor añadido-> 6
Valor añadido-> 7
Valor añadido-> 8
Valor añadido-> 9
Quitando valores ahora ...
Valor quitado-> 9
Valor quitado-> 8
Valor quitado-> 7
Valor quitado-> 6
Valor quitado-> 5
Valor quitado-> 4
Valor quitado-> 3
Valor quitado-> 2
Valor quitado-> 1
Valor quitado-> O
Comprender el alcance de las variables
class Class
(
int intl = 1; //visible para todo el código de la clase
public void methodiint int2) //visible para todo el código de este método.
{
int int3 = 3; //visible para todo el código de este método.
if (intl != int21 {
int int4 = 4; //visible sólo en este bloque de código.
[Link]("int1 = " + intl
+ " int2 = '' + int2
+ " int3 = " + int3
+ " int4 = " + int4);
1
1
1
public class app
{
public static void main(String[l args)
I
Class c = new Class () ;
Esto es lo que se ve cuando se ejecuta el código: C:
\>java app
intl = 1 int2 = 2 int3 = 3 int4 = 4
Recursividad
class calculator
(
public int factorial(int n)
I
if (n == 1) {
return n;
1
Else {
return n * factorialín - 1);
}
1
public class app
Jt
public static void rnain(String[] args)
{
calculator calc = new calculator();
[Link]("6! = " + [Link](6) );