Taller Hilos (Threads)

1. HILO

Todos los programadores conocen lo que es un proceso, la mayoria diria que es un programa en ejecucion: tiene un principio, una secuencia de instrucciones y tiene un final.
Un Thread es un flujo simple de ejecucion dentro de un programa. Hasta el momento, todos los programas creados contienen un unico Thread, pero un programa (o proceso)  puede iniciar la ejecucion de varios de ellos concurrentemente. Puede parecer que es lo mismo que la ejecucion de varios procesos concurrentemente a modo del FORK() en UNIX, pero existe una diferencia. Mientras en los procesos concurrentes cada uno de ellos dsipone de su propia memoria y contexto, en los Threads lanzados desde un mismo programa, la memoria se comparte utilizando el mismo contexto y recursos asignados al programa (tambien disponen de variables y atributos locales al Thread) .
Un Thread no puede existir independientemente de un programa, sino que se ejecuta dentro de un  programa o proceso.

2. Ciclo de vida de un hilo

El ciclo de vida de un Thread puede pasar por varios estados ilustrados en la siguiente figura

Cuando se instancia un Thread, se inicializa sin asignarle recursos. Està en el estado "nuevo Thread" . Un Thread en este estado unicamente acepta las llamdas a los metodos Start() o Stop().

3. Sintaxis de creacion de un hilo
class PrimerThread implements Runnable {


Thread t;

public void start() {

t = new Thread(this);

t.start();

}

public void run() {

int i;

for (i=1;i<=50;i++)

System.out.println(i);

}

}

class SegundoThread extends PrimerThread {

}

class ThreadRunnable {

public static void main(String args[]) {

SegundoThread s = new SegundoThread();

Threads.

206

SegundoThread ss = new SegundoThread();

s.start();

ss.start();

}

}

En este caso se utiliza el constructor de la clase Thread:

public Thread(Runnable destino);

Metodología para la creación del thread:

1) La clase creada debe implementar el interface Runnable:

class PrimerThread implements Runnable {

2) La clase ha de crear un atributo (o variable local en el método start() )

de la clase Thread:

Thread t;

3) Hay que redefinir el método start():

· Instanciar el atributo de la clase Thread llamando a su constructor

pasándole como parámetro la propia instancia de clase (this):

t = new Thread(this);

· Iniciar el thread:

t.start();

4) Redefinir el método run() tal y como se hace en la otra alternativa de

creación de threads (mediante subclases de Thread).

Una vez declarada la clase que implementa la interface Runnable, ya puede ser

instanciada e iniciada como cualquier thread. Es más, cualquier subclase

descendiente de esta clase poseerá también las características propias de los

threads, como ocurre en el ejemplo: SegundoThread es subclase de

PrimerThread, y por lo tanto, ambas son Thread.

4. Clase y metodos de clase que permiten manipular un hilo

 Thread().


public static Thread currentThread();

Devuelve el thread que se está ejecutando acutalmente. $ Ver ejemplo en

el punto siguiente.


isAlive().


public final boolean isAlive();

Devuelve false si el thread está en el estado nuevo thread o muerto y

true en caso contrario.

!

class MiThread extends Thread {

public void run() {

try {

sleep(2000);

} catch (InterruptedException e) { }

}

}

join().


public final void join() throws InterruptedException;

Hace que el thread que se está ejecutando actualmente pase al estado

“esperando” indefinidamente hasta que muera el thread sobre el que se

realiza el join().

 yield().


public static void yield();

Threads.

210

Transfiere el control al siguiente Thread en el scheduler41 (con la misma

prioridad que el actual) que se encuentre en estado ejecutable.

sleep().


1) public static void sleep(long milisegundos) throws InterruptedException;

2) public static void sleep(long milisegundos, int nanosegundos) throws

InterruptedException;

1) Hace que el thread actual pase del estado ejecutable a dormido y permanezca

en dicho estado durante los milisegundos especificados como parámetro. Una

vez que se ha cumplido el tiempo, el thread “despierta” y pasa

automáticamente al estado de ejecutable.

2) Acepta un parámetro más: un número entero de nanosegundos (0 … 999999 )

que se sumaran a los milisegundos de espera.



5. Para que sirve la interface Runable

