HTMLpointHTMLpoint HTMLpoint.com


 Variables



Las variables son valores modificables, es decir, son nombres que representan un valor de cierto tipo y el valor asociado al nombre se puede variar. Por ejemplo, si digo que X es una variable de tipo entero y después digo que tiene valor 10, escribiendo la expresión 5 + X es como si escribiera la expresión 5 + 10. De todas formas creo que todos vosotros tenéis familiaridad con las variables porque son lo principal de cada lenguaje de programación. Dicho esto, vamos a ver como Java trata las variables.
En primer lugar, antes de utilizarla, una variable se tiene que escribir. En Java la escritura de una variable está compuesta por tres partes: modificadores, tipo e indentificadores.

Los modificadores son una opción y son los que establecen el acceso a las variables, es decir, a los public particulares y protegidos que vimos en el capítulo anterior. Éstos se llaman modificadores de acceso y los hay estáticos, sincronizados y finales. No es importante ponerlos en órden, aunque sí es importante utilizar siempre el mismo órden para que sea legible el código. Estátic también lo vimos: nos permite escribir atributos y métodos constantes que se pueden invocar incluso antes de que un objeto se escriba. Final, en cambio, quiere decir que, cuando se utiliza un valor, éste se puede unir sólo una vez a un campo porque es también una constante. El modificador sincronizado lo dejaremos de lado: basta con indicar que sirve para decir que a un método, en el caso de una multiprogramación (con los thread), se puede acceder a través de una exclusión múltiple, es decir, un thread a la vez.

Los identificadores pueden ser uno o más, están separados por una coma y son nombres que tienen variables. Por ejemplo, la escritura de X en el ejemplo anterior se convertirá en:

ent X;

pero, también puedo escribir más de uno. Por ejemplo, la siguiente escritura se considera válida:

ent X,Y,Z;
doble W=3.12;


Como son atributos de las clases tienen que escribirse dentro de los mismos; escribirlos fuera de ellos se considera un error.
Como se puede ver en el ejemplo, también es posible inicializar una variable en el momento en el que la creamos: símplemente hay que añadir, después del nombre, el signo igual y el valor que toma.
Después de la escritura de la variable y su inicialización, el identificador de la variable, en cualquier lugar que se haya escrito, se entiende como su valor actual, excepto si le damos un nuevo valor. Por ejemplo, si escribo X = 10 me refiero a la variable X y no a su valor, y con el signo igual 10 me refiero a que el nuevo valor de la variable es 10.
Si después escribo:

X = X+1;

con la X a la izquierda del signo igual me refiero a que la variable se llama X, mientras que con la X a la derecha me refiero al valor actual de la variable X. La expresión X+1, entonces, en este caso será

10 + 1 y entonces 11, es decir por X = X + 1, he dicho X = 11;

Provad este pequeño programa que hace unos calculos:

class p
{
ent X,Y,Z;

double W = 3.12;

public double A = 15;

static int B = 101;

private final int C = 2;

protected static boolean D = true;

public p()

{

X= 10 ;

Y= X ;

Z= X + Y ;

System.out.println ("Al\'principio tengo: X="+X+", Y="+Y+", Z="+Z);

X= X + 1 ;

Y= Z - X;

System.out.println ("Hago las operaciones: \nX= X + 1 ;\nY= Z - X;\ned resultado:");

System.out.println ("X="+X+", Y="+Y+", Z="+Z);

}

}

class decl

{

public static void main(String[] a)

{
p Prueba=new p();

}
}


Como sabéis, visto que decl es la clase que incluye el main, tendréis que editar el programa en un archivo que se llama decl.java; después, ponedlo en marcha y a ver lo que ocurre. Hay también otros atributos para mostrar el uso de los modificadores.
En el ejemplo vemos que yo creé una clase p y le puse el objeto Prueba, llamando al constructor. Hice esto porque las variables son atributos y, por eso, si no son estáticos, son atributos de un objeto. Tuve que crear un objeto para poder trabajar con sus variables. Hay que acostumbrarse a programar desde esta perspectiva porque los programas Java son todos así. Como el main del programa TIENE que declararse static (y tiene que tener una cadena como parámetro), éste se pone en marcha en ausencia del objeto y, por eso, algunas variables no son estáticas. Si hubiera querido crear solo una clase, hubiese tenido que escribir algo parecido a:

