Los procesadores y los Sistemas Operativos modernos permiten la multitarea, es decir, la realización simultánea de dos o más actividades (al menos aparentemente). En la realidad, un ordenador con una sola CPU no puede realizar dos actividades a la vez. Sin embargo los Sistemas Operativos actuales son capaces de ejecutar varios programas "simultáneamente" aunque sólo se disponga de una CPU: reparten el tiempo entre dos (o más) actividades, o bien utilizan los tiempos muertos de una actividad (por ejemplo, operaciones de lectura de datos desde el teclado) para trabajar en la otra. En ordenadores con dos o más procesadores la multitarea es real, ya que cada procesador puede ejecutar un hilo o thread diferente. La Figura , tomada del Tutorial de Sun, muestra los esquemas correspondientes a un programa con una o dos threads.

Programa con 1 y con 2 threads o hilos.

Un proceso es un programa ejecutándose de forma independiente y con un espacio propio de memoria.

Un Sistema Operativo multitarea es capaz de ejecutar más de un proceso simultáneamente. Un thread o hilo es un flujo secuencial simple dentro de un proceso. Un único proceso puede tener varios hilos ejecutándose. Por ejemplo el programa Netscape sería un proceso, mientras que cada una de las ventanas que se pueden tener abiertas simultáneamente trayendo páginas HTML estaría formada por al menos un hilo.

Un sistema multitarea da realmente la impresión de estar haciendo varias cosas a la vez y eso es una gran ventaja para el usuario. Sin el uso de threads hay tareas que son prácticamente imposibles de ejecutar, particularmente las que tienen tiempos de espera importantes entre etapas.

Los threads o hilos de ejecución permiten organizar los recursos del ordenador de forma que pueda haber varios programas actuando en paralelo. Un hilo de ejecución puede realizar cualquier tarea que pueda realizar un programa normal y corriente. Bastará con indicar lo que tiene que hacer en el método run(), que es el que define la actividad principal de las threads.

Los threads pueden ser daemon o no daemon. Son daemon aquellos hilos que realizan en background (en un segundo plano) servicios generales, esto es, tareas que no forman parte de la esencia del programa y que se están ejecutando mientras no finalice la aplicación. Un thread daemon podría ser por ejemplo aquél que está comprobando permanentemente si el usuario pulsa un botón. Un programa de Java finaliza cuando sólo quedan corriendo threads de tipo daemon. Por defecto, y si no se indica lo contrario, los threads son del tipo no daemon.

Creación  de Thrads

En Java hay dos formas de crear nuevos threads. La primera de ellas consiste en crear una nueva clase que herede de la clase java.lang.Thread y sobrecargar el método run() de dicha clase. El segundo método consiste en declarar una clase que implemente la interface java.lang.Runnable, la cual declarará el método run(); posteriormente se crea un objeto de tipo Thread pasándole como argumento al constructor el objeto creado de la nueva clase (la que implementa la interface Runnable).

Como ya se ha apuntado, tanto la clase Thread como la interface Runnable pertenecen al package java.lang, por lo que no es necesario importarlas.

A continuación se presentan dos ejemplos de creación de threads con cada uno de los dos métodos citados.

Creación de threads derivando de la clase Thread

Considérese el siguiente ejemplo de declaración de una nueva clase:

En este caso, se ha creado la clase SimpleThread, que hereda de Thread. En su constructor se utiliza un String (opcional) para poner nombre al nuevo thread creado, y mediante super() se llama al constructor de la super-clase Thread. Asimismo, se redefine el método run(), que define la principal actividad del thread, para que escriba 10 veces el nombre del thread creado.

Para poner en marcha este nuevo thread se debe crear un objeto de la clase SimpleThread, y llamar al método start(),heredado de la super-clase Thread, que se encarga de llamar a run(). Por ejemplo:

SimpleThread miThread = new SimpleThread(“Hilo de prueba”);
miThread.start();

Creación de threads implementando la interface Runnable

Esta segunda forma también requiere que se defina el método run(), pero además es necesario crear un objeto de la clase Thread para lanzar la ejecución del nuevo hilo. Al constructor de la clase Thread hay que pasarle una referencia del objeto de la clase que implementa la interface Runnable.

Posteriormente, cuando se ejecute el método start() del thread, éste llamará al método run() definido en la nueva clase. A continuación se muestra el mismo estilo de clase que en el ejemplo anterior implementada mediante la interface Runnable:

El siguiente código crea un nuevo thread y lo ejecuta por este segundo procedimiento:

SimpleRunnable p = new SimpleRunnable("Hilo de prueba");
// se crea un objeto de la clase Thread pasándolo el objeto Runnable como argumento
Thread miThread = new Thread(p);
// se arranca el objeto de la clase Thread
miThread.start();

Este cobra especial interés con las applets, ya que cualquier applet debe heredar de la clase java.applet.Applet, y por lo tanto ya no puede heredar de Thread. Véase el siguiente ejemplo:

En este ejemplo, el argumento this del constructor de Thread hace referencia al objeto Runnable cuyo método run() debería ser llamado cuando el hilo ejecutado es un objeto de ThreadRunnable.