La interface Runnable proporciona un método alternativo a la utilización de la clase Thread, para los casos en los que no es posible hacer que la clase definida extienda la clase Thread. Esto ocurre cuando dicha clase, que se desea ejecutar en un hilo independiente deba extender alguna otra clase. Dado que no existe herencia múltiple, la citada clase no puede extender a la vez la clase Thread y otra más. En este caso, la clase debe implantar la interface Runnable, variando ligeramente la forma en que se crean e inician los nuevos hilos.


El siguiente ejemplo es equivalente al del apartado anterior, pero utilizando la interface Runnable:

public class ThreadEjemplo implements Runnable {

public void run() {

for (int i = 0; i < 5 ; i++)

System.out.println(i + " " +

Thread.currentThread().getName());

System.out.println("Termina thread " +

Thread.currentThread().getName());

}

public static void main (String [] args) {

new Thread (new ThreadEjemplo(), "Pepe").start();

new Thread (new ThreadEjemplo(), "Juan").start();

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

}

}

Herencia (RELATORIA)

RELATORIA

Herencia en java

Java permite el empleo de la herencia , característica muy potente que permite definir una clase tomando como base a otra clase ya existente. Esto es una de las bases de la reutilización de código, en lugar de copiar y pegar.

En java, como ya vimos la herencia se especifica agregando la claúsula extends después del nombre de la clase. En la claúsula extends indicaremos el nombre de la clase base de la cuál queremos heredar.

Al heredar de una clase base, heredaremos tanto los atributos como los métodos, mientras que los constructores son utilizados, pero no heredados.

Herencia Simple: Indica que se pueden definir nuevas clases solamente a partir de una clase inicial. Ejemplo:

Herencia múltiple: Indica que se pueden definir nuevas clases a partir de dos o más clases iniciales. Ejemplo:

Clase Abstracta:

Características: 

1.   No se instancia.

2.   Se usa únicamente para definir subclases.

¿Cuando es una clase abstracta?

En cuanto a uno de sus métodos no tiene implementación (En java, el método abstracto se etiqueta con la palabra reservada abstract) .

¿Cuando se utilizan clases abstractas?

Cuando deseamos definir una abstracción que englobe objetos de distintos tipos y queremos hacer uso del polimorfismo.

Ejemplo:

 

Interface en java

Una interface es un conjunto de declaraciones de funciones.Si una clase implementa (implements)
una interface, debe definir todas las funciones especificadas por la interface. Una clase puede implementar mas de una interface, representando una forma alternativa de la herencia múltiple.
A su vez, una  interface puede derivar de otra o incluso de varias interfaces, en cuyo caso incorpora todos
los métodos de las interfaces de las que deriva.

Declaración y uso

Una interface se declara:

interface nombre_interface {
    tipo_retorno nombre_metodo ( lista_argumentos ) ;
    . . .
}

Por ejemplo:

interface InstrumentoMusical {
    void tocar();
    void afinar();
    String tipoInstrumento();
}

Y una clase que implementa la interface:

class InstrumentoViento extends Object implements InstrumentoMusical {
    void tocar() { . . . };
    void afinar() { . . .};
    String tipoInstrumento() {}
}
class Guitarra extends InstrumentoViento {
    String tipoInstrumento() {
        return "Guitarra";
    }
}   

La clase InstrumentoViento implementa la interface, declarando los métodos y escribiendo el código correspondiente. Una clase derivada puede también redefinir si es necesario alguno de los métodos de la interface. 

Referencias a Interfaces

Es posible crear referencias a interfaces, pero las interfaces no pueden ser instanciadas. Una referencia a una interface puede ser asignada a cualquier objeto que implemente la interface. Por ejemplo:

InstrumentoMusical instrumento = new Guitarra();
instrumento.play();
System.out.prinln(instrumento.tipoInstrumento());

InstrumentoMusical i2 = new InstrumentoMusical(); //error.No se puede instanciar

Extensión de interfaces

Las interfaces pueden extender otras interfaces y, a diferencia de las clases, una interface puede extender más de una interface. La sintaxis es:

interface nombre_interface  extends nombre_interface  , . . . {
    tipo_retorno nombre_metodo ( lista_argumentos ) ;
    . . .
}

Agrupaciones de constantes

Dado que, por definición, todos los datos miembros que se definen en una interface son static y final, y dado que las interfaces no pueden instanciarse resultan una buena herramienta para implantar grupos de constantes. Por ejemplo:

