ÍNDICE: ! Programación con Java: 1. Introducción al lenguaje Java:

! Fundamentos. ! Gestión de eventos.

2. Creación y uso de "threads". 3. Sincronización. Referencias: • http://nuvol.uji.es/~vcholvi/teaching/dstr.html • http://Java.sun.com • http://www.fie.us.es/docencia/publi/JAVA/ • http://usuarios.tripod.es/Ozito/index.html • http://www.lucas.simplenet.com/trabajos/java/java.html • http://www.ctv.es/USERS/pagullo/arti/javacpp.htm

1. Introducción al lenguaje Java. Java: Es un cambio radical en el desarrollo de software pero reimplementando las buenas soluciones:

! Entornos de desarrollo visuales (Kawa, VisualAge, Forte,

J++,...).

! Paradigma principal: orientado a objetos.

! Abstracción para el acceso a base de datos JDBC.

Elementos que consiguen que le lenguaje Java sea una tecnología diferente:

! Applets: aplicaciones pequeñas, dinámicas, seguras, multiplataforma, activas y en red.

! Lenguaje de programación poderoso: orientado a objetos,

sintaxis simple y familiar, entorno robusto y agradable.

! Clases de objeto: abstracciones para las funciones del sistema habituales como gestión de ventanas, de red y de entrada/salida.

Lenguaje de programación revolucionario: ! Simple: Aprendizaje simple partiendo de conocimientos de

programación O. O.

o No muestra las interioridades del sistema.

! Orientado a objetos: Modelo de objetos simple y fácil de ampliar combinado con tipos simples que son “no objetos de alto rendimiento”.

! Robusto: Java evita muchas de loas principales causas de error

del programador:

o Gestión de memoria avanzada: recogida de basura.

o Orientado a objetos integrados.

o Se detectan los errores de tipos y de declaración en tiempo de compilación.

! Interactivo: Posibilita la construcción de sistemas interactivos que se ejecutan sin problemas.

! Arquitectura neutral: Se compila en una representación intermedia llamada código byte de java que es interpretable en cualquier sistema que tenga un interprete Java.

! El problema de los lenguajes interpretados es que son poco

eficientes.

! Sin embargo, el código byte de Java es sencillo de traducir a

código máquina nativo consiguiendo un rendimiento alto.

! Se compila en código de byte de alto nivel independiente de la

máquina. ! Seguro:

o No se puede llamar a funciones globales para ganar el acceso a recursos del sistema.

o No se producen desbordamiento en la pila.

o No hay conversiones ilegales entre datos.

o El cargador de Clases puede verificar una firma digital

antes de realizar una instancia de un objeto (validar los privilegios de acceso).

o Las operaciones con archivos se trabajan sobre el disco

duro de la máquina de donde partió el applet.

! Puede ejecutarse desde una máquina hipotética que es implementada por un sistema run-time, que si es dependiente de la máquina.

! Son dependientes del sistema la Máquina Virtual Java (JVM) y

las librerías fundamentales, que nos permiten acceder la hardware.

! También existen APIs de Java que entran en contacto con el hardware:

o Java 2D: gráficos 2D y manipulación de imágenes. o Java Media Framework: Elementos críticos en el tiempo:

audio, vídeo... o Java Animation: Animación de objetos en 2D. o Java Telephony: Integración con telefonía. o Java Share: Interacción entre aplicaciones multiusuario. o Java 3D: Gráficos 3D y su manipulación.

Clases de Internet: ! Conjunto de clases comunes que pueden crecer y posibilitan que

muchos programadores creen objetos en Java que interactúan.

! Clases de Internet: proporcionan un modelo unificador de protocolos de internet para PC, Mac y estaciones de trabajo Unix.

! Trabajo en red con TCP/IP: Implementaciones de ftp, http,

sockets de red de bajo nivel, etc. Protocolos de Internet -> objetos de Java simples.

! WWW y HTML: o Utilización de applets insertadas en páginas HTML. o Clases de manipulación de cadenas adecuadas al tipo de

procesamiento de texto que forma parte de cualquier programa basado en HTML.

! Programas distribuidos: o Invocación a objetos remotos. o Código que se ejecuta de manera distribuida a través de la

