Controlar el Acceso a los Miembros de la Clase

Uno de los beneficos de las clases es que pueden proteger sus variables y métodos miembros
frente al acceso de otros objetos. ¿Por qué es esto importante? Bien, consideremos esto. Se ha
escrito una clase que representa una petición a una base de datos que contiene toda clase de
información secreta, es decir, registros de empleados o proyectos secretos de la compañia.
Ciertas informaciones y peticiones contenidas en la clase, las soportadas por los métodos y
variables accesibles públicamente en su objeto son correctas para el consumo de cualquier otro
objeto del sistema. Otras peticiones contenidas en la clase son sólo para el uso personal de la
clase. Estas otras soportadas por la operación de la clase no deberían ser utilizadas por objetos de otros tipos. Se querría proteger esas variables y métodos personales a nivel del lenguaje y prohibir el acceso desde objetos de otros tipos.
En Java se puede utilizar los especificadores de acceso para proteger tanto las variables como los métodos de la clase cuando se declaran. El lenguaje Java soporta cuatro niveles de acceso para las variables y métodos miembros: private, protected, public, y, todavía no especificado, acceso de paquete.

La siguiente tabla le muestra los niveles de acceso pemitidos por cada especificador:
Especificador clase subclase paquete mundo
private X
protected X X* X
public X X X X
package X X
La primera columna indica si la propia clase tiene acceso al miembro definido por el especificador
de acceso. La segunda columna indica si las subclases de la clase (sin importar dentro de que
paquete se encuentren estas) tienen acceso a los miembros. La tercera columna indica si las
clases del mismo paquete que la clase (sin importar su parentesco) tienen acceso a los miembros.
La cuarta columna indica si todas las clases tienen acceso a los miembros.
Observa que la intersección entre protected y subclase tiene un '*' - este caso de acceso particular
tiene una explicación en más detalle más adelante.
Echemos un vistazo a cada uno de los niveles de acceso más detalladamente:
Private
El nivel de acceso más restringido es private. Un miembro privado es accesible sólo para
la clase en la que está definido. Se utiliza este acceso para declarar miembros que sólo
deben ser utilizados por la clase. Esto incluye las variables que contienen informaión
que si se accede a ella desde el exterior podría colocar al objeto en un estado de
inconsistencia, o los métodos que llamados desde el exterior pueden ponen en peligro el
estado del objeto o del programa donde se está ejecutando. Los miembros privados son
como secretos, nunca deben contarsele a nadie.
Para declarar un miembro privado se utiliza la palabra clave private en su declaración.
La clase siguiente contiene una variable miembro y un método privados:
class Alpha {
private int soyPrivado;
private void metodoPrivado() {
System.out.println("metodoPrivado");
}
}
Los objetos del tipo Alpha pueden inspeccionar y modificar la variable soyPrivado y
pueden invocar el método metodoPrivado(), pero los objetos de otros tipos no pueden
acceder. Por ejemplo, la clase Beta definida aquí:
class Beta {
void metodoAccesor() {
Alpha a = new Alpha();
a.soyPrivado = 10; // ilegal
a.metodoPrivado(); // ilegal
}
}
no puede acceder a la variable soyPrivado ni al método metodoPrivado() de un
objeto del tipo Alpha porque Beta no es del tipo Alpha.
Si una clase está intentando acceder a una variable miembro a la que no tiene
acceso--el compilador mostrará un mensaje de error similar a este y no compilará su
programa:
Beta.java:9: Variable iamprivate in class Alpha not accessible from class Beta.
a.iamprivate = 10; // ilegal
^
1 error
Y si un programa intenta acceder a un método al que no tiene acceso, generará un error
de compilación parecido a este:
Beta.java:12: No method matching privateMethod() found in class Alpha.
a.privateMethod(); // ilegal
1 error
Protected
El siguiente especificador de nivel de acceso es 'protected' que permite a la propia clase,
las subclases (con la excepción a la que nos referimos anteriormente), y todas las clases
dentro del mismo paquete que accedan a los miembros. Este nivel de acceso se utiliza
cuando es apropiado para una subclase da la clase tener acceso a los miembros, pero
no las clases no relacionadas. Los miembros protegidos son como secretos familiares -
no importa que toda la familia lo sepa, incluso algunos amigos allegados pero no se
quiere que los extraños lo sepan.
Para declarar un miembro protegido, se utiliza la palabra clave protected. Primero
echemos un vistazo a cómo afecta este especificador de acceso a las clases del mismo
paquete.
Consideremos esta versión de la clase Alpha que ahora se declara para estar incluida en
el paquete Griego y que tiene una variable y un método que son miembros protegidos:
package Griego;
class Alpha {
protected int estoyProtegido;
protected void metodoProtegido() {
System.out.println("metodoProtegido");
}
}
Ahora, supongamos que la clase Gamma, también está declarada como miembro del
paquete Griego (y no es una subclase de Alpha). La Clase Gamma puede acceder
legalmente al miembro estoyProtegido del objeto Alpha y puede llamar legalmente a
su método metodoProtegido():
package Griego;
class Gamma {
void metodoAccesor() {
Alpha a = new Alpha();
a.estoyProtegido = 10; // legal
a.metodoProtegido(); // legal
}
}
Esto es muy sencillo. Ahora, investiguemos cómo afecta el especificador portected a una
subclase de Alpha.
Introduzcamos una nueva clase, Delta, que desciende de la clase Alpha pero reside en
un paquete diferente - Latin. La clase Delta puede acceder tanto a estoyProtegido
como a metodoProtegido(), pero solo en objetos del tipo Delta o sus subclases. La
clase Delta no puede acceder a estoyProtegido o metodoProtegido() en objetos del
tipo Alpha. metodoAccesor() en el siguiente ejemplo intenta acceder a la variable
miembro estoyProtegido de un objeto del tipo Alpha, que es ilegal, y en un objeto del
tipo Delta que es legal. Similarmente, metodoAccesor() intenta invocar a
metodoProtegido() en un objeto del tipo Alpha, que también es ilegal:
import Griego.*;
package Latin;
class Delta extends Alpha {
void metodoAccesor(Alpha a, Delta d) {
a.estoyProtegido = 10; // ilegal
d.estoyProtegido = 10; // legal
a.metodoProtegido(); // ilegal
d.metodoProtegido(); // legal
}
}
Si una clase es una subclase o se cuentra en el mismo paquete de la clase con el
miembro protegido, la clase tiene acceso al miembro protegido.
Public
El especificador de acceso más sencillo es 'public'. Todas las clases, en todos los
paquetes tienen acceso a los miembros públicos de la clase. Los miembros públicos se
declaran ólo si su acceso no produce resultados indeseados si un extraño los utiliza.
Aquí no hay secretos familiares; no importa que lo sepa todo el mundo.
Para declarar un miembro público se utiliza la palabra clave public. Por ejemplo,
package Griego;
class Alpha {
public int soyPublico;
public void metodoPublico() {
System.out.println("metodoPublico");
}
}
Reescribamos nuestra clase Beta una vez más y la ponemos en un paquete diferente
que la clase Alpha y nos aseguramos que no están relacionadas (no es una subclase) de
Alpha:
import Griego.*;
package Romano;
class Beta {
void metodoAccesor() {
Alpha a = new Alpha();
a.soyPublico = 10; // legal
a.metodoPublico(); // legal
}
}
Como se puede ver en el ejemplo anterior, Beta puede inspeccionar y modificar
legalmente la variable soyPublico en la clase Alpha y puede llamar legalmente al
método metodoPublico().
Acceso de Paquete
Y finalmente, el último nivel de acceso es el que se obtiene si no se especifica ningún
otro nivel de acceso a loss miembros. Este nivel de acceso permite que las clases del
mismo paquete que la clase tengan acceso a los miembros. Este nivel de acceso asume
que las clases del mismo paquete son amigas de confianza. Este nivel de confianza es
como la que extiende a sus mejores amigos y que incluso no la tiene con su familia.
Por ejemplo, esta versión de la clase Alpha declara una variable y un método con acceso
de paquete. Alpha reside en el paquete Griego:
package Griego;
class Alpha {
int estoyEmpaquetado;
void metodoEmpaquetado() {
System.out.println("metodoEmpaquetado");
}
}
La clase Alpha tiene acceso a estoyEmpaquetado y a metodoEmpaquetado().
Además, todas las clases declaradas dentro del mismo paquete como Alpha también
tienen acceso a estoyEmpaquetado y metodoEmpaquetado(). Supongamos que
tanto Alpha como Beta son declaradas como parte del paquete Griego:
package Griego;
class Beta {
void metodoAccesor() {
Alpha a = new Alpha();
a.estoyEmpaquetado = 10; // legal
a.metodoEmpaquetado(); // legal
}
}
Entonces Beta puede acceder legalmente a estoyEmpaquetado y
metodoEmpaquetado().
Ozito