La elección de una u otra forma -derivar de Thread o implementar Runnable- depende del tipo de clase que se vaya a crear. Así, si la clase a utilizar ya hereda de otra clase (por ejemplo un applet, que siempre hereda de Applet), no quedará más remedio que implementar Runnable, aunque normalmente es más sencillo heredar de Thread.

Ciclo de vida de un Thread

En el apartado anterior se ha visto cómo crear nuevos objetos que  permiten incorporar en un programa la posibilidad de realizar varias tareas simultáneamente. En la Figura (tomada del Tutorial de Sun) se muestran los distintos estados por los que puede pasar un thread a lo largo de su vida. Un thread puede presentar cuatro estados distintos:

1. Nuevo (New): El thread ha sido creado pero no inicializado, es decir, no se ha ejecutado todavía el método start(). Se producirá un mensaje de error (IllegalThreadStateException) si se intenta ejecutar cualquier método de la clase Thread distinto de start().
2. Ejecutable (Runnable): El thread puede estar ejecutándose, siempre y cuando se le haya asignado un determinado tiempo de CPU. En la práctica puede no estar siendo ejecutado en un instante determinado en beneficio de otro thread.
3. Bloqueado (Blocked o Not Runnable): El thread podría estar ejecutándose, pero hay alguna actividad interna suya que lo impide, como por ejemplo una espera producida por una operación de escritura o lectura de datos por teclado (E/S). Si un thread está en este estado, no se le asigna tiempo de CPU.
4. Muerto (Dead): La forma habitual de que un thread muera es finalizando el método run(). También puede llamarse al método stop() de la clase Thread, aunque dicho método es considerado “peligroso” y no se debe utilizar.

A continuación se explicarán con mayor detenimiento los puntos anteriores.

Ciclo de vida de un Thread.

Ejecución de un nuevo thread

La creación de un nuevo thread no implica necesariamente que se empiece a ejecutar algo. Hace falta iniciarlo con el método start(), ya que de otro modo, cuando se intenta ejecutar cualquier método del thread distinto del método start()- se obtiene en tiempo de ejecución el error IllegalThreadStateException.

El método start() se encarga de llamar al método run() de la clase Thread. Si el nuevo thread se ha creado heredando de la clase Thread la nueva clase deberá redefinirir el método run() heredado. En el caso de utilizar una clase que implemente la interface Runnable, el método run() de la clase Thread se ocupa de llamar al método run() de la nueva clase.

Una vez que el método start() ha sido llamado, se puede decir ya que el thread está “corriendo” (running), lo cual no quiere decir que se esté ejecutando en todo momento, pues ese thread tiene que compartir el tiempo de la CPU con los demás threads que también estén running.

Por eso más bien se dice que dicha thread es runnable.

Detener un Thread temporalmente: Runnable - Not Runnable

El sistema operativo se ocupa de asignar tiempos de CPU a los distintos threads que se estén ejecutando simultáneamente. Aun en el caso de disponer de un ordenador con más de un procesador (2 ó más CPUs), el número de threads simultáneos suele siempre superar el número de CPUs, por lo que se debe repartir el tiempo de forma que parezca que todos los procesos corren a la vez (quizás más lentamente), aun cuando sólo unos pocos pueden estar ejecutándose en un instante de tiempo.

Los tiempos de CPU que el sistema continuamente asigna a los distintos threads en estado runnable se utilizan en ejecutar el método run() de cada thread. Por diversos motivos, un thread puede en un determinado momento renunciar “voluntariamente” a su tiempo de CPU y otorgárselo al sistema para que se lo asigne a otro thread. Esta “renuncia” se realiza mediante el método yield().

Es importante que este método sea utilizado por las actividades que tienden a “monopolizar” la CPU. El método yield() viene a indicar que en ese momento no es muy importante para ese thread el ejecutarse continuamente y por lo tanto tener ocupada la CPU. En caso de que ningún thread esté requiriendo la CPU para una actividad muy intensiva, el sistema volverá casi de inmediato a asignar nuevo tiempo al thread que fue “generoso” con los demás. Por ejemplo, en un Pentium II 400 Mhz es posible llegar a más de medio millón de llamadas por segundo al método yield(), dentro del método run(), lo que significa que llamar al método yield() apenas detiene al thread, sino que sólo ofrece el control de la CPU para que el sistema decida si hay alguna otra tarea que tenga mayor prioridad.

Si lo que se desea es parar o bloquear temporalmente un thread (pasar al estado Not Runnable), existen varias formas de hacerlo:

1. Ejecutando el método sleep() de la clase Thread. Esto detiene el thread un tiempo preestablecido. De ordinario el método sleep() se llama desde el método run().
2. Ejecutando el método wait() heredado de la clase Object, a la espera de que suceda algo que es necesario para poder continuar. El thread volverá nuevamente a la situación de runnable mediante los métodos notify() o notifyAll(), que se deberán ejecutar cuando cesa la condición que tiene detenido al thread.
3. Cuando el thread está esperando para realizar operaciones de Entrada/Salida o Input/Output (E/S ó I/O).
4. Cuando el thread está tratando de llamar a un método synchronized de un objeto, y dicho objeto está bloqueado por otro thread

Un thread pasa automáticamente del estado Not Runnable a Runnable cuando cesa alguna de las condiciones anteriores o cuando se llama a notify() o notifyAll().