red.

! Acceso a Base de Datos (JDBC). Clases requeridas por cualquier entorno JAVA: ! Lenguaje:

o Clase String o Clase Thread o Clase Exception o Clase Error o Clase Math

! Utilidades: conjunto completo de estructuras de datos complejas

y sus métodos asociados (pilas, matrices, tablas, etc...). ! Entrada/Salida. ! Trabajo en red a bajo nivel.

! Clases de la interfaz de usuario abstracta AWT: abstracciones para ventanas, botones, menús

Lenguaje JAVA ! Facilidad para aplicaciones relacionadas con INTERNET

(applets), aunque también para tareas de propósito general. ! ¿Cuándo Java no es la mejor elección?

o Texto por Internet -> HTML (menor coste de transferencia y de interpretación).

o Aplicaciones de propósito general rápidas. Ej: en funciones del API de Windows.

Programar en JAVA ! Compilación y ejecución del la aplicación típica “Holamundo” // Aplicación HolaMundo de ejemplo public class HolaMundo {

public static void main( String args[] ) {

System.out.println( "Hola Mundo!" ); }

} ! Se debe almacenar el texto en un archivo llamado

HolaMundo.java. El nombre del archivo debe coincidir con el nombre de la clase.

! El compilador javac crea un archivo HolaMundo.class que

contiene el código byte compilado de nuestro programa (instrucciones del lenguaje máquina para el interprete de maquina virtual Java).

javac HolaMundo.java

! El compilador javac se encuentra en el directorio bin por debajo de directorio Java donde se halla instalado el JDK.

Un Applet: ! Compilación y ejecución del applet HolaMundo con el siguiente

código: import java.applet.Applet; import java.awt.Graphics; public class HolaMundo extends java.applet.Applet{

public void paint(Graphics g){ g.drawString(“Hola Mundo”,5,50);

} } ! Se debe almacenar en un archivo llamado HolaMundo.java ! El compilador crea un archivo llamado HolaMundo.class

! Creación del fichero HTML que incluye el applet ubicado en el

mismo directorio que se encuentra la clase: <HTML> <HEAD> <TITLE> Applet HolaMundo </TITLE> </HEAD> <BODY> <P> Este es el applet HolaMundo: <BR> <APPLET CODE=”HolaMundo.class” WIDTH=100 HEIGHT=80> </APPLET> </BODY> </HTML>

! La ejecución del applet se realiza con appletviewer o con el

navegador. ! Un applet es una mínima aplicación Java diseñada para

ejecutarse en un navegador Web. No necesita método main(). ! El appletviewer crea un espacio de navegación, incluyendo

un área gráfica, donde se ejecutara el applet. Métodos de la clase Applet:

public void init (): Se activa cuando el applet es cargado. public void init() {

if( width < 200 || height < 200 ) resize( 200,200 ); valor_global1 = 0; valor_global2 = 100; // cargaremos imágenes en memoria sin mostrarlas // cargaremos música de fondo en memoria sin reproducirla

}

public void start (): Llamada para activa el applet. Es llamada cuando se visita el applet. Las clases derivadas deberían sobrecargarlo para comenzar una animación, sonido, etc. public void start() {

estaDetenido = false; // comenzar la reproducción de la música musicClip.play();

} public void paint (): Llamada cada vez que se refresca el área de dibujo del applet. void public paint( Graphics g ) { g.drawString( "Hola Java!",25,25 ); // Dibujaremos la imágenes que necesitemos

} public void stop (): Llamada para detener el applet. public void stop() {

estaDetenido = true; if( /* ¿se está reproduciendo música? */ ) musicClip.stop();

} public void destroy (): Es llamada cuando el applet no se va a usar más. En applet multithread deberán usar destroy() para “matar” cualquier thread del applet que quedase activo. public void run (): Contiene el código que se ejecutará: bucle del applet, nuevos métodos, etc. En gráficos suele llamar a repaint() para refrescar el área de dibujo.

La marca applet de html:

Dado que los applets están mayormente destinados a ejecutarse en navegadores Web, había que preparar el lenguaje HTML para soportar Java, o mejor, los applets.

El esquema de marcas de HTML, y la evolución del estándar