Constructores
Todas las clases Java tienen métodos especiales llamados Constructores que se
utilizan para inicializar un objeto nuevo de ese tipo. Los contructores tienen el
mismo nombre que la clase --el nombre del constructor de la clase Rectangle es
Rectangle(), el nombre del constructor de la clase Thread es Thread(), etc...
Java soporta la sobrecarga de los nombres de métodos para que una clase puede
tener cualquier número de constructores, todos los cuales tienen el mismo nombre.
Al igual que otros métodos sobrecargados, los constructores se diferencian unos de
otros en el número y tipo de sus argumentos.
Consideremos la clase Rectangle del paquete java.awt que proporciona varios
constructores diferentes, todos llamados Rectangle(), pero cada uno con número
o tipo diferentes de argumentos a partir de los cuales se puede crear un nuevo
objeto Rectangle. Aquí tiene las firmas de los constructores de la clase
java.awt.Rectangle:
public Rectangle()
public Rectangle(int width, int height)
public Rectangle(int x, int y, int width, int height)
public Rectangle(Dimension size)
public Rectangle(Point location)
public Rectangle(Point location, Dimension size)
El primer constructor de Rectangle inicializa un nuevo Rectangle con algunos
valores por defecto razonables, el segundo constructor inicializa el nuevo Rectangle
con la altura y anchura especificadas, el tercer constructor inicializa el nuevo
Rectangle en la posición especificada y con la altura y anchura especificadas, etc...
Típicamente, un constructor utiliza sus argumentos para inicializar el estado del
nuevo objeto. Entonces, cuando se crea un objeto, se debe elegir el constructor
cuyos argumentos reflejen mejor cómo se quiere inicializar el objeto.
Basándose en el número y tipos de los argumentos que se pasan al constructor, el
compilador determina cual de ellos utilizar, Así el compilador sabe que cuando se
escribe:
new Rectangle(0, 0, 100, 200);
el compilador utilizará el constructor que requiere cuatro argumentos enteros, y
cuando se escribe:
new Rectangle(miObjetoPoint, miObjetoDimension);
utilizará el constructor que requiere como argumentos un objeto Point y un objeto
Dimension.
Cuando escribas tus propias clases, no tienes porque proporcionar constructores. El
constructor por defecto, el constructor que no necesita argumentos, lo proporciona
automáticamente el sistema para todas las clases. Sin embargo, frecuentemente
se querrá o necesitará proporcionar constructores para las clases.
Se puede declarar e implementar un constructor como se haría con cualquier otro
método en una clase. El nombre del constructor debe ser el mismo que el nombre
de la clase y, si se proporciona más de un constructor, los argumentos de cada uno
de los constructores deben diferenciarse en el número o tipo. No se tiene que
especificar el valor de retorno del constructor.
El constructor para esta subclase de Thread, un hilo que realiza animación,
selecciona algunos valores por defecto como la velocidad de cuadro, el número de
imágenes y carga las propias imágenes:
class AnimationThread extends Thread {
int framesPerSecond;
int numImages;
Image[] images;
AnimationThread(int fps, int num) {
int i;
super("AnimationThread");
this.framesPerSecond = fps;
this.numImages = num;
this.images = new Image[numImages];
for (i = 0; i <= numImages; i++) {
. . .
// Carga las imágenes
. . .
}
}
}
Observa cómo el cuerpo de un constructor es igual que el cuerpo de cualquier otro
método -- contiene declaraciones de variables locales, bucles, y otras sentencias.
Sin embargo, hay una línea en el constructor de AnimationThread que no se verá
en un método normal--la segunda línea:
super("AnimationThread");
Esta línea invoca al constructor proporcionado por la superclase de
AnimationThread--Thread. Este constructor particular de Thread acepta una cadena
que contiene el nombre del Thread. Frecuentemente un constructor se aprovechará
del código de inicialziación escrito para la superclase de la clase.
En realidad, algunas clases deben llamar al constructor de su superclase para que
el objeto trabaje de forma apropiada. Tipicamente, llamar al constructor de la
superclase es lo primero que se hace en el constructor de la subclase: un objeto
debe realizar primero la inicialización de nivel superior.
Cuando se declaren constructores para las clases, se pueden utilizar los
especificadores de acceso normales para especificar si otros objetos pueden crear
ejemplares de sus clase:
private
Niguna otra clase puede crear un objeto de su clase. La clase puede contener
métodos públicos y esos métodos pueden construir un objeto y devolverlo,
pero nada más.
protected
Sólo las subclases de la clase pueden crear ejemplares de ella.
public
Cualquiera pueda crear un ejemplar de la clase.
package-access
Nadie externo al paquete puede construir un ejemplar de su clase. Esto es
muy útil si se quiere que las clase que tenemos en un paquete puedan crear
ejemplares de la clase pero no se quiere que lo haga nadie más.
Leer más...

Implementación de Métodos

Similarmente a la implementación de una clase, la implementación de un método consiste en dos
partes, la declaración y el cuerpo del método.
declaracióndeMétodo {
cuerpodeMétodo
}

La Declaración de Método
Una declaración de método proporciona mucha información sobre el método al
compilador, al sistema en tiempo de ejecución y a otras clases y objetos. Junto con el
nombre del método, la declaración lleva información como el tipo de retorno del
método, el número y el tipo de los argumentos necesarios, y qué otras clases y objetos
pueden llamar al método.
Los únicos elementos necesarios una declaración de método son el nombre y el tipo de
retorno del método.

Por ejemplo, el código siguiente declara un método llamado
estaVacio() en la clase Pila que devuelve un valor booleano (true o false):
class Pila {
. . .
boolean estaVacio() {
. . .
}
}
Devolver un Valor desde un Método
Java necesita que un método declare el tipo de dato del valor que devuelve. Si un
método no devuelve ningún valor, debe ser declarado para devolver void (nulo).
Los métodos pueden devolver tipos de datos primitivos o tipos de datos de referencia. El
método estaVacio() de la clase Pila devuelve un tipo de dato primitivo, un valor
booleano:
class Pila {
static final int PILA_VACIA = -1;
Object[] stackelements;
int topelement = PILA_VACIA;
. . .
boolean estaVacio() {
if (topelement == PILA_VACIA)
return true;
else
return false;
}
}
Sin embargo, el método pop de la clase PILA devuelve un tipo de dato de referencia: un
objeto.
class Pila {
static final int PILA_VACIA = -1;
Object[] stackelements;
int topelement = PILA_VACIA;
. . .
Object pop() {
if (topelement == PILA_VACIA)
return null;
else {
return stackelements[topelement--];
}
}
}
Los métodos utilizan el operador return para devolver un valor. Todo método que no
sea declarado como void debe contener una sentencia return.
El tipo de dato del valor devuelto por la sentencia return debe corresponder con el tipo
de dato que el método tiene que devolver; no se puede devolver un objeto desde un
método que fue declarado para devolver un entero.
Cuando se devuelva un objeto, el tipo de dato del objeto devuelto debe ser una
subclase o la clase exacta indicada. Cuando se devuelva un tipo interface, el objeto
retornado debe implementar el interface especificado.
Un Nombre de Método
Un nombre de método puede ser cualquier indentificador legal en Java. Existen tres
casos especiales a tener en cuenta con los nombres de métodos:
Java soporta la sobrecarga de métodos, por eso varios métodos pueden compartir
el mismo nombre. Por ejemplo, supon que se ha escrito una clase que puede
proporcionar varios tipos de datos (cadenas, enteros, etc...) en un área de dibujo.
Se podría escribir un método que supiera como tratar a cada tipo de dato. En otros
lenguajes, se tendría que pensar un nombre distinto para cada uno de los
métodos. dibujaCadena(), dibujaEntero, etc... En Java, se puede utilizar el
mismo nombre para todos los métodos pasándole un tipo de parámetro diferente a
cada uno de los métodos. Entonces en la clase de dibujo, se podrán declarar tres
métodos llamados draw<() y que cada uno aceptara un tipo de parámetro
diferente:
class DibujodeDatos {
void draw(String s) {
. . .
}
void draw(int i) {
. . .
}
void draw(float f) {
. . .
}
}
Nota: La información que hay dentro de los paréntesis de la declaración son los
argumentos del método. Los argumentos se cubren en la siguiente página: Pasar
Información a un Método.
Los métodos son diferenciados por el compilador basándose en el número y tipo de
sus argumentos. Así draw(String s)y draw(int i) son métodos distintos y únicos.
No se puede declarar un método con la misma firma: draw(String s)y
draw(String t) son idénticos y darán un error del compilador.
Habrás observado que los métodos sobrecargados deben devolver el mismo tipo de
1.
dato, por eso void draw(String s) y int draw(String t) declarados en la misma
clase producirán un error en tiempo de compilación.
Todo método cuyo nombre sea igual que el de su clase es un constructor y tiene
una tarea especial que realizar. Los constructores se utilizan para inicializar un
objeto nuevo del tipo de la clase. Los constructores sólo pueden ser llamados con
el operador new. Para aprender cómo escribir un constructor, puedes ver Escribir
un Método Constructor.
2.
Una clase puede sobreescribir un método de sus superclases. El método que
sobreescribe debe tener el mismo, nombre, tipo de retorno y lista de parámetros
que el método al que ha sobreescrito. Sobreescribir Métodos te enseñará como
sobreescribir los métodos de una superclase.
3.
Caractersiticas Avanzadas de la Declaración de Métodos
Junto con los dos elementos necesarios, una declaración de método puede contener
otros elementos. Estos elementos declaran los argumentos aceptados por el método, si
el método es un método de clase, etc...
Juntándolo todo, una declaración de método se parecería a esto:
[especificadordeAcceso] [static] [abstract] [final] [native] [synchronized]
tipodeRetorno nombredelMétodo ([listadeparámetros]) [throws listadeExcepciones]
Cada uno de estos elementos de una declaración se cubre en alguna parte de este
tutorial.