La clase Thread dispone también de un método stop(), pero no se debe utilizar ya que puede provocar bloqueos del programa (deadlock). Hay una última posibilidad para detener un thread, que consiste en ejecutar el método suspend(). El thread volverá a ser ejecutable de nuevo ejecutando el método resume().

Esta última forma también se desaconseja, por razones similares a la utilización del método stop().

El método sleep() de la clase Thread recibe como argumento el tiempo en milisegundos que ha de permanecer detenido. Adicionalmente, se puede incluir un número entero con un tiempo adicional en nanosegundos. Las declaraciones de estos métodos son las siguientes:

public static void sleep(long millis) throws InterruptedException
public static void sleep(long millis, int nanosecons) throws InterruptedException

Considérese el siguiente ejemplo:

Se observa que el método sleep() puede lanzar una InterruptedException que ha de ser capturada. Así se ha hecho en este ejemplo, aunque luego no se gestiona esa excepción.

La forma preferible de detener temporalmente un thread es la utilización conjunta de los métodos wait() y notifyAll(). La principal ventaja del método wait() frente a los métodos anteriormente descritos es que libera el bloqueo del objeto. por lo que el resto de threads que se encuentran esperando para actuar sobre dicho objeto pueden llamar a sus métodos. Hay dos formas de llamar a wait():

• Indicando el tiempo máximo que debe estar parado (en milisegundos y con la opción de indicar también nanosegundos), de forma análoga a sleep(). A diferencia del método sleep(), que simplemente detiene el thread el tiempo indicado, el método wait() establece el tiempo máximo que debe estar parado. Si en ese plazo se ejecutan los métodos notify() o notifyAll() que indican la liberación de los objetos bloqueados, el thread continuará sin esperar a concluir el tiempo indicado. Las dos declaraciones del método wait() son como siguen:

public final void wait(long timeout) throws InterruptedException
public final void wait(long timeout, int nanos) throws InterruptedException

• Sin argumentos, en cuyo caso el thread permanece parado hasta que sea reinicializado explícitamente mediante los métodos notify() o notifyAll().

public final void wait() throws InterruptedException

Los métodos wait() y notify() han de estar incluidas en un método synchronized, ya que de otra forma se obtendrá una excepción del tipo IllegalMonitorStateException en tiempo de ejecución. El uso típico de wait() es el de esperar a que se cumpla alguna determinada condición, ajena al propio thread. Cuando ésta se cumpla, se utilizará el método notifyAll() para avisar a los distintos threads que pueden utilizar el objeto.

Finalizar un Thread

Un thread finaliza cuando el método run() devuelve el control, por haber terminado lo que tenía que hacer (por ejemplo, un bucle for que se ejecuta un número determinado de veces) o por haberse dejado de cumplir una condición (por ejemplo, por un bucle while en el método run()). Es habitual poner las siguientes sentencias en el caso de Applets Runnables:

donde AppletThread es el thread que ejecuta el método run() MyApplet. Para finalizar el thread basta poner la referencia AppletThread a null. Esto se consigue en el ejemplo con el método stop() del applet (distinto del método stop() de la clase Thread, que no conviene utilizar).

Para saber si un thread está “vivo” o no, es útil el método isAlive() de la clase Thread, que devuelve true si el thread ha sido inicializado y no parado, y false si el thread es todavía nuevo (no ha sido inicializado) o ha finalizado.

Sincronización

La sincronización nace de la necesidad de evitar que dos o más threads traten de acceder a los mismos recursos al mismo tiempo. Así, por ejemplo, si un thread tratara de escribir en un fichero, y otro thread estuviera al mismo tiempo tratando de borrar dicho fichero, se produciría una situación no deseada. Otra situación en la que hay que sincronizar threads se produce cuando un thread debe esperar a que estén preparados los datos que le debe suministrar el otro thread. Para solucionar estos tipos de problemas es importante poder sincronizar los distintos threads.

Las secciones de código de un programa que acceden a un mismo recurso (un mismo objeto de una clase, un fichero del disco, etc.) desde dos threads distintos se denominan secciones críticas (critical sections). Para sincronizar dos o más threads, hay que utilizar el modificador synchronized en aquellos métodos del objeto-recurso con los que puedan producirse situaciones conflictivas. De esta forma, Java bloquea (asocia un bloqueo o lock) con el recurso sincronizado. Por ejemplo:

public synchronized void metodoSincronizado() {
...// accediendo por ejemplo a las variables de un objeto
...
}

La sincronización previene las interferencias solamente sobre un tipo de recurso: la memoria reservada para un objeto. Cuando se prevea que unas determinadas variables de una clase pueden tener problemas de sincronización, se deberán declarar como private (o protected). De esta forma sólo estarán accesibles a través de métodos de la clase, que deberán estar sincronizados.

Es muy importante tener en cuenta que si se sincronizan algunos métodos de un objeto pero otros no, el programa puede no funcionar correctamente. La razón es que los métodos no sincronizados pueden acceder libremente a las variables miembro, ignorando el bloqueo del objeto.

Sólo los métodos sincronizados comprueban si un objeto está bloqueado. Por lo tanto, todos los métodos que accedan a un recurso compartido deben ser declarados synchronized. De esta forma, si algún método accede a un determinado recurso, Java bloquea dicho recurso, de forma que el resto de threads no puedan acceder al mismo hasta que el primero en acceder termine de realizar su tarea. Bloquear un recurso u objeto significa que sobre ese objeto no pueden actuar simultáneamente dos métodos sincronizados.