marcado por Netscape hicieron fácil la adición de una nueva marca que permitiera, una vez añadido el correspondiente código gestor en los navegadores, la ejecución de programas Java en ellos.

La sintaxis de las etiquetas <APPLET> y <PARAM> es la que se muestra a continuación y que se irá explicando en párrafos posteriores:

<APPLET CODE= WIDTH= HEIGTH= [CODEBASE=] [ALT=] [NAME=] [ALIGN=] [VSPACE=] [HSPACE=]> <PARAM NAME= VALUE= > </APPLET> Los atributos que acompañan a la etiqueta <APPLET>, algunos son obligatorios y otros son opcionales. Todos los atributos, siguiendo la sintaxis de html, se especifican de la forma: atributo = valor. Los atributos obligatorios son:

CODE

Indica el fichero de clase ejecutable, que tiene la extensión .class. No se permite un URL absoluto, como ya se ha dicho, aunque sí puede ser relativo al atributo opcional CODEBASE. WIDTH Indica la anchura inicial que el navegador debe reservar para el applet en pixels. HEIGHT Indica la altura inicial en pixels. Un applet que disponga de una geometría fija no se verá redimensionado por estos atributos. Por ello, si los atributos definen una zona menor que la que el applet utiliza, únicamente se verá parte del mismo, como si se visualiza a través de una ventana, eso sí, sin ningún tipo de desplazamiento.

Los atributos opcionales que pueden acompañar a la marca APPLET comprenden los que se indican a continuación: CODEBASE Se emplea para utilizar el URL base del applet. En caso de no especificarse, se utilizará el mismo que tiene el documento. ALT Funciona exactamente igual que el ALT de la marca <IMG>, es decir, muestra un texto alternativo, en este caso al applet, en navegadores en modo texto o que entiendan la etiqueta APPLET pero no implementen una máquina virtual Java. NAME Otorga un nombre simbólico a esta instancia del applet en la página que puede ser empleado por otros applets de la misma página para localizarlo. Así, un applet puede ser cargado varias veces en la misma página tomando un nombre simbólico distinto en cada momento. ALIGN

Se emplea para alinear el applet permitiendo al texto fluir a su alrededor. Toma los siguientes valores: LEFT, RIGHT, TOP, TEXTTOP, MIDDLE, ABSMIDDLE, BASELINE, BOTTOM y ABSBOTTOM. VSPACE Indica el espaciado vertical entre el applet y el texto, en pixels. HSPACE Funciona igual que el anterior pero indicando espaciamiento horizontal, en pixels.

El Lenguaje Comentarios En Java hay tres tipos de comentarios:

// comentarios para una sola línea /* comentarios de una o más líneas */ /** comentario de documentación, de una o más líneas */ Los comentarios de documentación, son colocados antes de una declaración (de variable o función), indican que ese comentario ha de ser colocado en la documentación que se genera automáticamente cuando se utiliza la herramienta de Java, javadoc.

En este tipo de comentario para documentación, se permite la introducción de algunos tokens o palabras clave, que harán que la información que les sigue aparezca de forma diferente al resto en la documentación.

Palabras clave Las siguientes son las palabras clave que están definidas en Java y que no se pueden utilizar como identificadores: abstract continue for new switch boolean default goto null synchronized break do if package this byte double implements private threadsafe byvalue else import protected throw case extends instanceof public transient catch false int return true char final interface short try class finally long static void const float native super while

Palabras Reservadas cast future generic inner operator outer rest var

Operadores Aritméticos: Para los tipos numéricos y char + suma += suma y asignación - resta -= resta y asignación * multiplicación *= multiplicación y asignación / división /= división y asignación % modulo %= modulo y asignación ++ incremento - - decremento Ejemplo: Class Incdec{

Public static void main(String args[]){ int a=1; int b=2; int c=++b; int d=a++; c++; System.out.println(“a=” +a); System.out.println(“b=” +b); System.out.println(“c=” +c); System.out.println(“d=” +d);

} } Operadores == igual != distinto de > mayor que < menor que >= mayor o igual que <= menor o igual que & AND && Condicional AND | OR || Condicional OR ^ XOR

Arrays Se pueden declarar en Java arrays de cualquier tipo:

char s[]; int iArray[];

Incluso se pueden construir arrays de arrays:

int tabla[][] = new int[4][5]; ! Los límites de los arrays se comprueban en tiempo de ejecución

para evitar desbordamientos y la corrupción de memoria.

! En Java un array es realmente un objeto, porque tiene redefinido el operador []. Tiene una función miembro: length. Se puede utilizar este método para conocer la longitud de cualquier array.

int a[][] = new int[10][3]; a.length; /* 10 */ a[0].length; /* 3 */

! Para crear un array en Java hay dos métodos básicos. o Crear un array vacío: int lista[] = new int[50]; o Crear ya el array con sus valores iniciales:

String nombres[] = {"Juan","Pepe","Pedro","Maria"};

Esto que es equivalente a: String nombres[]; nombres = new String[4]; nombres[0] = new String( "Juan" ); nombres[1] = new String( "Pepe" ); nombres[2] = new String( "Pedro" ); nombres[3] = new String( "Maria" );

Errores: ! No se pueden crear arrays estáticos en tiempo de compilación:

int lista[50]; // generará un error en tiempo de compilación

! Tampoco se puede rellenar un array sin declarar el tamaño con

el operador new:

int lista[]; for( int i=0; i < 9; i++ ) lista[i] = i;

Accediendo a los elementos de un array: int a[]=new int[100]; a[0]=0; for(int i=1;i<a.length;i++) a[i]=i + a[i-1]; Operadores

Los operadores de Java son muy parecidos en estilo y funcionamiento a los de C. En la siguiente tabla aparecen los operadores que se utilizan en Java, por orden de precedencia:

. [] () ++ -- ! ~ instanceof * / % + - << >> >>> < > <= >= == != & ^ | && || ? : =

Control de Flujo Muchas de las sentencias de control del flujo del programa se han tomado del C: Sentencias de Salto: if/else

if( Boolean ) { sentencias;

} else{

sentencias; }

switch

switch( expr1 ) { case expr2:

sentencias; break;

case expr3: sentencias; break;

default: sentencias; break;

} Sentencias de Bucle: Bucles for for( expr1 inicio; expr2 test; expr3 incremento )

{ sentencias;

}

El siguiente trocito de código Java que dibuja varias líneas en pantalla alternando sus colores entre rojo, azul y verde. Este fragmento sería parte de una función Java (método):

//int contador; for( int contador=1; contador <= 12;

contador++ ){ switch( contador % 3 ) {

case 0: setColor( Color.red ); break;

case 1: setColor( Color.blue ); break;

case 2: setColor( Color.green ); break;

} g.drawLine( 10,contador*10,80,contador*10); }

Java permite introducir cadenas en el bucle y soporta el operador coma (,).

int i; String s; for (i=0, s=”testing”;(i<10)&&(s.length()>=1); i++,s=s.substring(1)){

System.out.println(s); } Los bucles do_while y while son igual que en C.

Excepciones ! Una excepción en Java es un objeto que describe una condición

anormal que se ha producido en un fragmento de código. ! Cuando surge una excepción se crea el objeto Exception que

se envía al método que ha provocado la excepción. ! Formas de aparecer una excepción:

o Asincronamente. o Creadas manualmente

try-catch-throw

try{ sentencias;

} catch( Exception ) {

sentencias; }

Excepciones asíncronas ! Los objetos de excepción los crea automáticamente el intérprete

de Java como respuesta a alguna condición excepcional. ! El flujo de código se interrumpe en la sentencia que provocó la

excepción y se busca en la pila de llamadas actual cualquier gestor de excepciones.

! Cuando no se ha establecido ningún gestor de excepciones, se

ejecuta el gestor por defecto en tiempo de ejecución. try-catch ! La instrucción try permite especificar el bloque de código que

se debería proteger frente a excepciones. ! La cláusula catch permite resolver la condición excepcional

poniendo las variables en un estado razonable y luego continuar. Pueden tenerse varias clausulas catch.

! El bloque de código finally se ejecuta siempre que se

produce una excepción y además cuando hay una sentencia return.