public interface Meses {
    int ENERO = 1 , FEBRERO = 2 . . . ;
    String [] NOMBRES_MESES = { " " , "Enero" , "Febrero" , . . . };
}

Esto puede usarse simplemente:

System.out.println(Meses.NOMBRES_MESES[ENERO]);

Un ejemplo casi real

El ejemplo mostrado a continuación es una simplificación de como funciona realmente la gestión de eventos en el sistema gráfico de usuario soportado por el API de Java (AWT o swing). Se han cambiado los nombres y se ha simplificado para mostrar un caso real en que el uso de interfaces resuelve un problema concreto.

Supongamos que tenemos una clase que representa un botón de acción en un entorno gráfico de usuario (el típico botón de confirmación de una acción o de cancelación). Esta clase pertenecerá a una amplia jerarquía de clases y tendrá mecanismos complejos de definición y uso que no son objeto del ejemplo. Sin embargo podríamos pensar que  la clase Boton tiene miembros como los siguientes.

class Boton extends . . . {
    protected int x , y, ancho, alto; // posicion del boton
    protected String texto;  // texto del boton
    Boton(. . .) {
        . . .
    }
    void dibujar() { . . .}
    public void asignarTexto(String t) { . . .}
    public String obtenerTexto() { . . .)
    . . .
}   

Lo que aquí nos interesa es ver lo que sucede cuando el usuario, utilizando el ratón pulsa sobre el botón. Supongamos que la clase Boton tiene un método, de nombre por ejemplo click(), que es invocado por el gestor de ventanas cuando ha detectado que el usuario ha pulsado el botón del ratón sobre él. El botón deberá realizar alguna acción como dibujarse en posición 'pulsado' (si tiene efectos de tres dimensiones) y además, probablemente, querrá informar a alguien de que se ha producido la acción del usuario. Es en este mecanismo de 'notificación' donde entra el concepto de interface. Para ello definimos una interface Oyente de la siguiente forma:

interface Oyente {
    void botonPulsado(Boton b);
}

La interface define un único método botonPulsado. La idea es que este método sea invocado por la clase Boton cuando el usuario pulse el botón. Para que esto sea posible en algún momento hay que notificar al Boton quien es el Oyente que debe ser notificado. La clase Boton quedaría:

class Boton extends . . . {
    . . .
    private Oyente oyente;
    void registrarOyente(Oyente o) {
        oyente = o;
    }
    void click() {
        . . .
        oyente.botonPulsado(this);
    }
}

El método registrarOyente sirve para que alguien pueda 'apuntarse' como receptor de las acciones del usuario. Obsérvese que existe una referencia de tipo Oyente. A Boton no le importa que clase va a recibir su notificación. Simplemente le importa que implante la interface Oyente para poder invocar el método botonPulsado. En el método click se invoca este método. En el ejemplo se le pasa como parámetro una referencia al propio objeto Boton. En la realidad lo que se pasa es un objeto 'Evento' con información detallada de lo que ha ocurrido.

Con todo esto la clase que utiliza este mecanismo podría tener el siguiente aspecto:

class miAplicacion extends . . . implements Oyente {
    public static main(String [] args) {
        new miAplicacion(. . .);
        . . .
    }
     . . .
    miAplicacion(. . .) {
        . . .
        Boton b = new Boton(. . .);
        b.registrarOyente(this);
    }

    . . .
    void botonPulsado(Boton x) {
        // procesar click
        . . .
    }
}

Obsérvese en el método registrarOyente que se pasa la referencia thisque en el lado de la clase Boton es recogido como una referencia a la interface Oyente. Esto es posible porque la clasemiAplicacion implementa la interface Oyente . En términos clásicos de herencia miAplicacion ES un Oyente .

Conferencias

1. Conferencia: Cluster de alto rendimiento: Una solución de los Sistemas Distribuidos.

(Miller Gómez)

Cluster sirven para:

Mejorar el rendimiento

Trabajar mas inteligentemente

Solicitar ayuda

Analogia para la Computacion

Utilizar hardware especial, por ejemplo reducir el tiempo por instruccion con un procesador de mayor ciclo de reloj.

Optimizar algoritmos y tecnicas de programacion.

Cluster: 
Coleccion de computadores independentes que dan al usuario la impresion de constituir un solo sistema coherente.

Clasificacion:

clusters de alto rendimiento(HPC-High prefomance clusters)

clusters de alta disponibilidad (Ha-High Availability)

clusters de alta eficiencia(HT-High Troughput)

Los clusters tienen escalabilidad incremental

Pueden agregarse nuevos nodos y reemplazar otros.

Herramientas de software

El cluster de nuestra UNIVERSIDAD DISTRITAL cuenta  con 1024 nodos.

2. Conferencia: Interconexión en Arquitectura de Alto Desempeño

(Msc. Esteban Hernández) 

Arquitectura de red HPC

1. red de servicio(Ethernet)

1. rede de administración

1. red para procesamiento

Cada nodo tiene una conexion tridimensional (x,y,z)

* Very low Latency (89ns/salto) VS (1gb Ethernet (70-150 MS)

Algoritmos de nucleo dinamico

1.4 1.8 y 2.5 GB/s enlace

Usada en IBM, cray XT, BladeCenters de IBM, SUN, HP y CRAY

las latencias de una SDR=200 ns

y las de un QDR= 100ns

*INFINIBAN

cada nodo guarda en la memoria de los datos de otro nodo esto baja la latencia,esta hecho en serie.

10G Ethernet

1.Bajo costo.

2. Amplia gama de fabricantes

3. Base para unfied Computing

Top 500 maquinas mas potentes:

TOP10 June 2010

1	Jaguar - Cray XT5-HE Opteron Six Core 2.6 GHz
2	Nebulae - Dawning TC3600 Blade, Intel X5650, NVidia Tesla C2050 GPU
3	Roadrunner - BladeCenter QS22/LS21 Cluster, PowerXCell 8i 3.2 Ghz / Opteron DC 1.8 GHz, Voltaire Infiniband
4	Kraken XT5 - Cray XT5-HE Opteron Six Core 2.6 GHz
5	JUGENE - Blue Gene/P Solution
6	Pleiades - SGI Altix ICE 8200EX/8400EX, Xeon HT QC 3.0/Xeon Westmere 2.93 Ghz, Infiniband
7	Tianhe-1 - NUDT TH-1 Cluster, Xeon E5540/E5450, ATI Radeon HD 4870 2, Infiniband
8	BlueGene/L - eServer Blue Gene Solution
9	Intrepid - Blue Gene/P Solution
10	Red Sky - Sun Blade x6275, Xeon X55xx 2.93 Ghz, Infiniband

Conceptos de Applet 19/08/2010

1.    Programación de applet

Un applet es una pequeña aplicación accesible en un servidor Internet, que se transporta por la red, se instala automáticamente y se ejecuta como parte de un documento web. Dado que los applets son soportados por ambos navegadores, su uso se ha popularizado bastante. Los applets tienen, sin embargo, un problema que impide que se utilicen más habitualmente. Este problema consiste en que, al igual que sucede con las imágenes, cuando colocamos un applet en una página web debemos definir un rectángulo de un tamaño determinado donde permanecerá el mismo, no pudiendo actuar fuera de sus márgenes.

2.    Aplicaciones autónomas

// Hola.java

import java.io.IOException;

public class Hola

{

    public static void main(String[] args)throws IOException {

        System.out.println("Hola, mundo!");

}

Este ejemplo necesita una pequeña explicación.

• Todo en Java está dentro de una clase, incluyendo programas autónomos.
• El código fuente se guarda en archivos con el mismo nombre que la clase que contienen y con extensión “.java”. Una clase (class) declarada pública (public) debe seguir este convenio. En el ejemplo anterior, la clase es Hola, por lo que el código fuente debe guardarse en el fichero “Hola.java”
• El compilador genera un archivo de clase (con extensión “.class”) por cada una de las clases definidas en el archivo fuente. Una clase anónima se trata como si su nombre fuera la concatenación del nombre de la clase que la encierra, el símbolo “$”, y un número entero.
• Los programas que se ejecutan de forma independiente y autónoma, deben contener el método ”main()”.
• La palabra reservada  ”void” indica que el método main no devuelve nada.
• El método main debe aceptar un array de objetos tipo String. Por acuerdo se referencia como ”args”, aunque puede emplearse cualquier otro identificador.
• La palabra reservada  ”static” indica que el método es un método de clase, asociado a la clase en vez de una instancias de la misma. El método main debe ser estático o ’’de clase’’.
• La palabra reservada public significa que un método puede ser llamado desde otras clases, o que la clase puede ser usada por clases fuera de la jerarquía de la propia clase. Otros tipos de acceso son ”private” o ”protected”.
• La utilidad de impresión (en pantalla por ejemplo) forma parte de la biblioteca estándar de Java: la clase ‘’’System’’’ define un campo público estático llamado ‘’’out’’’. El objeto out es una instancia de ‘’’PrintStream’’’, que ofrece el método ‘’’println (String)’’’ para volcar datos en la pantalla (la salida estándar).
• Las aplicaciones autónomas se ejecutan dando al entorno de ejecución de Java el nombre de la clase cuyo método main debe invocarse. Por ejemplo, una línea de comando (en Unix o Windows) de la forma java –cp . Hola ejecutará el programa del ejemplo (previamente compilado y generado “Hola.class”) . El nombre de la clase cuyo método main se llama puede especificarse también en el fichero “MANIFEST” del archivo de empaquetamiento de Java (.jar).

3.    Caracteristicas de un Applet

Un applet es una mini-aplicación escrita en Java. No tienen ventana propia, se ejecutan en la ventana del browser y tienen importantes restricciones de seguridad, las cuales se comprueban al llegar al browser: sólo pueden leer y escribir en el servidor del que han venido y solo pueden acceder a una limitada información en el servidor en el que se están ejecutando.

·         Los applets no tienen un método main( ) con el que comience la ejecución.

·         Todos los applets derivan de la clase java.applet.Applet

·         Los applets deben redefinir ciertos métodos heredados de Applet que controlan su ejecución: init(), start(), stop(), destroy().

·         Los métodos gráficos se heredan de Component, mientras que la capacidad de añadir componentes de interfase de usuario de heredan de Container y de Panel.

·         También suelen redefinir ciertos métodos gráficos: los más importantes son paint(), update() y repaint().

·         Los applets disponen de métodos relacionados con la obtención de información, como por ejemplo: getAppletInfo(), getAppletContext(), getParameterInfo(), getParameter(),getCodeBase(), getDocumentBase() e isActive()

4.    Caracteristicas de la clase AWT

AWT es el acrónimo del X Window Toolkit para Java, donde X puede ser cualquier cosa: Abstract, Alternative, Awkward o  Another. Se trata de una biblioteca de clases Java para el desarrollo de Interfaces de Usuario Gráficas. La versión del AWT que Sun proporciona con el JDK se desarrolló en sólo dos meses y es la parte más débil de todo lo que representa Java como lenguaje. El entorno que ofrece es demasiado simple, no se han tenido en cuenta las ideas de entornos gráficos novedosos, sino que se ha ahondado en estructuras orientadas a eventos, llenas de callbacks y sin soporte alguno del entorno para la construcción gráfica; veremos que la simple acción de colocar un dibujo sobre un botón se vuelve una tarea harto complicada. Quizá la presión de tener que lanzar algo al mercado haya tenido mucho que ver en la pobreza de AWT.

La estructura de la  versión actual del AWT podemos resumirla en los puntos que exponemos a continuación:

• Los Contenedores contienen Componentes, que son los controles básicos
• No se usan posiciones fijas de los Componentes, sino que están situados a través de una disposición controlada (layouts)
• El común denominador de más bajo nivel se acerca al teclado, ratón y manejo de eventos
• Alto nivel de abstracción respecto al entorno de ventanas en que se ejecute la aplicación (no hay áreas cliente, ni llamadas a X, ni hWnds, etc.)
• La arquitectura de la aplicación es dependiente del entorno de ventanas, en vez de tener un tamaño fijo
• Es bastante dependiente de la máquina en que se ejecuta la aplicación (no puede asumir que un diálogo tendrá el mismo tamaño en cada máquina)
• Carece de un formato de recursos. No se puede separar el código de lo que es propiamente interface. No hay ningún diseñador de interfaces (todavía)

Características de la clase SWING

·         Swing es una de las mejoras principales que ha experimentado el JDK en su versión 1.2 con respecto a la versión 1.1, y representa la nueva generación de AWT. También es una de las API de las Clases de Fundamentos de Java (JFC), lo cual es el resultado de un esfuerzo de colaboración muy grande entre Sun, Netscape, IBM y otras empresas. Lo que da a Swing su importancia es el poder que ofrece para desarrollar interfaces gráficas de usuario (GUI) para

·         Applets y aplicaciones. La cantidad y calidad de los controles GUI que ofrece Swing no tiene

·         rival en ningún otro juego de herramientas GUI.

·         El origen de los controles GUI que presenta Swing lo encontramos en las Clases de Fundamentos de Internet de Netscape (IFC). Los componentes Swing van más allá de las IFC, hasta el punto de que no hay un parecido apreciable entre los componentes Swing y los de las IFC. Swing ofrece también la posibilidad de cambiar fácil y rápidamente el aspecto y sensación (L&F) de un único componente o grupo de componente. Esta posibilidad, que se conoce como aspecto y sensación conectables (PL&F), es un sello distintivo de Swing.

5.    Listado de clases que se utilizan en un applet y la librería AWT

AWTEventMulticaster, dispatcher para sucesos AWT, eficaz y multiprogramable. Hace el multicast de sucesos a varios componentes.

AWTPermission, para los permisos AWT.

BorderLayout, es el primer gestor de ajuste de línea. Estos gestores, que analizaremos dentro de muy poco, sirven para disponer los elementos (los componentes) en los contenedores. Éste divide el contenedor en 5 partes: norte, sur, este, oeste y centro.

Button, clase de los botones.

Canvas, área en la que se puede dibujar una aplicación.

Checkbox, CheckboxGroup, CheckboxMenuItem gestionan los botones de tipo booleano (apretado o no apretado)

Choice, presenta un menú a cortina para elegir.

Color, colores en RGB o en otros espacios arbitrarios de colores.

Component, Clase de la que derivan todos los componentes GUI (pulsadores, etiquetas,…)

Cursor, cursores.

Dialog, ventanas de diálogo en las que se indican errores y no sólo eso.

Dimension, cajas que gestionan el tamaño de los componentes, la altura y la anchura.

Event, clase que gestiona los sucesos según el viejo modelo de gestión de los sucesos (Java 1.0). Se ha dejado para que se puedan trabajar las viejas aplicaciones y apliques Java y se declara deprecated. En efecto, este modelo se ha cambiado porque, en situaciones complejas, es decir, con muchos componentes puestos unos encima de otros, no se entendía qué componente recibía el suceso.

FileDialog, dialog especial que gestiona el input y el output del archivo. Es muy cómoda.

Font, fonts para el texto.

Frame, clase ya analizada que implementa las ventanas con título y marco.

Graphics, contexto gráfico en el que se puede dibujar.

Image, superclase para todas las clases que representan una imágen gráfica.

Label, etiqueta.

List, listado

Menu, menú de tipo pull-down (a descenso).

MenuBar, barra de los menús.

Panel, contenedor.

Scrollbar, barra de desplazamiento.

ScrollPane, panel con dos barras de desplazamiento.

SystemColor, representa los colores simbólicos de un objeto GUI en un sistema.

TextComponent, superclase de todos los componentes que incluyen el texto.

TextArea, área de testo.

TextField, simple línea de texto.

Window, ventana (sin borde y barra de menú).

6.    Métodos asociados a la clase Button.

La clase Button proporciona una implementación por defecto para los botones. Un botón es un sencillo control que genera un evento Action cuando el usuario lo pulsa. La apariencia en la pantalla de los botones depende de la plataforma en que se está ejecutando y si el botón está disponible o no. La única faceta de la apariencia de un botón que puede cambiar sin crear su propia clase son la fuente, el texto mostrado, los colores de fondo y de primer plano, y (habilitando o deshabilitando el botón) si el botón aparece activado o desactivado.

Abajo tienes el código que crea los tres botones y reacciona a las pulsaciones de los botones. (Aquí tienes el programa completo.)

//en el código de inicialización:

    b1 = new Button();

    b1.setLabel("Disable middle button");

    b2 = new Button("Middle button");

    b3 = new Button("Enable middle button");

    b3.disable();

    . . .

public boolean action(Event e, Object arg) {

    Object target = e.target;

    if (target == b1) { //Han pulsado "Disable middle button"

        b2.disable();

        b1.disable();

        b3.enable();

        return true;

    }

    if (target == b3) { //Han pulsado "Enable middle button"

        b2.enable();

        b1.enable();

        b3.disable();

        return true;

    }

    return false;

}

El código anterior muestra cómo utilizar uno de los métodos más comunes de la clase Button. Además, la clase Button define un método getLabel(), que le permite encontrar el texto mostrado en un botón particular.

7.    Métodos asociados a la clase Label.

La etiqueta es un contenedor para un texto. Esta hace aparecer en la pantalla una simple línea de texto que el usuario no puede editar, y que, sin embargo, la aplicación puede cambiar.
La etiqueta, invocada en Java Label, se encuentra en el paquete java.awt. Por lo tanto para ser utilizada, nuestro programa tendrá que empezar una import java.awt.Label (para incluir sólo la clase Label del paquete), o import java.awt.* (para incluir todas las clases del paquete) internamente al programa que quiere utilizarla, por lo tanto, tendrá que declarar un objeto de tipo Label de la siguiente forma:

·         Label etiqueta = new Label();

La Label tiene tres constructores:

·         Label() , que construye una etiqueta vacía.

·         Label(String text), que construye una etiqueta con texto Text, justificada a la izquierda.

·          Label(String text, int alignment) , que construye una etiqueta con texto Texto, justificada con alignment.

Algunos métodos del objeto son:

·         int getAlignment(), da la justificación actual del objeto.

·         String getText() , da el texto incluido en el label. void setAlignment(int alignment), cambia la justificación de la Label con alignment.

·       void setText(String text), ajusta el texto de la Label.

Además existe el método AccessibleContext getAccessibleContext(), que veremos cuando analicemos los contenedores. Realmente la Label es un contenedor de texto. Label viene de la siguiente jerarquía:


Por lo tanto hereda los métodos de Object y los de java.awt.Component. Todos los componentes GUI se heredan de Component, por lo tanto, al final de la panorámica de los GUI hablaremos de Component que incluye métodos muy útiles para sus gestión. Por ejemplo, métodos para ajustar y obtener informaciones sobre tamaño, colores del fondo, colores del texto, bordes, etc… del componente.
A parte los métodos de Component, estamos listos para utilizar las Label en nuestos programas. Por ahora no pongo ningún ejemplo sobre el uso de las Label porque las veremos en el siguiente párrafo cuando hablemos de los botones. El paquete swing pone a disposición una clase parecida llamada JLabel que es una extensión de Label, y que, a su vez, pone a disposición una amplia gama de funciones añadidas. Por ejemplo, es posible crear JLabel que tengan tanto un texto como una imagen

8.    Métodos asociados a la clase TextField

Para agregar un campo de texto (TextField) a  un applet, nos fijamos en la especificación de esta clase de objetos en la API (que está en la documentación que bajo para la instalación de Java). Aquí encontramos un  ejemplo que se usa para crear cuatro campos de texto con diferenctes especificaciones:
TextField tf1, tf2, tf3, tf4; 
   //  campo de texto  en blanco 
tf1  = new TextField(); 
  // campo blanco de 20 columnas
tf2  = new TextField("", 20); 
  //campo con texto predefinido 
tf3  = new TextField("Hello!"); 
  //texto predefinido en 30 columnas 
tf4  = new TextField("Hello", 30);
También se puede hacer así
//  campo de texto  en blanco 
TextField  tf1  = new TextField(); 
     // campo de texto  blanco de 20 columnas
TextField  tf2  = new TextField("", 20); 
    //con texto predefinido 
TextField tf3   = new TextField("Hello!"); 
     // con texto predefinido en 30 columnas  
TextField  tf4  = new TextField("Hello", 30);
El operador  new obtiene espacio de almacenamiento al momento de la compilación. Aquí  las variables tf1, tf2,tf3,tf4 sonreferencias   a objetos de la clase (o tipo) "TextField". Las variables tf1, tf2, tf3  y  tf4 son refrencias  a una posición de memoria creada con el contructor new.
Ahora queremos  poner esto en el cuerpo de un applet. 
import java.awt.*;
import java.applet.*;

public class CampoTexto extends Applet
{
   // declaración e inicialización de
  // las variables "globales"  tfi's                                       
   TextField  tf1  = new TextField();                     
   TextField  tf2  = new TextField("", 20);               
   TextField  tf3  = new TextField("Hello!");
   TextField  tf4  = new TextField("Hello", 30);

     public void init( )
    {
       add(tf1);
       add(tf2);
       add(tf3);
       add(tf4);
    }

}//