Existen dos niveles de bloqueo de un recurso. El primero es a nivel de objetos, mientras que el segundo es a nivel de clases. El primero se consigue declarando todos los métodos de una clase como synchronized. Cuando se ejecuta un método synchronized sobre un objeto concreto, el sistema bloquea dicho objeto, de forma que si otro thread intenta ejecutar algún método sincronizado de ese objeto, este segundo método se mantendrá a la espera hasta que finalice el anterior (y desbloquee por lo tanto el objeto). Si existen varios objetos de una misma clase, como los bloqueos se producen a nivel de objeto, es posible tener distintos threads ejecutando métodos sobre diversos objetos de una misma clase.

El bloqueo de recursos a nivel de clases se corresponde con los métodos de clase o static, y por lo tanto con las variables de clase o static. Si lo que se desea es conseguir que un método bloquee simultáneamente una clase entera, es decir todos los objetos creados de una clase, es necesario declarar este método como synchronized static. Durante la ejecución de un método declarado de esta segunda forma ningún método sincronizado tendrá acceso a ningún objeto de la clase bloqueada.

La sincronización puede ser problemática y generar errores. Un thread podría bloquear un determinado recurso de forma indefinida, impidiendo que el resto de threads accedieran al mismo.

Para evitar esto último, habrá que utilizar la sincronización sólo donde sea estrictamente necesario. Es necesario tener presente que si dentro un método sincronizado se utiliza el método sleep() de la clase Thread, el objeto bloqueado permanecerá en ese estado durante el tiempo indicado en el argumento de dicho método. Esto implica que otros threads no podrán acceder a ese objeto durante ese tiempo, aunque en realidad no exista peligro de simultaneidad ya que durante ese tiempo el thread que mantiene bloqueado el objeto no realizará cambios. Para evitarlo es conveniente sustituir sleep() por el método wait() de la clase java.lang.Object heredado automáticamente por todas las clases. Cuando se llama al método wait() (siempre debe hacerse desde un método o bloque synchronized) se libera el bloqueo del objeto y por lo tanto es posible continuar utilizando ese objeto a través de métodos sincronizados.

El método wait() detiene el thread hasta que se llame al método notify() o notifyAll() del objeto, o finalice el tiempo indicado como argumento del método wait(). El método unObjeto.notify() lanza una señal indicando al sistema que puede activar uno de los threads que se encuentren bloqueados esperando para acceder al objeto unObjeto. El método notifyAll() lanza una señal a todos los threads que están esperando la liberación del objeto.

Los métodos notify() y notifyAll() deben ser llamados desde el thread que tiene bloqueado el objeto para activar el resto de threads que están esperando la liberación de un objeto. Un thread se convierte en propietario del bloqueo de un objeto ejecutando un método sincronizado del objeto. Los bloqueos de tipo clase, se consiguen ejecutando un método de clase sincronizado (synchronized static). Véanse las dos funciones siguientes, de las que put() inserta un dato y get() lo recoge:

El bucle while de la función get() continúa ejecutándose (avalaible == false) hasta que el método put() haya suministrado un nuevo valor y lo indique con avalaible = true. En cada iteración del while la función wait() hace que el hilo que ejecuta el método get() se detenga hasta que se produzca un mensaje de que algo ha sido cambiado (en este caso con el método notifAll() ejecutado por put()). El método put() funciona de forma similar.

Existe también la posibilidad de sincronizar una parte del código de un método sin necesidad de mantener bloqueado el objeto desde el comienzo hasta el final del método. Para ello se utiliza la palabra clave syncronized indicando entre paréntesis el objeto que se desea sincronizar (synchronized(objetoASincronizar)). Por ejemplo si se desea sincronizar el propio thread en una parte del método run(), el código podría ser:

Un thread puede llamar a un método sincronizado de un objeto para el cual ya posee el bloqueo, volviendo a adquirir el bloqueo. Por ejemplo:

El anterior ejemplo obtendrá como resultado:

Estoy en b()
Estoy en a()

debido a que se ha podido acceder al objeto con el método b() al ser el thread que ejecuta el método a() “propietario” con anterioridad del bloqueo del objeto.

La sincronización es un proceso que lleva bastante tiempo a la CPU, luego se debe minimizar su uso, ya que el programa será más lento cuanta más sincronización incorpore.

Prioridades

Con el fin de conseguir una correcta ejecución de un programa se establecen prioridades en los threads, de forma que se produzca un reparto más eficiente de los recursos disponibles. Así, en un determinado momento, interesará que un determinado proceso acabe lo antes posible sus cálculos, de forma que habrá que otorgarle más recursos (más tiempo de CPU). Esto no significa que el resto de procesos no requieran tiempo de CPU, sino que necesitarán menos. La forma de llevar a cabo esto es gracias a las prioridades.

Cuando se crea un nuevo thread, éste hereda la prioridad del thread desde el que ha sido inicializado. Las prioridades viene definidas por variables miembro de la clase Thread, que toman valores enteros que oscilan entre la máxima prioridad MAX_PRIORITY (normalmente tiene el valor 10) y la mínima prioridad MIN_PRIORITY (valor 1), siendo la prioridad por defecto NORM_PRIORITY (valor 5). Para modificar la prioridad de un thread se utiliza el método setPriority(). Se obtiene su valor con getPriority().