Ejemplo: class multiCatch{

public static void main(String args[]){ try{

int a=args.length; System.out.println(“a= “+a); int b=42/a; int c[42]=99;

} catch (AritmeticException e){

System.out.println(“div por 0: “+e); } catch (ArrayIndexOutBoundsException e){

System.out.println(“fuera de limites: “ + e);

} finally{ // Terminate the output with a newline

System.out.println(“\n“); }

} } ! Averiguar la excepción que se esta produciendo: public class Prueba4{

public static void main(String [] args){ try{

int i = 4 /0; } catch(Exception e){

System.out.println(“Mensaje capturado:”); e.getMessage();e.printStackTrace();

} }

}

Excepciones creadas por el usuario throw

! Permite lanzar explícitamente una excepción. ! La forma general de una sentencia throw es:

Throw InstanciaThrowable;

! La instancia Throwable debe ser creada por new y posteriormente capturada con catch.

Ejemplo: Class ThrowDemo{

static void demoproc(){ try{

throw new NullPointerException(“demo”); } catch(NullPointerException e){

System.out.println(“capturada dentro de demoproc”); throw e;

} } public static void main (String args[]){

try{ demoproc();

} catch(NullPointerException e){

System.out.println(“capturada de nuevo “ + e);

} }

Programación orientada a objetos. Clase

! Los programas en Java sólo se pueden expresar como clases. ! Un programa completo consta de varias clases almacenadas en

distintos archivos fuente. ! ATENCIÓN: Java no soporta variables globales ni punteros. ! Variables de instancia: Son las variables que se declaran dentro

de una clase y fuera del ámbito de un método concreto. ! Métodos: Son subrutinas unidas a una definición de clase, se

declaran al mismo nivel que las variables de instancia. public class Circle{

public double x,y; public double r; // Métodos public double circunference(){

return 2*3.14159*r; } public double area(){

return 3.14159*r*r; }

} ! Cada clase que se crea añade un tipo que se puede utilizar igual

que los tipos simples. ! Referencia a objeto: se utiliza el nombre de la clase como tipo en

la declaración de variables. Circle c; ! El objeto tiene un valor null hasta que se crea el objeto real y

esta variable lo apunta.

! Operador new: Crea una única instancia de clase y devuelve una referencia a ese objeto.

Circle c; c = new Circle(); ! Acceso a los datos del objeto. Circle c = new Circle(); c.x=2.0; c.y=2.0; c.r=1.0; ! El acceso a los métodos del objeto es igual al acceso de los

datos. Circle c = new Circle(); double a; c.r=2.5; a=c.area(); // igual que un tipo estructurado ! Operador this: Se utiliza dentro de los métodos para referirse al

objeto actual. ! También sirve para ocultar variables de instancia. ! Puede ocurrir que los nombres de las variables locales o

parámetros formales se solapen con las variables de instancia. ! Para referirnos a las variables de instancia utilizaremos this. ! Los constructores inicializan un objeto inmediatamente después

de su creación. ! No devuelven ningún valor (ni siquiera void) y tienen el mismo

nombre que la clase.

public class Circle{

public double x,y,r; // constructor de nuestro método public Circle(double x,double y, double r){

this.x=x;this.y=y;this.r=r; } public double circunference(){

return 2*3.14159*r; } public double area(){

return 3.14159*r*r; }

} ! Encapsulado: Clase = abstracción para un conjunto de objetos

que comparten la misma estructura y comportamiento. ! Mecanismos para encapsular la complejidad: marcar cada

método o variable de una clase como público o privado. ! PRIVADOS: no pueden se accedidos por otro código que esté

fuera de la implementación de la clase. ! PÚBLICOS: accesibles por usuarios externos a la clase. ! PROTEGIDOS: pueden se accedidos únicamente por métodos

de su clase y de clases derivadas de él.

Herencia ! Subclase: es una clase que hereda todos los atributos y métodos

de sus antecesores en la jerarquía de clases. Es, por lo tanto, una clase más específica.

! Superclase: antecesor inmediato de una clase. ! super: se refiere a los constructores de unas superclase.

También se puede utilizar para seleccionar directamente métodos con nombre además de constructores.

! ATENCIÓN: En Java no se puede hacer herencia múltiple,

simplemente se traspasa la funcionalidad de los métodos asociados a la superclase.

