1. Introducción al lenguaje Java.

Í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
líneas
*/
de
documentación,
de
una
o
más
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
boolean
break
byte
byvalue
case
catch
char
class
const
continue
default
do
double
else
extends
false
final
finally
float
for
goto
if
implements
import
instanceof
int
interface
long
native
new
null
package
private
protected
public
return
short
static
super
switch
synchronized
this
threadsafe
throw
transient
true
try
void
while
Palabras Reservadas
cast future generic inner operator outer rest var
Operadores Aritméticos:
Para los tipos numéricos y char
+ suma
- resta
* multiplicación
/ división
% modulo
++ incremento
+= suma y asignación
-= resta y asignación
*= multiplicación y asignación
/= división y asignación
%= modulo y asignación
- - 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
OR
XOR
&& Condicional AND
|| Condicional OR
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(
nombres[1] = new String(
nombres[2] = new String(
nombres[3] = new String(
"Juan" );
"Pepe" );
"Pedro" );
"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
posteriormente capturada con catch.
creada
por
new
y
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
DrawableCircle dc = new
DrawableSquare ds = new
DrawableRectangle
dr
(2.3,4.5);
shapes
DrawableCircle(1,1);
DrawableSquare(2,5);
=
new
DrawableRectangle
// 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
import
import
import
java.awt.Graphics;
java.awt.Color;
java.awt.event.*;
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); }
}
}