class decl2
{
int X,Y,Z;

// Main
public static void main(String [] a)
{

decl2 Prueba=new decl2();

}

// Constructor

public decl2()
{

X= 10 ;

Y= X ;

Z= X + Y ;

System.out.println ("Al\'inicio tengo: X="+X+", Y="+Y+", Z="+Z);

X= X + 1 ;

Y= Z - X;

System.out.println ("Hago las operaciones: \nX= X + 1 ;\nY= Z - X;\ned resultado:");

System.out.println ("X="+X+", Y="+Y+", Z="+Z);

}

}


En este segundo ejemplo, editado y redactado en decl2.java, no se entiende bien cuándo vemos decl2 como clase y cuándo como objeto. Realmente el main está en la clase y en él se crea el objeto. Por tanto se invoca el constructor y dentro de él razonamos en términos de objeto creado. De todas formas, es posible y veréis que el programa funciona también en este caso. Algún día, cuando tengáis más familiaridad con el lenguaje, podréis hacerlo vosostros también. De momento no os lo aconsejo porque es fundamental, llegados a este punto, distinguir bien entre clases y objeto, y esto se consigue fácilmente con mucha experiencia.

Los identificadores Java tienen que empezar por una letra (o con _ o $) seguida por una secuencia larga de caracteres y cifras elegidas a vuestro antojo. Las cifras, codificadas en Unicode, son mucho más numerosas que las letras y que las cifras ASCII utilizadas por otros lenguajes. Lo siento, pero no tengo un mapa completo de los caracteres unicode que dejaros, pero puedo deciros que están incluidos los caracteres griegos, cirílicos, árabes, etc.

Ahora vamos a ver cómo escribir e inicializar un array. La escritura se hace poniéndo un par de corchetes después del tipo:

ent [] vectorDeEnteros;

Los array en Java son casi objetos, sólo que no pueden extenderse para añadirles nuevos métodos. Lo que acabamos de citar es una referencia a un array que, sin embargo, rl lenguaje no ha asignado. Si quiero inicializar el array elemento por elemento, como se hace con los demás lenguajes, tengo que escribir las dimensiones:

ent [] vectorDeEnteros = nuevo ent[100];

A partir de ahora puedo empezar a poner los elementos en el vector, en las posiciones de 0 a 99. Si salgo de estos números, el aparato nos dará unmensaje de excepción del tipo out of range.
Cuando creo, puedo además inicializar un array, basta con escribir:

ent [] vectorDeEnteros = { 1,2,3,10,100,555,0, ….otros valores…};

Además puedo crear unos vectores cuyos elementos son ellos mismos vectores, etc. Esto se consigue de esta forma:

double[] [] matrizIdentidadDeÓrden3 = { { 1.0 , 0.0 , 0.0 } ,
{ 0.0 , 1.0 , 0.0 } ,
{ 0.0 , 0.0 , 1.0 } };


El siguiente programa utiliza los array y lo editaremos en un archivo que se llama vect.java:

clase vect
{

static ent NOMBRE = 0;

static ent APELLIDOS = 1;

static ent PATODÓNALD=0;

static ent GILBERTO=1;

static ent JORGITO=2;

static ent JAIMITO=3;

static ent JUANITO=4;

static ent GUS=5;

static ent COMISARIO=6;

static ent RATÓN=7;

static ent SUPER PATO=8;

static ent PLUTO=9;

static ent ABUELA=10;

static ent GILITO=11;

static Cadena personajes[][] = {
{"Paolino","Pato Donald"},
{"Pietro","Gilberto"},
{"Jorgito","No especificado"},
{"Jaimito","No especificado"},
{"Juanito","No especificado"},
{"Ciccio","De Abuela Donald"},
{"No especificado","Comisario"},
{"No especificado","Ratón Micky"},
{"Tribilín","No especificado"},
{"Pluto","No especificado"},
{"No especificado","Daisy"},
{"No especificado","Gilito"},
};

public static void main(String [] a)
{

ent PersonajeTmp;

ent Número=1;

System.out.println ("Unos personajes de Walt Disney");

PersonajeTmp=PATODÓNALD;

System.out.println("Número:"+Número+"\tNombre:"+personajes[PersonajeTmp][NOMBRE]+" Apellidos:"+personajes[PersonajeTmp][APELLIDOS]);

Número=Número+1;

PersonajeTmp=GILBERTO;

System.out.println("Número:"+Número+"\tNombre:"+personajes[PersonajeTmp][NOMBRE]+" Apellidos:"+personajes[PersonajeTmp][APELLIDOS]);

Número=Número+1;

PersonajeTmp=JORGITO;

System.out.println("Número:"+Número+"\tNombre:"+personajes[PersonajeTmp][NOMBRE]+" Apellidos:"+personajes[PersonajeTmp][APELLIDOS]);

Número=Número+1;

PersonajeTmp=JAIMITO;

System.out.println("Número:"+Número+"\tNombre:"+personajes[PersonajeTmp][NOMBRE]+" Apellidos:"+personajes[PersonajeTmp][APELLIDOS]);

Número=Número+1;

PersonajeTmp=JUANITO;

System.out.println("Número:"+Número+"\tNombre:"+personajes[PersonajeTmp][NOMBRE]+" Apellidos:"+personajes[PersonajeTmp][APELLIDOS]);

Número=Número+1;

PersonajeTmp=GUS;

System.out.println("Número:"+Número+"\tNombre:"+personajes[PersonajeTmp][NOMBRE]+" Apellidos:"+personajes[PersonajeTmp][APELLIDOS]);

Número=Número+1;

PersonajeTmp=COMISARIO;

System.out.println("Número:"+Número+"\tNombre:"+personajes[PersonajeTmp][NOMBRE]+" Apellidos:"+personajes[PersonajeTmp][APELLIDOS]);

Número=Número+1;

PersonajeTmp=PLUTO;

System.out.println("Número:"+Número+"\tNombre:"+personajes[PersonajeTmp][NOMBRE]+" Apellidos:"+personajes[PersonajeTmp][APELLIDOS]);

Número=Número+1;

PersonajeTmp=TRIBILÍN;

System.out.println("Número:"+Número+"\tNombre:"+personajes[PersonajeTmp][NOMBRE]+" Apellidos:"+personajes[PersonajeTmp][APELLIDOS]);

Número=Número+1;

PersonajeTmp=GILITO;

System.out.println("Número:"+Número+"\tNombre:"+personajes[PersonajeTmp][NOMBRE]+" Apellidos:"+personajes[PersonajeTmp][APELLIDOS]);

Número=Número+1;

PersonajeTmp=RATÓN;

System.out.println("Número:"+Número+"\tNombre:"+personajes[PersonajeTmp][NOMBRE]+" Apellidos:"+personajes[PersonajeTmp][APELLIDOS]);

System.out.println("HiCe los cálculos "+Número+" personajes, y eran muchos más");

// Éste sí es un programa realmente inútil. El autor.

}
}


Un pequeño comentario sobre el programa. Os habéis dado cuanta de que en el main se establecen unas variables (es posible hacerlo): normalmente se usan sin redactarlas como static porque las variables del main, o de una función, por lo general, no son atributos y, por eso, no están relacionados con el objeto o con la clase, sino sólamente con la función en la que se escriben. En estas definiciones no están incluidos los modificadores porque estos se asocian a las clases.

Llegados a este punto nos queda por ver los tipos compuestos que se pueden fácilmente identificar ahora con las clases. Por ejemplo, si queréis definir el tipo compuesto Complejos, escribiremos:

clase Complejos
{
private double ParteReal;

private double ParteImaginaria;

Complejos (double Re, double Im)
{

ParteReal=Re;

ParteImaginaria=Im;

}

// ahora estableceremos todos nuestros obvios métodos en el nuevo tipo
double démeParteReal()
{
return ParteReal;
};
double démeParteImaginaria()
{
return ParteImaginaria;
};
double calculaMódulo()
{
return (java.lang.Math.sqrt((ParteImaginaria*ParteImaginaria)+ (ParteReal*ParteReal)));
};

}


Para probar, podéis escribir los siguiente(pruebaComplejos.java):

clase pruebaComplejos
{

public static void main (Cadena[] arg)
{
Complejos N=nuevo Complejos(3.0,1.1);

double Re=N.démeParteReal();

double Im=N.démeParteImaginaria();

double mod=N.calculaMódulo();

System.out.println("Número complejo:"+Re+"+i"+Im+" tiene "+mod);

}

}



  Vuelva al inicio de la página