Object------Circle------GraphicCircle Math System Component---Container---Panel---Applet Button List ! La superclase de una clase es especificado por la clausula

extends: public class GraphicCircle extends Circle{

// automaticamente heredamos las variables y //métodos de Circle. Color outline,fill; public void draw(DrawWindow dw){

dw.drawCircle(x,y,r,outline,fill); }

} Asignaciones: GraphicCicle gc = new GraphicCircle(); // hereda el método area de la clase Circle double area=gc.area();

! Operador super: Para llamar al método padre dentro de una clase que ha reemplazado ese método, se puede hacer referencia al método padre con la palabra clave super:

import MiClase; public class MiNuevaClase extends MiClase { public void Suma_a_i( int j ) { i = i + ( j/2 ); super.Suma_a_i( j ); } } Sobreescritura: Una subclase puede definir de manera diferente un método de su superclase. // superclase class Point{

int x,y; Point(int a, int b){ // constructor

x=a;y=b; } double distancia(int a,int b){

int dx=x-a; int dy=y-b; return Math.sqrt(dx*dx+dy*dy);

} } class Point3D extends Point{

int z; Point3D(int a, int b,int c){ // constructor

x=a;y=b;z=c } double distancia(int a,int b){

double dx=(x/z) - a; double dy=(y/z) - b; return Math.sqrt(dx*dx+dy*dy);

} }

Polimorfismo ! Una clase tiene varios métodos con el mismo nombre. ! A estos métodos se les pasa información en forma de

parámetros en la llamada al método. ! Los parámetros determinan el método al que se tiene que llamar. ! El método de la subclase oculta o anula el método de la clase

paterna. ! La búsqueda del método asociado siempre empieza examinando

los métodos asociados con el objeto. Si no se encuentra ningún método se busca entre los métodos asociados a la superclase.

// superclase class Point{

int x,y; Point(int a, int b){ // constructor

x=a;y=b; } double distancia(int a,int b){

int dx=x-a; int dy=y-b; return Math.sqrt(dx*dx+dy*dy);

} double distancia (Point p){

return distancia(int p.x,int p.y); }

} class Point3D extends Point{

int z; Point3D(int a, int b,int c){ // constructor

x=a;y=b;z=c } double distancia(int a,int b){

double dx=(x/z) - a; double dy=(y/z) - b; return Math.sqrt(dx*dx+dy*dy);

} }

Ejemplos: Point3D p1 = new Point3D(30,40,50); Point3D p2 = new Point3D(0,0,0); Point p = new Point(4,6); System.out.println(p1.distancia(p)); System.out.println(p2.distancia(4,6); Otras características. ! Método finalizer(): Java no utiliza destructores ya que

recoge de forma automática los objetos que se salen de su alcance

! No obstante proporciona un método para cerrar ficheros, finalizar

conexiones de red, etc.. protected void finalized() throws IOException{

if (fd != null) close(); } ! Clases Abstract: declaran la estructura de la clase sin

proporcionar una implementación completa de cada método. ! Una clase que contiene un método abstract también tiene que

ser declarada como abstract. public abstract class Shape{

public abstract double area(); public abstract double circumference();

} public class Circle extends Shape{

protected double r; protected static final double PI= 3.14159; public Circle(){r=1.0} public Circle(double r){ return PI*r*r;} public double area(){return 2*PI*r;}

}

! Interfaces: proporcionan un mecanismo para abstraer los métodos si forzar al usuario a utilizar la herencia.

! Clases sin variables de instancia y con métodos declarados pero

sin cuerpo. ! Se diferencian de las clases abstractas en que una clase puede

implementar un número ilimitado de interfaces, pero solo puede heredarlos de una superclase.

public interface Drawable{

public void setColor(Color c); public void setPosition(double x,double y); public void draw(DrawWindow dw);

} ! Las clases que quieran utilizar el interface Drawable utilizarán la

palabra implements y proporcionarán el código necesario para implementar los métodos que se han definido en el interface:

public class DrawableRectangle extends Rectangle inplements Drawable{

// new instance variables private Color c; private double x,y; // constructor public DrawableRectangle(double w,double h){

super(w,h);} // implementations of the Drawable methods public void setColor(Color c){this.c=c;} public void setPosition(double x,double y){

this.x=x;this.y=y; } public void draw(DrawWindow dw){

dw.drawRect(x,y,w,h,c); }

}

