Java partiendo de Cero - El cuerpo de la clase

El cuerpo de la clase, encerrado entre { y }, es la lista de atributos (variables) y métodos (funciones) que constituyen la clase.

No es obligatorio, pero en general se listan primero los atributos y luego los métodos.

Declaración de atributos

En Java no hay variables globales; todas las variables se declaran dentro del cuerpo de la clase o dentro de un método. Las variables declaradas dentro de un método son locales al método; las variables declaradas en el cuerpo de la clase se dice que son miembros de la clase y son accesibles por todos los métodos de la clase.

Por otra parte, además de los atributos de la propia clase se puede acceder a todos los atributos de la clase de la que desciende; por ejemplo, cualquier clase que descienda de la clase Polygon hereda los atributos npoints, xpoints e ypoints.

Finalmente, los atributos miembros de la clase pueden ser atributos de clase o atributos de instancia; se dice que son atributos de clase si se usa la palabra clave static: en ese caso la variable es única para todas las instancias (objetos) de la clase (ocupa un único lugar en memoria). Si no se usa static, el sistema crea un lugar nuevo para esa variable con cada instancia (o sea que es independiente para cada objeto).

La declaración sigue siempre el mismo esquema:


[private|protected|public] [static] [final] [transient] [volatile] Tipo NombreVariable [= Valor];

Private, protected o public

Java tiene 4 tipos de acceso diferente a las variables o métodos de una clase: privado, protegido, público o por paquete (si no se especifica nada).

De acuerdo a la forma en que se especifica un atributo, objetos de otras clases tienen distintas posibilidades de accederlos:

---

|| Acceso desde: || || || || ||
|| la propia clase || || || || ||
|| subclase en el mismo paquete || || || || ||
|| otras clases en el mismo paquete || || || || ||
|| subclases en otros paquetes || || || || ||
|| otras clases en otros paquetes || || || || ||

S: puede acceder

N: no puede acceder

X: puede acceder al atributo en objetos que pertenezcan a la subclase, pero no en los que pertenecen a la clase madre. Es un caso especial ; más adelante veremos ejemplos de todo esto.

Static y final

Como ya se vio, static sirve para definir un atributo como de clase, o sea único para todos los objetos de la clase.

En cuanto a final, como en las clases, determina que un atributo no pueda ser sobreescrito o redefinido. O sea: no se trata de una variable, sino de una constante.

Transient y volatile

Son casos bastante particulares y que no habían sido implementados en Java 1.0.

Transient denomina atributos que no se graban cuando se archiva un objeto, o sea que no forman parte del estado permanente del mismo.

Volatile se utiliza con variables modificadas asincrónicamente por objetos en diferentes threads (literalmente "hilos", tareas que se ejecutan en paralelo); básicamente esto implica que distintas tareas pueden intentar modificar la variable simultáneamente, y volatile asegura que se vuelva a leer la variable (por si fue modificada) cada vez que se la va a usar (esto es, en lugar de usar registros de almacenamiento como buffer).

Los tipos de Java

Los tipos de variables disponibles son básicamente 3:

• tipos básicos (no son objetos)
• arreglos (arrays)
• clases e interfases

Con lo que vemos que cada vez que creamos una clase o interfase estamos definiendo un nuevo tipo.

Los tipos básicos son:

---

|| Tipo || Tamaño/Formato || Descripción ||
|| byte || 8-bit complemento a 2 || Entero de un byte ||
|| short || 16-bit complemento a 2 || Entero corto ||
|| int || 32-bit complemento a 2 || Entero ||
|| long || 64-bit complemento a 2 || Entero largo ||
|| float || 32-bit IEEE 754 || Punto flotante, precisión simple ||
|| double || 64-bit IEEE 754 || Punto flotante, precisión doble ||
|| char || 16-bit caracter Unicode || Un caracter ||
|| boolean || true, false || Valor booleano (verdadero o falso) ||

Los arrays son arreglos de cualquier tipo (básico o no). Por ejemplo, existe una clase Integer; un arreglo de objetos de dicha clase se notaría:

Integer vector[ ];

Los arreglos siempre son dinámicos, por lo que no es válido poner algo como:

Integer cadena[5];

Aunque sí es válido inicializar un arreglo, como en:

int días[ ] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

char letras[ ] = { 'E', 'F', 'M', 'A', 'M', 'J', 'J', 'A', 'S', 'O', 'N', 'D' };

String nombres[ ] = new String[12];


Nota al margen: no confundir un String (cadena de caracteres) con un arreglo de caracteres! Son cosas bien distintas!