El algoritmo de distribución de recursos en Java escoge por norma general aquel thread que tiene una prioridad mayor, aunque no siempre ocurra así, para evitar que algunos procesos queden “dormidos”.

Cuando hay dos o más threads de la misma prioridad (y además, dicha prioridad es la más elevada), el sistema no establecerá prioridades entre los mismos, y los ejecutará alternativamente dependiendo del sistema operativo en el que esté siendo ejecutado. Si dicho SO soporta el “time-slicing” (reparto del tiempo de CPU), como por ejemplo lo hace Windows 95/98/NT, los threads serán ejecutados alternativamente.

Un thread puede en un determinado momento renunciar a su tiempo de CPU y otorgárselo a otro thread de la misma prioridad, mediante el método yield(), aunque en ningún caso a un thread de prioridad inferior.

Grupos de Thread

Todo hilo de Java debe formar parte de un grupo de hilos (ThreadGroup). Puede pertenecer al grupo por defecto o a uno explícitamente creado por el usuario. Los grupos de threads proporcionan una forma sencilla de manejar múltiples threads como un solo objeto. Así, por ejemplo es posible parar varios threads con una sola llamada al método correspondiente. Una vez que un thread ha sido asociado a un threadgroup, no puede cambiar de grupo.

Cuando se arranca un programa, el sistema crea un ThreadGroup llamado main. Si en la creación de un nuevo thread no se especifica a qué grupo pertenece, automáticamente pasa a pertenecer al threadgroup del thread desde el que ha sido creado (conocido como current thread group y current thread, respectivamente). Si en dicho programa no se crea ningún ThreadGroup adicional, todos los threads creados pertenecerán al grupo main (en este grupo se encuentra el método main()). La Figura presenta una posible distribución de threads distribuidos en grupos de threads.

Para conseguir que un thread pertenezca a un grupo concreto, hay que indicarlo al crear el nuevo thread, según uno de los siguientes constructores:

public Thread (ThreadGroup grupo, Runnable destino)
public Thread (ThreadGroup grupo, String nombre)
public Thread (ThreadGroup grupo, Runnable destino, String nombre)

A su vez, un ThreadGroup debe pertenecer a otro ThreadGroup. Como ocurría en el caso anterior, si no se especifica ninguno, el nuevo grupo pertenecerá al ThreadGroup desde el que ha sido creado (por defecto al grupo main). La clase ThreadGroup tiene dos posibles constructores:

ThreadGroup(ThreadGroup parent, String nombre);
ThreadGroup(String name);

el segundo de los cuales toma como parent el threadgroup al cual pertenezca el thread desde el que se crea (Thread.currentThread()). Para más información acerca de estos constructores, dirigirse a la documentación del API de Java donde aparecen numerosos métodos para trabajar con grupos de threads a disposición del usuario (getMaxPriority(), setMaxPriority(), getName(), getParent(), parentOf()).

En la práctica los ThreadGroups no se suelen utilizar demasiado. Su uso práctico se limita a efectuar determinadas operaciones de forma más simple que de forma individual. En cualquier caso, véase el siguiente ejemplo:

ThreadGroup miThreadGroup = new ThreadGroup("Mi Grupo de Threads");
Thread miThread = new Thread(miThreadGroup, ”un thread para mi grupo");

donde se crea un grupo de threads (miThreadGroup) y un thread que pertenece a dicho grupo (miThread).

Fuente: Thrads: Programas Multitarea

Ejemplo Completo de Java Clase Geometria

En este apartado se describe la clase más importante de esta aplicación. Es la más importante no en el sentido de lo que hace, sino en el de que las demás clases “derivan” de ella, o por decirlo de otra forma, se apoyan o cuelgan de ella. La Figura  muestra la jerarquía de clases utilizada en este ejemplo.

La clase Geometria es la base de la jerarquía. En realidad no es la base, pues en Java la clase base es siempre la clase Object. Siempre que no se diga explícitamente que una clase deriva de otra, deriva implícitamente de la clase Object (definida en el package java.lang). De las clases  Resultado de la ejecución del Ejemplo1.

• Dibujable
• RectanguloGrafico
• Rectangulo
• Dibujable
• CirculoGrafico
• Circulo
• Geometria

Rectangulo y Circulo derivan respectivamente las clases RectanguloGrafico y CirculoGrafico. En ambos casos está por en medio un elemento un poco especial donde aparece la palabra Dibujable. En términos de Java, Dibujable es una interface. Más adelante se verá qué es una interface. Se suele utilizar la nomenclatura de super-clase y sub-clase para referirse a la clase padre o hija de una clase determinada. Así Geometría es una super-clase de Circulo, mientras que CirculoGrafico es una sub-clase.

En este ejemplo sólo se van a dibujar rectángulos y círculos. De la clase Geometría van a derivar las clases Rectangulo y Circulo. Estas clases tienen en común que son “geometrías”, y como tales tendrán ciertas características comunes como un perímetro y un área. Un aspecto importante a considerar es que no va a haber nunca objetos de la clase Geometria, es decir “geometrías a secas”. Una clase de la que no va a haber objetos es una clase abstracta, y como tal puede ser declarada. A continuación se muestra el fichero Geometria.java en el que se define dicha clase:

1. // fichero Geometria.java

2. public abstract class Geometria {

3. // clase abstracta que no puede tener objetos

4. public abstract double perimetro();

5. public abstract double area();

6. }

La clase Geometria se declara como public para permitir que sea utilizada por cualquier otra clase, y como abstract para indicar que no se permite crear objetos de esta clase. Es característico de las clases tener variables y funciones miembro. La clase Geometria no define ninguna variable miembro, pero sí declara dos métodos: perímetro() y area(). Ambos métodos se declaran como public para que puedan ser llamados por otras clases y como abstract para indicar que no se da ninguna definición -es decir ningún código- para ellos. Interesa entender la diferencia entre declaración (la primera línea o header del método) y definición (todo el código del método, incluyendo la primera línea). Se indica también que su valor de retorno -el resultado- va a ser un double y que no tienen argumentos (obtendrán sus datos a partir del objeto que se les pase como argumento implícito). Es completamente lógico que no se definan en esta clase los métodos perimetro() y area(): la forma de calcular un perímetro o un área es completamente distinta en un rectángulo y en un círculo, y por tanto estos métodos habrá que definirlos en las clases Rectangulo y Circulo. En la clase Geometria lo único que se puede decir es cómo serán dichos métodos, es decir su nombre, el número y tipo de sus argumentos y el tipo de su valor de retorno.

Fuente: WordXy

Ejemplo Completo de Java Ejemplo

Este ejemplo contiene algunas de las características más importantes de Java: clases, herencia, interfaces, gráficos, polimorfismo, etc. Las sentencias se numeran en cada fichero, de modo que resulta más fácil hacer referencia a ellas en los comentarios. La ejecución de este programa imprime algunas líneas en la consola MS-DOS y conduce a crear la ventana mostrada en la Figura.

Clase Ejemplo

A continuación se muestra el programa principal, contenido en el fichero Ejemplo1.java. En realidad, este programa principal lo único que hace es utilizar la clase Geometría y sus clases derivadas. Es pues un programa puramente “usuario”, a pesar de lo cual hay que definirlo dentro de una clase, como todos los programas en Java.

1. // fichero Ejemplo1.java

2. import java.util.ArrayList;

3. import java.awt.*;

4. class Ejemplo1 {

5. public static void main(String arg[]) throws InterruptedException

6. {

7. System.out.println("Comienza main()...");

8. Circulo c = new Circulo(2.0, 2.0, 4.0);

9. System.out.println("Radio = " + c.r + " unidades.");

10. System.out.println("Centro = (" + c.x + "," + c.y + ") unidades.");

11. Circulo c1 = new Circulo(1.0, 1.0, 2.0);

12. Circulo c2 = new Circulo(0.0, 0.0, 3.0);

13. c = c1.elMayor(c2);

14. System.out.println("El mayor radio es " + c.r + ".");

15. c = new Circulo(); // c.r = 0.0;

16. c = Circulo.elMayor(c1, c2);

17. System.out.println("El mayor radio es " + c.r + ".");

18. VentanaCerrable ventana =

19. new VentanaCerrable("Ventana abierta al mundo...");

20. ArrayList v = new ArrayList();

21. CirculoGrafico cg1 = new CirculoGrafico(200, 200, 100, Color.red);

22. CirculoGrafico cg2 = new CirculoGrafico(300, 200, 100, Color.blue);

23. RectanguloGrafico rg = new

24. RectanguloGrafico(50, 50, 450, 350, Color.green);

25. v.add(cg1);

26. v.add(cg2);

27. v.add(rg);

28. PanelDibujo mipanel = new PanelDibujo(v);

29. ventana.add(mipanel);

30. ventana.setSize(500, 400);

31. ventana.setVisible(true);

32. System.out.println("Termina main()...");

33. } // fin de main()

34. } // fin de class Ejemplo1

La sentencia 1 es simplemente un comentario que contiene el nombre del fichero. El compilador de Java ignora todo lo que va desde los caracteres // hasta el final de la línea.

Las sentencias 2 y 3 “importan” clases de los packages de Java, esto es, hacen posible acceder a dichas clases utilizando nombres cortos. Por ejemplo, se puede acceder a la clase ArrayList simplemente con el nombre ArrayList en lugar de con el nombre completo java.util.ArrayList, por haber introducido la sentencia import de la línea 2. Un package es una agrupación de clases que tienen una finalidad relacionada. Existe una jerarquía de packages que se refleja en nombres compuestos, separados por un punto (.). Es habitual nombrar los packages con letras minúsculas (como java.util o java.awt), mientras que los nombres de las clases suelen empezar siempre por una letra mayúscula (como ArrayList).

El asterisco (*) de la sentencia 3 indica que se importan todas las clases del package. Hay un package, llamado java.lang, que se importa siempre automáticamente. Las clases de java.lang se pueden utilizar directamente, sin importar el package.

La sentencia 4 indica que se comienza a definir la clase Ejemplo1. La definición de dicha clase va entre llaves {}. Como también hay otras construcciones que van entre llaves, es habitual indentar o sangrar el código, de forma que quede claro donde empieza (línea 4) y donde termina (línea 34) la definición de la clase. En Java todo son clases: no se puede definir una variable o una función que no pertenezca a una clase. En este caso, la clase Ejemplo1 tiene como única finalidad acoger al método main(), que es el programa principal del ejemplo. Las clases utilizadas por main() son mucho más importantes que la propia clase Ejemplo1. Se puede adelantar ya que una clase es una agrupación de variables miembro (datos) y funciones miembro (métodos) que operan sobre dichos datos y permiten comunicarse con otras clases. Las clases son verdaderos tipos de variables o datos, creados por el usuario. Un objeto (en ocasiones también llamado instancia) es una variable concreta de una clase, con su propia copia de las variables miembro.

Las líneas 5-33 contienen la definición del programa principal de la aplicación, que en Java siempre se llama main(). La ejecución siempre comienza por el programa o método main(). La palabra public indica que esta función puede ser utilizada por cualquier clase; la palabra static indica que es un método de clase, es decir, un método que puede ser utilizado aunque no se haya creado ningún objeto de la clase Ejemplo1 (que de hecho, no se han creado); la palabra void indica que este método no tiene valor de retorno. A continuación del nombre aparecen, entre paréntesis, los argumentos del método. En el caso de main() el argumento es siempre un vector o array (se sabe por la presencia de los corchetes []), en este caso llamado arg, de cadenas de caracteres (objetos de la clase String). Estos argumentos suelen ser parámetros que se pasan al programa en el momento de comenzar la ejecución (por ejemplo, el nombre del fichero donde están los datos). El cuerpo (body) del método main(), definido en las líneas 6-33, va también encerrado entre llaves {...}. A un conjunto de sentencias encerrado entre llaves se le suele llamar bloque. Es conveniente indentar para saber dónde empieza y dónde terminan los bloques del método main() y de la clase Ejemplo1. Los bloques nunca pueden estar entrecruzados; un bloque puede contener a otro, pero nunca se puede cerrar el bloque exterior antes de haber cerrado el interior.

La sentencia 7 (System.out.println("Comienza main()...");) imprime una cadena de caracteres o String en la salida estándar del sistema, que normalmente será una ventana de MSDOS o una ventana especial del entorno de programación que se utilice (por ejemplo Visual J++, de Microsoft). Para ello se utiliza el método println(), que está asociado con una variable static llamada out, perteneciente a la clase System (en el package por defecto, java.lang). Una variable miembro static, también llamada variable de clase, es una variable miembro que es única para toda la clase y que existe aunque no se haya creado ningún objeto de la clase. La variable out es una variable static de la clase System. La sentencia 7, al igual que las que siguen, termina con el carácter punto y coma (;).

La sentencia 8 (Circulo c = new Circulo(2.0, 2.0, 4.0);) es muy propia de Java. En ella se crea un objeto de la clase Circulo, que se define en los próximos capítulos. Esta sentencia es equivalente a las dos sentencias siguientes:

Circulo c;

c = new Circulo(2.0, 2.0, 4.0);

que quizás son más fáciles de explicar. En primer lugar se crea una referencia llamada c a un objeto de la clase Circulo. Crear una referencia es como crear un “nombre” válido para referirse a un objeto de la clase Circulo. A continuación, con el operador new se crea el objeto propiamente dicho. Puede verse que el nombre de la clase va seguido por tres argumentos entre paréntesis. Estos argumentos se le pasan al constructor de la clase como datos concretos para crear el objeto (en este caso los argumentos son las dos coordenadas del centro y el radio). Interesa ahora insistir un poco más en la diferencia entre clase y objeto. La clase Circulo es lo genérico: es el patrón o modelo para crear círculos concretos. El objeto c es un círculo concreto, con su centro y su radio. De la clase Circulo se pueden crear tantos objetos como se desee; la clase dice

que cada objeto necesita tres datos (las dos coordenadas del centro y el radio) que son las variables miembro de la clase. Cada objeto tiene sus propias copias de las variables miembro, con sus propios valores, distintos de los demás objetos de la clase.

La sentencia 9 (System.out.println("Radio = " + c.r + " unidades.");) imprime por la salida estándar una cadena de texto que contiene el valor del radio. Esta cadena de texto se compone de tres sub-cadenas, unidas mediante el operador de concatenación (+). Obsérvese cómo se accede al radio del objeto c: el nombre del objeto seguido del nombre de la variable miembro r, unidos por el operador punto (c.r). El valor numérico del radio se convierte automáticamente en cadena de caracteres.

La sentencia 10 es similar a la 9, imprimiendo las coordenadas del centro del círculo.

Las sentencias 11 y 12 crean dos nuevos objetos de la clase Circulo, llamados c1 y c2.

La sentencia 13 (c = c1.elMayor(c2);) utiliza el método elMayor() de la clase Circulo. Este método compara los radios de dos círculos y devuelve como valor de retorno una referencia al círculo que tenga mayor radio. Esa referencia se almacena en la referencia previamente creada c. Un punto importante es que todos los métodos de Java (excepto los métodos de clase o static) se aplican a un objeto de la clase por medio del operador punto (por ejemplo, c1.elMayor()). El otro objeto (c2) se pasa como argumento entre paréntesis. Obsérvese la forma “asimétrica” en la que se pasan los dos argumentos al método elMayor(). De ordinario se llama argumento implícito a c1, mientras que c2 sería el argumento explícito del método.

La sentencia 14 imprime el resultado de la comparación anterior y la sentencia 15 crea un nuevo objeto de la clase Circulo guardándolo en la referencia c. En este caso no se pasan argumentos al constructor de la clase. Eso quiere decir que deberá utilizar algunos valores “por defecto” para el centro y el radio. Esta sentencia anula o borra el resultado de la primera comparación de radios, de modo que se pueda comprobar el resultado de la segunda comparación.

La sentencia 16 (c = Circulo.elMayor(c1, c2);) vuelve a utilizar un método llamado elMayor() para comparar dos círculos: ¿Se trata del mismo método de la sentencia 13, utilizado de otra forma? No. Se trata de un método diferente, aunque tenga el mismo nombre. A las funciones o métodos que son diferentes porque tienen distinto código, aunque tengan el mismo nombre, se les llama funciones sobrecargadas (overloaded). Las funciones sobrecargadas se diferencian por el numero y tipo de sus argumentos.

El método de la sentencia 13 tiene un único argumento, mientras que el de la sentencia 16 tiene dos (en todos los casos objetos de la clase Circulo). En realidad, el método de la sentencia 16 es un método static (o método de clase), esto es, un método que no necesita ningún objeto como argumento implícito. Los métodos static suelen ir precedidos por el nombre de la clase y el operador punto (Java también permite que vayan precedidos por el nombre de cualquier objeto, pero es considerada una nomenclatura más confusa.). La sentencia 16 es absolutamente equivalente a la sentencia 13, pero el método static de la sentencia 16 es más “simétrico”.

Las sentencias 17 y 18 no requieren ya comentarios especiales.

Las sentencias 18-31 tienen que ver con la parte gráfica del ejemplo. En las líneas 18-19 (VentanaCerrable ventana = new VentanaCerrable("Ventana abierta al mundo...");) se crea una ventana para dibujar sobre ella. Una ventana es un objeto de la clase Frame, del package java.awt. La clase VentanaCerrable, explicada en el Apartado 1.3.9 en la página 17, añade a la clase Frame la capacidad de responder a los eventos que provocan el cierre de una ventana. La cadena que se le pasa como argumento es el título que aparecerá en la ventana. En la sentencia 20 (ArrayList v = new ArrayList();) se crea un objeto de la clase ArrayList (contenida o definida en el package java.util). La clase ArrayList permite almacenar referencias a objetos de distintas clases. En este caso se utilizará para almacenar referencias a varias figuras geométricas diferentes.

Las siguientes sentencias 21-27 crean elementos gráficos y los incluyen en la lista v para ser dibujados más tarde en el objeto de la clase PanelDibujo. Los objetos de la clase Circulo creados anteriormente no eran objetos aptos para ser dibujados, pues sólo tenían información del centro y el radio, y no del color de línea. Las clases RectanguloGrafico y CirculoGrafico, definidas en los Apartados 1.3.6 y 1.3.7, derivan respectivamente de las clases Rectangulo (Apartado 1.3.3) y Circulo (Apartado 1.3.4), heredando de dichas clases sus variables miembro y métodos, añadiendo la información y los métodos necesarios para poder dibujarlos en la pantalla. En las sentencias 21- 22 se definen dos objetos de la clase CirculoGrafico; a las coordenadas del centro y al radio se une el color de la línea. En la sentencia 23-24 se define un objeto de la clase RectanguloGrafico, especificando asimismo un color, además de las coordenadas del vértice superior izquierdo, y del vértice inferior derecho. En las sentencias 25-27 los objetos gráficos creados se añaden al objeto v de la clase ArrayList, utilizando el método add() de la propia clase ArrayList.

En la sentencia 28 (PanelDibujo mipanel = new PanelDibujo(v);) se crea un objeto de la

clase PanelDibujo, definida en el Apartado 1.3.8. Por decirlo de alguna manera, los objetos de dicha clase son paneles, esto es superficies en las que se puede dibujar. Al constructor de PanelDibujo se le pasa como argumento el vector v con las referencias a los objetos a dibujar. La sentencia 29 (ventana.add(mipanel);) añade o incluye el panel (la superficie de dibujo) en la ventana; la sentencia 30 (ventana.setSize(500, 400);) establece el tamaño de la ventana en pixels; finalmente, la sentencia 31 (ventana.setVisible(true);) hace visible la ventana creada. ¿Cómo se consigue que se dibuje todo esto? La clave está en la serie de órdenes que se han ido dando al computador. La clase PanelDibujo deriva de la clase Container a través de Panel, y redefine el método paint() de Container. En este método, explicado en el Apartado 1.3.8, se realiza el dibujo de los objetos gráficos creados. El usuario no tiene que preocuparse de llamar al método paint(), pues se llama de modo automático cada vez que el sistema operativo tiene alguna razón para ello (por ejemplo cuando se crea la ventana, cuando se mueve, cuando se minimiza o maximiza, cuando aparece después de haber estado oculta, etc.). La Figura muestra la ventana resultante de la ejecución del programa main() de la clase Ejemplo1. Para entender más a fondo este resultado es necesario considerar detenidamente las clases definidas en los apartados que siguen.

Fuente: WordXy