Utilización Shape[] shapes= new Shape[3]; Drawable[] drawables = new Drawable[3]; // create some drawable shapes DrawableCircle dc = new DrawableCircle(1,1); DrawableSquare ds = new DrawableSquare(2,5); DrawableRectangle dr = new DrawableRectangle (2.3,4.5); // Las formas pueden ser asignadas a ambos arrays shapes[0]= dc; shapes[1]=ds; shapes[2]= dr; drawables[0]= dc; drawables[1]=ds; drawables[2]= dr; double total_area=0.0; for (int i=0;i<shapes.length;i++)

total_area+= shapes[i].area();

Gestión de eventos ! Los eventos sólo recibe aquellas componentes que las llaman

mediante un sistema de "clases de escucha". ! Estas implementa un interface genérico con eventos y se registra

con un objeto productor de eventos. ! Es necesario importar las clases java.awt.event.* ! Ejemplo: Applet que dibuja un punto azul cuando se pulsa un

boton del ratón. import java.awt.Graphics; import java.awt.Color; import java.awt.event.*; public class Puntos extends java.applet.Applet{

final int MAXPUNTOS = 10; int xpuntos[] = new int[MAXPUNTOS]; int ypuntos[] = new int[MAXPUNTOS]; int puntoact =0; public void init(){

setBackground(Color.white); addMouseListener(new M);

} class M implements MouseListener{

//Se ha presionado un boton del ratón public void mousePressed(MouseEvent e){ if(puntoact<MAXPUNTOS) ponpunto(e.getX(),e.getY()); } // soltar el botón del ratón

public void mouseReleased(MouseEvent e){}; // se ha pulsado el botón del ratón public void mouseClicket(MouseEvent e){};

// el puntero del ratón sobre componente public void mouseEntered(MouseEvent e){};

// salir ratón de la componente public void mouseExited(MouseEvent e){};

} void ponpunto(int x,int y){

xpuntos[puntoact]=x; ypuntos[puntoact]=y; puntoact++; repaint();

}

public void paint(Graphics g){ g.setColor(Color.blue); for(int i=0;i<puntoact;i++){ g.fillOval(xpuntos[i]-10,ypuntos[i]-10,20,20); }

} } Movimientos del ratón. ! Añadir en init un nuevo evento: addMouseMotionListener (new M2(); ! Movimiento de ratón pulsado: public void mouseDragged(MouseEvent e){}; ! Movimiento del ratón no pulsado: public void mouseMoved(MouseEvent e){};

Dibujar mientras el ratón esta pulsado. ! Sustituir MouseListener y MouseMotionListener. class M1 extends MouseAdapter{} class M2 extends MouseMotionAdapter{} Eventos de Teclado ! El método keyPressed() captura los eventos de teclado. ! La clase KeyEvent tiene el método getKeyChar() que

devuelve el carácter correspondiente a la tecla que ha producido el evento.

! El método getKeyCode() devuelve un entero con el código de

la tecla. ! Ejemplo: pintar el carácter tecleado en pantalla. Además,

podemos moverlo por la pantalla. import java.awt.Graphics; import java.awt.Color; import java.awt.event.*; import java.awt.Font; public class Teclas extends java.applet.Applet{

char currkey; int currx; int curry; public void init(){

currx=(this.getSize().width/2)-8; curry=(this.getSize().height/2)-16; setBackground(Color.white); setFont(new Font("Helvetica",Font.BOLD,36); addKeyListener(new M());

}

class M extends KeyAdapter{ public void keypressed(Keyevent e){

switch(e.getKeyCode(){ case KeyEvent.VK_DOWN: curry+=5; break; case KeyEvent.VK_UP: curry-=5; break; case KeyEvent.VK_LEFT: curry-=5; break; case KeyEvent.VK_RIGHT: curry+=5; break; default: currkey = e.getKeyChar(); } repaint();

} } public void paint(Graphics g){

if(currkey !=0){ g.drawString(String.valueOf(currkey),currx,curry); }

} }