Ya hablaremos más adelante de las clases String y StringBuffer.

En Java, para todas las variables de tipo básico se accede al valor asignado a la misma directamente (no se conoce la dirección de memoria que ocupa). Para las demás (arrays, clases o interfases), se accede a través de un puntero a la variable. El valor del puntero no es accesible ni se puede modificar (como en C); Java no necesita esto y además eso atentaría contra la robustez del lenguaje.

De hecho, en Java no existen los tipos pointer, struct o union. Un objeto es más que una estructura, y las uniones no se hacen necesarias con un método de programación adecuado (y además se evita la posibilidad de acceder a los datos incorrectamente).

Algo más respecto a los arreglos: ya que Java gestiona el manejo de memoria para los mismos, y lanza excepciones si se intenta violar el espacio asignado a una variable, se evitan problemas típicos de C como acceder a lugares de memoria prohibidos o fuera del lugar definido para la variable (como cuando se usa un subíndice más grande que lo previsto para un arreglo…).

Y los métodos

Los métodos, como las clases, tienen una declaración y un cuerpo.

La declaración es del tipo:


[private|protected|public] [static] [abstract] [final] [native] [synchronized] TipoDevuelto NombreMétodo ( [tipo1 nombre1[, tipo2 nombre2 ]…] ) [throws excepción1 [,excepción2]… ]


A no preocuparse: poco a poco aclararemos todo con ejemplos.

Básicamente, los métodos son como las funciones de C: implementan, a través de funciones, operaciones y estructuras de control, el cálculo de algún parámetro que es el que devuelven al objeto que los llama. Sólo pueden devolver un valor (del tipo TipoDevuelto), aunque pueden no devolver ninguno (en ese caso TipoDevuelto es void). Como ya veremos, el valor de retorno se especifica con la instrucción return, dentro del método.

Los métodos pueden utilizar valores que les pasa el objeto que los llama (parámetros), indicados con tipo1 nombre1, tipo2 nombre2… en el esquema de la declaración.

Estos parámetros pueden ser de cualquiera de los tipos ya vistos. Si son tipos básicos, el método recibe el valor del parámetro; si son arrays, clases o interfases, recibe un puntero a los datos (referencia). Veamos un pequeño ejemplo:


public int AumentarCuenta(int cantidad) {
cnt = cnt + cantidad;
return cnt;
}

Este método, si lo agregamos a la clase Contador, le suma cantidad al acumulador cnt. En detalle:

• el método recibe un valor entero (cantidad)
• lo suma a la variable de instancia cnt
• devuelve la suma (return cnt)

¿Cómo hago si quiero devolver más de un valor? Por ejemplo, supongamos que queremos hacer un método dentro de una clase que devuelva la posición del mouse.

Lo siguiente no sirve:

}

porque el método no puede modificar los parámetros x e y (que han sido pasados por valor, o sea que el método recibe el valor numérico pero no sabe adónde están las variables en memoria).

La solución es utilizar, en lugar de tipos básicos, una clase:


y luego utilizar esa clase en nuestro método:

}

El resto de la declaración

Public, private y protected actúan exactamente igual para los métodos que para los atributos, así que veamos el resto.

Los métodos estáticos (static), son, como los atributos, métodos de clase; si el método no es static es un método de instancia. El significado es el mismo que para los atributos: un método static es compartido por todas las instancias de la clase.

Ya hemos hablado de las clases abstractas; los métodos abstractos (abstract) son aquellos de los que se da la declaración pero no la implementación (o sea que consiste sólo del encabezamiento). Cualquier clase que contenga al menos un método abstracto (o cuya clase madre contenga al menos un método abstracto que no esté implementado en la hija) es una clase abstracta.

Es final un método que no puede ser redefinido por ningún descendiente de la clase.

Las clases native son aquellas que se implementan en otro lenguaje (por ejemplo C o C++) propio de la máquina. Sun aconseja utilizarlas bajo riesgo propio, ya que en realidad son ajenas al lenguaje. Pero la posibilidad de usar viejas bibliotecas que uno armó y no tiene ganas de reescribir existe!.

Las clases synchronized permiten sincronizar varios threads para el caso en que dos o más accedan concurrentemente a los mismos datos. De nuevo, más detalles habrá en el futuro, cuando hablemos de threads.

Finalmente, la cláusula throws sirve para indicar que la clase genera determinadas excepciones. También hablaremos de las excepciones más adelante.


En la próxima veremos el cuerpo de la declaración y empezaremos a armar algunos ejemplos concretos para ir aclarando todos estos conceptos