Pasar Información a un Método.
Cuando se escribe un método, se declara el número y tipo de los argumentos requeridos por ese
método. Esto se hace en la firma del método. Por ejemplo, el siguiente método calcula el pago
mensual de una hipoteca basándose en la cantidad prestada, el interés, la duración de la hipoteca
(número de meses) y el valor futuro de la hipoteca (presumiblemente el valor futuro sea cero,
porque al final de la hipoteca, ya la habrás pagado):
double hipoteca(double cantidad, double interes, double valorFinal, int numPeriodos)
{
double I, parcial1, denominador, respuesta;
I = interes / 100.0;
parcial1 = Math.pow((1 + I), (0.0 - numPeriodos));
denominador = (1 - parcial1) / I;
respuestar = ((-1 * cantidad) / denominador) - ((valorFinal * parcial1) /
denominador);
return respuesta;
}
Este método toma cuatro argumentos: la cantidad prestada, el interés, el valor futuro y el número
de meses. Los tres primeros son números de coma flotante de doble precisión y el cuarto es un
entero.
Al igual que este método, el conjunto de argumentos de cualquier método es una lista de
declaraciones de varibales delimitadas por comas donde cada declaración de varibale es un par
tipo/nombre:
tipo nombre
Como has podido ver en el ejemplo anterior, sólo tienes que utilizar el nombre del argumento para
referirte al valor del argumento.
Tipos de Argumentos
En Java, se puede pasar como argumento a un método cualquier tipo de dato válido en
Java. Esto incluye tipos primitivos, como enteros, dobles, etc.. y tipos de referencia como
arrays, objetos, etc...
Aquí tienes un ejemplo de un constructor que acepta una array como argumento. En este
ejemplo el constructor inicializa un objeto Polygon a partir de una lista de puntos (Point es
una clase del paquete java.awt que representa una coordenada xy):
Polygon polygonFrom(Point[] listadePuntos) {
. . .
}
Al contrario que en otros lenguajes, no se puede pasar un método a un método Java. Pero
si se podría pasar un objeto a un método y luego llamar a los métodos del objeto.
Nombres de Argumentos
Cuando se declara un argumento para un método Java, se proporciona el nombre para ese
argumento. Este nombre es utilizado dento del cuerpo del método para referise al valor
del argumento.
Un argumento de un método puede tener el mismo nombre que una variable de la clase.
En este caso, se dice que el argumento oculta a la variable miembro. Normalmente los
argumentos que ocultan una variable miembro se utilizan en los constructores para
inicializar una clase. Por ejemplo, observa la clase Circle y su constructor:
class Circle {
int x, y, radius;
public Circle(int x, int y, int radius) {
. . .
}
}
La clase Circle tiene tres variables miembro x, y y radius. Ademñas, el constructor de la
clase Circle acepta tres argumentos cada uno de los cuales comparte el nombre con la
variable miembro para la que el argumento proporciona un valor inicial.
Los nombres de argumentos ocultan los nombres de las variables miembro. Por eso
utilizar x, y o radius dentro del cuerpo de la función, se refiere a los argumentos, no a las
variables miembro. Para acceder a las varibales miembro, se debe referenciarlas a través
de this--el objeto actual.
class Circle {
int x, y, radius;
public Circle(int x, int y, int radius) {
this.x = x;
this.y = y;
this.radius = radius;
}
}
Los nombres de los argumentos de un método no pueden ser el mismo que el de otros
argumentos del mismo método, el nombre de cualquier variable local del método o el
nombre de cualquier parámetro a una clausula catch() dentro del mismo método.
Paso por Valor
En los métodos Java, los argumentos son pasados por valor. Cuando se le llama, el
método recibe el valor de la variable pasada. Cuando el argumento es de un tipo primitivo,
pasar por valor significa que el método no puede cambiar el valor. Cuando el argumento
es del tipo de referencia, pasar por valor significa que el método no puede cambiar el
objeto referenciado, pero si puede invocar a los métodos del objeto y puede modificar las
variables accesibles dentro del objeto.
Consideremos esta serie de sentencias Java que intentan recuperar el color actual de un
objeto Pen en una aplicación gráfica:
. . .
int r = -1, g = -1, b = -1;
pen.getRGBColor(r, g, b);
System.out.println("red = " + r + ", green = " + g + ", blue = " + b);
. . .
En el momento que se llama al método getRGBColor(), las variables r, g, y b tienen un
valor de -1. El llamador espera que el método getRGBColor() le devuelva los valores de
rojo, verde y azul para el color actual en las variables r, g, y b.
Sin embargo, el sistema Java pasa los valores de las variables(-1) al método
getRGBColor(); no una referencia a las variables r, g, y b. Con esto se podría visualizar
la llamada a getRGBColor() de esta forma: getRGBColor(-1, -1, -1).
Cuando el control pasa dentro del método getRGBColor(), los argumentos entran dentro
del ámbito (se les asigna espacio) y son inicializados a los valores pasados al método:
class Pen {
int valorRojo, valorVerde, valorAzul;
void getRGBColor(int rojo, int verde, int azul) {
// rojo, verde y azul han sido creados y sus valores son -1
. . .
}
}
Con esto getRGBColor() obtiene acceso a los valores de r, g, y b del llamador a tavés de
sus argumentos rojo, verde, y azul, respectivamente. El método obtiene su propia copia
de los valores para utilizarlos dentro del ámbito del método. Cualquier cambio realizado en
estas copias locales no seran reflejados en las variables originales del llamador.
Ahora veremos la implementación de getRGBColor() dentro de la clase Pen que
implicaba la firma de método anterior:
class Pen {
int valorRojo, valorVerde, valorAzul;
. . .
// Este método no trabaja como se espera
void getRGBColor(int rojo, int verde, int azul) {
rojo = valorRojo;
verde=valorVerde;
azul=valorAzul;
}
}
Este método no trabajará como se espera. Cuando el control llega a la sentencia println()
en el siguiente fragmento de código, los argumentos rojo, verde y azul de
getRGBColor() ya no existen. Por lo tanto las asignaciones realizadas dentro del método
no tendrán efecto; r, g, y b seguiran siendo igual a -1.
. . .
int r = -1, g = -1, b = -1;
pen.getRGBColor(r, g, b);
System.out.println("rojo = " + r + ", verde = " + g + ", azul = " + b);
. . .
El paso de las varibales por valor le ofrece alguna seguridad a los programadores: los
métodos no puede modificar de forma no intencionada una variable que está fuera de su
ámbito. Sin embargo, alguna vez se querrá que un método modifique alguno de sus
argumentos. El metodo getRGBColor() es un caso apropiado. El llamador quiere que el
método devuelva tres valores a través de sus argumentos. Sin embargo, el método no
puede modificar sus argumentos, y, además, un método sólo puede devolver un valor a
través de su valor de retorno. Entonces, ¿cómo puede un método devolver más de un
valor, o tener algún efecto (modificar algún valor) fuera de su ámbito?
Para que un método modifique un argumento, debe ser un tipo de referencia como un
objeto o un array. Los objetos y arrays también son pasados por valor, pero el valor de un
objeto es una referencia. Entonces el efecto es que los argumentos de tipos de referencia
son pasados por referencia. De aquí el nombre. Una referencia a un objeto es la dirección
del objeto en la memoria. Ahora, el argumento en el método se refiere a la misma
posición de memoria que el llamador.
Reescribamos el método getRGBColor() para que haga lo que queremos. Primero
introduzcamos un nuevo objeto RGBColor, que puede contener los valores de rojo, verde y
azul de un color en formato RGB:
class RGBColor {
public int rojo, verde, azul;;
}
Ahora podemos reescribir getRGBColor() para que acepte un objeto RGBColor como
argumento. El método getRGBColor() devuelve el color actual de lápiz, en los valores de
las variables miembro rojo, verde y azul de su argumento RGBColor:
class Pen {
int valorRojo, valorVerde, valorAzul;
void getRGBColor(RGBColor unColor) {
unColor.rojo = valorRojo;
unColor.verde = valorVerde;
unColor.azul = valorAzul;
}
}
Y finalmente, reescribimos la secuencia de llamada:
. . .
RGBColor penColor = new RGBColor();
pen.getRGBColor(penColor);
System.out.println("ojo = " + penColor.rojo + ", verde = " + penColor.verde + ",
azul = " + penColor.azul);
. . .
Las modificaciones realizadas al objeto RGBColor dentro del método getRGBColor()
afectan al objeto creado en la secuencia de llamada porque los nombres penColor (en la
secuencia de llamada) y unColor (en el método getRGBColor()) se refieren al mismo
objeto.

El Cuerpo del Método
En el siguiente ejemplo, el cuerpo de método para los métodos estaVacio() y
poner() están en negrita:
class Stack {
static final int PILA_VACIA = -1;
Object[] elementosPila;
int elementoSuperior = PILA_VACIA;
. . .
boolean estaVacio() {
if (elementoSuperior == PILA_VACIA)
return true;
else
return false;
}
Object poner() {
if (elementoSuperior == PILA_VACIA)
return null;
else {
return elementosPila[elementoSuperior--];
}
}
}
Junto a los elementos normales del lenguaje Java, se puede utilizar this en el
cuerpo del método para referirse a los miembros del objeto actual. El objeto actual
es el objeto del que uno de cuyos miembros está siendo llamado. También se
puede utilizar super para referirse a los miembros de la superclase que el objeto
actual haya ocultado mediante la sobreescritura. Un cuerpo de método también
puede contener declaraciones de variables que son locales de ese método.
this
Normalmente, dentro del cuerpo de un método de un objeto se puede
referir directamente a las variables miembros del objeto. Sin embargo,
algunas veces no se querrá tener ambiguedad sobre el nombre de la
variable miembro y uno de los argumentos del método que tengan el
mismo nombre.
Por ejemplo, el siguiente constructor de la clase HSBColor inicializa
alguna variable miembro de un objeto de acuerdo a los argumentos
pasados al constructor. Cada argumento del constructor tiene el mismo
nombre que la variable del objeto cuyo valor contiene el argumento.
class HSBColor {
int hue, saturacion, brillo;
HSBColor (int luminosidad, int saturacion, int brillo) {
this.luminosidad = luminosidad;
this.saturacion = saturacion;
this.brillo = brillo;
}
}
Se debe utilizar this en este constructor para evitar la embiguedad entre
el argumento luminosidad y la variable miembro luminosidad (y así
con el resto de los argumentos). Escribir luminosidad = luminosidad;
no tendría sentido. Los nombres de argumentos tienen mayor
precedencia y ocultan a los nombres de las variables miembro con el
mismo nombre. Para referirise a la variable miembro se debe hacer
explicitamente a través del objeto actual--this.
También se puede utilizar this para llamar a uno de los métodos del
objeto actual. Esto sólo es necesario si existe alguna ambigüedad con el
nombre del método y se utiliza para intentar hacer el código más claro.
super
Si el método oculta una de las variables miembro de la superclase, se
puede referir a la variable oculta utilizando super. De igual forma, si el
método sobreescribe uno de los métodos de la superclase, se puede
llamar al método sobreescrito a través de super.
Consideremos esta clase:
class MiClase {
boolean unaVariable;
void unMetodo() {
unaVariable = true;
}
}
y una subclase que oculta unaVariable y sobreescribe unMetodo():
class OtraClase extends MiClase {
boolean unaVariable;
void unMetodo() {
unaVariable = false;
super.unMetodo();
System.out.println(unaVariable);
System.out.println(super.unaVariable);
}
}
Primero unMetodo() selecciona unaVariable (una declarada en
OtraClase que oculta a la declarada en MiClase) a false. Luego
unMetodo() llama a su método sobreescrito con esta sentencia:
super.unMetodo();
Esto selecciona la versión oculta de unaVariable (la declarada en
MiClase) a true. Luego unMetodo muestra las dos versiones de
unaVariable con diferentes valores:
false
true
Variables Locales
Dentro del cuerpo de un método se puede declarar más variables para
usarlas dentro del método. Estas variables son variables locales y viven
sólo mientras el control permanezca dentro del método. Este método
declara un variable local i y la utiliza para operar sobre los elementos del
array.
Object encontrarObjetoEnArray(Object o, Object[] arrayDeObjetos) {
int i; // variable local
for (i = 0; i < arrayDeObjetos.length; i++) {
if (arrayDeObjetos[i] == o)
return o;
}
return null;
}
Después de que este método retorne, i ya no existirá más.
Leer más...

Declarar Clases

Ahora que ya sabemos como crear, utilizar y destruir objetos, es hora de aprender cómo escribir clases
de las que crear esos objetos.
Una clase es un proyecto o prototipo que se puede utilizar para crear muchos objetos. La implementación
de una clase comprende dos componentes: la declaración y el cuerpo de la clase:
DeclaraciónDeLaClase {
CuerpoDeLaClase
}
La Declaración de la Clase
Como mínimo, la declaración de una clase debe contener la palabra clave class y el nombre de
la clase que está definiendo. Así la declaración más sencilla de una clase se parecería a esto:
class NombredeClase {
. . .
}
Por ejemplo, esta clase declara una nueva clase llamada NumeroImaginario:
class NumeroImaginario {
. . .
}

Los nombres de las clases deben ser un identificador legal de Java y, por convención, deben
empezar por una letra mayúscula. Muchas veces, todo lo que se necesitará será una
declaración mínima. Sin embargo, la declaración de una clase puede decir más cosas sobre la
clase. Más especificamente, dentro de la declaración de la clase se puede:
l declarar cual es la superclase de la clase.
l listar los interfaces implementados por la clase
l declarar si la clase es pública, abstracta o final
Declarar la Superclase de la Clase
En Java, todas las clases tienen una superclase. Si no se especifica una superclase para una
clase, se asume que es la clase Object (declarada en java.lang). Entonces la superclase de
NumeroImaginario es Object porque la declaración no explicitó ninguna otra clase. Para
obtener más información sobre la clase Object, puede ver La clase Object.
Para especificar explícitamente la superclase de una clase, se debe poner la palabra clave
extends más el nombre de la superclase entre el nombre de la clase que se ha creado y el
corchete abierto que abre el cuerpo de la clase, así:
class NombredeClase extends NombredeSuperClase {
. . .
}
Por ejemplo, supon que quieres que la superclase de NumeroImaginario sea la clase Number
en vez de la clase Object. Se podróa escribir esto:
class NumeroImaginario extends Number {
. . .
}
Esto declara explícitamente que la clase Number es la superclase de NumeroImaginario. (La
clase Number es parte del paquete java.lang y es la base para los enteros, los números en
coma flotante y otros números).
Declarar que Number es la superclase de NumeroImaginario declara implícitamente que
NumeroImaginario es una subclase de Number. Una subclase hereda las variables y los
métodos de su superclase.
Crear una subclase puede ser tan sencillo como incluir la clausula extends en su declaración
de clase. Sin embargo, se tendrán que hacer otras provisiones en su código cuando se crea una
subclase, como sobreescribir métodos. Para obtener más información sobre la creacción de
subclases, puede ver Subclases, Superclases, y Herencia.
Listar los Interfaces Implementados por la Clase
Cuando se declara una clase, se puede especificar que interface, si lo hay, está implementado
por la clase. Pero, ¿Qué es un interface? Un interface declara un conjunto de métodos y
constantes sin especificar su implementación para ningún método. Cuando una clase exige la
implementación de un interface, debe proporcionar la implementación para todos los métodos
declarados en el interface.
Para declarar que una clase implementa uno o más interfaces, se debe utilizar la palabra clave
implements seguida por una lista de los interfaces implementados por la clase delimitada por
comas. Por ejemplo, imagina un interface llamado Aritmetico que define los métodos llamados
suma(), resta(), etc... La clase NumeroImaginario puede declarar que implementa el
interface Aritmetico de esta forma:
class NumeroImaginario extends Number implements Aritmetico {
. . .
}
se debe garantizar que propociona la implementación para los métodos suma(), resta() y
demás métodos declarados en el interface Aritmetico. Si en NumeroImaginario falta alguna
implementación de los métodos definidos en Aritmetico, el compilador mostrará un mensaje de
error y no compilará el programa:
nothing.java:5: class NumeroImaginario must be declared abstract. It does not define
java.lang.Number add(java.lang.Number, java.lang.Number) from interface Aritmetico.
class NumeroImaginario extends Number implements Aritmetico {
^
Por convención, la clausula implements sigue a la clausula extends si ésta existe.
Observa que las firmas de los métodos declarados en el interface Aritmetico deben
corresponder con las firmas de los métodos implementados en la clase NumeroImaginario.
Tienes más información sobre cómo crear y utilizar interfaces en Crear y Utilizar Interfaces.
Clases Public, Abstract, y Final
Se puede utilizar uno de estos tres modificadores en una declaración de clase para declarar que
esa clase es pública, abstracta o final. Los modificadores van delante de la palabra clave class
y son opcionales.
El modificador public declara que la clase puede ser utilizada por objetos que estén fuera del
paquete actual. Por defecto, una clase sólo puede ser utiliza por otras clases del mismo
paquete en el que están declaradas.
public class NumeroImaginario extends Number implements Aritmetico {
. . .
}
Por convención, cuando se utiliza la palabra public en una declaración de clase debemos
asegurarnos de que es el primer item de la declaración.
El modificador abstract declara que la clase es una clase abstracta. Una clase abstracta podría
contener métodos abstractos (métodos sin implementación). Una clase abstracta está diseñada
para ser una superclase y no puede ejemplarizarse. Para una discusión sobre las clases
abstractas y cómo escribirlas puedes ver Escribir Clases y Métodos Abstractos.
Utilizando el modificador final se puede declarar que una clase es final, que no puede tener
subclases. Existen (al menos) dos razones por las que se podría querer hacer esto: razones de
seguridad y razones de diseño. Para un mejor explicaión sobre las clases finales puedes ver
Escribir Clases y Métodos Finales.
Observa que no tiene sentido para una clase ser abstracta y final. En otras palabras, una clase
que contenga métodos no implementados no puede ser final. Intentar declarar una clase como
final y abstracta resultará en un error en tiempo de compilación.
Sumario de la Daclaración de una Clase
En suma, una declaración de clase se parecería a esto:
[ modificadores ] class NombredeClase [ extends NombredeSuperclase ]
[ implements NombredeInterface ] {
. . .
}
Los puntos entre [ y ] son opcionales. Una declaración de clase define los siguientes aspectos
de una clase:
l modificadores declaran si la clase es abstracta, pública o final.
l NombredeClase selecciona el nombre de la clase que está declarando
l NombredeSuperClase es el nombre de la superclase de NombredeClase
NombredeInterface es una lista delimitada por comas de los interfaces implementados
por NombredeClase
l
De todos estos items, sólo la palabra clave class y el nombre de la clase son necesarios. Los
otros son opcionales. Si no se realiza ninguna declaración explícita para los items opcionales, el
compilador Java asume ciertos valores por defecto (una subclase de Object no final, no pública,
no obstracta y que no implementa interfaces).
El Cuerpo de la Clase
Anteriormente se vió una descripción general de la implementación de una clase:
DeclaraciondeClase {
CuerpodeClase
}
La página anterior describe todos los componentes de la declaración de una clase.
Esta página describe la estructura general y la organización del cuerpo de la clase.
El cuerpo de la clase compone la implementación de la propia clase y contiene dos
secciones diferentes: la declaración de varibles y la de métodos. Una variable
miembro de la clase representa un estado de la clase y sus métodos implemetan el
comportamiendo de la clase. Dentro del cuerpo de la clase se definen todas las
variables miembro y los métodos soportados por la clase.
Típicamente, primero se declaran las variables miembro de la clase y luego se
porporciona las declaraciones e implementanciones de los métodos, aunque este
orden no es necesario.
DeclaracióndeClase {
DeclaracionesdeVariablesMiembros
DeclaracionesdeMétodos
}
Aquí tienes una pequeña clase que declara tres variables miembro y un método:
class Ticket {
Float precio;
String destino;
Date fechaSalida;
void firma(Float forPrecio, String forDestino, Date forFecha) {
precio = forPrecio;
destino = forDestino;
fechaSalida = forFecha;
}
}
Para más información sobre cómo declarar variables miembro, puedes ver Declarar
Variables Miembro. Y para obtener más información sobre cómo implementar
métodos, puedes ver Implementar Métodos.
Además de las variables miembro y los métodos que se declaran explícitamente
dentro del cuerpo de la clase, una clase puede heredar algo de su superclase. Por
ejemplo, todas las clases del entorno Java son una descendencia (directa o
indirecta) de la clase Object. La clase Object define el estado básico y el
comportamieto que todos los objetos deben tener como habilidad para comparar
unos objetos con otros, para convertir una cadena, para esperar una condición
variable, para notificar a otros objetos que una condición variable ha cambiado,
etc... Así, como descendentes de esta clase, todos los objetos del entorno Java
heredan sus comportamientos de la clase Object.

Leer más...

Crear Objetos

En Java, se crea un objeto mediante la creacción de un objeto de una clase o, en
otras palabras, ejemplarizando una clase. Aprenderás cómo crear una clase más
adelante en Crear Clases. Hasta entonces, los ejemplos contenidos aquí crean
objetos a apartir de clases que ya existen en el entorno Java.
Frecuentemente, se verá la creacción de un objeto Java con un sentencia como
esta:
Date hoy = new Date();
Esta sentencia crea un objeto Date (Date es una clase del paquete java,util). Esta
sentencia realmente realiza tres acciones: declaración, ejemplarización e
inicialización. Date hoy es una declaración de variable que sólo le dice al
compilador que el nombre hoy se va a utilizar para referirse a un objeto cuyo tipo
es Date, el operador new ejemplariza la clase Date (creando un nuevo objeto
Date), y Date() inicializa el objeto.

Declarar un Objeto
Ya que la declaración de un objeto es una parte innecesaria de la
creacción de un objeto, las declaraciones aparecen frecuentemente en la
misma línea que la creacción del objeto. Como cualquier otra declaración
de variable, las declaraciones de objetos pueden aparecer solitarias como
esta:
Date hoy;
De la misma forma, declarar una variable para contener un objeto es
exactamente igual que declarar una variable que va a contener un tipo
primitivo:
tipo nombre
donde tipo es el tipo de dato del objeto y nombre es el nombre que va a
utilizar el objeto. En Java, las clases e interfaces son como tipos de
datos. Entonces tipo puede ser el nombre de una clase o de un interface.
Las declaraciones notifican al compilador que se va a utilizar nombre
para referirse a una variable cuyo tipo es tipo. Las declaraciones no
crean nuevos objetos. Date hoy no crea un objeto Date, sólo crea un
nombre de variable para contener un objeto Date. Para ejemplarizar la
clase Date, o cualquier otra clase, se utiliza el operador new.
Ejemplarizar una Clase
El operador new ejemplariza una clase mediante la asignación de
memoria para el objeto nuevo de ese tipo. new necesita un sólo
argumento: una llamada al método constructor. Los métodos
constructores son métodos especiales proporcionados por cada clase
Java que son reponsables de la inicialización de los nuevos objetos de
ese tipo. El operador new crea el objeto, el constructor lo inicializa.
Aquí tienes un ejemplo del uso del operador new para crear un objeto
Rectangle (Rectangle es una clase del paquete java.awt):
new Rectangle(0, 0, 100, 200);
En el ejemplo, Rectangle(0, 0, 100, 200) es una llamada al
constructor de la clase Rectangle.
El operador new devuelve una referencia al objeto recien creado. Esta
referencia puede ser asignada a una variable del tipo apropiado.
Rectangle rect = new Rectangle(0, 0, 100, 200);
(Recuerda que una clase escencialmente define un tipo de dato de
referencia. Por eso, Rectangle puede utilizarse como un tipo de dato en
los programas Java. El valor de cualquier variable cuyo tipo sea un tipo
de referencia, es una referencia (un puntero) al valor real o conjunto de
valores representado por la variable.
Inicializar un Objeto
Como mencioné anteriormente, las clases porporcionan métodos
constructores para incializar los nuevos objetos de ese tipo. Una clase
podría proporcionar múltiples constructores para realizar diferentes tipos
de inicialización en los nuevos objetos. Cuando veas la implementación
de una clase, reconocerás los constructores porque tienen el mismo
nombre que la clase y no tienen tipo de retorno. Recuerda la creacción
del objeto Date en el sección inicial. El constructor utilizado no tenía
ningún argumento:
Date()
Un constructor que no tiene ningún argumento, como el mostrado arriba,
es conocido como constructor por defecto. Al igual que Date, la mayoría
de las clases tienen al menos un constructor, el constructor por defecto.
Si una clase tiene varios constructores, todos ellos tienen el mismo
nombre pero se deben diferenciar en el número o el tipo de sus
argmentos. Cada constructor inicializa el nuevo objeto de una forma
diferente. Junto al constructor por defecto, la clase Date proporciona otro
constructor que inicializa el nuevo objeto con un nuevo año, mes y dia:
Date cumpleaños = new Date(1963, 8, 30);
El compilador puede diferenciar los constructores a través del tipo y del
número de sus argumentos.
Utilizar Objetos
Una vez que se ha creado un objeto, probablemente querrás hacer algo con él.
Supón, por ejemplo, que después de crear un nuevo rectángulo, quieres moverlo a
una posición diferente (es decir, el rectángulo es un objeto en un programa de
dibujo y el usuario quiere moverlo a otra posición de la página).
La clase Rectangle proporciona dos formas equivalentes de mover el rectángulo:
1. Manipular directamente las variables x e y del objeto.
2. Llamar el método move().
La opción 2 se considera "más orientada a objetos" y más segura porque se
manipulan las variables del objeto indirectamente a través de una capa protectora
de métodos, en vez de manejarlas directamente. Manipular directamente las
variables de un objeto se considera propenso a errores; se podría colocar el objeto
en un estado de inconsistencia. Sin embargo, una clase no podría (y no debería)
hacer que sus variables estuvieran disponibles para la manipulación directa por
otros objetos, si fuera posible que esas manipulaciones situaran el objeto en un
estado de inconsistencia. Java proporciona un mecanismo mediante el que las
clases puede restringir o permitir el acceso a sus variables y métodos a otros
objetos de otros tipos.
Esta sección explica la llamada a métodos y la manipulación de variables que se
han hecho accesibles a otras clases. Para aprender más sobre el control de acceso
a miembros puedes ir Controlar el Acceso a Miembros de una Clase.
Las variables x e y de Rectangle son accesibles desde otras clases. Por eso
podemos asumir que la manipulación directa de estas variables es segura.
Referenciar Variables de un Objeto
Primero, enfoquemos cómo inspeccionar y modificar la posición del
rectángulo mediante la manipulación directa de las variables x e y. La
siguiente sección mostrará como mover el rectángulo llamando al
método move().
Para acceder a las variables de un objeto, sólo se tiene que añadir el
nombre de la variable al del objeto referenciado introduciendo un punto
en el medio ('.').
objetoReferenciado.variable
Supón que tienes un rectángulo llamado rect en tu programa. puedes
acceder a las variables x e y con rect.x y rect.y, respectivamente.
Ahora que ya tienes un nombre para las variables de rect, puedes
utilizar ese nombre en sentencias y expresiones Java como si fueran
nombres de variables "normales". Así, para mover el rectángulo a una
nueva posición podrías escribir:
rect.x = 15; // cambia la posición x
rect.y = 37; // cambia la posición y
La clase Rectangle tiene otras dos variables--widthy height--que son
accesibles para objetos fuera de Rectangle. Se puede utilizar la misma
notación con ellas: rect.width y rect.height. Entonces se puede
calcular el área del rectángulo utilizando esta sentencia:
area = rect.height * rect.width;
Cuando se accede a una variable a través de un objeto, se está
refiriendo a las variables de un objeto particular. Si cubo fuera también
un rectángulo con una altura y anchura diferentes de rect, esta
instrucción:
area = cubo.height * cubo.width;
calcula el área de un rectángulo llamado cubo y dará un resultado
diferente que la instrucción anterior (que calculaba el área de un
rectángulo llamado rect).
Observa que la primera parte del nombre de una variable de un objeto
(el objetoReferenciado en objetoReferenciado.variable) debe ser
una referencia a un objeto. Como se puede utilizar un nombre de
variable aquí, también se puede utilizar en cualquier expresión que
devuelva una referencia a un objeto. Recuerda que el operador new
devuelve una referencia a un objeto. Por eso, se puede utilizar el valor
devuelto por new para acceder a las variables del nuevo objeto:
height = new Rectangle().height;
Llamar a Métodos de un Objeto
Llamar a un método de un objeto es similar a obtener una variable del
objeto. Para llamar a un método del objeto, simplemente se añade al
nombre del objeto referenciado el nombre del método, separados por un
punto ('.'), y se proporcionan los argumentos del método entre
paréntesis. Si el método no necesita argumentos, se utilizan los
paréntesis vacios.
objetoReferenciado.nombreMétodo(listaArgumentos);
o
objetoReferenciado.nombreMétodo();
Veamos que significa esto en términos de movimiento del rectángulo.
Para mover rect a una nueva posición utilizando el método move()
escribe esto:
rect.move(15, 37);
Esta sentencia Java llama al método move() de rect con dos
parámetros enteros, 15 y 37. Esta sentencia tiene el efecto de mover el
objeto rect igual que se hizo en las sentencias anteriores en las que se
moficaban directamente los valores x e y del objeto:
rect.x = 15;
rect.y = 37;
Si se quiere mover un rectángulo diferente, uno llamado cubo, la nueva
posición se podría escribir:
cubo.move(244, 47);
Como se ha visto en estos ejemplos, las llamadas a métodos se hacen
directamente a un objeto específico; el objeto especificado en la llamada
al método es el que responde a la instrucción.
Las llamadas a métodos también se conocen como mensajes. Como en la
vida real, los mensajes se deben dirigir a un receptor particular. Se
pueden obtener distintos resultados dependiendo del receptor de su
mensaje. En el ejemplo anterior, se ha enviado el mensaje move() al
objeto llamado rect para que éste mueva su posición. Cuando se envía
el mensaje move() al objeto llamado cubo, el que se mueve es cubo.
Son resultados muy distintos.
Una llamada a un método es una expresión (puedes ver Expresiones
para más información) y evalúa a algún valor. El valor de una llamada a
un método es su valor de retorno, si tiene alguno. Normalmente se
asignará el valor de retorno de un método a una variable o se utilizará la
llamada al método dentro del ámbito de otra expresión o sentencia.
El método move() no devuelve ningún valor (está declarado como
void). Sin embargo, el método inside() de Rectangle si lo hace. Este
método toma dos coordendas x e y, y devuelte true si este punto está
dentro del rectángulo. Se puede utilizar el método inside() para hacer
algo especial en algún punto, como decir la posición del ratón cuando
está dentro del rectangulo:
if (rect.inside(mouse.x, mouse.y)) {
. . .
// ratón dentro del rectángulo
. . .
} else {
. . .
// ratón fuera del rectángulo
. . .
}
Recuerda que una llamada a un método es un mensaje al objeto
nombrado. En este caso, el objeto nombrado es rect. Entonces:
rect.inside(mouse.x, mouse.y)
le pregunta a rect si la posición del cursor del ratón se encuentra entre
las coordenadas mouse.x y mouse.y. Se podría obtener una respuesta
diferente si envía el mismo mensaje a cubo.
Como se explicó anteriormente, el objetoReferenciado en la llamada al
método objetoReferenciado.método() debe ser una referencia a un
objeto. Como se puede utilizar un nombre de variable aquí, también se
puede utilizar en cualquier expresión que devuelva una referencia a un
objeto. Recuerda que el operador new devuelve una referencia a un
objeto. Por eso, se puede utilizar el valor devuelto por new para acceder
a las variables del nuevo objeto:
new Rectangle(0, 0, 100, 50).equals(anotherRect)
La expresión new Rectangle(0, 0, 100, 50) evalúa a una referencia a
un objeto que se refiere a un objeto Rectangle. Entonces, como verás, se
puede utilizar la notació de punto ('.') para llamar al método equals()
del nuevo objeto Rectangle para determinar si el rectangúlo nuevo es
igual al especificado en la lista de argumentos de equals().
Leer más...

Arrays y Cadenas

Al igual que otros lenguajes de programación, Java permite juntar y manejar múltiples
valores a través de un objeto array (matriz). También se pueden manejar datos
compuestos de múltiples caracteres utilizando el objeto String (cadena).
Arrays Esta sección te enseñará todo lo que necesitas para crear y utilizar arrays en
tus programas Java.
Como otras variables, antes de poder utilizar un array primero se debe
declarar. De nuevo, al igual que otras variables, la declaración de un array
tiene dos componentes primarios: el tipo del array y su nombre. Un tipo de
array incluye el tipo de dato de los elementos que va contener el array. Por
ejemplo, el tipo de dato para un array que sólo va a contener elementos
enteros es un array de enteros. No puede existir un array de tipo de datos
genérico en el que el tipo de sus elementos esté indefinido cuando se declara
el array. Aquí tienes la declaración de un array de enteros:
int[] arrayDeEnteros;
La parte int[] de la declaración indica que arrayDeEnteros es un array de
enteros. La declaración no asigna ninguna memoria para contener los
elementos del array.


Si se intenta asignar un valor o acceder a cualquier elemento de
arrayDeEnteros antes de haber asignado la memoria para él, el compilador
dará un error como este y no compilará el programa:
testing.java:64: Variable arraydeenteros may not have been initialized.
Para asignar memoria a los elementos de un array, primero se debe
ejemplarizar el array. Se puede hacer esto utilizando el operador new de Java.
(Realmente, los pasos que se deben seguir para crear un array son similares a
los se deben seguir para crear un objeto de una clase: declaración,
ejemplarización e inicialización.
La siguiente sentencia asigna la suficiente memoria para que arrayDeEnteros
pueda contener diez enteros.
int[] arraydeenteros = new int[10]
En general, cuando se crea un array, se utiliza el operador new, más el tipo
de dato de los elementos del array, más el número de elementos deseados
encerrado entre cochetes cuadrados ('[' y ']').
TipodeElemento[] NombredeArray = new TipodeElementos[tamanoArray]
Ahora que se ha asignado memoria para un array ya se pueden asignar
valores a los elemetos y recuperar esos valores:
for (int j = 0; j < arrayDeEnteros.length; j ++) {
arrayDeEnteros[j] = j;
System.out.println("[j] = " + arrayDeEnteros[j]);
}
Como se puede ver en el ejemplo anterior, para referirse a un elemento del
array, se añade corchetes cuadrados al nombre del array. Entre los corchetes
caudrados se indica (bien con una variable o con una expresión) el índice del
elemento al que se quiere acceder. Observa que en Java, el índice del array
empieza en 0 y termina en la longitud del array menos uno.
Hay otro elemento interesante en el pequeño ejemplo anterior. El bucle for
itera sobre cada elemento de arrayDeEnteros asignándole valores e
imprimiendo esos valores. Observa el uso de arrayDeEnteros.length para
obtener el tamaño real del array. length es una propiedad proporcionada para
todos los arrays de Java.
Los arrays pueden contener cualquier tipo de dato legal en Java incluyendo los
tipos de referencia como son los objetos u otros array. Por ejemplo, el
siguiente ejemplo declara un array que puede contener diez objetos String.
String[] arrayDeStrings = new String[10];
Los elementos en este array son del tipo referencia, esto es, cada elemento
contiene una referencia a un objeto String. En este punto, se ha asignado
suficiente memoria para contener las referencias a los Strings, pero no se ha
asignado memoria para los propios strings. Si se intenta acceder a uno de los
elementos de arraydeStrings obtendrá una excepción 'NullPointerException'
porque el array está vacio y no contiene ni cadenas ni objetos String. Se debe
asignar memoria de forma separada para los objetos String:
for (int i = 0; i < arraydeStrings.length; i ++) {
arraydeStrings[i] = new String("Hello " + i);
}
Strings
Una secuencia de datos del tipo carácter se llama un string (cadena) y en el
entorno Java está implementada por la clase String (un miembro del paquete
java.lang).
String[] args;
Este código declara explícitamente un array, llamado args, que contiene
objetos del tipo String. Los corchetes vacios indican que la longitud del array
no se conoce en el momento de la compilación, porque el array se pasa en el
momento de la ejecución.
El segundo uso de String es el uso de cadenas literales (una cadena de
caracteres entre comillas " y "):
"Hola mundo!"
El compilador asigna implicitamente espacio para un objeto String cuando
encuentra una cadena literal.
Los objetos String son inmutables - es decir, no se pueden modificar una vez
que han sido creados. El paquete java.lang proporciona una clase diferente,
StringBuffer, que se podrá utilizar para crear y manipular caracteres al vuelo.
Concatenación de Cadenas
Java permite concatenar cadenas facilmente utilizando el operador
+. El siguiente fragmento de código concatena tres cadenas para
producir su salida:
"La entrada tiene " + contador + " caracteres."
Dos de las cadenas concatenadas son cadenas literales: "La
entrada tiene " y " caracteres.". La tercera cadena - la del medioes
realmente un entero que primero se convierte a cadena y luego
se concatena con las otras.
Leer más...

Sentencias de Control de Flujo

Las sentencias de control de flujo determinan el orden en que se ejecutarán las otras sentencias
dentro del programa. El lenguaje Java soporta varias sentencias de control de flujo, incluyendo:
Sentencias palabras clave
toma de decisiones if-else, switch-case
bucles for, while, do-while
excepciones try-catch-finally, throw
miscelaneas break, continue, label:, return
Nota: Aunque goto es una palabra reservada, actualmente el lenguaje Java no la soporta.
Podemos utilizar las rupturas etiquetadas en su lugar.


La sentencia if-else
La sentencia if-else de java proporciona a los programas la posibilidad de ejecutar
selectivamente otras sentencias basándose en algún criterio. Por ejemplo, supon que
tu programa imprime información de depurado basándose en el valor de una variable
booleana llamada DEBUG. Si DEBUG fuera verdadera true, el programa imprimiría la
información de depurado, como por ejemplo, el valor de una variable como x. Si
DEBUG es false el programa procederá normalmente. Un segmento de código que
implemente esto se podría parecer a este:
. . .
if (DEBUG)
System.out.println("DEBUG: x = " + x);
. . .
Esta es la versión más sencilla de la sentencia if: la sentencia gobernada por if se
ejecuta si alguna codición es verdadera. Generalmente, la forma sencilla de if se puede
escribir así:
if (expresión)
sentencia
Pero, ¿y si quieres ejecutar un juego diferente de sentencias si la expresión es falsa?
Bien, puedes utilizar la sentencia else. Echemos un vistazo a otro ejemplo. Supon que
tu programa necesita realizar diferentes acciones dependiendo de que el usuario pulse
el botón OK o el botón Cancel en un ventana de alarma. Se podría hacer esto
utilizando una sentencia if:
. . .
// Respuesta dependiente del botoón que haya pulsado el usuario
// OK o Cancel
. . .
if (respuesta == OK) {
. . .
// Código para la acción OK
. . .
} else {
. . .
// código para la acción Cancel
. . .
}
Este uso particular de la sentencia else es la forma de capturarlo todo. Existe otra
forma de la sentecia else, else if que ejecuta una sentencia basada en otra expresión.
Por ejemplo, supon que has escrito un programa que asigna notas basadas en la
puntuación de un examen, un Sobresaliente para una puntuación del 90% o superior,
un Notable para el 80% o superior y demás. odrías utilizar una sentencia if con una
serie de comparaciones else if y una setencia else para escribir este código:
int puntuacion;
String nota;
if (puntuacion >= 90) {
nota = "Sobresaliente";
} else if (puntuacion >= 80) {
nota = "Notable";
} else if (puntuacion >= 70) {
nota = "Bien";
} else if (puntuacion >= 60) {
nota = "Suficiente";
} else {
nota = "Insuficiente";
}
Una sentencia if puede tener cualquier número de sentencias de acompañamiento else
if. Podrías haber observado que algunos valores de puntuacion pueden satisfacer más
una de las expresiones que componen la sentencia if. Por ejemplo, una puntuación de
76 podría evaluarse como true para dos expresiones de esta sentencia:puntuacion
>= 70 y puntuacion >= 60. Sin embargo, en el momento de ejecución, el sistema
procesa una sentencia if compuesta como una sóla; una vez que se ha satisfecho una
condición (76 >= 70), se ejecuta la sentencia apropiada (nota = "Bien";), y el control
sale fuera de la sentencia if sin evaluar las condiciones restantes.
La sentencia switch
La sentencia switch se utiliza para realizar sentencias condicionalmente basadas en
alguna expresión. Por ejemplo, supon que tu programa contiene un entero llamado
mes cuyo valor indica el mes en alguna fecha. Supon que también quieres mostrar el
nombre del mes basándose en su número entero equivalente. Podrías utilizar la
sentencia switch de Java para realizar esta tarea:
int mes;
. . .
switch (mes) {
case 1: System.out.println("Enero"); break;
case 2: System.out.println("Febrero"); break;
case 3: System.out.println("Marzo"); break;
case 4: System.out.println("Abril"); break;
case 5: System.out.println("May0"); break;
case 6: System.out.println("Junio"); break;
case 7: System.out.println("Julio"); break;
case 8: System.out.println("Agosto"); break;
case 9: System.out.println("Septiembre"); break;
case 10: System.out.println("Octubre"); break;
case 11: System.out.println("Noviembre"); break;
case 12: System.out.println("Diciembre"); break;
}
La sentencia switch evalúa su expresión, en este caso el valor de mes, y ejecuta la
sentencia case apropiada. Decidir cuando utilizar las sentencias if o switch dependen
del juicio personal. Puedes decidir cual utilizar basándose en la buena lectura del
código o en otros factores.
Cada sentencia case debe ser única y el valor proporcionado a cada sentencia case
debe ser del mismo tipo que el tipo de dato devuelto por la expresión proporcionada a
la sentencia switch.
Otro punto de interes en la sentencia switch son las sentencias break después de
cada case. La sentencia break hace que el control salga de la sentencia switch y
continúe con la siguiente línea. La sentencia break es necesaria porque las sentencias
case se siguen ejecutando hacia abajo. Esto es, sin un break explícito, el flujo de
control seguiría secuencialmente a través de las sentencias case siguientes. En el
ejemplo anterior, no se quiere que el flujo vaya de una sentencia case a otra, por eso
se han tenido que poner las sentencias break. Sin embargo, hay ciertos escenario en
los que querrás que el control proceda secuencialmente a través de las sentencias
case. Como este código que calcula el número de días de un mes de acuerdo con el
ritmico refrán que dice "Treinta tiene Septiembre...".
int mes;
int numeroDias;
. . .
switch (mes) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
numeroDias = 31;
break;
case 4:
case 6:
case 9:
case 11:
numeroDias = 30;
break;
case 2:
if ( ((ano % 4 == 0) && !(ano % 100 == 0)) || ano % 400 == 0) )
numeroDias = 29;
else
numeroDias = 28;
break;
}
Finalmente, puede utilizar la sentencia default al final de la sentencia switch para
manejar los valores que no se han manejado explícitamente por una de las sentencias
case.
int mes;
. . .
switch (mes) {
case 1: System.out.println("Enero"); break;
case 2: System.out.println("Febrero"); break;
case 3: System.out.println("Marzo"); break;
case 4: System.out.println("Abril"); break;
case 5: System.out.println("Mayo"); break;
case 6: System.out.println("Junio"); break;
case 7: System.out.println("Julio"); break;
case 8: System.out.println("Agosto"); break;
case 9: System.out.println("Septiembre"); break;
case 10: System.out.println("Octubre"); break;
case 11: System.out.println("Noviembre"); break;
case 12: System.out.println("Diciembre"); break;
default: System.out.println("Ee, no es un mes válido!");
break;
}
Sentencias de Bucle
Generalmente hablando, una sentencia while realiza una acción mientras se cumpla
una cierta condición. La sintaxis general de la sentencia while es:
while (expresión)
sentencia
Esto es, mientras la expresión sea verdadera, ejecutará la sentencia.
sentencia puede ser una sóla sentencia o puede ser un bloque de sentencias. Un
bloque de sentencias es un juego de sentencias legales de java contenidas dentro de
corchetes('{'y '}'). Por ejemplo, supon que además de incrementar contador dentro
de un bucle while también quieres imprimir el contador cada vez que se lea un
carácter. Podrías escribir esto en su lugar:
. . .
while (System.in.read() != -1) {
contador++;
System.out.println("Se ha leido un el carácter = " + contador);
}
. . .
Por convención el corchete abierto '{' se coloca al final de la misma línea donde se
encuentra la sentencia while y el corchete cerrado '}' empieza una nueva línea
indentada a la línea en la que se encuentra el while.
Además de while Java tiene otros dos constructores de bucles que puedes utilizar en
tus programas: el bucle for y el bucle do-while.
Primero el bucle for. Puedes utilizar este bucle cuando conozcas los límites del bucle
(su instrucción de inicialización, su criterio de terminación y su instrucción de
incremento). Por ejemplo, el bucle for se utiliza frecuentemente para iterar sobre los
elementos de un array, o los caracteres de una cadena.
// a es un array de cualquier tipo
. . .
int i;
int length = a.length;
for (i = 0; i < length; i++) {
. . .
// hace algo en el elemento i del array a
. . .
}
Si sabes cuando estas escribiendo el programa que quieres empezar en el inicio del
array, parar al final y utilizar cada uno de los elementos. Entonces la sentencia for es
una buena elección. La forma general del bucle for puede expresarse asi:
for (inicialización; terminación; incremento)
sentencias
inicialización es la sentencia que inicializa el bucle -- se ejecuta una vez al iniciar el
bucle.
terminación es una sentecia que determina cuando se termina el bucle. Esta expresión
se evalúa al principio de cada iteracción en el bucle. Cuando la expreión se evalúa a
false el bucle se termina.
Finalmente, incremento es una expresión que se invoca en cada interacción del bucle.
Cualquiera (o todos) de estos componentes puden ser una sentencia vacía (un punto y
coma).
Java proporciona otro bucle, el bucle do-while,que es similar al bucle while que se
vió al principio, excepto en que la expresión se avalú al final del bucle:
do {
sentencias
} while (Expresión Booleana);
La sentencia do-while se usa muy poco en la construcción de bucles pero tiene sus
usos. Por ejemplo, es conveniente utilizar la sentencia do-while cuando el bucle debe
ejecutarse al menos una vez. Por ejemplo, para leer información de un fichero,
sabemos que al menos debe leer un carácter:
int c;
InputStream in;
. . .
do {
c = in.read();
. . .
} while (c != -1);
Sentencias de Manejo de Excepciones
Cuando ocurre un error dentro de un método Java, el método puede lanzar una
excepción para indicar a su llamador que ha ocurrido un error y que el error está
utilizando la sentencia throw. El método llamador puede utilizar las sentencias try,
catch, y finally para capturar y manejar la excepción. Puedes ver Manejar Errores
Utilizando Excepciones para obtener más información sobre el lanzamiento y manejo
de excepciones.
Sentencias de Ruptura
Ya has visto la sentencia break en acción dentro de la sentencia switch
anteriormente. Como se observó anteriormente, la sentencia break hace que el
control del flujo salte a la sentencia siguiente a la actual.
Hay otra forma de break que hace que el flujo de control salte a una sentencia
etiquetada. Se puede etiquetar una sentencia utilizando un identificador legal de Java
(la etiqueta) seguido por dos puntos (:) antes de la sentencia:
SaltaAqui: algunaSentenciaJava
Para saltar a la sentencia etiquetada utilice esta forma de la sentencia break.
break SaltaAqui;
Las rupturas etiquetadas son una alternativa a la sentencia goto que no está
soportada por el lenguaje Java.
Se puede utiliza la sentencia continue dentro de un bucle para saltar de la sentencia
actual hacia el principio del bucle o a una sentencia etiquetada. Considera esta
implementación del método indexOf() de la clase String que utiliza la forma de
continue que continúa en una sentencia etiquetada:
public int indexOf(String str, int fromIndex) {
char[] v1 = value;
char[] v2 = str.value;
int max = offset + (count - str.count);
test:
for (int i = offset + ((fromIndex < 0) ? 0 : fromIndex); i <= max ; i++) {
int n = str.count;
int j = i;
int k = str.offset;
while (n-- != 0) {
if (v1[j++] != v2[k++]) {
continue test;
}
}
return i - offset;
}
return -1;
}
Nota: Sólo se puede llamar a la sentencia continue desde dentro de un bucle.
Y finalmente la sentencia return. Esta sentencia se utiliza para salir del método actual
y volver a la sentencia siguiente a la que originó la llamada en el método original.
Existen dos formas de return: una que devuelve un valor y otra que no lo hace. Para
devolver un valor, simplemente se pone el valor (o una expresión que calcule el valor)
detrás de la palabra return:
return ++count;
El valor devuelto por return debe corresponder con el tipo del valor de retorno de la
declaración del método.
Cuando un método se declara como void utiliza la forma de return que no devuelve
ningún valor:
return;


Leer más...

Expresiones

Las expresiones realizan el trabajo de un programa Java. Entre otras cosas, las
expresiones se utilizan para calcular y asignar valores a las variables y para
controlar el flujo de un programa Java. El trabajo de una expresión se divide en
dos partes: realizar los cálculos indicados por los elementos de la expresión y
devolver algún valor.
Definición: Una expresión es una serie de variables, operadores y llamadas a
métodos (construida de acuerdo a la sintaxis del lenguaje) que evalúa a un valor
sencillo.
El tipo del dato devuelto por una expresión depende de los elementos utilizados en
la expresión. La expresión count++ devuelve un entero porque ++ devuelve un
valor del mismo tipo que su operando y count es un entero. Otras expresiones
devuelven valores booleanos, cadenas, etc...

Una expresión de llamada a un método devuelve el valor del método; así el tipo de
dato de una expresión de llamada a un método es el mismo tipo de dato que el
valor de retorno del método. El método System.in.read() se ha declarado como
un entero, por lo tanto, la expresión System.in.read() devuelve un entero.
La segunda expresión contenida en la sentencia System.in.read() != -1 utiliza el
operador !=. Recuerda que este operador comprueba si los dos operandos son
distintos. En esta sentencia los operandos son System.in.read() y -1.
System.in.read() es un operando válido para != porque devuelve un entero. Así
System.in.read() != -1 compara dos enteros, el valor devuelto por
System.in.read() y -1. El valor devuelto por != es true o false dependiendo de
la salida de la comparación.
Como has podido ver, Java te permite construir expresiones compuestas y
sentencias a partir de varias expresiones pequeñas siempre que los tipos de datos
requeridos por una parte de la expresión correspondan con los tipos de datos de la
otra. Tambíen habrás podido concluir del ejemplo anterior, el orden en que se
evalúan los componentes de una expresión compuesta.
Por ejemplo, toma la siguiente expresión compuesta:
x * y * z
En este ejemplo particular, no importa el orden en que se evalúe la expresión
porque el resultado de la multiplicación es independiente del orden. La salida es
siempre la misma sin importar el orden en que se apliquen las multiplicaciones. Sin
embargo, esto no es cierto para todas las expresiones. Por ejemplo, esta expresión
obtiene un resultado diferente dependiendo de si se realiza primero la suma o la
división:
x + y / 100
Puedes decirle directamente al compilador de Java cómo quieres que se evalúe una
expresión utilizando los paréntesis ( y ). Por ejemplo, para aclarar la sentencia
anterior, se podría escribir: (x + y)/ 100.
Si no le dices explícitamente al compilador el orden en el que quieres que se
realicen las operaciones, él decide basándose en la precedencia asignada a los
operadores y otros elementos que se utilizan dentro de una expresión.
Los operadores con una precedencia más alta se evalúan primero. Por ejemplo. el
operador división tiene una precedencia mayor que el operador suma, por eso, en
la expresión anterior x + y / 100, el compilador evaluará primero y / 100. Así
x + y / 100
es equivalente a:
x + (y / 100)
Para hacer que tu código sea más fácil de leer y de mantener deberías explicar e
indicar con parétesis los operadores que se deben evaluar primero.
La tabla siguiente muestra la precedencia asignada a los operadores de Java. Los
operadores se han listado por orden de precedencia de mayor a menor. Los
operadores con mayor precedencia se evalúan antes que los operadores con un
precedencia relativamente menor. Lo operadores con la misma precedencia se
evalúan de izquierda a derecha.
Precedencia de Operadores en Java
operadores sufijo [] . (params) expr++ expr--
operadores unarios ++expr --expr +expr -expr ~ !
creación o tipo new (type)expr
multiplicadores * / %
suma/resta + -
desplazamiento << >> >>>
relacionales < > <= >= instanceof
igualdad == !=
bitwise AND &
bitwise exclusive OR ^
bitwise inclusive OR |
AND lógico &&
OR lógico ||
condicional ? :
asignación = += -= *= /= %= ^= &= |= <<=
>>= >>>=

Leer más...