Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Programacion Java POO
Programacion Java POO
.
=== Introducción a la Programación
.
=== Orientada a Objetos con Java
.
.
v
3. Fundamentos de la Programación Orientada a Objetos con Java 49
3.1. Clases y objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
3.1.1. Instanciación de clases . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
3.1.2. Destrucción de objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
3.2. Métodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
3.2.1. Constructores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
3.2.2. Ocultación de atributos . . . . . . . . . . . . . . . . . . . . . . . . . . 57
3.2.3. Sobrecarga de métodos . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
3.2.4. Objetos como argumentos de un método . . . . . . . . . . . . . . . . . 59
3.2.5. Devolución de objetos desde un método . . . . . . . . . . . . . . . . . 61
3.3. Miembros de instancia y de clase . . . . . . . . . . . . . . . . . . . . . . . . . 62
3.4. Encapsulación de código . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
3.4.1. Modificadores de acceso . . . . . . . . . . . . . . . . . . . . . . . . . . 68
3.5. Clases anidadas y clases internas . . . . . . . . . . . . . . . . . . . . . . . . . 70
3.6. La clase String . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
3.7. Paquetes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
3.7.1. La variable de entorno CLASSPATH . . . . . . . . . . . . . . . . . . . . 74
3.8. Paso de argumentos al programa . . . . . . . . . . . . . . . . . . . . . . . . . 74
3.9. Ejercicios resueltos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
3.10. Ejercicios propuestos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
4. Herencia y Polimorfismo 81
4.1. Herencia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
4.1.1. Conceptos básicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
4.1.2. Uso de la palabra reservada super . . . . . . . . . . . . . . . . . . . . 84
4.1.3. Constructores y herencia . . . . . . . . . . . . . . . . . . . . . . . . . . 85
4.1.4. Modificadores de acceso . . . . . . . . . . . . . . . . . . . . . . . . . . 89
4.1.5. La clase Object . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
4.2. Polimorfismo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
4.2.1. Sobreescritura de métodos . . . . . . . . . . . . . . . . . . . . . . . . . 90
4.2.2. Tipo estático y tipo dinámico . . . . . . . . . . . . . . . . . . . . . . . 93
4.2.3. La conversión hacia arriba . . . . . . . . . . . . . . . . . . . . . . . . . 93
4.2.4. Enlace dinámico y polimorfismo . . . . . . . . . . . . . . . . . . . . . 97
4.2.5. Clases abstractas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
4.2.6. La conversión hacia abajo: instanceof . . . . . . . . . . . . . . . . . 103
4.2.7. Sobreescribiendo la clase Object . . . . . . . . . . . . . . . . . . . . . 105
4.3. Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
4.3.1. El problema de la herencia múltiple . . . . . . . . . . . . . . . . . . . 107
4.3.2. Declaración e implementación de interfaces . . . . . . . . . . . . . . . 108
4.3.3. Implementación de polimorfismo mediante interfaces . . . . . . . . . . 111
4.3.4. Definición de constantes . . . . . . . . . . . . . . . . . . . . . . . . . . 115
4.3.5. Herencia en las interfaces . . . . . . . . . . . . . . . . . . . . . . . . . 115
4.4. Ejercicios resueltos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
4.4.1. Enunciados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
4.4.2. Soluciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
4.5. Ejercicios propuestos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
vi
5. Manejo de excepciones 123
5.1. Introducción a las excepciones . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
5.2. Captura de excepciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
5.2.1. La sentencia try-catch . . . . . . . . . . . . . . . . . . . . . . . . . . 125
5.2.2. Refinando la captura de excepciones . . . . . . . . . . . . . . . . . . . 127
5.2.3. Capturando más de una excepción . . . . . . . . . . . . . . . . . . . . 128
5.2.4. try-catch anidados . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
5.2.5. La sentencia finally . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
5.2.6. La forma general de try-catch . . . . . . . . . . . . . . . . . . . . . . 130
5.2.7. Excepciones no capturadas . . . . . . . . . . . . . . . . . . . . . . . . 131
5.3. La clase Throwable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
5.3.1. El método getMessage . . . . . . . . . . . . . . . . . . . . . . . . . . 133
5.3.2. El método printStackTrace . . . . . . . . . . . . . . . . . . . . . . . 133
5.4. Captura vs. propagación de excepciones: la sentencia throws . . . . . . . . . 134
5.4.1. Otra forma de propagar excepciones: la sentencia throw . . . . . . . . 135
5.4.2. Sentencias throw y bloques finally . . . . . . . . . . . . . . . . . . . 137
5.5. Lanzando nuevas excepciones . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
5.5.1. Lanzando excepciones de tipos existentes . . . . . . . . . . . . . . . . 138
5.5.2. Lanzando excepciones de nuevos tipos . . . . . . . . . . . . . . . . . . 139
5.6. Cuestiones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
5.7. Ejercicios resueltos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
5.8. Ejercicios propuestos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
vii
Capı́tulo 1
Introducción a la Programación
Orientada a Objetos
1.1. Introducción
Antes de empezar a desarrollar las caracterı́sticas propias de la programación orientada a
objeto, conviene hacer una revisión de alto nivel de la programación, sus fases y sus diferentes
métodos.
En el proceso de desarrollo de un sistema de información (un programa, software, en
general) hay una serie de etapas o fases en las que la programación como tal es una de ellas,
ni tan siquiera la más importante. Hay diferentes modelos de desarrollo en los que se definen
esas fases o etapas antes comentadas; uno de ellos es el método en cascada (waterfall ) que
nos servirá como guı́a en el desarrollo de estas ideas.
Según este modelo, a grandes rasgos, el desarrollo software consta de las siguientes fases:
Análisis: Esta es una de las fases más importantes puesto que se trata de definir y
analizar el problema en su totalidad. En general, se trata de entender el enunciado
del problema. Evidentemente, para una resolución correcta (eficaz y eficiente) de un
problema lo mejor es conocerlo.
Diseño: Junto con la anterior, la más importante y consiste en, dado el análisis ante-
rior, diseñar una solución del problema. Se tratarı́a de definir los módulos, patrones,
algoritmos, etc. que nos ayudaran a su solución. Entre esta fase y la anterior, se deberı́a
consumir un 70-80 % del tiempo del proyecto.
1
2 Capı́tulo 1. Introducción a la Programación Orientada a Objetos
Un lenguaje orientado a objetos ataca estos problemas. Tiene tres caracterı́sticas básicas:
debe estar basado en objetos, basado en clases y capaz de tener herencia de clases. Muchos
lenguajes cumplen uno o dos de estos puntos; muchos menos cumplen los tres. La barrera
1.3. Los objetos 3
En primer lugar, un objeto no es un dato simple, sino que contiene en su interior cierto
número de componentes bien estructurados.
En segundo lugar, cada objeto no es un ente aislado, sino que forma parte de una
organización jerárquica o de otro tipo.
Para ilustrar mejor las diferencias entre la programación procedural clásica y la POO
vamos a plantear, de forma intuitiva, un pequeño ejemplo escrito en C y después planteado en
Java. Se trata de tener en un array una serie de figuras geométricas que tendrán lógicamente
los subprogramas encargados de leer los datos, dibujarlos, etc...
La estructura de datos en C podrı́a ser:
struct Figura {
int Tipo; // 1.-hex 2.-rect
int Color;
int Borde;
float x, y, z, t, w;
}
En el caso de que quisiéramos dibujar todas las figuras que aparecen en el array harı́amos
algo parecido a esto:
En general, tendremos para cada figura sus correspondientes funciones que se encarguen
de leer las coordenadas, de dibujarlos por pantalla, etc. ¿Qué ocurre si quiero añadir una
nueva figura geométrica? Tendremos que modificar el programa añadiendo el tipo corre-
spondiente y los subprogramas necesarios para manejarlos, además es más que probable que
tengamos que revisar la mayor parte del código para actualizarlo a la nueva situación. Esta
tarea será más o menos dificultosa en función de lo ordenado que se haya sido al crear el
código.
Si resolviéramos este mismo problema de forma OO la solución a la hora de añadir una
nueva figura geométrica no serı́a tan aparatosa. En primer lugar definirı́amos un nuevo tipo de
figura, por ejemplo, para representar los nuevos objetos “Cı́rculos” que tendrán sus atributos
propios (en este caso, por ejemplo, el punto que define el centro y el radio del cı́rculo) y sus
métodos, como por ejemplo LeerCoordenadas y Dibujar. De forma que el for anterior se
podrı́a reescribir de esta forma:
Como vemos, el hecho de añadir un nuevo tipo de objeto no implica ninguna modificación
en la estructura. Lógicamente implicará añadir la nueva figura al código, pero si se ha sido
cuidadoso a la hora de encapsular los datos propios (atributos) y los subprogramas encargados
de manejarlos (métodos) será bastante más sencillo mantener y trabajar con el código. En
la figura 1.1 se muestra un esquema de cómo se ven los objetos desde el punto de vista que
acabamos de plantear.
Usando como ejemplo el caso de un objeto cı́rculo tendremos que, desde un punto de
vista estructural, está compuesto de:
Atributos: como podrı́an ser las coordenadas que definen el centro del cı́rculo y el radio.
Métodos: por ejemplo, el que nos permite leer o modificar los valores de estos atributos,
dibujarlo o bien calcular su circunferencia o su área.
Son conceptos fundamentales en este paradigma la idea de encapsulación, en cuanto a
que atributos y métodos forman el objeto como una única unidad y el de ocultación de
información en cuanto que los atributos deben estar lo más ocultos posibles al exterior y sólo
ser manipulados o consultados a través de los métodos pertinentes que son los que conforman
la interfaz del objeto.
Metodos
:
:
Integer AñosEmpresa();
:
:
Integer Edad();
:
:
Real Sueldo(Real Extras);
:
:
}
6 Capı́tulo 1. Introducción a la Programación Orientada a Objetos
Todos los objetos son instancias de una clase, es decir, ejemplares o ejemplos concretos
de la clase. Como vemos, la clase lo define todo, es una entidad autocontenida en cuanto que
contiene todo lo necesario para definir la estructura o los datos (atributos) que cada objeto
tendrá y la manera de manejarse esos objetos a través de los métodos.
Dada la clase anterior, podremos crear (ya veremos cómo) los empleados (objetos, in-
stancias de la clase, ejemplares, etc..) que necesite de los que tendré una referencia, es decir,
una variable que apunte a ese empleado. Ası́ podré tener la referencia emp1 que coincide con
el empleado con DNI 00001, con NRP 2345, de nombre José Garcı́a, etc... Si quiero obtener
el sueldo de este empleado tendré que invocar al método correspondiente en el objeto que lo
representa a través de la referencia de la siguiente forma:
emp1.Sueldo(136000);
Esta invocación tendrá como contrapartida la ejecución del método Sueldo en el objeto
especificado y no en otro.
Recordando lo comentado en el apartado anterior, y siendo más formales en la definición,
cada clase posee una doble componente:
Una componente estática, los datos, que son campos con nombres, que poseen ciertos
valores. Estos campos caracterizan el estado del objeto. A los campos les llamaremos
usualmente atributos.
Una componente dinámica, los procedimientos o funciones, llamados métodos, que
representan el comportamiento común de los objetos que pertenecen a la misma clase.
Los métodos son los encargados de manipular los campos de los objetos (además, es
una práctica muy mala el modificar atributos de forma directa: rompe la encapsulación
y la ocultación de la información) y caracterizan las acciones que se pueden realizar
sobre los mismos. Esta componente dinámica forma la llamada interfaz de la clase, y
suministra la única forma de acceso a los objetos. Para efectuar una operación asociada
con un objeto se debe mencionar el objeto implicado, que llamaremos el receptor del
mensaje, el método a activar, y los argumentos sobre los que se aplica.
En cuanto a los métodos conviene comentar que no todos tienen por qué ser accesibles
desde el exterior a cualquier usuario; puede que existan métodos que sólo sean visibles para
un grupo concreto de clases o sólo para la clase en la que se definen. Una visión sencilla de
un objeto es la combinación de estado y comportamiento. El estado se describe mediante los
atributos, en tanto que el comportamiento se caracteriza por los métodos.
que se crea un objeto de la clase asociada. Veamos un ejemplo de una clase que representa
números complejos escrito esta vez ya en Java y no en pseudo-código:
class Complejo {
Complejo () {
real = 0;
imag = 0;
}
int real () {
return (real);
}
int imag () {
return (imag);
}
}
En primer lugar nos fijamos en que hemos construido métodos para acceder a los atributos
de la clase. Éstos los hemos declarado privados para enfatizar que sólo deben poder ser
accedidos desde fuera de la clase a través de los métodos que creemos a tal fin. Si quisiéramos
hacer uso de un número complejo, deberı́amos tener una porción de código similar a la
siguiente:
Complejo c;
...
c = new Complejo(34, 4);
Con lo que se crearı́a un objeto de tipo Complejo con los valores 34 y 4 para la parte real
e imaginaria, respectivamente. Una instancia es un objeto particular, que se crea respetando
los planes de construcción dados por la clase a la que pertenece. Todas las instancias de
una misma clase tienen los mismos atributos con los valores que le corresponda. Todas las
instancias poseen los mismos métodos, sólo que al invocarlos, sólo se ejecuta el del objeto de
esa clase al que se le invoca.
Aunque todas las instancias de la misma clase posean los mismos atributos, éstos pueden
contener valores diferentes correspondientes a la naturaleza particular de cada instancia. La
lista de atributos es retenida por la clase, mientras que las instancias poseen los valores de
esos campos.
El mecanismo de constructores se hace considerablemente más poderoso cuando se com-
bina con la capacidad de sobrecargar funciones (aunque como veremos, esta cualidad no
es exclusiva de los constructores). Se dice que una función está sobrecargada cuando hay
dos o más cuerpos de función conocidos por el mismo nombre. Se rompe la ambigüedad
de las funciones sobrecargadas por las listas de parámetros. En nuestro caso, el constructor
está sobrecargado, de forma que si escribimos
8 Capı́tulo 1. Introducción a la Programación Orientada a Objetos
Complejo d;
...
d = new Complejo();
Se creará un número Complejo en el que tanto la parte real como la imaginaria valen
0. El hecho de elegir uno de los dos métodos se realiza en función de los parámetros. En la
figura 1.2 se muestra esta situación esquemáticamente.
Veamos cómo usarı́amos la clase anteriormente presentada con alguna instrucción más.
Algunas de las instrucciones que aparecen no las hemos explicado todavı́a pero no influyen
en el objetivo del ejemplo:
Fı́sicamente, los atributos de una instancia se pueden considerar como variables (en al-
gunos casos aparecen como variables de instancia); cada vez que el valor de un campo es
modificado el nuevo valor se sustituye en la correspondiente instancia. Cada instancia ten-
drá su colección independiente de variables que sólo se podrán modificar usando los métodos
dispuestos para ello (si se han declarado como privadas).
Existen otro tipo de atributos llamados atributos de clase (también llamados variables
de clase) que se utilizan para definir campos que tienen un valor que es común a todas las
instancias de una misma clase (en Java son los atributos estáticos). El valor de un atributo
de clase reside en la propia clase y es compartido por todos los objetos de la citada clase.
Esta visión de objeto que acabamos de comentar tiene un término asociado de uso muy
común en los diferentes paradigmas de programación que es la encapsulación.
El comportamiento general de un programa orientado a objeto se estructura en términos
de responsabilidades. Es decir, se invocan métodos en objetos que tienen la responsabilidad
de responder mediante la ejecución de los mismos.
Cuando en el ejemplo anterior escribı́amos c1.imag() estábamos invocando el método
imag() al objeto de tipo Complejo de referencia c1 que provocaba la ejecución del método
imag() definido en el mismo. Volvemos aquı́ al principio de ocultación de información en
1.6. Herencia 9
cuanto a que el cliente que envı́a la petición no necesita conocer el medio real con el que ésta
será atendida.
1.6. Herencia
Supongamos que estamos diseñando un programa orientado a objetos y nos damos cuenta
de que aparece una Clase B que es idéntica a una Clase A excepto que tiene unos atributos
y métodos más que ésta. Una manera muy sencilla y poco OO de solucionar la situación
serı́a simplemente copiar el código de la Clase A en la Clase B y añadir las lı́neas de código
propias de esta clase. El mecanismo ideal, sin embargo, es el concepto de herencia. En todo
caso, serı́a un error pensar que el principal uso de la herencia es evitarnos escribir código,
como veremos en el tema correspondiente, la herencia tiene que ver con la relación entre
tipos de datos.
Una vez aceptada la filosofı́a básica de diseño OO, el siguiente paso para aprender a
programar de forma OO implica adquirir conocimientos sobre cómo usar con efectividad
clases organizadas bajo una estructura jerárquica basada en el concepto de herencia. Por
herencia nos referimos a la propiedad por la que los ejemplares de una clase hija (subclase)
pueden tener acceso tanto a los datos como al comportamiento (métodos) asociados con una
clase paterna (superclase).
La herencia significa que el comportamiento y los datos asociados con las clases hijas son
siempre una extensión de las propiedades asociadas con las clases paternas. Una subclase
debe reunir todas las propiedades de la clase paterna y otras más. Esquemáticamente, la
herencia la podemos representar como se muestra en la figura 1.3.
¿Qué beneficios nos aporta el uso de la herencia? Entre los muchos beneficios que se
otorgan al uso de la herencia, los dos más relevantes en el punto en el que nos encontramos
son:
más fácil garantizar que las interfaces para objetos similares sean en efecto similares y
difieran lo menos posible.
Al principio es normal tener cierta inseguridad a la hora de reconocer las clases en nuestros
sistemas y también el reconocer cuando una clase debe ser una subclase de otra. La regla más
importante es que, para que una clase se relacione con otra por medio de la herencia, debe
haber una relación de funcionalidad entre ambas. Al decir que una clase es una superclase
de una subclase, estamos diciendo que la funcionalidad y los datos asociados con la clase
hija (subclase) forman un superconjunto de la funcionalidad y los datos de la clase paterna
(superclase).
El principio que dice que el conocimiento de una categorı́a más general es aplicable
también a la categorı́a más especı́fica se llama herencia. Por ejemplo, un estudiante se puede
ver como una clase cuya categorı́a más general (superclase) es la clase Humano que a su
vez tiene otra categorı́a más general (otra superclase) que son los mamı́feros, formando una
organización del conocimiento en forma de árbol, encontrándose en las hojas las instancias
de las clases. Por ejemplo podemos encontrarnos con una estructura jerárquica como la
mostrada en la figura 1.4 de una representación de una realidad.
Dentro de este marco general hay lugar para variaciones en la forma en la que hacer uso
de la herencia, la más habitual es la siguiente:
Especialización: Es el uso más común de la herencia. Si se consideran dos conceptos
abstractos A y B, y tiene sentido el enunciado “A es un B”, entonces es probablemente
correcto hacer a A subclase de B. Por ejemplo, “un perro es un mamı́fero”. Por otra parte,
si tiene más sentido decir “A tiene un B” entonces quizá sea mejor hacer que los objetos de
la clase B sean atributos de la clase A. Por ejemplo, “un número complejo tiene una parte
imaginaria”.
Por otro lado, existen dos enfoques alternativos en cuanto a cómo deben estructurarse
las clases como un todo en los lenguajes OO. Un enfoque sostiene que todas las clases deben
estar contenidas en una sola gran estructura de herencia (Smalltalk, Objetive-C, Java). La
1.7. Evolución histórica y diferencias entre la programación clásica y la POO 11
ventaja de este enfoque es que la funcionalidad proporcionada en la raı́z del árbol (clase
Object) es heredada por todos los objetos. El otro enfoque sostiene que las clases que no
están lógicamente relacionadas deben ser por completo distintas (C++ y Object Pascal ).
struct reg {
int px;
struct reg *seg;
};
if (*l == NULL)
inscab(&(*l),i); // si está vacio se usa el insertar en cabeza
else {
p = (struct reg *) malloc(sizeof(struct reg)) ;
p -> seg = (*l)->seg;
p -> px = i ;
(*l)-> seg = p ;
}
return;
}
Como estamos en un lenguaje procedural clásico, hemos tenido que definir por un lado
la estructura de datos que define un nodo y por otro los procedimientos que sirven para
trabajar con él. Se cumple la regla de estructuras de datos + algoritmos = programas.
En el caso de Java tendrı́amos que identificar los objetos de nuestro sistema, en este caso
solo uno: el nodo.
class Nodo {
int info;
Nodo prox;
Nodo (int i) {
Info = i;
prox = null;
}
e.prox = prox;
prox = e;
}
}
La diferencia podemos intuirla claramente con el ejemplo. En este caso, un nodo es una
unidad auto-contenida en la que se define la estructura del nodo y las operaciones necesarias
para trabajar con él.
A efectos de potenciar la idea de encapsulación y ocultación de la información se deberı́a
acceder a los atributos sólo a través de los métodos que se dispongan para ello. Para forzar
esta situación, lo habitual es haber hecho que los atributos fueran privados a la clase:
class Nodo {
private int info;
private Nodo prox;
Nodo (int i) {
info = i;
prox = null;
}
Nodo prox() {
return prox;
}
Int info() {
return info;
}
Desde un punto de vista histórico, la idea de la POO aparece por primera vez en SmallTalk
(a principios de los 70), pero conceptos similares a los que se usan en la POO ya aparecı́an
en Simula (1967). De cualquier forma se considera que Smalltalk fue el primer lenguaje
orientado a objetos:
Es uno de los lenguajes orientados a objetos más consistentes: todos sus tipos de datos
son clases y todas sus operaciones son mensajes.
A mediados de los 80 aparecen lenguajes hı́bridos como son el C++, Objetive-C, Object-
Pascal entre otros:
Existen muchas diferencias entre la programación convencional y la POO, aunque las más
evidentes, es decir, las sintácticas son las menos importantes y en cambio, las diferencias más
importantes son las menos evidentes. Nos vamos a centrar en este apartado en las menos
evidentes, aunque a lo largo del curso vamos a intentar que se detecten con mayor claridad:
Sin embargo, los beneficios vienen pagando una serie de costes, muchos de los cuales
hacen que la POO no sea efectiva para muchas empresas y que siga estando relegada a la
solución de problemas menores, aunque dı́a a dı́a va tomando mayor relevancia:
2.1. Introducción
En este tema describiremos las caracterı́sticas principales del lenguaje Java. En la sección
2.2, se trata la portabilidad de Java, uno de los principales motivos del éxito que ha tenido
este lenguaje.
En las secciones siguientes, se tratan los fundamentos para escribir programas en Java:
15
16 Capı́tulo 2. Introducción al lenguaje Java
La JVM más el conjunto de clases necesarias para ejecutar los programas constituyen
el entorno de ejecución de Java, o JRE (Java Runtime Environment). Para ejecutar código
Java es suficiente con instalar el JRE. Si, además, se quiere escribir y compilar código fuente,
se necesita el kit de desarrollo de Java, o SDK (Software Development Kit), que incluye el
JRE.
En la figura 2.1 se muestra la jerarquı́a (simplificada) del software que constituye la
plataforma Java 2. Se aprecia que la Java Virtual Machine es el nivel inmediato superior
a los sistemas operativos, que el entorno JRE incluye la JVM y además todas las librerı́as
estándar de Java (API’s), y que el kit SDK incluye las herramientas de desarrollo.
Los programas o utilidades principales del SDK son las siguientes:
Estos programas se pueden ejecutar desde la lı́nea de comandos del sistema operativo.
Por ejemplo, si se ha escrito un programa en Java y el fichero que lo contiene se llama
MiPrograma.java, se puede compilar mediante:
javac MiPrograma.java
java MiPrograma
2.3. Cuestiones sintácticas 17
2.3.1. Indentación
Para separar las instrucciones del código fuente (por razones de legibilidad) se pueden
usar espacios en blanco, tabuladores y saltos de lı́nea.
Además, como en cualquier lenguaje de programación, se recomienda sangrar o indentar
las lı́neas para facilitar la lectura del código e identificar rápidamente donde empiezan y
terminan los bloques de código (las estructuras condicionales o iterativas que incluyan un
cierto número de instrucciones o, a su vez, otros bloques de código).
El compilador no necesita que el código contenga estas separaciones, pero su uso es
imprescindible para que el código sea comprensible para los programadores que lo lean.
2.3.2. Comentarios
Los comentarios en el código fuente son lı́neas que el compilador ignora y, por tanto,
el programador puede escribir en el lenguaje que prefiera, que suele ser su propio lenguaje
natural, por ejemplo, español, inglés, etc.
El texto incluido en los comentarios pretende facilitar la comprensión del código fuente
a otros programadores (o a su mismo autor, tiempo después de haber terminado el desar-
rollo del programa). Se trata, pues, de explicaciones o aclaraciones a su funcionamiento y
constituyen una documentación del programa.
Al igual que otros lenguajes, Java dispone de indicadores de comentario de una sola lı́nea
y de múltiples lı́neas:
Comentarios de una lı́nea. Si es de lı́nea completa, ésta debe iniciarse con //. Si sólo
parte de la lı́nea es comentario, el separador // delimitará la frontera entre lo que es
código a compilar (a la izquierda del separador) y lo que es comentario (a la derecha
del separador y hasta el final de la lı́nea).
Comentarios de varias lı́neas. Deben escribirse dentro de los separadores /* (para mar-
car el inicio) y */ (para marcar el final del comentario).
Java, además, proporciona un tercer tipo de comentario, similar al segundo (/* . . . */),
que se denomina comentario de documentación (/** . . . */). Java dispone de una herramienta
de documentación, javadoc, que extrae este tipo de comentarios para generar automática-
mente documentación de referencia de los programas. Se puede obtener toda la información
relativa a esta herramienta en la siguiente página web: http://java.sun.com/j2se/javadoc.
2.3.3. Identificadores
Al escribir código fuente, los programadores tienen que dar nombres a diferentes elementos
del programa: variables, constantes, objetos, métodos. . . Para ello se usan identificadores.
En Java, los identificadores se forman con letras mayúsculas y minúsculas (Java las
distingue), dı́gitos y también los caracteres dólar y guión bajo, $ . Un identificador válido
debe comenzar siempre con una letra, y no puede coincidir con una palabra reservada del
lenguaje.
2.3.4. Separadores
En los lenguajes de programación existen caracteres separadores del código, como los
paréntesis o las llaves, con funciones bien definidas.
En la tabla 2.1 se enumeran los separadores de Java y para qué se usan. Si se ha pro-
gramado en otros lenguajes, como C, la mayorı́a de estos usos serán conocidos. Sin embargo,
algunos usos de los separadores no se comprenderán en este momento. Ya se irán viendo a
lo largo de este tema y los siguientes.
{} llaves
• Delimitar bloques de código (en las estructuras condi-
cionales, en las iterativas, y en los métodos completos).
• Dar valores iniciales a variables de tipo vector.
[] corchetes
• Declaración de vectores.
• Referencias a los elementos de los vectores.
; punto y coma
• Separador de instrucciones.
, coma
• Separar identificadores (por ejemplo, en una declaración
de variables de un mismo tipo, o en una asignación de
valores a un vector).
• Separar los argumentos formales y actuales de los méto-
dos.
. punto
• Separador de paquetes, subpaquetes y clases.
Si el fichero contiene sólo una clase, su nombre debe dar nombre al fichero y, cuando
se compile, se generará un fichero con el mismo nombre y con la extensión class (en
este caso, HolaMundo.class).
Si el fichero contiene varias clases, una de ellas contendrá el programa principal main
(que es una función o método dentro de esa clase) y su nombre será el nombre del
fichero. Cuando se compile un fichero java con varias clases, se generarán varios ficheros
class, uno por cada una de las clases existentes en el fichero java.
La estructura del programa principal (método main) del ejemplo puede servirnos para co-
mentar algunos aspectos de sintaxis generales para cualquier método escrito en Java:
Presencia de calificadores antes del nombre del método (en el ejemplo, aparecen tres
palabras reservadas: public, static y void).Veremos el significado de estas palabras a
lo largo del texto. Sólo anticiparemos que cuando el método no devuelve nada (como
sucede aquı́), se indica mediante la palabra reservada void.
2.4. Estructura básica de un programa en Java 21
Esta instrucción es una llamada al método println. Este método permite mostrar en
la consola los datos que se le pasen como argumento. En este caso, la cadena de texto
“Hola Mundo”.
En este ejemplo, el programa principal crea una ventana y muestra ahı́ un mensaje de
saludo. En la figura 2.3 se muestra una captura de pantalla donde se aprecia la ventana de
edición del código fuente, y (superpuesta, a la derecha) la ventana generada al ejecutar el
programa.
El programa principal contiene cuatro instrucciones, que realizan las siguientes cuatro
acciones:
Se crea un objeto (de la clase Frame), llamado ventana, con lo que se crea la ventana
de la aplicación gráfica.
Se crea un objeto (de la clase TextArea), llamado texto, y con el valor “Hola Mundo”.
Se añade el texto a la ventana.
Se activa la visibilidad de la ventana.
En las clases de estas aplicaciones gráficas se incluirá todo el código necesario para que
las ventanas contengan todos los elementos (menús, paneles gráficos, etc.) que se desee.
2.4.3. Applet
Un applet es un caso particular de aplicación gráfica de Java, pero que se ejecuta integrada
en una página web (y es gestionado por el navegador web), en lugar de ejecutarse como
aplicación independiente.
Para ilustrar la estructura básica de un applet, consideraremos el siguiente sencillo ejem-
plo:
}
}
int contador;
double dato, resultado;
Los objetos no suelen almacenar un solo dato simple, sino varios ı́tems de información
(que llamamos atributos).
Los objetos disponen además de una serie de funciones (que llamamos métodos) para
manipular la información que almacenan.
2.5. Tipos de datos 25
Los objetos de cualquier clase se declaran de manera similar a las variables de tipos
simples. Por ejemplo, si en un programa se necesitan tres objetos, uno de la clase Date
que llamaremos ayer y dos de la clase String y de nombres unaPalabra y otraPalabra, se
pueden declarar mediante:
Date ayer;
String unaPalabra, otraPalabra;
Sin embargo, y a diferencia de las variables de tipo simple, los objetos han de ser in-
stanciados (es decir, debe reservarse explı́citamente la memoria necesaria para guardar la
información que contienen).
Los objetos se instancian mediante el operador new y la invocación de un método especial
de la clase llamado constructor (método que tiene el mismo nombre de la clase). Por ejemplo,
con la siguiente instrucción se construirı́a un objeto llamado hoy de la clase Date:
Las constantes (también llamadas variables finales) se declaran de forma parecida, pero
indicando que son constantes mediante la palabra reservada final, y asignándoles valores.
Por ejemplo:
Tanto para definir las constantes como para asignar valores a las variables, se debe tener
en cuenta las formas válidas de especificar sus valores, según su tipo de dato. La tabla 2.4
resume las normas y muestra ejemplos para los tipos simples y para la clase String.
26 Capı́tulo 2. Introducción al lenguaje Java
Este código contiene un error. Se han definido dos ámbitos, y un ámbito está anidado en
el otro. La variable x1 se ha declarado en el ámbito externo y existe también en el ámbito
interno (que es parte del ámbito externo). En cambio, la variable x2 se ha declarado en
el ámbito interno y deja de existir cuando la ejecución abandone ese ámbito. Por ello, la
asignación a dicha variable fuera de su ámbito genera un error de compilación.
2.5.4. Operadores
Java proporciona los operadores básicos para manipular datos de los tipos simples. Ası́, se
dispone de operadores aritméticos, operadores de bits, operadores relacionales, operadores
lógicos (booleanos) y un operador ternario. En esta sección se enumeran y describen los
mismos.
Operadores aritméticos
Para datos de tipo entero y de tipo real, se dispone de operadores aritméticos de suma,
resta, multiplicación, división y módulo (obtener el resto de la división entera). De todos
ellos, existe una versión reducida, donde se combina el operador aritmético y la asignación,
que se puede usar cuando el resultado de la operación se almacena en uno de los operandos.
Por último, existen los operadores de autoincremento y autodecremento para sumar y restar
una unidad.
En la tabla 2.5 se muestran todos los operadores aritméticos.
El siguiente bloque de código ilustra el uso de los operadores aritméticos. En los co-
mentarios de lı́nea se ha indicado el valor de la variable modificada después de ejecutar la
instrucción de cada lı́nea.
{
int i=2, j, k;
j = i * 3; // resultado: j = 2*3 = 6
i++; // resultado: i = 2+1 = 3
j *= i; // resultado: j = 6*3 = 18
k = j \% i; // resultado: k = 18\%3 = 0
i++; // resultado: i = 3+1 = 4
j /= i; // resultado: j = 18/4 = 4
double x=3.5, y, z;
y = x + 4.2; // resultado: y = 3.5+4.2 = 7.7
x--; // resultado: x = 3.5-1.0 = 2.5
z = y / x; // resultado: z = 7.7/2.5 = 3.08
}
operación operador
operandos iguales ==
operandos distintos !=
1er operando mayor que 2o operando >
1er operando menor que 2o operando <
1er operando mayor o igual que 2o operando >=
1er operando menor o igual que 2o operando <=
con signo o sin signo. También existe la posibilidad de combinar las operaciones bit a bit y
la asignación (operadores reducidos).
En la tabla 2.6 se muestran los operadores a nivel de bit.
El siguiente bloque de código ilustra el uso de los operadores bit a bit. En los comen-
tarios de lı́nea se ha indicado el valor de cada variable, en binario, después de ejecutarse la
instrucción de cada lı́nea.
{
int a = 18, b = 14, c; // a = 10010 , b = 1110
c = a & b; // c = 10
c = a | b; // c = 11110
c = a ˆ b; // c = 11100
c <<= 2; // c = 1110000
c >>= 3; // c = 1110
}
Operadores relacionales
En Java, como en otros lenguajes de programación, los operadores relacionales sirven
para comparar dos valores de variables de un mismo tipo y el resultado de la comparación
es un valor de tipo booleano.
En la tabla 2.7 se muestran los operadores relacionales.
Considérese el siguiente bloque de código como ejemplo del uso de los operadores rela-
cionales:
{
int a = 18, b = 14;
30 Capı́tulo 2. Introducción al lenguaje Java
Operadores lógicos
Los operadores lógicos (booleanos) proporcionan las habituales operaciones lógicas (ne-
gación, conjunción, disyunción. . . ) entre variables de tipo booleano o entre expresiones que
se evalúen a booleano (verdadero o falso).
En la tabla 2.8 se muestran los operadores lógicos. En la tabla 2.9 se muestran sus tablas
de verdad.
Todos los operadores lógicos son binarios, excepto la negación (que es unario, y se escribe
delante de la variable o expresión a negar).
En el caso de las operaciones AND y OR, existen dos versiones del operador:
Si se usan los sı́mbolos &, |, siempre se han de evaluar los dos operandos para determinar
el resultado de la operación.
Si se usan los sı́mbolos &&, ||, puede conocerse el resultado según el valor del primer
operando (y sin calcular o evaluar el segundo operando). En la tabla 2.10 se muestra el
comportamiento de estos operadores. Se ha indicado con “???” cuando no es necesario
evaluar el 2o operando de la expresión lógica.
2.5. Tipos de datos 31
a b a && b a b a || b
false ??? false false false false
true false false false true true
true true true true ??? true
a a ? b : c;
false c
true b
Operador ternario
El operador ternario ?: tiene la siguiente sintaxis:
a ? b : c;
Donde a es una expresión booleana, y b y c son valores o expresiones del mismo tipo. El
operador ternario devuelve un valor (y, por tanto, puede usarse en una asignación). El valor
devuelto será b si a se evalúa a verdadero, o será c si a se evalúa a falso, tal como indica la
tabla 2.11.
Considérese el siguiente bloque de código como ejemplo de su uso:
{
int a = 18, b = 14, c = 22, maximo;
maximo = a>b ? a : b; // maximo = 18
maximo = maximo>c ? maximo : c; // maximo = 22
}
{
int a = 18, b = 14, c = 22;
String s = "";
s = ( a>b && a>c ) ? "maximo = " +a : s+"";
s = ( b>a && b>c ) ? "maximo = " +b : s+"";
s = ( c>a && c>b ) ? "maximo = " +c : s+"";
System.out.println(s);
}
Este segundo ejemplo también calcula el mayor valor de tres variables enteras y el resul-
tado lo muestra mediante un mensaje en la consola.
32 Capı́tulo 2. Introducción al lenguaje Java
En esta ocasión, el resultado del operador ternario es una cadena de caracteres, que se
almacena en el objeto s de la clase String. Cuando la expresión booleana del operador se
evalúa a falso, no se añade nada a s (puesto que s+""; es concatenar la cadena vacı́a). Pero
cuando se evalúa a verdadero, se asigna a s la cadena "maximo = "+c.
En cuanto a la evaluación de las expresiones booleanas, hay que indicar que:
Por tanto, usando el operador &&, se han evaluado sólo cinco de las seis comparaciones.
En cambio, si se hubiera usado el operador & se habrı́an evaluado todas las comparaciones.
En consecuencia, los operadores && y || pueden ser más eficientes que & y |, si el programador
elige con cuidado el orden de los componentes de una expresión booleana compleja. Además,
los operadores && y || proporcionan mayor seguridad frente a errores en ejecución.
{
int a;
byte b = 7;
a = b;
}
{
int a = 7, c = 5;
byte b;
b = (byte) (a + c);
}
El valor de la suma de las variables a y c es de tipo int, y se convierte a tipo byte antes
de asignarlo a la variable b. Si no se hiciera el casting del resultado (es decir, si la instrucción
fuera: b = a + c), el compilador genera el siguiente error:
2.5. Tipos de datos 33
{
char ch1 = ’a’;
char ch2 = (char) ((int)ch1 + 3);
System.out.println(""+ch2+ch1);
}
Al ejecutarse el código de este ejemplo, se asigna el valor ‘dá la variable ch2. Por ello,
mediante println, se escribe en la consola la cadena “da”.
Obsérvese la expresión que asigna valor a ch2. En el lenguaje C se podrı́a haber escrito
simplemente: ch2 = ch1 + 3; y la expresión se hubiera evaluado usando el código ASCII
de la letra ‘a’para obtener el de la letra ‘d’. En Java, sin embargo, el compilador rechaza esa
instrucción por incompatibilidad entre los tipos, y para llevarla a cabo son necesarias dos
operaciones explı́citas de conversión de tipos:
La conversión también se puede realizar con tipos no primitivos (clases). Este caso, que
tiene implicaciones de gran trascendencia en la programación orientada a objetos, se verá con
detalle en capı́tulos posteriores.
2.5.6. Vectores
Los vectores o arrays son estructuras de datos que almacenan un número fijo de elementos
de información, siendo estos elementos del mismo tipo (o de la misma clase, si se trata de
objetos).
Vectores unidimensionales
La declaración de vectores en Java tiene la siguiente sintaxis:
identificadorTipo [] nombreVector;
Donde:
identificadorTipo ha de ser el nombre de un tipo conocido.
nombreVector es el identificador o nombre que se le da al vector.
Los elementos del vector son del tipo identificadorTipo.
Los corchetes indican que se declara un vector, y no una variable de un solo elemento.
Por ejemplo, una declaración válida de un vector de enteros:
34 Capı́tulo 2. Introducción al lenguaje Java
int [] diasMeses;
Existe una segunda forma de declarar vectores. En esta alternativa, los corchetes se sitúan
después del nombre del vector: identificadorTipo nombreVector [];. Sin embargo, en este texto
no usaremos esta segunda forma, por homogeneidad del código.
Para usar variables vector son necesarias dos acciones: la declaración y la instanciación
de los vectores.
En la declaración de una variable vector simplemente se define una referencia, un nombre
para el vector, pero no se reserva espacio de almacenamiento para sus elementos y, por tanto,
no es obligatorio especificar su dimensión.
El tamaño del vector quedará fijado cuando se haga la instanciación de la variable, del
siguiente modo:
Donde:
También se puede declarar el vector con inicialización de sus valores, conforme a la sigu-
iente sintaxis:
int[] diasMeses = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
Vectores multidimensionales
Los vectores pueden tener varias dimensiones. La declaración de vectores o arrays multi-
dimensionales (matrices) se hace de modo similar al caso de los vectores de una dimensión.
Sólo hay que añadir un par de corchetes para cada dimensión que tenga la matriz o vector
multidimensional.
Por ejemplo, una declaración e instanciación válida de una matriz de enteros de tres filas
y tres columnas serı́a la siguiente:
Otra forma equivalente de declarar e instanciar la misma matriz, pero reservando memoria
independiente para cada fila, serı́a la siguiente:
Por último, la declaración de la matriz con inicialización de sus valores se harı́a del
siguiente modo:
Sentencia if
La estructura condicional más importante en Java (y en otros lenguajes) es la sentencia
if. La sintaxis de esta sentencia es la siguiente:
if ( condición ) sentencias1;
else sentencias2;
Donde:
{
int a = 18, b = 14, c = 22;
int maximo, minimo;
if ( a>b ) {
maximo = a;
minimo = b;
} else {
maximo = b;
minimo = a;
} // maximo = 18, minimo = 14
if ( maximo<c ) {
maximo = c;
} // maximo = 22, minimo = 14
if ( minimo>c ) {
minimo = c;
} // maximo = 22, minimo = 14
}
En este ejemplo, dados tres números enteros, se obtienen los valores máximo y mı́nimo.
Se indican, mediante comentarios al código, los valores obtenidos después de ejecutarse cada
sentencia if.
Se han utilizado tres sentencias condicionales:
Con la 2a sentencia if se determina el valor máximo (esta vez no hay cláusula else
porque no se necesita hacer nada si no se cumple la condición).
En Java, como en otros lenguajes, las sentencias if-else pueden concatenarse en una
secuencia de verificación de condiciones. Como ejemplo, considérese el siguiente código:
{
double nota = ... ; // llamar a un método que calcule la nota
// mostrar la palabra correspondiente al valor de la nota
if ( nota >= 9 ) System.out.println( "Sobresaliente" );
else if ( nota >= 7 ) System.out.println( "Notable" );
else if ( nota >= 5 ) System.out.println( "Aprobado" );
else System.out.println( "Suspenso" );
}
Sentencia switch
La sentencia de selección switch evalúa una expresión que devuelve un valor en función
del cual se selecciona un determinado bloque de instrucciones a ejecutar. La instrucción
switch tiene la siguiente sintaxis:
switch ( expresión ) {
case valor1: sentencias1; break;
case valor2: sentencias2; break;
...
case valorN: sentenciasN; break;
default: sentencias por defecto;
}
Donde:
Los valores de la lista {valor1, valor2, . . . , valorN} han de ser valores del mismo tipo
que el devuelto por la expresión evaluada.
Cada case señala un punto de entrada en el bloque de código de la sentencia switch.
Cada break señala un punto de salida en el bloque de código de la sentencia switch.
La cláusula default es opcional en la sentencia switch.
La expresión evaluada debe ser de un tipo simple enumerable (enteros, caracteres, booleanos).
No se permite usar números reales.
Si la expresión del switch devuelve:
Un cierto valor-i para el que existe un case, entonces se ejecuta su bloque de instruc-
ciones sentencias-i. Si el case termina con una sentencia break, sólo se ejecuta su bloque.
Pero si no hubiera break, se ejecutarı́an el bloque sentencias-(i+1) y siguientes, hasta
encontrar algún break o acabar el bloque del switch.
38 Capı́tulo 2. Introducción al lenguaje Java
{
int contadorA ... // declarar e inicializar contadores
char vocal = ... ; // llamar a un método que obtenga una vocal
// incrementar el contador correspondiente a la vocal obtenida
switch ( vocal ) {
case ’A’:
case ’a’: contadorA++; break;
case ’E’:
case ’e’: contadorE++; break;
case ’I’:
case ’i’: contadorI++; break;
case ’O’:
case ’o’: contadorO++; break;
case ’U’:
case ’u’: contadorU++; break;
default: contadorNoVocal++;
}
}
En este ejemplo, se actualizan los valores de unas variables enteras (llamadas contadorA,
contadorE, etc.) que llevan la cuenta de las vocales obtenidas mediante la ejecución de
algún método. Supondremos que la llamada al método, previa a la sentencia switch, devuelve
casi siempre vocales. Suponemos también que las variables enteras han sido correctamente
declaradas e inicializadas en otro bloque de código (antes de ejecutarse el código mostrado).
La sentencia switch del ejemplo evalúa una variable de tipo char, llamada vocal. Si la letra
es una vocal, se entra en el case correspondiente, incrementándose el contador apropiado.
Obsérvese que el contador de cada vocal se incrementa tanto si la letra está en mayúsculas
como en minúsculas. Para el caso de que la letra no sea vocal, se ha especificado un caso
default donde se actualizarı́a un contador, contadorNoVocal, que lleva la cuenta de los
caracteres que no sean vocales.
Hay que llamar la atención sobre la importancia de incluir la instrucción break al final
de cada bloque case. Si se omite algún break en el ejemplo anterior, los contadores no se
incrementan correctamente. Por ejemplo, si se omite el primer break, dejando el código de
la siguiente forma:
switch ( vocal ) {
case ’A’:
case ’a’: contadorA++;
case ’E’:
case ’e’: contadorE++; break;
case ’I’:
...
}
Sentencia while
La sintaxis de esta sentencia es la siguiente:
Donde:
La condición se evalúa antes de entrar en el bloque. Por tanto, puede darse el caso de que
el bloque no se ejecute ni una sola vez (cuando la condición sea falsa inicialmente). Cada vez
que condición sea verdadera, se ejecutará una iteración del bloque sentencias, y se volverá a
evaluar la condición.
Para que el bucle sea finito, ha de garantizarse que, en algún momento, la condición
dejará de cumplirse. Para ello, se debe incluir en el bloque sentencias alguna instrucción que
modifique alguna variable que forme parte de la condición a evaluar.
Como ejemplo de uso de la estructura while, considérese el siguiente bloque de código
que calcula las sumas de los números pares e impares almacenados en un vector de enteros:
{
int[] a = {3, 7, 12, 22, 9, 25, 18, 31, 21, 14, 45, 2};
int sumaPares = 0, sumaImpares = 0;
int i = 0;
while ( i < a.length ) {
if ( a[i] \% 2 == 0 ) sumaPares += a[i];
else sumaImpares += a[i];
i++;
}
System.out.println( "sumaPares = " + sumaPares);
System.out.println( "sumaImpares = " + sumaImpares);
}
El número de iteraciones del bucle while de este ejemplo se controla con la variable i.
Esta variable:
Se incrementa en una unidad (i++) al final de cada iteración (ası́ se accede a com-
ponentes sucesivas del vector, y también se actualiza adecuadamente el número de
repeticiones).
40 Capı́tulo 2. Introducción al lenguaje Java
Y se compara con la longitud del vector (i < a.length) de manera que el bucle con-
cluye cuando la variable se iguala a esa longitud, porque entonces ya se han procesado
todas las componentes del vector.
Otro ejemplo de estructura while se muestra en el siguiente método que comprueba si un
vector es capicúa:
// método capicúa
public static boolean capicua (int[] v) {
int i = 0;
int j = v.length-1;
while ( i<j && v[i]==v[j] ) {
i++;
j--;
}
return i>=j;
}
Sentencia do-while
Es una variante de la sentencia while. Tiene la siguiente sintaxis:
Sentencia for
Java, como otros lenguajes, proporciona también una sentencia de repetición llamada
for. Esta estructura tiene la siguiente sintaxis:
Donde se usa una variable que habitualmente permite fijar el número de iteraciones,
estableciendo:
El valor inicial de dicha variable (en la asignación llamada inicialización en el esquema).
La modificación de esa variable al final de cada iteración (en la expresión llamada
iteración).
El valor final de esa variable (en la expresión booleana llamada condición).
Para cada valor de la variable de control del bucle, desde su valor inicial hasta su valor
final, se ejecuta una iteración del bloque de sentencias.
La sentencia for es la recomendada cuando se conoce de antemano el número de iteraciones
del bucle. Esta situación es muy frecuente cuando se trabaja con vectores.
Considérese el siguiente bloque de código:
{
int[] v1 = { 16,22,31,41,65,16,77,89,19 };
int[] v2 = { 12,27,39,42,35,63,27,18,93 };
int[] v3 = new int[v1.length];
int[] v4 = new int[v1.length];
for ( int i=0; i<v1.length; i++ ) {
v3[i] = v1[i] + v2[i];
v4[i] = v1[i] - v2[i];
}
}
En este ejemplo, dados dos vectores, v1 y v2, se obtienen otros dos vectores: v3, vector
suma, componente a componente, de los anteriores; y v4, vector resta. La variable i del bucle
for recorre el rango [0..v1.length[. En consecuencia, dadas las sentencias dentro del bucle
for, todas las componentes de los vectores v1 y v2 se suman y restan, almacenándose en v3
y v4, respectivamente.
Véase otro ejemplo, esta vez con matrices (vectores bidimensionales):
42 Capı́tulo 2. Introducción al lenguaje Java
{
int[][] m1 = { {16,22,31}, {41,65,16}, {77,89,19} };
int[][] m2 = { {12,27,39}, {42,35,63}, {27,18,93} };
int[][] m3 = new int[m1.length][m1[0].length];
for (int i=0; i<m1.length; i++)
for (int j=0; j<m1[0].length; j++)
m3[i][j] = m1[i][j] + m2[i][j];
}
En este ejemplo, dadas dos matrices, m1 y m2, se obtiene m3, matriz suma. Para sumar
componente a componente las dos matrices, se requieren dos bucles for con anidamiento: el
bucle controlado por la variable j es interno a (está anidado en) el bucle controlado por la
variable i.
Sentencia return
La sentencia return permite devolver el resultado obtenido al ejecutarse un método
(como ya se ha visto en ejemplos anteriores). También puede situarse al final del programa
principal, puesto que el main es también un método.
En el código de un método pueden aparecer varias instrucciones return. Sin embargo, en
cada ejecución del método, sólo una de las instrucciones return se ejecutará, dado que la
misma siempre supone la conclusión del método.
Como ejemplo, véase la siguiente versión del método que verifica si un vector es capicúa:
Sentencia break
La sentencia break ya se ha visto en su uso para interrumpir la ejecución de una sentencia
switch. En esa situación, la ejecución del break supone saltar a la primera instrucción que
esté justo después del final de la estructura switch.
Además, break puede usarse dentro de los bucles para salir de los mismos sin verificar la
condición de finalización del bucle. Considérese el siguiente ejemplo:
Sentencia continue
La sentencia continue sirve, dentro de bucles, para salir anticipadamente de la iteración
del bucle y continuar con la ejecución de la siguiente iteración del mismo bucle.
Veamos su uso con una variante del anterior ejemplo de método que divide dos matrices:
En este ejemplo, cuando se encuentra una componente nula de la matriz m2, se interrumpe
la iteración actual (de modo que no se ejecuta la instrucción m3[i][j]=m1[i][j]/m2[i][j];
evitándose el error de la división por cero) y se pasa a la siguiente iteración del bucle (es
decir, se incrementa la variable j).
Las instrucciones break y continue se pueden usar también con etiquetas que indican
los lugares del código a donde saltar. Sin embargo, no se recomiendan estos usos dado que
dificultan seriamente la legibilidad y comprensión del código fuente.
Escribir el código del método estadistica pares impares para que realice los sigu-
ientes cálculos con las componentes del vector de números enteros que recibe como
argumento:
Escribir el código del método estadistica vocales para que realice los siguientes
cálculos con las componentes del vector de caracteres que recibe como argumento:
e) Escribir el código de un método que devuelva una matriz que sea el producto
de dos matrices dadas, previa comprobación de que son multiplicables (en caso
contrario, devolver una matriz con todos los valores a cero).
f ) Implementar un método que muestre en la consola los valores de una matriz dada.
g) Escribir un método main donde se invoquen todos los métodos anteriores de modo
que se compruebe su funcionamiento.
2.8.2. Soluciones
1. public class Estadistica {
public static void estadistica_pares_impares (int[] a) {
int sumaPares = 0, contPares = 0, mayorPar = 0;
int sumaImpares = 0, contImpares = 0, mayorImpar = 0;
boolean pp = true, pi = true;
int i = 0;
while ( i < a.length ) {
if ( a[i] \% 2 == 0 ) {
sumaPares += a[i];
contPares++;
if ( pp || a[i] > mayorPar ) mayorPar = a[i];
pp = false;
} else {
sumaImpares += a[i];
contImpares++;
if ( pi || a[i] > mayorImpar ) mayorImpar = a[i];
pi = false;
}
i++;
}
System.out.println("sumaPares= " + sumaPares);
System.out.println("sumaImpares= " + sumaImpares);
System.out.println("contPares= " + contPares);
System.out.println("contImpares= " + contImpares);
System.out.println("mayorPar= " + mayorPar);
System.out.println("mayorImpar= " + mayorImpar);
}
}
} else {
System.out.print("distintas dimensiones: " );
System.out.println("matrices no sumables" );
}
return m3;
}
e) public static int[][] producto_matrices (int[][] m1,
int[][] m2) {
int[][] m3 = new int[filas(m1)][columnas(m2)];
if ( columnas(m1)==filas(m2) ) {
for (int i=0; i<filas(m1); i++)
for (int j=0; j<columnas(m2); j++)
for (int k=0; k<columnas(m1); k++)
m3[i][j] += m1[i][k] * m2[k][j];
} else {
System.out.println( "matrices no multiplicables" );
}
return m3;
}
f) public static void mostrar_matriz (int[][] m) {
for (int i=0; i<filas(m); i++) {
for (int j=0; j<columnas(m); j++)
System.out.print(m[i][j]+" ");
System.out.println("");
}
System.out.println("");
}
g) public static void main (String[] args) {
int[][] m1 = crear_matriz(5,4,1,100);
int[][] m2 = crear_matriz(5,4,1,100);
int[][] m3 = crear_matriz(4,7,100,1000);
mostrar_matriz(m1);
mostrar_matriz(m2);
mostrar_matriz(m3);
int[][] m4 = sumar_matrices(m1,m2);
mostrar_matriz(m4);
int[][] m5 = sumar_matrices(m2,m3);
mostrar_matriz(m5);
int[][] m6 = crear_matriz(3,4,1,10);
int[][] m7 = crear_matriz(4,3,1,10);
int[][] m8 = producto_matrices(m6,m7);
mostrar_matriz(m6);
mostrar_matriz(m7);
mostrar_matriz(m8);
int[][] m9 = crear_matriz(5,5,1,10);
mostrar_matriz(m9);
if ( es_cuadrada(m9) )
System.out.println("matriz cuadrada");
int[][] m10 = { {1,2,3,5}, {2,5,7,8},
{3,7,4,9}, {5,8,9,1} };
mostrar_matriz(m10);
if ( es_simetrica(m10) )
System.out.println("matriz simétrica");
48 Capı́tulo 2. Introducción al lenguaje Java
1. Escribir el código de un método que devuelva una “palabra” (un vector de caracteres).
El método debe generar un vector de caracteres aleatorios, recibiendo como argu-
mentos: la longitud del vector y el rango de valores permitidos (rango al que deben
pertenecer los caracteres aleatorios que se elijan como valores).
2. Escribir el código de un método que devuelva una “sopa de letras” (una matriz de
caracteres).
El método debe generar una matriz de caracteres aleatorios, recibiendo como argumen-
tos: el número de filas, el número de columnas, y el rango de valores permitidos (rango
al que deben pertenecer los caracteres aleatorios que se elijan como valores).
6. Escribir el código de un método que compruebe si una palabra dada está en una deter-
minada posición (descrita por las coordenadas de inicio de búsqueda y las coordenadas
de sentido o dirección de la búsqueda) de una sopa de letras.
7. Escribir el código de un método que muestre en la consola los valores de una sopa de
letras.
8. Escribir el código de un método main donde se genere una sopa de letras, se genere
una palabra a buscar, y se realice la búsqueda de todas las apariciones de la palabra
en la sopa de letras, listando por pantalla las coordenadas de inicio y de dirección de
cada una de las apariciones.
Capı́tulo 3
Fundamentos de la
Programación Orientada a
Objetos con Java
...
}
La estructura anterior permite observar dos partes claramente diferenciadas en las que se
debe dividir una clase. En primer lugar, la declaración de atributos de la clase y, en segundo
49
50 Capı́tulo 3. Fundamentos de la Programación Orientada a Objetos con Java
consultar los atributos del objeto, tanto para simplemente devolver el valor de un
atributo (dado que lo usual es que sólo sean accesibles desde dentro de la propia
clase) como para devolver valores derivados de algún cálculo que involucra a los
atributos; y,
modificar los atributos del objeto (los atributos no deberı́an nunca modificarse de
otra forma que no fuera a través de un método de la clase 3.4).
Ası́ pues, los métodos constituyen un mecanismo para acceder a los atributos de un ob-
jeto. La ejecución de una aplicación orientada a objetos puede verse como un conjunto
de objetos que se crean y destruyen. Una vez creados los objetos éstos van cambiando
su estado (a través de sus métodos) mientras dura su tiempo de vida.
Una vez declarada la clase, se puede utilizar como un nuevo tipo de dato para realizar
dos cosas:
Mediante una clase se define un nuevo tipo de dato. A los objetos también se les suele
denominar instancias de la clase, instancias del tipo de dato o simplemente instancias. Por
eso, también se suele decir que crear objetos es instanciar la clase.
La declaración de una referencia del tipo definido por la clase se realiza de la misma
manera que se declaran variables simples, por ejemplo,
Esfera miesfera;
donde miesfera es una variable referencia que servirá para apuntar o tener acceso a un
objeto o instancia de la clase Esfera. El concepto de referencia es sumamente importante
para comprender el resto del material. Una referencia es lo más parecido a un puntero en
otros lenguajes como el lenguaje C, es decir, es una variable que se puede considerar como
simple, ya que su tamaño es de 32 bits1 y contendrá la dirección de memoria de comienzo del
objeto o instancia al que haga referencia. De la misma manera que una variable simple como
int, double, etc. contiene bits que representan números enteros, reales, etc., una referencia
es una variable simple cuyos 32 bits representan direcciones de memoria. Cuando se declara
una variable simple, se reserva un espacio de memoria de 8 hasta 64 bits para almacenar un
dato de tipo simple. Cuando se declara una variable referencia a una cierta clase, se reserva
espacio de memoria para esos 32 bits que necesita una dirección de memoria.
El concepto de referencia es importante puesto que el acceso a los objetos que se vayan
creando se realiza siempre a través de este tipo de variables. Al contrario que en otros
lenguajes, la aritmética con las variables tipo referencia es muy limitada en Java. Esto
ofrece gran robustez a los programas escritos en Java dado que la posibilidad de equivocarse
al utilizar aritmética de punteros en otros lenguajes suele ser bastante alta. En Java se
pueden realizar asignaciones entre referencias siempre que los tipos sean compatibles. La
compatibilidad de tipos en el caso de tipos definidos por el usuario, es decir, de clases,
se verá en el apartado 4.2.6. Existe una constante denominada null que se puede asignar
a cualquier referencia para indicar que la variable no apunta a ningún objeto. Con una
referencia se pueden utilizar los siguientes operadores: ==, !=, =, ., instanceof.
Esfera miesfera;
miesfera = new Esfera();
miesfera
1. Declaración de una referencia
miesfera Esfera
2. Instanciación de un objeto -
radio = 0.0
El acceso a los atributos y métodos del objeto se realiza a través de la referencia y del
operador de acceso (.). Por ejemplo, para asignar el valor 10 al atributo radio,
miesfera.radio = 10;
Los objetos son entidades completamente independientes. Cada objeto tiene su propio
espacio de memoria, y cada cual debe tener una referencia distinta para su acceso. Ası́ pues,
en el siguiente código
Esfera miesfera1 = new Esfera();
Esfera miesfera2 = new Esfera();
se han instanciado dos objetos de la misma clase, cada uno con sus propios atributos. Se
puede, por ejemplo, asignar valores a los atributos de cada uno de los objetos y calcular su
área:
3.1. Clases y objetos 53
class Ejemplo {
public static void main( String args[] ) {
Esfera miesfera1 = new Esfera();
Esfera miesfera2 = new Esfera();
miesfera1.radio = 1.0;
miesfera2.radio = 2.0;
Aunque en los ejemplos anteriores para cada objeto instanciado existı́a una variable
referencia que lo apuntaba, la utilización de las referencias para apuntar a los objetos es
versátil e independiente. Por ejemplo, se declara la referencia miesfera1 de tipo Esfera
y se instancia un objeto de tipo Esfera que será apuntado por miesfera1. Seguidamente,
se declara la referencia miesfera2 de tipo Esfera y se le asigna el valor de la referencia
miesfera1 (lı́neas 1-3 del código siguiente).
miesfera1
HH Esfera
Hj
H
miesfera2 *
radio = 3.0
A continuación se muestra un ejemplo que deja clara la idea de dos objetos iguales en el
sentido de que poseen el mismo valor para sus atributos y de dos referencias que apuntan al
mismo objeto.
class Ejemplo {
public static void main( String args[] ) {
Esfera miesfera1 = new Esfera();
Esfera miesfera2;
Esfera miesfera3 = new Esfera();
miesfera1.radio = 1.0;
miesfera2 = miesfera1;
miesfera3.radio = 1.0;
donde se muestra que las referencias miesfera1 y miesfera2 apuntan al mismo objeto
mientras que las referencias miesfera3 y miesfera1 apuntan a objetos distintos, aunque
éstos tengan el mismo valor para su atributo.
3.2. Métodos
Como se ha mencionado anteriormente, un método es un “trozo” de código que se en-
capsula de manera independiente del resto del código. Desde este punto de vista, coincide
con el concepto de función, procedimiento o subrutina de otros lenguajes. Esto es ası́ dado
que puede recibir unos parámetros o argumentos, y puede devolver un valor como resultado.
Sin embargo, al contrario que en los lenguajes no orientados a objetos, los métodos no son
completamente independientes, pertenecen siempre a una clase y sólo tienen sentido dentro
de la misma dado que tienen como cometido acceder a sus atributos.
La estructura de un método es la siguiente:
3.2. Métodos 55
donde tipo_de_dato especifica, bien un tipo de dato simple, bien un tipo de dato definido
por el usuario o bien nada, en cuyo caso se utiliza la palabra reservada void. Después,
figura un identificador válido para el nombre del método y, entre paréntesis, una lista de
argumentos separados por comas que puede estar vacı́a. Los argumentos se componen de un
nombre precedido de su tipo de dato. Aunque existan varios argumentos con el mismo tipo
de dato, cada uno ha de llevar especificado su tipo. El cuerpo del método es un bloque de
código englobado entre llaves aun cuando esté constituido por una sola instrucción.
El ejemplo siguiente muestra la clase Esfera a la que se ha incorporado el método area.
class Esfera {
double radio;
double area( ) {
return 4.0 * 3.14159 * radio * radio;
}
}
Cabe mencionar que, desde el punto de vista del diseño orientado a objetos, es más
apropiado incluir un método como éste dentro de la clase que averiguar el área del objeto
desde fuera de la misma tal y como se ha hecho en ejemplos anteriores. En general y como
estrategia de diseño orientado a objetos, se pretende dotar al objeto de toda aquella fun-
cionalidad que pueda llevar a cabo, es decir, encapsular en la clase que define su tipo de dato
todo lo que le atañe en cuanto a atributos y comportamiento.
Los métodos pueden verse de alguna manera como “solicitudes de servicio” que se realizan
sobre el objeto sobre el que es llamado el método desde fuera del mismo. El código siguiente
serı́a la versión correcta del ejemplo de la página 52. En lugar de realizar cálculos externos
sobre atributos de un objeto (cálculo del área en el ejemplo), desde el punto de vista de la
programación orientada a objetos resulta más adecuado solicitar que el objeto realice por
sı́ mismo dichos cálculos en el método area y ofrezca el resultado tal como muestra el código
siguiente:
class Ejemplo {
public static void main( String args[] ) {
Esfera miesfera1 = new Esfera();
Esfera miesfera2 = new Esfera();
miesfera1.radio = 1.0;
miesfera2.radio = 2.0;
double a = miesfera2.area();
System.out.println(" Área de la esfera 2: " + a );
}
}
ofreciendo como resultado la misma salida que en el caso ejemplo de la página 52.
Como se ha observado en el ejemplo anterior, el método area no tiene argumentos pero
sı́ devuelve un valor de tipo double que se ha impreso por la salida estándar en el primer
caso y se ha asignado a la variable a en el segundo.
56 Capı́tulo 3. Fundamentos de la Programación Orientada a Objetos con Java
Un ejemplo de método con argumentos podrı́a ser el método setRadio que se define de
la siguiente manera:
void setRadio( double r ) {
radio = r;
}
de manera que ahora se puede estar seguro de que, aunque el método reciba un valor negativo
como argumento, el radio de la esfera no tendrá nunca un valor negativo. A continuación se
muestra la utilización del método setRadio:
Esfera miesfera1 = new Esfera(), miesfera2 = new Esfera();
miesfera1.setRadio( 1.0 );
miesfera2.setRadio( -4.0 );
miesfera2.setRadio( 2.0 );
...
Según la implementación del método setRadio, una llamada al mismo con un valor negativo
no modificará el valor del radio de la esfera.
Conviene recordar en este punto que los argumentos de un método y las variables definidas
dentro del mismo son variables locales al método y, por lo tanto, no son visibles fuera de éste.
Su tiempo de vida está limitado al tiempo en el que se está ejecutando el método (por ejemplo,
el argumento r del método setRadio). Por el contrario, los atributos declarados en el ámbito
de la clase (radio), son perfectamente visibles dentro de cualquier método definido en la
misma y cualquier modificación que se realice a través de un método permanecerá mientras
no se cambie explı́citamente y el objeto siga en ejecución.
Los métodos pueden no devolver nada (void) o devolver algún valor. En este segundo
caso es preceptivo que exista al menos una instrucción de tipo return.
Antes de pasar a describir con detalle las particularidades de los métodos en Java, cabe
mencionar que existe la recursividad en Java, es decir, la posibilidad de llamar al mismo
método desde dentro del cuál se está realizando la llamada.
3.2.1. Constructores
Como se ha venido observando, en la instanciación de una clase para crear un objeto,
se utiliza el nombre de la misma seguido de un paréntesis abierto y otro cerrado. En esta
instanciación de la clase tiene lugar la ejecución de un constructor. El constructor, aunque
sintácticamente es semejante a un método, no es un método. El constructor puede recibir
argumentos, precisamente se utilizan los mencionados paréntesis para hacerlo, de la misma
manera que se pasan argumentos en las llamadas a los métodos. Aunque el constructor
no haya sido definido explı́citamente, en Java siempre existe un constructor por defecto
que posee el nombre de la clase y no recibe ningún argumento. Esa es la razón por la que
3.2. Métodos 57
Esfera( double r ) {
radio = r;
}
...
}
this.radio = radio;
}
}
Esto no origina ningún conflicto para el compilador. Sin embargo, la utilización del mismo
nombre oculta el atributo radio dentro del método dado que las variables más internas, es
decir, las declaradas dentro del método y los argumentos tienen prioridad sobre los atributos
de la clase. Tal como se ha mostrado en el ejemplo, mediante la utilización de la palabra
reservada this es posible acceder a los atributos de clase distinguiéndolos ası́ de las variables
declaradas en el método y/o los argumentos con el mismo nombre.
class Esfera {
double radio;
Esfera( ) {
radio = 0.0;
}
Esfera( double r ) {
radio = r;
}
...
}
Un constructor puede ser llamado desde otro constructor. La forma de hacerlo consiste
en utilizar la palabra reservada this en lugar del nombre del constructor. El constructor que
será llamado vendrá determinado por el número y tipo de argumentos. El siguiente ejemplo
muestra el constructor Esfera sobrecargado 4 veces.
class Esfera {
double radio;
Color color;
Esfera( ) {
color = Color.white;
radio = 0.0;
}
Esfera( double radio ) {
this();
3.2. Métodos 59
this.radio = radio;
}
Esfera( Color color ) {
this();
this.color = color;
}
Esfera( Color color, double radio ) {
this.color = color;
this.radio = radio;
}
}
La clase Esfera incluye ahora dos atributos: el radio y el color. Este segundo atributo
pertenece a una clase definida en el API de Java denominada Color. La instanciación de
un objeto de tipo Esfera sin argumentos crea una esfera blanca y de radio 0.0. El segundo
constructor permite crear una esfera con un determinado radio y el color por defecto (el
blanco). En este último caso se hace uso de this para llamar al constructor sin argumentos
que asigna el color blanco al atributo color. El tercer constructor es análogo al anterior y
se utiliza para asignar un color determinado a la nueva esfera sin que importe el radio. Estos
dos últimos constructores son un ejemplo de sobrecarga con el mismo número de argumentos.
El cuarto constructor permite la inicialización de los atributos con los valores pasados como
argumentos.
Puede llamarse a cualquier constructor con y sin argumentos utilizando this. En el caso
de este último constructor podrı́a haberse pensado en implementarlo de la siguiente forma:
Esfera( Color color, double radio ) {
this(radio);
this(color);
}
Sin embargo, en este caso es incorrecto debido a que la utilización de this para llamar a un
constructor sólo puede hacerse en la primera instrucción. La segunda llamada (this(color))
produce, por tanto, un error de compilación.
Por último, decir que desde un método no es posible utilizar this() para ejecutar el
código de un constructor.
pasada a dicho método, es decir, se pasa únicamente su valor. El siguiente ejemplo muestra
este concepto.
class A {
void metodo( double argumento ) {
argumento = 4.0;
}
}
Según la explicación dada, la salida por pantalla deberı́a quedar claro que debe ser la sigu-
iente:
variable = 2.5
class Esfera {
double radio;
Esfera( Esfera e ) {
radio = e.radio;
}
...
}
de manera que se tendrá la posibilidad de definir esferas con los mismos atributos de manera
sencilla. Las siguientes dos esferas tienen exactamente la misma dimensión:
Esfera miesfera1 = new Esfera( 2.0 );
Esfera miesfera2 = new Esfera( miesfera1 );
Como se ha podido observar, dentro del nuevo constructor se ha accedido a los elementos
de la clase Esfera a través de su referencia.
El siguiente ejemplo muestra un método que modifica el valor del atributo de un objeto:
void escalar( Esfera esfera, double escalado ) {
esfera.radio *= escalado;
}
...
Esfera doble( ) {
Esfera c = new Esfera( 2*radio );
return c;
}
}
El método doble tiene por cometido crear una esfera nueva que tenga el doble de radio.
Una vez creada esta nueva esfera, el método devuelve la variable referencia que contiene la
dirección de memoria del objeto creado dentro del método. Esta referencia puede ser utilizada
fuera del método para tener acceso a dicha esfera tal como muestra el ejemplo siguiente,
Esfera miesfera1 = new Esfera( 2.0 );
Esfera miesfera2 = miesfera1.doble( );
Después de la ejecución del código anterior, se dispone de dos objetos de tipo Esfera: el
objeto apuntado por la variable referencia miesfera1 con radio 2.0 y el objeto apuntado
por la variable referencia miesfera2 con radio 4.0.
Los argumentos y las variables locales a un método son variables simples y referencias.
Las primeras se utilizan para representar números, caracteres y booleanos mientras que las
62 Capı́tulo 3. Fundamentos de la Programación Orientada a Objetos con Java
En el caso de los métodos, las implicaciones son más sencillas ya que el código de un método
no puede cambiar durante la ejecución de un programa tal y como lo hace una variable. Lo
usual en la utilización de los métodos estáticos es acceder a ellos por el nombre de la clase
a la que pertenecen.
Hay que tener en cuenta que los métodos y atributos de clase pueden ser utilizados
siempre dado que no es necesario que se haya instanciado una clase para poder acceder a
ellos. Sin embargo, constituye un problema el acceso a un método o atributo de instancia
desde un método estático. En el ejemplo siguiente
class Atristatic {
static int atributo_estatico;
int atributo_de_instancia;
class Complejo {
double re, im;
// Constructores
Complejo ( double r, double i ) { ... }
Complejo ( Complejo a ) { ... }
// Métodos de instancia
void inc( Complejo a ) { ... }
void dec( Complejo a ) { ... }
void por( Complejo a ) { ... }
void por( double d ) { ... }
void div( double d ) { ... }
double modulo( ) { ... }
Complejo conjugado( ) { ... }
64 Capı́tulo 3. Fundamentos de la Programación Orientada a Objetos con Java
// Métodos de clase
static Complejo suma ( Complejo a, Complejo b ) { ... }
static Complejo resta ( Complejo a, Complejo b ) { ... }
static Complejo producto ( Complejo a, Complejo b ) { ... }
static Complejo division ( Complejo a, Complejo b ) { ... }
}
En la clase Complejo, existen siete métodos de instancia (no estáticos) cuya definición es
la que figura en la Tabla 3.1. Se observa que el método por está sobrecargado para permitir
la multiplicación de un número complejo por otro complejo o un escalar.
inc c←c+a
dec c←c−a
por c←c×a
c←c×d
div c←c÷d
modulo c
conjugado c∗
Desde el punto de vista del diseño de una aplicación es importante notar cómo se han
utilizado y por qué los métodos de instancia. Todos los métodos de instancia trabajan sobre
el estado de un objeto concreto, bien para obtener alguna información del mismo (modulo y
conjugado), o bien para modificar su estado (inc, dec, por y div). Por ejemplo,
Complejo conjugado( ) {
return new Complejo( re, -im );
}
void por( double d ) {
re *= d;
im *= d;
}
Los métodos que modifican el estado de una instancia de la clase Complejo pretenden simular
operaciones como c = c + a, c = c * a, . . . que pueden realizarse sobre variables simples
pero no sobre objetos de una clase.
A raı́z de este hecho, cabe mencionar que, en otros lenguajes de programación orientados
a objetos como C++, existe la posibilidad de sobrecargar operadores, lo que permitirı́a dotar
a los operadores aritméticos de la posibilidad de operar sobre objetos de determinadas clases
tales como la clase Complejo.
En la Tabla 3.2 se muestran los cuatro métodos de clase de la clase Complejo y un
ejemplo de implementación es el siguiente:
static Complejo suma ( Complejo a, Complejo b ) {
return new Complejo( a.re+b.re, a.im+b.im );
}
Estos métodos se implementan para ofrecer servicios que se considera adecuado que pro-
porcione la clase y de manera independiente de las instancias concretas que se hayan creado.
3.3. Miembros de instancia y de clase 65
suma c←a+b
resta c←a−b
producto c←a×b
division c←a÷b
Dicho de otra forma, los métodos de clase son la manera más parecida en la que se imple-
mentarı́a dicha operación en otros lenguajes de programación no orientados a objetos. Los
métodos suma, resta, producto y division permiten realizar cualquiera de estas opera-
ciones aritméticas sobre dos objetos de tipo Complejo que son pasados como argumentos y
ofrecer un resultado del mismo tipo. Hay que notar que no se modifica el estado de ninguna
instancia al realizar llamadas sobre estos métodos, su función consiste en recibir dos objetos
como argumento, crear uno nuevo que sea resultado de la operación que implementan y
devolverlo.
En muchos casos, una misma operación puede implementarse como método de instancia
o como método de clase. Es una decisión de estilo de programación la que hay que tomar
para decantarse por una u otra solución. La que se ha mostrado aquı́ a través de la clase
ejemplo Complejo se ha justificado convenientemente y resulta bastante adecuada aunque
no siempre es la que se sigue. Por ejemplo, en el API2 de Java existe una clase denominada
Object (apartado 4.1.5) con un método equals que devuelve cierto si el objeto pasado como
argumento es igual que el objeto sobre el que es invocado el método. Según la estrategia de
programación planteada hasta el momento este método deberı́a haberse implementado como
un método de clase.
Si se necesita ejecutar instrucciones para inicializar las variables estáticas en el proceso
de “carga de la clase” éstas se pueden especificar en un bloque estático. Java utiliza lo que
se denomina carga dinámica (dynamic loading) de código. Éste es un mecanismo mediante
el cual la aplicación Java carga o lee en memoria un fichero ejecutable Java (extensión
.class) en tiempo de ejecución en el momento en que lo “necesita”. Este momento es la
primera vez que se utiliza la clase para instanciarla o para acceder a un miembro estático.
La utilización de un bloque estático tiene la forma que muestra el siguiente ejemplo:
class UsoStatic {
static int a = 3;
static int b;
// Bloque estatico
static {
System.out.println("Entra en el bloque estático.");
b = a * 4;
}
clases, métodos, . . . ) proporcionados para poder ser utilizados por otro software.
66 Capı́tulo 3. Fundamentos de la Programación Orientada a Objetos con Java
Cuando se carga la clase del ejemplo se calculan las 10 primeras potencias de 2. Este cálculo
se lleva a cabo una sola vez mientras dure la ejecución de la aplicación.
que, a ser posible, tengan entidad propia. Una rutina tiene entidad propia cuando es inde-
pendiente del resto y reutilizable. La reutilización de código es una caracterı́stica altamente
deseable dado que no solo supone reducción de costes de programación sino que también
proporciona
fiabilidad: en la medida en que las rutinas son más utilizadas son más fiables, y
...........................................................................................
.... ..
... ...
atributo1
...
..................................................................................................
..
.. método público 1
.
.............................................................................................
....
...
..
...
método público 2
atributo n
...
................................................................................................
..
.........................................................................................................................................................
... .. método público 3
....
...
método privado 1
... ..
.......................................................................................................................................................... ..
.. .
.
.........................................................................................................................................................
... ... método público p
método privado m
...
....
...
...
..........................................................................................................................................................
Figura 3.3: Encapsulación de código en una clase. Los métodos públicos constituyen la in-
terfaz de la clase con el exterior.
class B {
A a = new A();
3.4. Encapsulación de código 69
a.i = 10;
// a.j = 10 no está permitido
// System.out.println("Variable j: " + a.j); tampoco está permitido
}
public void add( int valor ): Mediante esta operación se añade el nuevo número entero
proporcionado como argumento. La operación no devuelve nada.
public int get(): Mediante esta operación se extrae el último número entero introducido
en la estructura. Cada extracción devuelve los números de la estructura en orden inverso
al que se introdujeron. La operación devuelve el número entero extraı́do.
public int top(): Esta operación devuelve el último número entero introducido en la pila.
La operación no modifica la información de pila.
class Pila {
private int n;
private int vector[];
return a;
}
}
La clase Pila puede albergar números enteros hasta un máximo de talla definido por
el usuario de la clase en la instanciación de la misma. Se utiliza un vector para almacenar
los números de la pila y una variable para almacenar la cantidad de elementos almacenados.
Según la implementación propuesta la introducción de un nuevo elemento cuando la pila
está llena no tiene efecto. La extracción de un elemento de una pila vacı́a devuelve un valor
de -11111. Se verá en el Capı́tulo 5 la forma correcta de realizar el control necesario para
operaciones que pueden desencadenar errores como introducir datos en una pila llena o
extraerlos de una pila vacı́a. Nótese, además, que los atributos de la clase se han declarado
como privados mientras que los métodos que forman parte de la interfaz (en este caso todos)
se han declarados como públicos.
class Sistema_Solar {
private Estrella estrella;
private Planeta planeta[];
class Estrella {
private String nombre;
Estrella( String nombre ) {
this.nombre = nombre;
}
public String getNombre() {
return nombre;
}
}
class Planeta {
private String nombre;
Planeta( String nombre ) {
this.nombre = nombre;
}
public String getNombre() {
return nombre;
}
}
3.6. La clase String 71
void mostrar_planetas() {
System.out.println("Estrella del sistema solar = "+
estrella.getNombre());
for( int i=0; i<planeta.length; i++ ) {
System.out.println("Planeta "+(i+1)+" = "+
planeta[i].getNombre());
}
}
}
Dado que String es una clase especial, los dos códigos anteriores son equivalentes.
Otra particularidad de la clase String es que tiene el operador + sobrecargado, es decir,
se pueden “sumar” objetos de tipo String dando como resultado una cadena nueva formada
por ambas cadenas concatenadas. Por ejemplo, la salida del código siguiente,
72 Capı́tulo 3. Fundamentos de la Programación Orientada a Objetos con Java
serı́a,
Esto es la cadena resultado
donde 100 es el valor de una variable entera declarada de esta manera: int x=100;, serı́a
System.out.println("x = "+x);
length(): Devuelve la longitud de una cadena. Nota: obsérvese que length() es un método
de la clase String que no hay que confundir con el atributo length de los vectores.
3.7. Paquetes
Los paquetes de Java son contenedores de clases que se utilizan para mantener el espacio
de nombres dividido en compartimentos. Las clases se almacenan en dichos paquetes y tienen
un nombre único dentro de dicho paquete de manera que ninguna clase pueda entrar en
conflicto con otra clase con el mismo nombre pero en distinto paquete, ya que el nombre
del paquete las diferencia. Los paquetes pueden estar a su vez dentro de otros paquetes
estructurándose ası́ de manera jerárquica.
La definición de un paquete consiste simplemente en la inclusión de la palabra reservada
package como primera sentencia de una archivo Java. Por ejemplo, cualquier clase que se
defina dentro del archivo que posee como primera lı́nea la siguiente:
package mi_paquete;
pertenecerá al paquete mi_paquete.
Si se omite la sentencia package, las clases se asocian al paquete por defecto, que no tiene
nombre.
Java utiliza los directorios del sistema de archivos para almacenar los paquetes. El pa-
quete mi_paquete declarado más arriba ha de encontrarse en el directorio mi_paquete. Se
pueden crear subpaquetes dentro de otros paquetes respetando la jerarquı́a de directorios,
siendo la forma general de declaración la siguiente:
package paq1[.paq2[.paq3]];
hasta el nivel de profundidad necesario y, por supuesto, coincidiendo con la jerarquı́a de direc-
torios apropiada. Esta jerarquı́a de la que se ha hablado hacer referencia a los ficheros objeto
Java, es decir, los .class. La organización de los códigos fuente (.java) es responsabilidad
del programador y no tiene porqué seguir esta estructura jerárquica.
Dentro de un paquete, sólo son visibles aquellas clases que pertenecen a dicho paquete.
La utilización de clases que se encuentran en otros paquetes diferentes al que pertenecen
las clases que se están implementando en el fichero actual se lleva a cabo mediante su
importación. Por ejemplo, si se desea utilizar la clase mi_clase definida en el paquete
mi_paquete en el fichero actual, se ha de incluir al principio de dicho fichero (siempre
después de la declaración de paquete) la siguiente instrucción:
import mi_paquete.mi_clase;
Asimismo, es posible importar todas las clases del paquete mediante el comodı́n *,
import mi_paquete.*;
para poder ası́ tener acceso a todas las clases de dicho paquete.
La importación de clases mediante el mecanismo explicado no es necesaria, por ejemplo,
si van a ser sólo unas pocas las clases importadas. Siempre es posible denotar una clase de
otro paquete utilizando su nombre completo, por ejemplo,
java.util.GregorianCalendar cal = new java.util.GregorianCalendar();
Tampoco es necesaria para el caso particular del paquete java.util del JDK de Java.
74 Capı́tulo 3. Fundamentos de la Programación Orientada a Objetos con Java
Crear el directorio con el mismo nombre que el paquete que se desea crear, por ejemplo,
mi_paquete.
Asegurarse que el fichero con el bytecode correspondiente a las clases que pertenecen a
dicho paquete (contienen la sentencia package.mi_paquete;) se encuentran en dicho
directorio.
Esto se puede omitir si se utiliza la opción -d del compilador de Java. Mediante esta
opción, el compilador coloca las clases (.class) en el directorio y subdirectorios corre-
spondientes, creando incluso las carpetas necesarias si éstas no existen, para almacenar
las clases y reflejar la estructura elegida según los paquetes creados.
Para ejecutar una clase (por ejemplo, mi_clase) de dicho paquete es necesario indicar
al intérprete Java el paquete y la clase que se desea ejecutar,
java mi_paquete.mi_clase
Windows. Para darle valores a dicha variable abrirı́amos una ventana del intérprete de
comandos de MS-DOS:
Hay que tener en cuenta que el comando exacto depende del tipo de shell de linux.
La ejecución de aplicaciones Java que utilizan paquetes definidos por el usuario tiene
algunos detalles a tener en cuenta por lo que se recomienda ver el Ejercicio 2.
el argumento args del método main es un vector de referencias a objetos de tipo String.
En la llamada al método main:
1. se instancia automáticamente este vector con un tamaño igual al número de argumen-
tos,
2. para cada argumento se crea un objeto de tipo String con el argumento, y
3. dicho objeto pasa a ser referenciado por el elemento del vector args correspondiente.
Teniendo en cuenta la clase Sistema_Solar definida en el apartado 3.5, si ejecutamos la
clase Planetas con el siguiente comando y argumentos:
> java Planetas Sol Mercurio Venus Tierra Marte Júpiter Saturno Urano
Neptuno Plutón
Los argumentos pasados a una aplicación Java siempre son cadenas de caracteres. Si se
desea pasar otros tipos de datos como números es necesario realizar una conversión de tipo
String al tipo de dato deseado. El paquete java.util contiene clases que proporcionan
esta funcionalidad. Por ejemplo, mediante
int n = Integer.parseInt(args[0]);
class Elemento {
}
class Elem {
Elem sig;
private Elemento elemento;
class ListaSimple {
private Elem primero;
private int elementos;
public ListaSimple() {
primero = null;
elementos = 0;
}
}
}
Ejercicio 2 Seguir los siguientes pasos para crear una clase dentro de un paquete definido
por el usuario y utilizarla desde otra (las instrucciones proporcionadas son para un terminal
de usuario linux).
mkdir mi_paquete
cd mi_paquete
package mi_paquete;
javac Mi_clase.java
cd ..
y crear la clase
import mi_paquete.Mi_clase;
class Clase_principal {
public static void main(String[] args) {
Mi_clase a = new Mi_clase();
}
}
javac Clase_principal.java
java Clase_principal
Ejercicio 3 Implementar una estructura tipo pila de números enteros sin talla máxima.
Utilizar una lista enlazada y clases internas.
Solución:
class Pila {
private Elemento primero;
private int n;
class Elemento {
Elemento next;
int valor;
Elemento( int valor ) {
next = primero;
this.valor = valor;
}
int get() {
primero = next;
return valor;
}
int getValor() {
return valor;
}
}
public Pila( ) {
primero = null;
n = 0;
}
un nuevo número entero. Los elementos se eliminan de la lista cuando se extrae un elemento.
Utilizando una lista enlazada se elimina la restricción de tener una talla máxima de elementos
para la pila. Obsérvese que desde la clase interna Elemento se accede al atributo primero
de la clase envolvente Pila.
Ejercicio 2 Implementar una clase Lista con la misma interfaz que la clase Lista del
ejercicio resuelto 3.9 pero que añada elementos al final y los extraiga de la cabeza.
Ejercicio 3 Utilizando el ejercicio anterior, modificar la clase Elemento para que almacene
objetos de tipo String y crear un constructor de ListaSimple a partir de los argumentos
pasados. En el programa principal crear una lista con la clase Lista implementada con los
argumentos pasados por linea de comandos.
Ejercicio 4 Crear una clase que almacene en una variable el número de veces que es
instanciada.
Herencia y Polimorfismo
Tal y como se ha visto en capı́tulos anteriores, una clase representa un conjunto de ob-
jetos que comparten una misma estructura y comportamiento. La estructura se determina
mediante un conjunto de variables denominadas atributos, mientras que el comportamiento
viene determinado por los métodos. Ya se ha visto en capı́tulos anteriores que esta forma de
estructurar los programas ofrece grandes ventajas, pero lo que realmente distingue la pro-
gramación orientada a objetos (POO) de otros paradigmas de programación es la capacidad
que tiene la primera de definir clases que representen objetos que comparten sólo una parte
de su estructura y comportamiento, esto es, que representen objetos con ciertas similitudes,
pero no iguales. Estas similitudes pueden expresarse mediante el uso de la herencia y el
polimorfismo. Estos dos mecanismos son, sin lugar a dudas, pilares básicos de la POO.
4.1. Herencia
La herencia es el mecanismo que permite derivar una o varias clases, denominadas sub-
clases, de otra más genérica denominada superclase. La superclase reúne aquellos atributos
y métodos comunes a una serie de subclases, mientras que estas últimas únicamente definen
aquellos atributos y métodos propios que no hayan sido definidos en la superclase. Se dice
que una subclase extiende el comportamiento de la superclase. En ocasiones se utiliza el
término clase base para referirse a la superclase y clase derivada para referirse a la subclase.
En la figura 4.1 se representa gráficamente el concepto de herencia.
Figura 4.1: La clase B (subclase o clase derivada) hereda los atributos y métodos de la clase
A (superclase o clase base).
81
82 Capı́tulo 4. Herencia y Polimorfismo
Por ejemplo:
class Esfera {
private double radio;
En este ejemplo la clase Planeta hereda todos los métodos y atributos definidos en Esfera
que no sean privados. Al fin y al cabo, un planeta también es una esfera (despreciaremos las
pequeñas deformaciones que pueda tener). En el siguiente fragmento de código vemos cómo
es posible acceder a los atributos y métodos heredados.
En el ejemplo anterior puede observarse cómo los objetos de la clase Planeta utilizan
los métodos heredados de Esfera (setRadio y superficie) exactamente del mismo modo
a como utiliza los definidos en su misma clase (setNumSatelites).
Cuando se define un esquema de herencia, la subclase hereda todos los miembros (métodos
y atributos) de la superclase que no hayan sido definidos como privados. Debe observarse
que en el ejemplo anterior la clase Planeta no hereda el atributo radio. Sin embargo, esto
no quiere decir que los planetas no tengan un radio asociado, sino que no es posible acceder
directamente a ese atributo. En realidad los objetos de tipo Planeta pueden establecer su
radio a través del método setRadio. Debe remarcarse que es una práctica muy habitual
definir como privados los atributos de una clase e incluir métodos públicos que den acceso a
dichos atributos, tal y como se explicó en el apartado 3.4.
Veamos un nuevo ejemplo sobre el uso de la herencia. Supongamos que queremos imple-
mentar un juego en el que una nave debe disparar a ciertas amenazas que se le aproximan.
De forma muy simplista, podrı́amos definir el comportamiento de nuestra nave mediante el
siguiente código:
4.1. Herencia 83
class Nave {
private int posX, posY; // Posición de la nave en la pantalla
private int municion;
Nave() {
posX = 400;
posY = 50;
municion = 100;
}
void moverDerecha( int dist ) {
posX += dist;
}
void moverIzquierda( int dist ) {
posX -= dist;
}
void disparar() {
if( municion > 0 ) {
municion--;
// Código necesario para realizar disparo
}
}
void dibujar() {
// Obviaremos la parte gráfica y nos limitaremos a mostrar
// un texto por la consola
System.out.println("Nave en " + posX + "," + posY);
System.out.println("Munición restante: " + municion);
}
}
Supongamos ahora que tras superar cierto nivel en el juego, podemos disponer de otra
nave con mayores prestaciones (por ejemplo, un escudo protector). En este caso podemos
tomar como base la nave anterior e implementar una segunda clase que contenga únicamente
la nueva funcionalidad.
class NaveConEscudo extends Nave {
private boolean escudo;
NaveConEscudo() {
escudo = false;
}
void activarEscudo() {
escudo = true;
}
void desactivarEscudo() {
escudo = false;
}
}
Ahora serı́a posible hacer uso de esta nueva nave en nuestro juego.
class Juego {
public static void main(String[] args) {
NaveConEscudo miNave = new NaveConEscudo();
miNave.moverDerecha(20);
miNave.disparar();
miNave.activarEscudo();
miNave.dibujar();
84 Capı́tulo 4. Herencia y Polimorfismo
}
}
Estos dos modos de usar la palabra super se verán con más detalle en los apartados 4.1.3
y 4.2.1 respectivamente.
class A {
A() { System.out.println("En A"); }
}
class B extends A {
B() { System.out.println("En B"); }
}
class C extends B {
C() { System.out.println("En C"); }
}
class Constructores_y_Herencia {
public static void main(String[] args) {
C obj = new C();
}
}
class A {
A() { System.out.println("En A"); }
A(int i) { System.out.println("En A(i)"); }
}
class B extends A {
B() { System.out.println("En B"); }
B(int j) { System.out.println("En B(j)"); }
}
En A
En B(j)
Hay, sin embargo, un modo de cambiar este comportamiento por defecto para permitir
ejecutar en la superclase un constructor diferente. Para ello debemos hacer uso de la sen-
tencia super(). Esta sentencia invoca uno de los constructores de la superclase, el cual se
escogerá en función de los parámetros que contenga super().
En el siguiente ejemplo se especifica de forma explı́cita el constructor que deseamos
ejecutar en A:
class A {
A() {
System.out.println("En A");
}
A(int i) {
System.out.println("En A(i)");
}
}
class B extends A {
B() {
System.out.println("En B");
}
B(int j) {
super(j); // Ejecutar en la superclase un constructor
// que acepte un entero
System.out.println("En B(j)");
}
}
En A(i)
En B(j)
Mientras que la sentencia B obj = new B() mostrarı́a:
En A()
En B()
Ha de tenerse en cuenta que en el caso de usar la sentencia super(), ésta deberá ser
obligatoriamente la primera sentencia del constructor. Esto es ası́ porque se debe respetar el
orden de ejecución de los constructores comentado anteriormente.
En resumen, cuando se crea una instancia de una clase, para determinar el construc-
tor que debe ejecutarse en cada una de las superclases, en primer lugar se exploran los
constructores en orden jerárquico ascendente (desde la subclase hacia las superclase). Con
este proceso se decide el constructor que debe ejecutarse en cada una de las clases que
componen la jerarquı́a. Si en algún constructor no aparece explı́citamente una llamada a
super(lista_de_argumentos) se entiende que de forma implı́cita se está invocando a
super() (constructor sin parámetros de la superclase). Finalmente, una vez se conoce el
constructor que debe ejecutarse en cada una de las clases que componen la jerarquı́a, éstos
se ejecutan en orden jerárquico descendente (desde la superclase hacia las subclases).
class A {
int i;
A( int valor) {
i=valor;
}
}
class B extends A {
int j;
B( int valor) {
j=valor;
}
}
En este caso la sentencia B obj = new B(5) generará igualmente un error ya que, puesto
que no hemos especificado un comportamiento distinto mediante super(), en A deberı́a
ejecutarse el constructor sin parámetros, sin embargo, tal constructor no existe puesto que
se ha perdido el constructor por defecto. La solución pasarı́a por sobrecargar el constructor
de A añadiendo un constructor sin parámetros,
class A {
int i;
A() {
i=0;
}
A( int valor) {
i=valor;
}
}
class B extends A {
int j;
B( int valor) {
j=valor;
}
}
class A {
int i;
A( int valor) {
i=valor;
}
}
class B extends A {
int j;
B( int valor) {
super(0);
j=valor;
}
}
4.1. Herencia 89
Figura 4.3: En Java existe un único árbol jerárquico, en el que la clase Object ocupa el nivel
más alto.
4.2. Polimorfismo
Una de las caracterı́sticas de la herencia es que una referencia de una clase base puede
utilizarse para referenciar objetos de cualquir otra clase heredada (este concepto se explica en
el apartado 4.2.3). Esta caracterı́stica, tan simple y a la vez tan potente, permite implementar
lo que se conoce como polimorfismo.
El término polimorfismo hace referencia a la capacidad que tienen algunos métodos de
presentar “múltiples formas”, en el sentido de que una llamada a un mismo método puede
ofrecer comportamientos distintos en función del contexto en el que se ejecute. El polimorfis-
mo, como se verá más adelante, dota a los lenguajes orientados a objetos de una potencia de
la que carecen otros lenguajes, ya que permite realizar ciertas abstracciones sobre los tipos
de datos con los que se trabaja.
Es imposible tratar y entender el polimorfismo sin antes abordar una serie de conceptos
relacionados. Estos conceptos son independientes del tema del polimorfismo, pero necesarios
para su comprensión.
class Esfera {
double radio;
void mostrarValores() {
System.out.println("R=" + radio);
}
}
int numSatelites;
void mostrarValores() {
System.out.println("R=" + radio + "Num. Sat.=" + numSatelites);
}
}
class Nave {
int posX, posY;
int municion;
Nave() { . . . }
void moverDerecha( int dist ) { . . . }
void moverIzquierda( int dist ) { . . . }
void disparar() { if( municion > 0) municion--; }
void dibujar() { . . . }
}
De este modo cada nave tiene su propia versión del método disparar. De forma similar
podrı́a sobreescribirse el método dibujar para que cada tipo de nave tuviese una repre-
sentación gráfica distinta.
Reemplazo y refinamiento
La sobreescritura de un método podemos enfocarla desde dos puntos de vista: reescribir
el método completamente ignorando el código que hubiese en la superclase, o ampliar el
código existente en la superclase con nuevas instrucciones. En el primer caso hablaremos
de reemplazo y en el segundo de refinamiento. Los ejemplos vistos anteriormente corre-
sponden a sobreescritura mediante reemplazo. Para implementar la sobreescritura mediante
refinamiento se debe invocar desde el método sobreescrito de la subclase el método corre-
spondiente de la superclase mediante el uso de super. Por ejemplo podrı́amos pensar que
una NaveConEscudo se dibuja como una Nave con algunos elementos extras. En este caso
serı́a más interesante el refinamiento que el reemplazo, ya que aprovecharı́amos el código del
método dibuja escrito para la clase Nave.
class Nave {
. . .
void dibujar() {
// Código para dibujar una nave básica
}
}
class A {
final void metodo1() {
. . .
}
}
class B extends A {
// Esta clase no puede sobreescribir metodo1()
}
En este caso vemos que el tipo (clase) de la referencia coincide con el tipo de objeto que
se crea, sin embargo, esto no tiene por qué ser siempre ası́. De hecho es posible declarar una
referencia de una clase determinada e instanciar un objeto, no de dicha clase, sino de una
subclase de la misma. Por ejemplo, dada la siguiente relación de clases
class Esfera {
double radio;
double superficie() {
return 4*Math.PI*radio*radio;
}
}
Conviene diferenciar el tipo estático de una variable del tipo dinámico. Denominamos
tipo estático al tipo con el que se declara una variable referencia, y tipo dinámico al tipo del
objeto al que apunta dicha referencia. En el primer ejemplo mostrado, tanto el tipo estático
como el tipo dinámico de la variable e es Esfera. Por el contrario, en el segundo ejemplo se
ha declarado una variable e de tipo Esfera (tipo estático), pero, el objeto creado es de tipo
Planeta (tipo dinámico).
motivado por la forma en que se representa gráficamente la herencia, donde las superclases
aparecen arriba de las subclases. En la conversión hacia arriba se referencia un objeto dado
mediante una referencia perteneciente a un tipo o clase que jerárquicamente está “arriba”
de la clase correspondiente al objeto creado.
Cuando se utiliza la conversión hacia arriba es importante tener en cuenta una limitación:
si creamos un objeto de un tipo determinado y empleamos una referencia de una superclase
para acceder al mismo, a través de dicha referencia únicamente podremos “ver” la parte del
objeto que se definió en la superclase. Dicho de otro modo, el tipo estático limita la interfaz,
esto es, la visibilidad que se tiene de los atributos y métodos de un objeto determinado.
Tomemos como ejemplo las siguientes clases:
class A {
public void m1() {
. . .
}
}
class B extends A {
public void m2() {
. . .
}
}
Supongamos ahora que en algún punto de nuestro programa se crean los siguientes obje-
tos:
Figura 4.4: Dadas una superclase A y una subclase B, se crean objetos de distinta manera. (a)
Tipo estático=B, tipo dinámico=B: se tiene acceso a todo el objeto. (b) Tipo estático=A, tipo
dinámico=B (conversión hacia arriba): se tiene acceso únicamente a la parte de A. (c) Tipo
estático=B, tipo dinámico=A: Error. Si se permitiera, se deberı́a tener acceso a elementos
que realmente no han sido creados.
En la figura 4.4 se muestra cómo, a partir de la referencia obj1 se tiene acceso tanto al
método m1() como a m2(). Sin embargo, con la referencia obj2, a pesar de que referencia a
4.2. Polimorfismo 95
un objeto de tipo B, únicamente se tiene acceso a los métodos definidos en A, ya que el tipo
estático impone esta limitación.
Retomando el ejemplo de la Esfera del apartado anterior, sobreescribamos ahora alguno
de los métodos definidos en la superclase. Por ejemplo, supongamos que se desea medir la
superficie de un planeta con mayor precisión, teniendo en cuenta el achatamiento existente
en los polos. Para ello podrı́amos redefinir la clase Planeta como sigue:
class Esfera {
double radio;
double superficie() {
return 4*Math.PI*radio*radio;
}
}
Planeta(double r, double c) {
radio = r;
coeficienteAchatamiento = c;
}
// Sobreescribimos el método superficie
double superficie() {
// Cálculo preciso de la superficie teniendo en cuenta
// el coeficiente de achatamiento
}
}
El tipo estático Esfera contiene el método superficie, por lo tanto dicho método es
visible a través de la referencia e, sin embargo es importante entender que se ejecutará el
método del objeto que hemos creado (en este caso de tipo Planeta). Puesto que el método
superficie ha sido sobreescrito en la clase Planeta se ejecutará esta nueva versión del
método.
A modo de resumen diremos que el tipo estático dictamina QUÉ operaciones pueden
realizarse, pero es el tipo dinámico el que determina CÓMO se realizan. Esta caracterı́stica
tiene una enorme transcendencia en la programación orientada a objetos ya que, como se
verá en apartados posteriores, permite realizar ciertas abstracciones sobre los tipos de datos
(clases) con los que se trabaja.
Existen algunas restricciones lógicas en la utilización de tipos estáticos y dinámicos dis-
tintos. Una variable referencia con un tipo estático determinado puede tener, como se ha
visto, un tipo dinámico que sea derivado del tipo estático, pero no a la inversa. Esto es, la
siguiente declaración no serı́a correcta:
Planeta p = new Esfera();
La restricción impuesta es lógica por varios motivos. Si se declara una referencia con el
tipo estático Esfera, ésta puede ser utilizada para referenciar un Planeta. Es como decir
96 Capı́tulo 4. Herencia y Polimorfismo
que “un planeta también es una esfera”. Sin embargo, no tiene tanto sentido declarar una
referencia de tipo Planeta e intentar referirse con ella a un objeto de tipo Esfera, ya que
serı́a como decir que “cualquier esfera es un planeta”.
Desde el punto de vista semántico del lenguaje existe una razón todavı́a más contundente.
Si declaramos una referencia de tipo estático Planeta estamos indicando que con dicha
referencia podemos acceder a cualquier miembro de la clase Planeta (el tipo estático indica
qué se puede hacer), esto es, deberı́amos poder hacer
Planeta p;
. . .
p.numSatelites=1;
Sin embargo, si dicha referencia la utilizamos para instanciar un objeto de tipo Esfera
Planeta p;
p = new Esfera();
resultarı́a incorrecta. De algún modo estarı́amos dando al tipo estático un alcance o visi-
bilidad mayor de lo que realmente existe en el tipo dinámico, tal y como se muestra en la
figura 4.4(c), lo que generarı́a inconsistencias como la que acabamos de exponer.
class Dispositivo {
Dispositivo salida;
. . .
}
Lo interesante de este ejemplo es que el atributo salida es del tipo genérico Dispositivo,
sin embargo, gracias a la conversión hacia arriba, esta referencia puede utilizarse para refer-
enciar objetos de cualquier tipo de dispositivo (filtro, amplificador, etc.). De modo similar,
el método conectar admite cualquier tipo de dispositivo. Podrı́a parecer extraño que un
método que acepta como parámetro objetos de un tipo determinado pueda llegar a aceptar
objetos de otro tipo, sin embargo, tomando el ejemplo anterior, hemos de pensar que al fin
y al cabo, un filtro también es un tipo de dispositivo.
class Figura {
double area() {
return 0; // No sabemos qué área tiene una figura genérica
}
}
class Rectangulo extends Figura {
double alto, ancho;
Rectangulo( double al, double an) {
alto = al;
ancho = an;
}
double area() {
return alto*ancho;
}
}
class Circulo extends Figura {
double radio;
Circulo(double r) {
radio = r;
}
double area() {
return Math.PI*radio*radio;
}
}
En este programa se crea un vector con 10 referencias de tipo Figura, esto es, el tipo
estático de cada referencia v[i] es Figura (la sentencia v = new Figura[10] crea un vector
con 10 referencias, pero éstas todavı́a no referencian ningún objeto). A continuación se crean
objetos de tipo Rectangulo y Circulo los cuales quedan referenciados por las referencias
contenidas en v. Por tanto, el tipo dinámico de cada referencia v[i] es o bien Rectangulo
o bien Circulo (nótese el uso de la conversión hacia arriba estudiada en el apartado 4.2.3).
Observemos que realmente no tenemos certeza sobre el tipo dinámico concreto ya que dicho
tipo se ha elegido de forma aleatoria, lo único que sabemos es que, de un modo más genérico,
todos ellos son Figuras. Finalmente se calcula el área de cada figura mediante la sentencia
v[i].area(). En esta situación se tiene que el tipo estático de v[i] es Figura, y puesto
que el método area está definido en dicho tipo, la sentencia v[i].area() es correcta (el
tipo estático indica QUÉ podemos hacer). Sin embargo, ya se ha explicado que realmente
se ejecutará el método area definido en el tipo dinámico (el tipo dinámico indica CÓMO se
hace). Se ejecutará por tanto el método area del objeto que se haya creado en cada caso.
Llegados a este punto no es difı́cil observar que es imposible conocer en tiempo de compi-
lación cuál de los métodos area se va a ejecutar en cada caso, ya que hasta que no se ejecute
el programa no se van a conocer los tipos dinámicos de cada figura. En consecuencia debe
existir un mecanismo que en tiempo de ejecución, y no en tiempo de compilación, sea capaz
de establecer qué método ejecutar en función del tipo dinámico del objeto. Dicho mecanismo
existe en la máquina virtual de Java y se conoce como enlace dinámico o selección dinámica
de método y es el que permite llevar a cabo el polimorfismo en tiempo de ejecución.
El polimorfismo es una caracterı́stica fundamental de los lenguajes orientados a obje-
tos, que permite realizar ciertas abstracciones sobre los tipos de datos. Lo sorprendente del
ejemplo anterior es que el programa principal no necesita saber qué tipo de objetos hay
almacenados en el vector v para poder realizar ciertas operaciones con ellos (calcular el área
en este caso), es suficiente con saber que, de forma genérica, son figuras. Es más, serı́a posible
crear nuevos tipos de figuras, por ejemplo triángulos, y añadirlas en el vector v; el bucle que
calcula el área de cada una de ellas seguirı́a funcionando sin necesidad de ningún cambio,
a pesar de que cuando se escribió ni siquiera existı́a la clase Triangulo. Esto es ası́ porque
realmente a la hora de escribir el bucle que calcula las áreas no estamos concretando el méto-
do area que deseamos ejecutar, sino que lo estamos posponiendo hasta el último momento
(la ejecución del programa) lo que permite en cualquier momento crear nuevas figuras, cada
una con su propio método area.
Supongamos ahora que necesitamos un método que calcule si dos figuras cualesquiera
tienen o no la misma área. Para ello podrı́amos añadir a la clase Figura el método mismaArea.
class Figura {
double area() {
return 0; // No sabemos qué área tiene una figura genérica
4.2. Polimorfismo 99
}
boolean mismaArea(Figura otra) {
double a1 = area();
double a2 = otra.area();
if( a1 == a2 )
return true;
else
return false;
// O simplemente: return ( a1==a2 );
}
}
class Rectangulo extends Figura {
// Igual que en el ejemplo anterior
}
class Circulo extends Figura {
// Igual que en el ejemplo anterior
}
Ahora la clase Figura implementa dos métodos, uno de los cuales (area) se sobreescribe
en las subclases y otro (mismaArea) que se hereda tal cual. Observemos ahora el siguiente
fragmento de código:
Figura f1 = new Rectangulo(10,10);
Figura f2 = new Circulo(5);
if( f1.mismaArea(f2) )
System.out.println("Figuras con la misma área");
El método mismaArea definido en la clase Figura invoca a su vez al método area, pero
¿qué método area se ejecuta en este caso? Tratemos de averiguar qué método area se ejecuta
en la llamada double a1 = area(). Un razonamiento erróneo podrı́a llevar a pensar que,
puesto que estamos ejecutando el método mismaArea que se encuentra en la clase Figura
(ya que no ha sido sobreescrito en Rectangulo ni en Circulo) entonces cuando este mismo
método invoca a su vez a area se estará ejecutando igualmente el método area definido en
Figura.
El error de este razonamiento radica en pensar que se está ejecutando el método mismaArea
de la clase Figura. Realmente dicho método se está ejecutando sobre un objeto de tipo
Rectangulo ya que el tipo dinámico de f1 corresponde a esta clase y, si bien es cierto
que Rectangulo no sobreescribe el método mismaArea, sı́ que lo hereda. En otras pal-
abras, Rectangulo tiene su propio método mismaArea, cuyo código es idéntico al método
mismaArea definido en Figura. Una vez aclarado que se ejecuta el método mismaArea de
Rectangulo, parece lógico pensar que la llamada al método area se ejecutará también sobre
la clase Rectangulo. Ello podrı́a verse más claro si en lugar de escribir
boolean mismaArea(Figura otra) {
double a1 = area();
. . .
}
Sabemos que this siempre hace referencia al objeto que invocó al método. Puesto que en
nuestro ejemplo el método mismaArea fue invocado por f1, mentalmente podemos substi-
tuir this.area() por f1.area(), donde es obvio que f1 referencia a un objeto de tipo
Rectangulo. Por otro lado, en la llamada
double a2 = otra.area();
la referencia otra toma su valor de f2, la cual a su vez referencia a un objeto de tipo
Circulo. En este caso, por tanto, se ejecutará el método area de la clase Circulo.
Nuevamente, lo sorprendente del método mismaArea es que puede comparar las áreas de
cualquier tipo de figura, aunque todavı́a no hayan sido definidas. Si en un futuro definimos la
clase Dodecaedro el método mismaArea podrá trabajar con este tipo de objetos sin necesidad
de cambiar una sola lı́nea de su código. Esto es ası́ porque el método area es un método
polimórfico (cambia de forma, o de código, en función del contexto en el que se ejecuta). El
único requerimiento será que Dodecaedro herede de Figura y que sobreescriba su propia
implementación del método area.
double area() {}
ya que, al menos, debe devolver un valor de tipo double, tal y como indica el tipo del
método. ¿No serı́a posible poder definir métodos sin código para este tipo de situaciones? La
respuesta es sı́, y estos métodos especiales son los denominados métodos abstractos.
Un método abstracto es un método del que únicamente existe la cabecera y que carece de
código. El objetivo de incluir este tipo de métodos en una clase es permitir el polimorfismo en
tiempo de ejecución. La idea, tal y como se verá más adelante, es obligar a que las subclases
que extiendan a la clase donde está definido lo sobreescriban.
En Java se define un método abstracto simplemente anteponiendo la palabra reservada
abstract delante del método, y finalizando el mismo con un punto y coma tras el paréntesis
que cierra la lista de parámetros.
En el ejemplo anterior hubiéramos podido definir el método area abstracto del siguiente
modo:
y
Figura [] v = new Figura[100];
Figura() {
x=0;
y=0;
}
// Resto de métodos
. . .
}
class Circulo extends Figura {
int radio;
// Resto de métodos
4.2. Polimorfismo 103
. . .
}
La instrucción
Circulo c = new Circulo(5);
dará lugar a que se invoque el constructor sin parámetros en la superclase, lo que ini-
cializará los atributos con valores x=0, y=0 y radio=5, mientras que la instrucción
Circulo c = new Circulo(5,10,15);
dará lugar a que se invoque el constructor con parámetros en la superclase, lo que ini-
cializará los atributos con valores x=10, y=15 y radio=5.
También se puede hacer un cambio de tipo temporal sin necesidad de almacenar el nuevo
tipo en otra variable referencia.
Figura f = new Circulo(); // Conversión hacia arriba
((Circulo)f).radio=1; // Acceso a miembros de la subclase
// A continuación f sigue siendo de tipo Figura
En el ejemplo anterior, para acceder a la interfaz completa del objeto Circulo (por
ejemplo para acceder al método setRadio) es necesaria la conversión hacia abajo. Ahora
bien, hemos de tener la certeza de que el objeto que se encuentra referenciado es realmente
del nuevo tipo al que queremos convertirlo, de lo contrario se producirá un error en tiempo
de ejecución, tal y como ocurre en la última instrucción.
En este ejemplo es obvio que v[0] referencia un Rectangulo y v[1] un Circulo, por
lo que es fácil darse cuenta del error cometido en la última instrucción, sin embargo, esto no
siempre es ası́. Hagamos la siguiente modificación sobre el código anterior:
. . .
}
}
Como recomendación final cabrı́a decir que el uso del operador instanceof deberı́a
restringirse a los casos en que sea estrictamente necesario. En la medida de lo posible es
preferible emplear métodos polimórficos que permitan realizar las operaciones requeridas sin
necesidad de conocer con exactitud el tipo concreto del objeto con el que se trabaja.
class Complejo {
double real, imag;
Complejo(double r, double i) {
real = r;
imag = i;
}
106 Capı́tulo 4. Herencia y Polimorfismo
class P {
public static void main(String [] args) {
// Creamos dos números complejos iguales
Complejo c1 = new Complejo(4, 3);
Complejo c2 = new Complejo(4, 3);
if( c1 == c2 )
System.out.println("Objetos con la misma referencia");
else
System.out.println("Objetos con distintas referencias");
if( c1.equals(c2) )
System.out.println("Objetos con la misma información");
else
System.out.println("Objetos con distinta información");
corresponde realmente a una sobreescritura, ya que recibe como parámetro una referencia
de tipo Object. Tal y como se ha visto en apartados anteriores, es perfectamente válido
referenciar un objeto de tipo Complejo mediante una referencia de tipo estático Object, sin
embargo, será necesario cambiar el tipo estático mediante una conversión hacia abajo para
poder acceder a los atributos propios de la clase Complejo.
En cuanto a la sobreescritura de toString, debe entenderse que cuando se utiliza cualquier
objeto como si fuera un String, internamente se invoca el método toString de dicho objeto.
En este sentido, la instrucción
System.out.println("c1 = "+ c1)
serı́a equivalente a
System.out.println("c1 = " +c1.toString());
donde c1.toString()) se sustituye, lógicamente, por la cadena que devuelva el método
toString.
4.3. Interfaces
Se entiende por interfaz de una clase el conjunto de operaciones (métodos) que se pueden
realizar con los objetos de dicha clase. Aunque dicha interfaz puede deducirse fácilmente
observando los métodos públicos implementados en una clase determinada, el lenguaje Java
dispone de un mecanismo para definir de forma explı́cita las interfaces de las clases. Este
mecanismo, más allá de detallar simplemente la interfaz de las clases, aporta mayor nivel de
abstracción al lenguaje, tal y como se irá viendo en los siguientes apartados.
El acceso de una interfaz debe ser público, bien con la palabra reservada public o sin
modificador de acceso (friendly). Después se especifica que la siguiente definición pertenece
a una interfaz utilizando la palabra reservada interface, seguida del nombre de la interfaz
y del bloque de código correspondiente a la definición de la interfaz. Las variables declaradas
en la interfaz son implı́citamente estáticas (static) y finales (final), lo que significa que
han de ser inicializadas con un valor constante y su valor no puede cambiarse posteriormente.
Los métodos no tienen cuerpo puesto que son básicamente métodos abstractos que han de
ser implementados por las clases que implementan la interfaz.
Como se irá viendo a lo largo de esta sección, las interfeces tienen ciertas similitudes
con las clases abstractas. De hecho, una interfaz podrı́a verse como una clase abstracta sin
atributos de instancia y en la que todos sus métodos son abstractos.
2 En este contexto el concepto público no se restringe únicamente a aquellos miembros declarados con la
palabra reservada public sino a aquellos miembros que sean visibles desde otros objetos. El que sean o no
visibles dependerá del modificador de acceso (public, protected, private o friendly), de la relación de herencia
entre las distintas clases y del paquete donde se encuentren.
4.3. Interfaces 109
Como ejemplo se podrı́a definir la interfaz de cierta colección de objetos del siguiente
modo:
interface Coleccion {
void añadirElemento( Object o );
int getNumElementos();
void mostrar();
}
Se puede observar que la interfaz no hace suposiciones acerca de los detalles de imple-
mentación. Básicamente una interfaz define qué operaciones se pueden realizar, pero no
cómo se realizan.
Una vez definida una interfaz, cualquier número de clases puede implementarla. Imple-
mentar una interfaz implica implementar cada uno de los métodos definidos en la misma.
Para indicar que una clase implementa una interfaz determinada, se utiliza la palabra reser-
vada implements con la siguiente sintaxis:
acceso class nombreClase implements NombreInterfaz1[, NombreInterfaz2] {
...
}
Básicamente, todo lo que necesita una clase para implementar una interfaz es sobreescribir
el conjunto completo de métodos declarados en dicha interfaz. En caso de que la clase no
sobreescriba todos los métodos, dicha clase deberá declararse abstracta, ya que contiene
métodos sin implementar. Los métodos definidos en una interfaz deben ser declarados con
public en la clase que los implementa.
Por ejemplo, podrı́amos realizar la siguiente implementación de la interfaz Coleccion
utilizando un vector para almacenar los distintos elementos del conjunto:
Podrı́a realizarse, por otro lado, una implementación alternativa basada en una lista
enlazada:
Conjunto() {
cabeza = null;
numElementos = 0;
}
Una misma interfaz puede ser implementada por más de una clase.
Cualquier clase que implemente una interfaz deberá implementar todos los métodos
definidos en la misma. Si no lo hace se convierte en una clase abstracta (por no tener
todos sus métodos implementados) y deberá declararse como tal mediante la palabra
reservada abstract.
Coleccion c;
if( cierta_condicion )
c = new Conjunto();
else
112 Capı́tulo 4. Herencia y Polimorfismo
c = new ListaEnlazada();
// Añadir elementos
for( int i=0; i<10; i++ )
c.añadirElemento( new Integer(i) );
// Mostrar el contenido
System.out.print("La colección contiene los siguientes ");
System.out.println( c.getNumElementos() + "elementos");
c.mostrar();
En este ejemplo, según ciertas condiciones, se crea un objeto de tipo Conjunto o de tipo
ListaEnlazada. Lo interesante del código anterior es que nuestro programa puede trabajar
perfectamente con la referencia c sin necesidad de conocer qué tipo de objeto se ha creado
realmente bajo dicha referencia. Será en tiempo de ejecución cuando, al invocar cualquiera
de los métodos de c, se decida qué método debe ejecutarse (en nuestro caso un método de
la clase Conjunto o de la clase ListaEnlazada). Ya se vio en el apartado 4.2.4 que este
mecanismo que permite posponer hasta el último momento la decisión del método que debe
ejecutarse se conoce como selección dinámica de método o enlace dinámico 3 y, a la postre,
permite implementar el polimorfismo en tiempo de ejecución.
A continuación se muestra un ejemplo completo en el que se ha definido la interfaz
ConjuntoOrdenable y una clase Ordena con una serie de métodos que permiten ordenar
cualquier conjunto ordenable. Lógicamente, para que un conjunto sea considerado ordenable
debe implementar la interfaz ConjuntoOrdenable. Nuevamente, lo interesante del ejemplo
que se muestra a continuación radica en que los métodos de la clase Ordena no necesitan
conocer el tipo real de los objetos que se están ordenando.
interface ConjuntoOrdenable {
public int getNumElementos();
public boolean menor(int i, int j);
public void intercambiar(int i, int j);
}
class Ordena {
// Este método puede ordenar cualquier conjunto
// que implemente la interfaz ConjuntoOrdenable
static void seleccionDirecta( ConjuntoOrdenable c ) {
int pos_min, N = c.getNumElementos();
for( int i = 0; i <= N-2; i++ ) {
pos_min = i;
for( int j = i+1; j < N; j++ ) {
if( c.menor(j, pos_min) )
pos_min = j;
}
c.intercambiar(i, pos_min);
}
}
static void burbuja( ConjuntoOrdenable c ) {
// Otros métodos de ordenación
// . . .
}
static void quickSort( ConjuntoOrdenable c ) {
3 Algunos autores utilizan el término ligadura tardı́a para referirse a este mismo concepto.
4.3. Interfaces 113
// Métodos propios
ConjuntoPalabras() {
lista = new LinkedList();
}
public void inserta(String s) {
lista.add(s);
}
public String toString() {
String s = "";
for( int i=0; i<lista.size(); i++ )
s = s + lista.get(i) + " ";
return s;
}
// Métodos exigidos por la interfaz ConjuntoOrdenable
public int getNumElementos() {
return lista.size();
}
public boolean menor( int i, int j ) {
String s1 = (String)lista.get(i);
String s2 = (String)lista.get(j);
if( s1.compareTo(s2) < 0 )
return true;
else
return false;
}
public void intercambiar(int i, int j) {
Object pal1 = lista.get(i);
Object pal2 = lista.get(j);
lista.set(j, pal1);
lista.set(i, pal2);
}
}
class EjemploInterfazOrdena {
public static void main( String[] args ) {
ConjuntoPalabras cp = new ConjuntoPalabras();
cp.inserta("las");
cp.inserta("interfaces");
cp.inserta("son");
cp.inserta("muy");
cp.inserta("utiles");
System.out.println(cp);
Ordena.seleccionDirecta(cp);
System.out.println(cp);
114 Capı́tulo 4. Herencia y Polimorfismo
}
}
Podrı́amos ampliar el ejemplo anterior para ilustrar cómo una clase puede implementar
más de una interfaz al mismo tiempo.
interface ConjuntoDesordenable {
public int getNumElementos();
public void intercambiar(int i, int j);
}
class Desordena {
// Este método puede desordenar cualquier conjunto que
// implemente la interfaz ConjuntoDesordenable
static void desordenar( ConjuntoDesordenable c ) {
Random rnd = new Random();
int n = c.getNumElementos();
for(int i=0; i<n*2; i++) {
// Selecciono dos elementos aleatorios y los
// cambio de lugar
int elem1 = Math.abs(rnd.nextInt()) % n;
int elem2 = Math.abs(rnd.nextInt()) % n;
c.intercambiar(elem1, elem2);
}
}
}
class ConjuntoPalabras implements ConjuntoOrdenable,
ConjuntoDesordenable {
. . .
}
Ahora, los objetos de tipo ConjuntoPalabras no sólo pueden ordenarse sino también desor-
denarse. Esto es ası́ porque ConjuntoPalabras implementa tanto la interfaz ConjuntoOrdenable
como ConjuntoDesordenable y, por tanto, cualquier método que requiera como parámetro
objetos de alguno de estos tipos, podrá recibir sin problemas objetos de tipo ConjuntoPalabras.
Por otro lado, el cuerpo de la clase ConjuntoPalabras será igual al del ejemplo anterior
ya que, aunque ahora implementa también la interfaz ConjuntoDesordenable, todos los
métodos requeridos por esta interfaz ya existı́an en la versión anterior y, por tanto, ya
están implementados. De no ser ası́, hubiese sido necesario implementar los nuevos métodos
requeridos por la interfaz ConjuntoDesordenable.
4.4. Ejercicios resueltos 115
Aunque no se haya indicado explı́citamente, se considera que LUNES, MARTES, etc. son
estáticas y finales. Por otro lado, si bien no es un requerimiento del lenguaje, por convenio
las constantes se suelen escribir en mayúsculas.
Un posible uso de la interfaz anterior serı́a:
for( int i = DiasSemana.LUNES; i <= DiasSemana.DOMINGO; i++ ) {
. . .
}
interface I1 {
void metodo1();
void metodo2();
}
interface I2 {
void metodo3();
}
interface I3 extends I1, I2 { // Herencia múltiple entre interfaces
void metodo4();
// metodo1, metodo2 y metodo3 se heredan de I1 e I2
}
class C implements I3 {
// La clase C deberá implementar
// metodo1, metodo2, metodo3 y metodo4
}
class A {
}
class B extends A {
void metodo() {
116 Capı́tulo 4. Herencia y Polimorfismo
System.out.println("Método de B");
}
}
public class Clase {
public static void main( String[] args ) {
A obj = new B();
obj.metodo();
}
}
2. Indica lo que mostrarı́a por pantalla el siguiente programa o, en caso de que sea incor-
recto, explica cuál es el error:
class A {
void metodo() {
System.out.println("Método de A");
}
}
class B extends A {
void metodo() {
System.out.println("Método de B");
}
}
public class Clase {
public static void main( String[] args ) {
A obj = new B();
obj.metodo();
}
}
super.escribe(s);
}
}
Indicar la salida por pantalla que generarı́a cada una de las siguientes sentencias o, en
caso de que alguna de ellas no sea correcta, explicar el error.
class Cuestion {
118 Capı́tulo 4. Herencia y Polimorfismo
6. Reescribe el siguiente código para que realice la misma operación sin utilizar la instruc-
ción instanceof y sin utilizar casting. En la solución aportada se debe usar la técnica
de enlace dinámico.
interface Procesable {}
class A implements Procesable{
void procesarA() { System.out.println("Procesando A") };
}
class B implements Procesable {
void procesarB() { System.out.println("Procesando B") };
}
class Cuestion {
public static void main(String[] args){
Procesable p;
if( cierta_condicion )
p = new A();
else
p = new B();
if( p instanceof A )
((A)p).procesarA();
else
((B)p).procesarB();
}
}
interface I {
int i = 10;
void mostrar();
}
class A implements I {
A(int i) {
this.i = i;
}
void mostrar() {
System.out.println(i);
}
}
abstract class A {
abstract void m1();
void m2() { System.out.println("Soy el método 2 de A");
}
4.4. Ejercicios resueltos 119
class B extends A {
void m2() { System.out.println("Soy el método 2 de B");
}
4.4.2. Soluciones
1. La referencia obj tiene tipo estático A y tipo dinámico B. El tipo estático indicá QUÉ se
puede hacer y el dinámico CÓMO se hace. A pesar de que metodo() está definido en
el tipo dinámico, como no se encuentra en el tipo estático se generará un error de
compilación.
}
}
class C1 {
int i;
C1() { i = 1;}
void m1() { System.out.println( i ); }
void m2() { m1(); m1(); }
}
class C2 extends C1 {
C2() { i = 2; }
void m1() { System.out.println( -i ); }
}
class C3 extends C2 {
C3() { i++; }
void m2() { m1(); }
}
class Herencia_y_Sobreescritura {
public static void main( String[] args ) {
C1 a = new C1();
a.m2();
C1 b = new C2();
b.m2();
C2 c = new C3();
c.m2();
}
}
Todos los elementos (redes, encaminadores y hosts) tienes una dirección asocia-
da formada por dos números enteros. Las redes y los encaminadores tienen una
dirección del tipo X.0, mientras que los hosts tienen una dirección de tipo X.Y.
4.5. Ejercicios propuestos 121
Cada host se conecta a una red determinada. Las direcciones de todos los host de
una misma red tendrán el primer campo en común, que coincidirá a su vez con
el primer campo de la dirección de la red a la que están conectados (por ejemplo,
los hosts con direcciones 128.1, 128.2, etc. deberán pertenecer a la red 128.0).
Las redes deben de mantener una lista de los hosts que están presentes en ella. Para
ello se aconseja que la clase red tenga un atributo privado de tipo LinkedList.
Además, las redes pueden estar conectadas a un encaminador.
Cada encaminador tiene N puertos, a los que pueden conectarse tanto redes como
otros encaminadores. Cuando se crea un encaminador se debe indicar el número
de puertos que tiene.
class Redes {
public static void main(String[] args){
Red r1,r2,r3;
Encaminador e1,e2;
Host h11,h12,h21,h22,h31,h32;
3. Ampliar el programa del ejercicio anterior para que permita el envı́o de mensajes (en
nuestro caso objetos de tipo String) entre dos hosts. Para mandar un mensaje del
host X1.Y1 al host X2.Y2 se sigue el siguiente procedimiento:
Manejo de excepciones
123
124 Capı́tulo 5. Manejo de excepciones
La clase Error también tiene diversas subclases, aunque en general, los programas Java
no suelen estar preparados para detectar y manejar dichos errores.
En la figura 5.1 se representa una pequeña parte de la jerarquı́a de clases de la librerı́a
estándar de Java que representan excepciones.
Throwable
XXX
XXX
9
z
X
Error Exception
XX
? XXX z ...
XXX
XX XXz
-
...
OutOfMemoryError ClassNotFoundException IOException
?
XXX
XXz
X ...
... ?
VirtualMachineError FileNotFoundException
La instrucción utilizada para abrir el fichero data.bin puede producir o lanzar una ex-
cepción, por ejemplo, en caso de que el fichero en cuestión no exista. Además, las operaciones
utilizadas para leer los datos contenidos en el fichero (no indicadas en el ejemplo anterior)
posiblemente también lancen excepciones, si se produce algún error leyendo el fichero. En
caso de que esto ocurra, la ejecución del programa se interrumpe y en la salida de error del
programa se escribe un resultado como el siguiente:
java.lang.FileNotFoundException: data.bin
at Exc0.main(Exc0.java:3).
En este caso, se dice que el programa ha lanzado una excepción. La salida anterior
se conoce como la traza de la excepción y contiene información sobre el error producido
(consultar el apartado 5.3.2).
5.2. Captura de excepciones 125
try {
... // Código que puede generar excepciones
} catch (Tipos de excepciones a capturar) {
... // Código para tratar el error
}
} catch (Exception e) {
System.out.println("No es posible abrir el fichero");
return;
}
Las operaciones que pueden lanzar alguna excepción están protegidas mediante el bloque
try. Si las operaciones protegidas se ejecutan correctamente y no se produce ninguna excep-
ción, entonces la ejecución continúa a partir de la siguiente instrucción al bloque try-catch.
En el ejemplo, una vez leı́dos los datos, se procederı́a a usarlos, según las necesidades del
programa.
En caso de que alguna de las operaciones protegidas lance una excepción, ésta será cap-
turada por el bloque catch. En este bloque se incluye el código manejador de la excepción.
En el ejemplo anterior, el manejo de la excepción consiste únicamente en informar al usuario
mediante un mensaje escrito en la salida estándar y ejecutar la sentencia return, que termi-
na inmediatamente la ejecución del método actual. Como este método es el propio método
main, el efecto de la sentencia return es el de terminar la ejecución del programa.
126 Capı́tulo 5. Manejo de excepciones
En la declaración del bloque catch, se utiliza la expresión Exception e, con dos obje-
tivos. En primer lugar, esta expresión indica el tipo de excepciones que van a ser capturadas
en caso de que se produzcan. En el ejemplo anterior, se captura cualquier excepción de tipo
Exception o de cualquiera de sus subclases. Además, la expresión ”Exception e” es también
la declaración de una variable e que representa a la propia excepción y permite obtener
información relativa a la misma (tal como se presenta en el apartado 5.3). El ámbito de esta
variable es solo el bloque catch, por lo que no puede ser utilizada fuera de dicho bloque.
Una vez ejecutado el bloque catch, la ejecución del programa continúa en la instrucción
siguiente al bloque try-catch, a menos que la ejecución sea alterada de alguna manera, por
ejemplo, mediante una sentencia return, como en el ejemplo anterior. En el apartado 5.4.1
se introduce otra forma de alterar el flujo del programa dentro de un bloque catch. En el
ejemplo anterior, otro posible tratamiento de la excepción podrı́a consistir en asignar unos
datos por defecto (y no ejecutar ninguna sentencia return), de manera que la ejecución del
programa pueda continuar.
En el ejemplo anterior, se indica que el bloque try-catch está capturando una excepción
(de tipo FileNotFoundException que nunca podrá ser lanzada por el código incluido en el
bloque try.
Por último, conviene saber que existe un cierto subconjunto de tipos de excepciones que
no necesitan ser explı́citamente capturadas. Estos tipos de excepciones se conocen como
excepciones no capturadas (se presentan en el apartado 5.2.7. En estos casos, el compilador
no obliga a capturarlas mediante bloques try-catch (o cláusulas throws).
Asegurando el estado
Conviene tener en cuenta que, en caso de que se produzca una excepción al ejecutar un
cierto conjunto de instrucciones contenidas en un bloque try, en general no se sabe con
seguridad qué instrucciones se han ejecutado correctamente, cuáles han fallado y cuáles ni
siquiera se han ejecutado. En general, en el bloque catch se debe asumir que todas las
instrucciones del bloque try han fallado.
En el ejemplo anterior, se podrı́a sustituir el bloque catch propuesto, por éste otro:
} catch (Exception e) {
// Asignación de valores por defecto
d1 = 0;
d2 = -1;
d3 = 1000;
}
Ası́, la ejecución del programa podrı́a continuar, utilizando unos valores por defecto (en
lugar de terminar la ejecución, como en el ejemplo inicial). En este caso, es necesario dar un
valor por defecto a los tres datos leı́dos en el bloque try, porque no se sabe con seguridad
qué datos han sido leı́dos correctamente y cuáles no.
try {
FileInputStream f = new FileInputStream("data.bin");
se ejecutará ningún otro bloque, sino que la ejecución del programa continuará a partir de
la sentencia siguiente al bloque try-catch.
Por último, conviene tener en cuenta que los nombres de las variables utilizados en las
cláusulas catch no deben colisionar entre sı́ ni con ninguna otra variable o atributo. En el
ejemplo anterior, se han utilizado las variables ioe, para el bloque que captura IOException
y e, para el bloque que captura Exception (asumiendo que no hay ningún atributo ni variable
llamados ioe o e). Es una buena práctica utilizar algún convenio para nombrar las variables
utilizadas en las cláusulas catch. Un convenio conocido es utilizar las iniciales de cada tipo
de excepción (ioe para IOException, fnfe para FileNotFoundException, etc.). Puede
ocurrir que en un mismo ámbito (por ejemplo, en un mismo método, haya varios bloques
try-catch, que capturen el mismo tipo de excepción. En este caso, se recomienda numerar
las variables (por ejemplo, ioe, ioe2, etc., para distinguir distintas excepciones de tipo
IOException).
if (datosLeidos == false) {
try {
FileOutputStream f2 = new FileOutputStream("incidencias.log")
f2.write(...);
} catch (Exception e2) {
...
}
}
En el apartado 5.4 se relacionan los bloques try-catch anidados con otras caracterı́sticas
del tratamiento de excepciones en Java.
FileInputStream f = null;
int a, b;
try {
f = new FileInputStream(fichero);
a = f.read();
b = f.read();
...
} catch (IOException e) {
...
} finally {
if (f != null)
f.close();
}
En el ejemplo anterior, se utiliza un bloque finally para cerrar el flujo de datos, en caso
de que haya sido abierto.
En el apartado 5.4 se relaciona la cláusula finally con otras caracterı́sticas del tratamien-
to de excepciones en Java y los bloques try-catch.
try {
// Fragmento de código que puede generar una excepción
} catch (tipo_de_excepción variable) {
// Fragmento de código manejador de la excepción
} catch (tipo_de_excepción variable) {
// Fragmento de código manejador de la excepción
} ... {
} finally {
// Código que se ejecuta siempre
}
5.2. Captura de excepciones 131
en caso de que el valor de i no sea válido (cuando es menor que 0 o mayor o igual que
enteros.length).
Existen otros casos muy comunes como las excepciones de tipo ArithmeticException,
que se lanza, por ejemplo, al hacer una división entre cero, o las de tipo ClassCastException,
que se lanzan cuando se intenta hacer una operación de casting incorrecta, como la siguiente:
Linea linea = new Linea(punto1, punto2);
Cuadrado cuadrado = (Cuadrado)linea;
Si se quisiera proteger el código que puede lanzar estas excepciones, prácticamente habrı́a
que proteger cualquier lı́nea de código dentro de algún bloque try-catch. El resultado serı́a
un programa poco legible e inmantenible.
Para evitar este problema, éstas y otras excepciones no necesitan ser capturadas. En su
lugar, se confı́a en que el programador tomará las medidas necesarias para evitar que pasen.
Por ejemplo, para evitar las excepciones de tipo NullPointerException, el programador
debe asegurarse de inicializar correctamente sus objetos. Además, puede hacer comproba-
ciones del tipo if (objeto == null) ..., para evitar que ocurran dichas excepciones.
Para evitar excepciones de tipo IndexOutOfBoundsException, el programador debe ase-
gurarse de que los ı́ndices utilizados en los accesos a arrays son correctos. En el caso de
las excepciones de tipo ArithmeticException, se deben hacer las comparaciones sobre los
operandos de las expresiones matemáticas a evaluar y en el caso de las excepciones de tipo
ClassCastException, se puede hacer uso del operador instanceof para comprobar previ-
amente que el cast a realizar es correcto. En otros casos, el programador deberá hacer las
comprobaciones correspondientes.
Todos los tipos de excepciones que no necesitan ser capturadas son subclases (directas
o indirectas) de RuntimeException, que a su vez es una subclase de Exception, como se
indica en la figura 5.2.
A este tipo de excepciones se les suele llamar excepciones no capturadas 3 , porque no
suelen capturarse explı́citamente.
Conviene notar que, en caso de que sea necesario por algún motivo, estas excepciones
pueden ser capturadas como cualquier otra. En el siguiente ejemplo se manejan de forma
distinta las excepciones debidas a la evaluación matemática y el resto de excepciones:
3 En los libros y manuales escritos en inglés suelen llamarse non-checked exceptions.
132 Capı́tulo 5. Manejo de excepciones
Throwable
?
XX
XXX
z...
Exception
z ...
XXX
? XX
RuntimeException
z ...
H XXX
HH XX
)
j
H
IndexOutOfBoundsException ArithmeticException
int resultado;
try {
dato1 = ...
dato2 = ...
resultado = ...
} catch (ArithmeticException ae) {
System.out.println("Los operandos no son correctos");
resultado = 0;
} catch (Exception e) {
return;
}
Conviene notar que este uso de los bloques try-catch es, en cierta manera, una forma
de controlar el flujo del programa. Por ejemplo, el ejemplo anterior es similar al siguiente:
int resultado;
dato1 = ...
dato2 = ...
if (correctos(dato1, dato2) == true) {
resultado = ...
} else {
...
}
Aunque es posible utilizar los bloques try-catch para realizar el control de flujo de un
programa, en general no es recomendable . En su lugar, es preferible utilizar sentencias de
control de flujo convencionales (por ejemplo, condiciones if).
try {
C c = new C();
c.m1();
} catch (FileNotFoundException fnfe) {
System.out.println(fnfe.getMessage());
}
try {
FileInputStream f;
f = new FileInputStream("fichero.dat");
...
} catch (FileNotFoundException fnfe) {
fnfe.printStackTrace();
}
Como en casos anteriores, es necesario proteger mediante un bloque try-catch las in-
strucciones anteriores, frente a las excepciones de tipo IOException que puedan producirse.
El método modificado serı́a el siguiente:
}
}
Una alternativa serı́a propagar las excepciones, lo que permitirı́a retrasar su manejo. En
lugar de utilizar un bloque try-catch que contenga las instrucciones que pueden lanzar
excepciones, esta alternativa consiste en utilizar una cláusula throws, en la declaración del
método que contiene dichas instrucciones, de la siguiente manera:
Mediante la cláusula throws, se está indicando que el código del método leerDatos
puede lanzar excepciones de tipo IOException. Esto obliga a que cualquier invocación del
método leerDatos esté protegida mediante un try-catch donde se capturen las excepciones
de tipo IOException (o alguna clase padre, como Exception):
En este caso, el bloque catch solo captura las excepciones de tipo ArithmeticException.
Las posibles excepciones de tipo IOException son propagadas al método invocante (el méto-
do calcularBalance, del ejemplo anterior) y capturadas por éste.
try {
...
} catch (Exception e) {
...
throw e;
} finally {
...
}
Si se produce una excepción de un tipo distinto a IOException, por ejemplo una excep-
ción de tipo NullPointerException, el bloque catch no se ejecutará, pero sı́ se ejecutará el
bloque finally. Por último, se propagará la excepción al método invocante.
138 Capı́tulo 5. Manejo de excepciones
En esta nueva versión, se lanza una excepción en caso de que los parámetros no sean
correctos. Esta excepción es de tipo IllegalArgumentException, un subtipo de Exception,
utilizado para señalar precisamente aquellas situaciones en que los parámetros o datos de
entrada proporcionados no son correctos por algún motivo.
De esta forma, no es necesario utilizar ningún valor especial para señalar una situación
anormal y por tanto el método que invoca al método calcularBalance no tiene por qué cono-
cer ningún valor especial.
En el ejemplo anterior, en lugar de utilizar la clase Exception como clase base se podrı́a utilizar la clase
IllegalArgumentExcepion, que en general se utiliza para representar excepciones producidas por operaciones
cuando reciben parámetros incorrectos.
140 Capı́tulo 5. Manejo de excepciones
Esta excepción se podrı́a capturar igual que el resto de excepciones, como se ha indicado
en apartados anteriores. Por ejemplo, es posible utilizar el siguiente código:
try {
otroMetodo(1.0, 2.0, 3.0);
} catch (Exception e) {
e.printStackTrace();
}
Nótese que en la primera lı́nea de la traza se incluye la cadena devuelta por el método
getMessage sobreescrito en ParametrosException.
5.6. Cuestiones
1. Indica cuál es la clase base de la jerarquı́a de excepciones de Java. Indica cuáles son sus
subclases directas y las diferencias entre ellas. Consulta la ayuda de la librerı́a estándar
para obtener más información.
2. Indica el nombre de tres tipos de excepciones que no se hayan nombrado en este
capı́tulo. Para ello, consulta la ayuda de la librerı́a estándar de Java.
3. Explica qué ventajas e inconvenientes presentan las excepciones no capturadas frente
el resto de excepciones.
4. Explica en qué casos es necesario hacer una captura múltiple de excepciones (mediante
varios bloques catch).
5. Explica la utilidad de los bloques finally. Indica en qué casos son obligatorios.
Solución
3. Modifica el siguiente código para que propague las excepciones, en lugar de capturarlas:
142 Capı́tulo 5. Manejo de excepciones
try {
FileInputStream f = new FileInputStream("f.txt");
i = f.read(...);
...
} catch (IOException e) {
System.out.println("Error de entrada/salida: " + e.getMessage());
return;
} catch (Exception e) {
e.printStackTrace();
return;
}
if (i == 0)
...
}
Solución La solución más sencilla consiste en eliminar la cláusula try y los bloques
catch y añadir la cláusula throws, como se indica a continuación:
if (i == 0)
...
}
Sin embargo, conviene tener que con esta solución se elimina la posibilidad de manejar
de forma diferente excepciones de distinto tipo.
public void m1 () {
try {
m2(1, 0);
} catch (ArithmeticException ae) {
System.out.println("Error aritmético al ejecutar m2");
ae.printStackTrace();
}
}
float f = a/b;
System.out.println("f = " + f);
} catch (ArithmeticException ae) {
ae.printStackTrace();
throw ae;
} catch (Exception e) {
System.out.println("Error de otro tipo");
e.printStackTrace();
}
}
2. Dadas las siguientes clases Java, indicar qué se escribe en la salida estándar cuando se
ejecuta el método main:
class C {
private int a;
public void m1 () {
a = 0;
m2();
System.out.println(a);
}
public void m2 ()
throws NullPointerException {
try {
m3();
} finally {
System.out.println(a);
a = 1;
}
System.out.println(a);
}
private void m3 () {
if (a == 0)
throw new NullPointerException();
}
}
public class TryFinally {
public static void main (String [] args) {
new C().m1();
}
}
144 Capı́tulo 5. Manejo de excepciones
Capı́tulo 6
6.1. Introducción
Un applet es una aplicación Java diseñada para ejecutarse en el contexto de un navegador
web. De la misma forma que un navegador carga texto, gráficos y sonido a partir de las
indicaciones contenidas en un fichero html, puede cargar el código de un applet Java y
lanzarlo a ejecución en respuesta a una etiqueta (tag) especı́fica contenida en dicho fichero
html.
El applet es responsable de la gestión de lo que se denomina área de interacción del applet,
que es una parte del documento web. Este esquema obliga a abandonar la entrada/salida
orientada a consola y a trabajar en modo gráfico. Una interfaz gráfica facilita la interacción
y permite mejorar la cantidad o calidad de la información que se muestra, pero desde el
punto de vista del programador presenta nuevas necesidades e introduce cierto grado de
complejidad:
Se rompe la noción de secuencialidad: en una interfaz basada en texto hay una secuen-
cia clara de introducción de datos y visualización de resultados (esquema rı́gido pero
simple); una interfaz gráfica permite que el usuario interaccione con mucha mayor lib-
ertad, sin imponer un orden estricto (por ejemplo, al rellenar un formulario los campos
pueden cumplimentarse en cualquier orden). Para abordar este tipo de problemas se
utiliza la programación dirigida por eventos. Se entiende por evento cualquier acción
externa a la aplicación que pueda afectar a la misma (en este caso cualquier acción del
usuario, tal como pulsación de una tecla o utilización del ratón). El sistema registra los
eventos y los almacena en una cola (cola de eventos). La aplicación extrae los eventos
de la cola y determina la acción a realizar en respuesta a cada uno.
Se necesita un conjunto de primitivas gráficas que permitan manipular la pantalla,
ası́ como bibliotecas que soporten los distintos componentes de interfaz (menús, botones,
áreas de texto, barras de desplazamiento, etc.). Además, debe gestionarse la ubicación
de dichos componentes dentro del área de interacción del applet mediante potentes
esquemas de ubicación que permitan especificar relaciones entre las posiciones de los
componentes en lugar de posiciones absolutas. Esto es necesario ya que un applet debe
integrarse en un documento html que no se muestra con un formato fijo sino que se
presentará de forma ligeramente distinta en navegadores distintos.
145
146 Capı́tulo 6. Interfaz gráfica de usuario y applets
Una aplicación Java autónoma (lanzada directamente desde el sistema operativo) tı́pica-
mente funciona o en modo consola o en modo gráfico. Un applet únicamente puede funcionar
en modo gráfico. Una aplicación autónoma en modo gráfico es tan parecida a un applet que
se pueden construir fácilmente programas que se ejecuten indistintamente desde el sistema
operativo (como aplicación autónoma) o en el contexto de un navegador (como applet).
6.2. Applets
6.2.1. Concepto de applet
Un navegador web es un programa diseñado para descargar un fichero html (a partir
del almacenamiento local o a través de la red), interpretar su contenido, y crear una imagen
del mismo. Un fichero html contiene un conjunto de etiquetas (tags) que delimitan sus
contenidos. El estándar html define distintas etiquetas para propósitos diferentes: delimitar
un enlace dinámico, indicar un tipo de letra especı́fico, indicar la inclusión de un fichero
de imagen o de sonido, etc. Además, define también una etiqueta especı́fica para incluir
referencias a programas Java (applets).
Supongamos que se ejecuta un navegador web para acceder a un fichero html que contiene
la siguiente información (los puntos suspensivos indican información adicional que no afecta
a la discusión),
import java.awt.Graphics;
import javax.swing.JApplet;
<HTML>
<HEAD><TITLE>Saludo</TITLE></HEAD>
<BODY>
<APPLET CODE="Hola.class" WIDTH="100" HEIGHT="50"></APPLET>
</BODY>
</HTML>
148 Capı́tulo 6. Interfaz gráfica de usuario y applets
Al igual que cualquier otro programa Java, el fichero .java contiene sentencias de im-
portación (en este ejemplo import java.awt.Graphics, donde se definen las primitivas
gráficas; e import javax.swing.JApplet, clase base para crear los applets en Swing), y
una secuencia formada por una o más clases, de las cuales, una es la principal (en este ejem-
plo sólo hay una, y se denomina Hola). La diferencia estriba en que en un applet la clase
principal es una extensión de la clase JApplet.
Para ejecutar el applet, el navegador crea una instancia de la clase principal (en el ejemplo,
de la clase Hola) y provoca la invocación de distintos métodos del applet en respuesta a
distintas situaciones (por ejemplo, inicio o fin de la ejecución, el área de interacción ha
quedado oculta, etc). Todo applet debe ajustarse a un marco estricto que define su ciclo de
vida (mecanismos para iniciar, parar, reanudar y terminar un applet).
Cuando el navegador ha cargado los bytecodes correspondientes a la clase principal (la
extensión de JApplet), crea una instancia de la misma sobre la que invoca el método init().
El método init() es el punto de entrada al applet y normalmente se utiliza para inicializar
las variables necesarias y dibujar los componentes de interacción. En este caso no se necesita
código alguno en init(), ya que no existen variables en la clase, ni se utilizan componentes
de interacción, por lo que no se sobreescribe la versión por defecto proporcionada por la clase
JApplet.
El navegador invoca el método paint() del applet cada vez que necesita redibujar el
área de interacción (por ejemplo, al visualizar el documento por vez primera, o cada vez que
la zona vuelve a ser visible después de haber permanecido oculta –por ejemplo, estaba tras
otra ventana, la ventana del navegador estaba minimizada, etc.–). En el ejemplo, paint()
dibuja en pantalla el saludo, para lo cual utiliza el método drawString() definido en la clase
Graphics. El parámetro de paint() es de tipo Graphics, y corresponde al contexto gráfico
asociado al área de interacción del applet, por lo que los métodos invocados sobre dicho
parámetro afectan al área de interacción. El aspecto visual de este applet en un navegador
es el que se muestra en la figura 6.1.
vida del applet. En la tabla 6.1 se definen las acciones que deben realizar los métodos y
cuándo son invocados.
6.3. Gráficos
Java proporciona distintas primitivas para dibujar figuras, mostrar texto, gestionar col-
ores, etc.
6.3.2. Figuras
Toda acción de dibujo de figuras (lı́neas, rectángulos, óvalos, polı́gonos y sus rellenos)
se lleva a cabo a través de la clase Graphics (o contexto gráfico), que define los distintos
métodos para dibujar figuras. Cada objeto de tipo Graphics posee su propio origen de
coordenadas, colores de dibujo y fondo, etc.
El código de dibujo debe aparecer en el método paint(Graphics g) del applet, de forma
que se pueda reconstruir el contenido dibujado en el applet cuando lo solicita el navegador.
150 Capı́tulo 6. Interfaz gráfica de usuario y applets
Acción Método
Dibujar lı́nea drawLine(x1, y1, x2, y2)
Dibujar rectángulo drawRect(x, y, ancho, alto)
Dibujar rectángulo relleno fillRect(x, y, ancho, alto)
Borrar rectángulo clearRect(x, y, ancho, alto)
Dibujar óvalo drawOval(x, y, ancho, alto)
Dibujar óvalo relleno fillOval(x, y, ancho, alto)
Dibujar arco drawArc(x, y, ancho, alto, angIni, angArc)
Dibujar arco relleno fillArc(x, y, ancho, alto, angIni, angArc)
Dibujar polı́gono drawPolygon(p)
Ejemplos de utilización de los métodos de la tabla 6.2 son los siguientes (g es un objeto
de tipo Graphics):
g.drawLine(0, 0, 99, 99);
g.drawRect(20, 20, 20, 20);
g.fillRect(40, 40, 15, 25);
g.clearRect(30, 30, 5, 5);
g.drawOval(25, 0, 50, 25);
g.fillOval(25, 75, 50, 25);
g.drawArc(57, 37, 30, 20, 45, 90);
g.fillArc(57, 42, 30, 20, 45, 90);
int[] x = {25, 40, 10}, y = {60, 70, 90};
Polygon p = new Polygon(x, y, 3);
g.drawPolygon(p);
6.3.3. Color
Java define la clase Color, que declara diferentes constantes estáticas que corresponden
a otros tantos colores predefinidos: Color.black, Color.white, Color.red, Color.blue,
Color.green, etc.). Además, la clase Color permite construir cualquier otro color especifi-
cando en el constructor sus valores RGB.
Una vez definidos los colores, es posible especificar el color de dibujo y el color de fondo
(setForeground(color) y setBackground(color), respectivamente). El color de dibujo
se utiliza en las primitivas gráficas (las descritas en el apartado anterior y la correspondiente
al texto, que se introduce en el apartado siguiente). El color de fondo corresponde al fondo
del componente. También se definen primitivas para obtener los colores de dibujo y fondo
(getForeground() y getBackground(), respectivamente).
setForeground(Color.red);
g.drawLine(0, 0, 99, 99); // se pinta en rojo
6.3. Gráficos 151
6.3.4. Texto
La primitiva básica de Graphics para mostrar texto en la zona de interacción del applet
es drawString(texto, x, y) (similar a los otros métodos de dibujo de figuras). Pero,
además, se pueden controlar aspectos tales como el tipo de letra que se utiliza para mostrar
el mensaje, o el tamaño o atributos del mismo.
La clase Font describe tipos de letra. Se puede construir un tipo de letra a partir de
la denominación (por ejemplo, Serif, Helvetica, Courier), atributo (la clase Font define
las constantes ITALIC, BOLD, PLAIN) y tamaño (por ejemplo, 12, 14, 18). Todo componente
Java (por ejemplo, un applet) define el método setFont(tipoLetra), mediante el que se
puede asociar un tipo determinado de letra a dicho componente. La clase Graphics también
define este método para el dibujado de cadenas de caracteres.
import java.awt.*;
import javax.swing.*;
import java.applet.*;
import java.awt.*;
import javax.swing.*;
Ya hemos visto anteriormente que la clase Graphics permite dibujar cadenas de texto.
Las diferencias entre una etiqueta creada mediante drawString() y otra creada mediante
un JLabel son las siguientes:
un JLabel dispone, además, de métodos diversos (por ejemplo, para asociar un icono
a la etiqueta).
Como métodos más usados, se pueden destacar los que permiten obtener y modificar el
texto contenido en el campo:
Área de edición de texto (JTextArea) Es un campo compuesto por varias lı́neas (per-
mite visualizar una cadena de caracteres única que incluye caracteres de salto de lı́nea).
Durante la construcción se fijan las dimensiones iniciales (altura y anchura) del campo. Si
el texto que contiene ocupa más que dicho tamaño inicial, el área aumenta su tamaño. Si
lo que queremos es que mantenga el tamaño inicial y se cree una barra de desplazamiento
(scroll) de ser necesario, el componente deberá mostrarse dentro de un JScrollPane.
Igual que en el caso del JTextField, JTextArea dispone de los métodos getText() y
setText(), con los que se obtiene y modifica el contenido del área de texto.
154 Capı́tulo 6. Interfaz gráfica de usuario y applets
Elección (JComboBox) Son menús desplegables (pop-up) cuya etiqueta es la entrada ac-
tualmente seleccionada en el menú. Cuando se selecciona una entrada genera un evento que
indica la entrada seleccionada. Se pueden hacer editables, de forma que el usuario puede
introducir un nuevo valor.
Conmutador (JCheckBox y JRadioButton) Es una etiqueta con una pequeña zona sensi-
ble a pulsaciones de ratón y que posee dos estados: cierto (marcado) y falso. Cada pulsación
conmuta el estado (por defecto está a falso).
Ambos componentes poseen el método isSelected() que devuelve el estado del conmu-
tador: true si está marcado y false en otro caso.
grupoConmutadores1.add(conmutadorGrupo1);
grupoConmutadores1.add(conmutadorGrupo2);
Lista (JList) Es una lista de opciones entre las cuales, dependiendo de un atributo, pode-
mos seleccionar una (al seleccionar una se deselecciona la previamente seleccionada) o varias
(se pueden mantener tantas entradas seleccionadas como se desee).
El método getSelectedValue() devuelve el ı́tem seleccionado y getSelectedIndex(),
el ı́ndice correspondiente a dicho ı́tem (el primer ı́tem ocupa la posición 0). Cuando se per-
mite selección múltiple se deben utilizar getSelectedValues() y getSelectedIndices()
respectivamente (devuelven como respuesta un vector en lugar de un valor único).
Para obtener el valor actual del control, se dispone del método getValue().
4. Crear nuevos JMenu para incorporarlos como submenús dentro de otro JMenu, de ser
necesario.
5. Incorporar los objetos JMenu a la JMenuBar (en el orden en que deben aparecer de
izquierda a derecha).
El resultado visual del menú del código anterior es el mostrado en la figura 6.2.
import java.awt.*;
import javax.swing.*;
6.5.1. Contenedores
En este libro nos centraremos en un único tipo de contenedor: el panel. De esta forma,
todos los componentes los añadiremos a un panel existente. Hay que recordar que todo
JApplet incorpora por defecto un contentPane como panel principal, de tal forma que
cuando invocamos el método add() sobre un JApplet para incorporar un componente, en
realidad se está añadiendo dicho componente al contentPane por defecto. De la misma
forma, y como veremos más adelante, cuando invocamos setLayout() sobre un JApplet, lo
que estamos cambiando es el gestor de ubicación de su contentPane. Este comportamiento
permite tratar a un JApplet como si se tratara de un panel a estos efectos.
A continuación se describen los contenedores proporcionados por Swing.
Marco (JFrame) Un JFrame es lo que visualmente conocemos como ventana. Posee borde
y tı́tulo y puede incluir una barra de menú. Los objetos de tipo JFrame son capaces de
generar varios tipos de eventos (por ejemplo, WindowClosing cuando el usuario pincha con
el ratón sobre el icono cerrar en la barra de tı́tulo del JFrame).
Diálogo (JDialog) Es una ventana con borde y tı́tulo que permite recoger entradas del
usuario. El diálogo se lanza desde otra ventana, y puede ser modal (todas las entradas del
usuario las recoge este diálogo, por lo que no se puede proseguir con la aplicación hasta
concluir el diálogo) o no modal (se puede mantener el diálogo abierto e interactuar con
diálogo y aplicación simultáneamente), según se indique en el constructor (también puede
conmutarse a modal una vez creado). Se puede mover (libremente, sin restringirlo a las
dimensiones del padre) y redimensionar, pero no minimizar o maximizar.
ese componente). Los contenedores también pueden indicar el espacio alrededor de su bor-
de interior que debe quedar libre (no se situará ningún componente) mediante el método
getInsets(). El gestor de ubicación parte de estas indicaciones para cada componente del
conjunto de componentes a gestionar y, según la polı́tica establecida (por ejemplo, situar en
una rejilla), intenta obtener el mejor resultado visual posible.
Existe un conjunto de gestores de ubicación ya definidos y, además, se pueden crear otros
propios. Los gestores de ubicación ya definidos más comunes se describen a continuación.
Flujo (FlowLayout) Ubica los componentes de izquierda a derecha hasta agotar la lı́nea, y
entonces pasa a la lı́nea siguiente. En cada lı́nea, los componentes están centrados. Es el que
se utiliza por defecto en JPanel. El siguiente código mostrarı́a el aspecto visual capturado
en la figura 6.41 .
import java.awt.*;
import javax.swing.*;
Bordes (BorderLayout) Es el empleado por defecto en JApplet. Posee cinco zonas: norte,
sur, este, oeste y centro. Cuando se añade un componente se indica su ubicación (por ejemplo,
norte). No es necesario cubrir todas las zonas. Una caracterı́stica importante de este gestor
de ubicación es que redimensiona cada componente para que ocupe todo el espacio de la zona
en la que se inserta. De esta forma, sólo se visualiza un componente por zona (el último,
si se añade más de uno en la misma zona). Para ubicar varios componentes en la misma
zona, se debe añadir un contenedor como único componente de la zona y colocar en él los
componentes deseados.
El código siguiente ofrece el resultado visual de la figura 6.5.
1 Otro ejemplo de uso de este gestor de ubicación está en la sección 6.4.2.
6.5. Contenedores y gestores de ubicación 161
import java.awt.*;
import javax.swing.*;
import java.awt.*;
import javax.swing.*;
add(pantalla);
add(teclado);
}
perderá.
164 Capı́tulo 6. Interfaz gráfica de usuario y applets
ejemplo, un botón genera un evento cada vez que el usuario lo pulsa. En este caso, el evento
generado es la pulsación y la fuente del evento es el botón (la fuente no es el ratón ni el
usuario, sino el componente de interacción). Adicionalmente, diversos elementos se pueden
registrar como oyentes en las fuentes que sean de su interés, con el fin de ser invocados
cada vez que se genera un evento, para realizar las acciones pertinentes. Este esquema de
programación se conoce con el nombre de programación dirigida por eventos.
Siguiendo un esquema parecido, y como ya vimos al principio del tema, el navegador puede
generar eventos de repintado cuando detecta que es necesario actualizar (repintar) la zona
de interacción del applet (por ejemplo, cuando dicha zona vuelve a quedar visible después
de haber permanecido parcialmente cubierta por otra ventana, o se recarga el documento
html, o se ha minimizado y vuelto a maximizar la ventana del navegador, etc.). La gestión
de dicha zona es responsabilidad exclusiva del applet, con lo que el applet se convierte en
oyente de los eventos de repintado. La diferencia con la arquitectura general es que, para
recibir eventos de repintado, el applet no necesita registrarse como oyente especı́ficamente
en ninguna fuente.
6.6.1. Eventos
Existen muchos tipos de eventos distintos. Clases de eventos diferentes se represen-
tan mediante distintas clases Java, todas ellas subclase de java.util.EventObject. En
este texto analizamos los eventos generados por el usuario (ratón y teclado, y acción so-
bre los distintos componentes de interacción). Todos los eventos AWT derivan de la clase
java.awt.AWTEvent (subclase de java.util.EventObject), y se incluyen en el paquete
java.awt.event.
Cada evento es generado por un objeto fuente (puede obtenerse mediante getSource())
y posee un tipo (puede obtenerse con getID()). El tipo se utiliza para distinguir los dis-
tintos tipos de eventos representados por la misma clase de evento (por ejemplo, la clase
MouseEvent define, entre otros, MOUSE_CLICKED y MOUSE_DRAGGED). Cada clase de evento
posee el conjunto de métodos adecuado para los eventos que representa (por ejemplo, sobre
los objetos de tipo MouseEvent se pueden invocar métodos tales como getX(), getY() y
getClickCount()).
define una interfaz de oyente para cada tipo de evento que define (excepto para los eventos
de ratón, sobre los que define dos oyentes, MouseListener y MouseMotionListener).
Cada interfaz de oyente puede definir varios métodos (por ejemplo, MouseEvent repre-
senta eventos tales como pulsar el boton del ratón, liberarlo, desplazar el ratón, etc., y cada
uno de estos eventos supone invocar un método distinto). Todos estos métodos reciben como
único parámetro el objeto evento, por lo que éste debe contener toda la información relativa
al evento que el programa pueda necesitar. La tabla 6.4 recoge, para las principales clases
de eventos, las interfaces que los oyentes deben implementar y los métodos de cada interfaz.
Una vez creada la clase que implementa la correspondiente interfaz, se debe crear una
instancia (objeto oyente) y registrarla en la fuente de eventos (siempre será algún componente
de interacción), mediante el correspondiente método addXListener().
6.6. Programación dirigida por eventos 167
import java.awt.event.*;
import javax.swing.*;
import java.awt.event.*;
import javax.swing.*;
import java.awt.event.*;
import javax.swing.*;
addMouseMotionListener(new MouseMotionAdapter() {
public void mouseDragged (MouseEvent e) {
int x = e.getX(), y = e.getY();
// recta desde punto anterior
getGraphics().drawLine(x0, y0, x, y);
x0 = x;
y0 = y;
}
});
}
}
5 Al proporcionar sólo el nombre de la clase padre o de la interfaz implementada, no se asigna un nombre
Además de los campos obligatorios (CODE, WIDTH, HEIGHT), se puede añadir el atributo
CODEBASE para indicar la url donde está el código (sólo es necesario si no coincide con la
ubicación del fichero html):
<APPLET CODEBASE="una URL" CODE="Ejemplo.class"
HEIGHT=100 WIDTH=50></APPLET>
Cada parámetro requiere su propia etiqueta <PARAM>, donde se indica el nombre del
parámetro y su valor (en ambos casos se trata de cadenas de caracteres). Para acceder a los
parámetros desde el applet se invoca getParameter(nombreParametro), que devuelve una
cadena de caracteres que corresponde al valor del parámetro indicado.
import javax.swing.*;
Fichero Java:
import java.awt.*;
import javax.swing.*;
import java.util.StringTokenizer;
En algunos casos estas restricciones pueden parecer excesivas. Cada navegador puede
definir distintos niveles de restricciones, de forma que el usuario puede relajar las restricciones
si lo desea. Sin embargo, resulta más útil asociar una firma digital al fichero, de forma que
si se carga un applet firmado por un servidor que ha sido etiquetado como fiable, se relajan
las restricciones de ejecución.
174 Capı́tulo 6. Interfaz gráfica de usuario y applets
Pero no todo son restricciones, ya que los applets disfrutan de un conjunto de posibilidades
vedadas a una aplicación Java autónoma, como abrir conexiones de red con la máquina
remota, visualizar documentos html, o invocar métodos públicos de otros applets en la
misma máquina.
Estas directrices, aunque quizás más laboriosas que simplemente colocar el código de
pintado en el método paint() del applet (como se hace por simplicidad en algunos ejemplos
del tema), son más seguras puesto que evitan ciertos comportamientos no deseados que
suceden a veces al redibujar las interfaces.
6.10. Cuestiones
Cuestión 1 ¿En qué se diferencian una aplicación Java autónoma y un applet?
Cuestión 2 ¿Cuáles son los métodos que constituyen el ciclo de vida de un applet?
Cuestión 3 ¿Qué utilidad tienen los contenedores y los gestores de ubicación?
Cuestión 4 ¿Qué condiciones debe cumplir un elemento para poder escuchar un evento y
realizar una acción en respuesta a dicho evento?
6.11. Ejercicios resueltos 175
Cuestión 5 ¿Qué ocurre si, al dispararse un evento, no hay ningún oyente registrado en la
fuente?
Cuestión 6 ¿Qué ventajas e inconvenientes presenta la implementación de oyentes en clases
externas independientes frente a la implementación en el propio applet?
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
setLayout(new FlowLayout());
// Crear componentes
tfCen = new JTextField(5);
tfFar = new JTextField(5);
bConvertir = new JButton("Convertir");
// Añadir componentes
add(new JLabel("C"));
add(tfCen);
add(new JLabel("F"));
add(tfFar);
add(bConvertir);
Como se puede observar, sólo ha sido necesario implementar métodos getters para los
atributos, ya que se trata de referencias a objetos y no de tipos simples. Adicionalmente,
tfFar y tfCen son componentes de la interfaz del applet, más que atributos en el sentido
tradicional (representantes del estado interno de la clase). Por ello, otra forma posible de
resolver este ejercicio serı́a pasando las referencias a dichos componentes de interfaz como
parámetros del constructor de la clase oyente. Esta solución no será siempre adecuada ya
que el oyente podrı́a necesitar acceder a muchos componentes de interfaz.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
setLayout(new FlowLayout());
// Crear componentes
tfCen = new JTextField(5);
tfFar = new JTextField(5);
bConvertir = new JButton("Convertir");
// Añadir componentes
add(new JLabel("C"));
6.11. Ejercicios resueltos 177
add(tfCen);
add(new JLabel("F"));
add(tfFar);
add(bConvertir);
Ejercicio 2 Crear un applet que detecte cuando el ratón se sitúa sobre una zona especial
resaltada en rojo e informe de ello al usuario. Implementar la escucha de los eventos de todas
las formas estudiadas: en el applet, en clases externas, en clases internas y en clases anónimas.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
}
}
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
pr.addMouseListener(new OyenteExterno(tf));
add(BorderLayout.NORTH, pr);
add(BorderLayout.SOUTH, tf);
}
Escucha de eventos en una clase externa independiente mediante el uso del adaptador.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
}
private TextField tf;
private PanelRojo pr;
pr = new PanelRojo();
pr.addMouseListener(new OyenteInterno());
add(BorderLayout.NORTH, pr);
add(BorderLayout.SOUTH, tf);
}
}
private TextField tf;
private PanelRojo pr;
super();
setBackground(Color.red);
}
}
Ejercicio 3 Un ordenador se halla conectado a un sensor que puede generar dos tipos
de evento (ACTION1 y ACTION2). Se desea controlar dicho sensor mediante el sistema de
eventos de Java. Dado que no existe actualmente ningún evento que pueda responder a
esta necesidad, será necesario incorporar al sistema de eventos de Java las herramientas
oportunas que permitan manejar los eventos que produce dicho sensor. Para ello, se debe
realizar lo siguiente:
Definir un nuevo evento SensorEvent, teniendo en cuenta que todos los eventos en
Java son subtipos de EventObject.
Definir la clase Sensor para que se pueda utilizar como un componente de interfaz gráfi-
ca de usuario (todos los componentes en Java heredan de la clase Component). Dicho
componente es una fuente del evento definido en el punto anterior y, por tanto, debe per-
mitir la incorporación de un oyente (listener) para dicho evento (addSensorListener).
Definir las interfaces y adaptadores necesarios para poder crear oyentes del evento.
Solución:
import java.awt.*;
import javax.swing.*;
interface SensorListener {
public void action1Performed (SensorEvent e);
public void action2Performed (SensorEvent e);
}
Como puede verse en la figura, el applet consta de tres partes: un campo de texto donde
se permite la introducción de texto por parte del usuario, un área donde aparece reflejado
dicho texto pero todo en mayúsculas o minúsculas, y un botón que sirve para cambiar el
modo de transformación.
El comportamiento del applet debe ser el siguiente. A medida que el usuario escribe
en el campo de texto, el área de texto se va actualizando automáticamente. El texto que
aparece en dicha área es exactamente igual al del campo de texto excepto en que está todo en
minúsculas o todo en mayúsculas. Pulsar el botón implica cambiar de modo. Ası́, cuando el
texto se transforma en minúsculas, en el botón aparece “Mayúsculas” para cambiar a dicho
modo y viceversa. Pulsar el botón hace que se cambie de modo de transformación y también
transforma todo lo escrito hasta el momento.
Uso del método getSource() de un evento que permite obtener una referencia al
componente de interacción que lanzó el evento. En este caso, nos permite obtener una
referencia al botón para leer su estado y cambiarlo (dicho estado está representado por
el texto del botón, que corresponde con el modo de transformación del texto).
Un evento propio de Swing, DocumentEvent que permite escuchar eventos de trans-
formación del texto contenido en un JTextField o en un JTextArea en tiempo real,
es decir, a medida que se producen, letra a letra. Este evento tiene un funcionamien-
to similar a los vistos hasta el momento, aunque presenta ciertas diferencias. La más
inmediata es que su fuente no es directamente el componente de interacción, sino un
atributo del mismo: el Document. Esto es ası́ porque en Swing se emplea el paradigma
Modelo-Vista-Controlador, que separa los datos (Modelo) de la representación visual
de los mismos (Vista) y del código que responde a eventos y realiza los cambios opor-
tunos en los anteriores elementos (Controlador). Ası́ pues, a través del componente de
interacción, obtenemos una referencia al modelo y nos registramos como oyentes de
los eventos que afecten a los datos. La interfaz de oyente correspondiente en este caso,
DocumentListener, posee tres métodos: changedUpdate(), que informa de cambios
en los atributos del texto; insertUpdate(), que informa de las inserciones en el texto;
y removeUpdate(), que informa de los borrados en el texto. Para este ejercicio, sólo
nos interesan los dos últimos.
Fichero html:
<HTML>
<HEAD><TITLE>MinusMayus</TITLE></HEAD>
<BODY>
<APPLET CODE="MinusMayus.class" WIDTH=300 HEIGHT=200></APPLET>
</BODY>
</HTML>
Código Java:
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
import java.util.*;
add(t, BorderLayout.NORTH);
add(a, BorderLayout.CENTER);
add(b, BorderLayout.SOUTH);
b.addActionListener(new EscuchaBoton());
t.getDocument().addDocumentListener(new DocumentListener() {
public void changedUpdate (DocumentEvent e) { }
public void insertUpdate (DocumentEvent e) {
actualizar();
}
public void removeUpdate (DocumentEvent e) {
actualizar();
}
});
}
Métodos:
Se desea realizar un applet que proporcione una interfaz visual a un conjunto de este
tipo. Inicialmente se debe crear un conjunto vacı́o y posteriormente el usuario podrá añadir
cadenas de texto en el mismo. La apariencia visual del applet es la de la figura 6.10.
Por otra parte, si en la lista se selecciona cualquier ı́tem, en la caja de texto de mensajes
aparecerá el número de repeticiones del mismo, por ejemplo: “Repeticiones = 4”.
class ConjuntoPalabras {
c = new ConjuntoPalabras();
modelo = new DefaultListModel();
lista = new JList(modelo);
add(mensaje, BorderLayout.NORTH);
p1.add(p2);
p1.add(lista);
lista.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
lista.addListSelectionListener(new ListSelectionListener() {
public void valueChanged(ListSelectionEvent e) {
int r = c.buscar((String) lista.getSelectedValue());
mensaje.setText("Repeticiones = " + r);
}
});
}
}
190 Capı́tulo 6. Interfaz gráfica de usuario y applets