Manual JAVA

Elaborado por: Ing. Jesús Pando Barrón

Versión 1.0

Elaboró: Ing. Jesús Pando Barrón(Mocis)

“Excelencia Tecnológica, Fortaleza de México”

1

http://www.java.com/

INDICETemas Subtemas PáginaIntroducción 51. Generalidades

1.1 Antecedentes 61.2 Pasos para la

instalación y configuración del kit J2SE

9

2.Programación Orientada a Objetos

2.1 Entorno de Java 112.2 Tipos primitivos 132.3 Estructuras básicas de control en Java

2.3.1 Estructuras secuenciales

16

2.3.2 Estructuras alternativas

19

2.3.3 Estructuras repetitivas

20

2.4 Conceptos de Programación Orientada a Objetos

24

2.4.1 Una introducción al alcance de datos

36

2.4.2 Manejo de datos privados

37

2.4.3 Métodos constructores

38

2.4.4 Métodos mutadores (set) y accesores (get)

39

2.4.5 Sobrecarga de métodos

41

2.4.6 Sobrecarga de métodos constructores

45

2.4.7 Una introducción a la palabra clave this

47

2.4.8 Control de acceso a los miembros de clase

51

2.4.9 Static 532.4.10 Paquetes 562.4.11 Arreglos 612.4.12 Herencia 72

2.4.12.1 otro punto de vista de la herencia

74

2.4.12.2 Ejemplos de 77

Elaboró: Ing. Jesús Pando Barrón(Mocis) 2

herencia2.4.12.3 Composición 862.4.12.4 Herencia y composición

87

2.4.12.5 Clases y métodos abstractos

89

2.4.12.6 Interfaces 912.4.12.7 Simulación de la herencia múltiple

92

2.4.12.8 Herencia múltiple con una clase abstracta

93

2.4.12.9 Polimorfismo 962.4.12.10 Clases internas 104

3. Manejo de excepciones

105

3.1 Ejemplos 1094. Interfaz Gráfica de Usuario (GUI) Parte I. AWT

117

4.1 Frames 1184.2 Panels 1224.3 Dialogs 1244.4 Tipos de Layout Managers

127

4.4.1 El administrador BorderLayout

127

4.4.2 El administrador FlowLayout

131

4.4.3 El administrador GridLayout

133

4.4.4 Ejemplos varios

134

5. Manejo de eventos 1395.1 Categorías de los eventos

144

5.2 Clases adaptadoras 1495.3 Manejando eventos con una clase interna

150

5.4 Ejemplos 1545.5 posicionamiento absoluto

165

5.6 Checkbox 1725.7 Choice y List 174

5.8 Componentes de texto

178

5.9 Componentes canvas y ScrollPane

184

5.10 Componentes Menu

193


5.11Controlando colores y fuentes

196

6. Interfaz Gráfica de Usuario (GUI). Parte II. Swing

201

6.1 Campos y etiquetas 2036.2 Botones 2066.3 CheckBox y RadioButton

208

6.4 JcomboBox implementado con una clase interna anónima

212

6.5 JList 2146.6 Eventos del mouse 2186.7 Manejo de eventos de teclas

224

6.8 JTextArea 2266.9 Panel personalizado 2286.10 Menús 2306.11 JPopupMenu 2356.12 Apariencia visual 2386.13 Interfaz de múltiples documentos (MDI)

242

6.14 Administradores de esquemas BoxLayout y GridBagLayout

246

7.0 Proyecto Cliente-Servidor

255

8.0 Bibliografía 270


INTRODUCCION

El presente manual es una recopilación de diversas fuentes que reúne los aspectos

más relevantes del lenguaje Java que tanta inquietud ha causado entre los programadores y

también mucha confusión en cuál es la fuente idónea para aprender dicha tecnología, cada

libro o manual tiene su propia e interesante aportación, lo novedoso que se presenta en esta

documentación es que extrae lo mejor de cada fuente bibliográfica relacionando los

contenidos con los los parámetros que establece Sun y los planes de estudio del área de

Informática y Sistemas. El manual es un soporte para el catedrático y el estudiante ya que

incluye una diversidad de ejemplos por cada tema centrándose en la sencillez de los

mismos y dejando la complejidad de elementos distractores, de esta manera, los programas

desarrollados sirven como plantilla y guía para entender el concepto y que va a permitir a

los estudiantes conformar aplicaciones más elaboradas.

Adicionalmente ofrece la facilidad de entender y desarrollar aplicaciones en el

lenguaje Java basado en la potencialidad que ofrece la Programación Orientada a Objetos

haciendo hincapié en los aspectos primarios de un lenguaje orientado a objetos como son:

Abstracción

Encapsulamiento

Modularidad

Jerarquía

Esta documentación inicia con los antecedentes de Java y profundiza en los temas

de la POO, arreglos, herencia e Interfaz Gráfica de Usuario para culminar con el manejo de

eventos posponiendo para una segunda entrega los temas de Redes y conectividad con

bases de datos bajo el estándar J2EE.


Java1. Generalidades1.1. Antecedentes1

Java fue diseñado en 1990 por James Gosling, de Sun Microsystems, como software para dispositivos electrónicos de consumo. Curiosamente, todo este lenguaje fue diseñado antes de que diese comienzo la era World Wide Web, puesto que fue diseñado para dispositivos electrónicos como calculadoras, microondas y la televisión interactiva.

En los primeros años de la década de los noventa, Sun Microsystems decidió intentar introducirse en el mercado de la electrónica de consumo y desarrollar programas para pequeños dispositivos electrónicos. Tras unos comienzos dudosos, Sun decidió crear una filial, denominada FirstPerson Inc., para dar margen de maniobra al equipo responsable del proyecto.

Inicialmente Java se llamó Oak (roble en inglés), aunque tuvo que cambiar de denominación, debido a que dicho nombre ya estaba registrado por otra empresa. Se dice que este nombre se le puso debido a la existencia de tal árbol en los alrededores del lugar de trabajo de los promotores del lenguaje.

Tres de las principales razones que llevaron a crear Java son:

1. Creciente necesidad de interfaces mucho más cómodas e intuitivas que los sistemas de ventanas que proliferaban hasta el momento.

2. Fiabilidad del código y facilidad de desarrollo. Gosling observó que muchas de las características que ofrecían C o C++ aumentaban de forma alarmante el gran coste de pruebas y depuración. Por ello en sus ratos libres creó un lenguaje de programación donde intentaba solucionar los fallos que encontraba en C++.

3. Enorme diversidad de controladores electrónicos. Los dispositivos electrónicos se controlan mediante la utilización de microprocesadores de bajo precio y reducidas prestaciones, que varían cada poco tiempo y que utilizan diversos conjuntos de instrucciones. Java permite escribir un código común para todos los dispositivos.

Por todo ello, en lugar de tratar únicamente de optimizar las técnicas de desarrollo y dar por sentada la utilización de C o C++, el equipo de Gosling se planteó que tal vez los lenguajes existentes eran demasiado complicados como para conseguir reducir de forma apreciable la complejidad de desarrollo asociada a ese campo. Por este motivo, su primera propuesta fue idear un nuevo lenguaje de programación lo más sencillo posible, con el objeto de que se pudiese adaptar con facilidad a cualquier entorno de ejecución.

Basándose en el conocimiento y estudio de gran cantidad de lenguajes, este grupo decidió recoger las características esenciales que debía tener un lenguaje de programación moderno y potente, pero eliminando todas aquellas funciones que no eran absolutamente imprescindibles.

El proyecto Green fue el primero en el que se aplicó Java, y consistía en un sistema de control completo de los aparatos electrónicos y el entorno de un hogar. Con este fin se construyó un ordenador experimental denominado *7 (Star Seven). El sistema presentaba una interfaz basada en la representación de la casa de forma animada y el control se llevaba a cabo mediante una pantalla sensible al tacto. En el sistema aparecía ya Duke, la actual mascota de Java.

1 http://pisuerga.inf.ubu.es/lsi/Invest/Java/Tuto/I_2.htm


http://pisuerga.inf.ubu.es/lsi/Invest/Java/Tuto/I_2.htm

Más tarde Java se aplicó a otro proyecto denominado VOD (Video On Demand) en el que se empleaba como interfaz para la televisión interactiva que se pensaba iba a ser el principal campo de aplicación de Java. Ninguno de estos proyectos se convirtió nunca en un sistema comercial, pero fueron desarrollados enteramente en un Java primitivo.

Una vez que en Sun se dieron cuenta de que a corto plazo la televisión interactiva no iba a ser un gran éxito, instaron a FirstPerson a desarrollar nuevas estrategias que produjeran beneficios. Entre ellas se encontraba la aplicación de Java a Internet, la cual no se consideró productiva en ese momento.

Aunque muchas de las fuentes consultadas señalan que Java no llegó a caer en un olvido, lo cierto es que tuvo que ser Bill Joy (cofundador de Sun y uno de los desarrolladores principales del sistema operativo Unix de Berckley) el que sacó a Java del letargo en que estaba sumido. Joy juzgó que Internet podría llegar a ser el campo adecuado para disputar a Microsoft su supremacía en el terreno del software, y vio en Oak el instrumento idóneo para llevar a cabo estos planes.

Para poder presentarlo en sociedad se tuvo que modificar el nombre de este lenguaje de programación y se tuvo que realizar una serie de modificaciones de diseño para poderlo adaptar al propósito mencionado. Así Java fue presentado en sociedad en agosto de 1995.

Algunas de las razones que llevaron a Bill Joy a pensar que Java podría llegar a ser rentable son:

Java es un lenguaje orientado a objetos: Esto es lo que facilita abordar la resolución de cualquier tipo de problema.

Es un lenguaje sencillo, aunque sin duda potente. La ejecución del código Java es segura y fiable: Los programas no acceden directamente a la

memoria del ordenador, siendo imposible que un programa escrito en Java pueda acceder a los recursos del ordenador sin que esta operación le sea permitida de forma explícita. De este modo, los datos del usuario quedan a salvo de la existencia de virus escritos en Java. La ejecución segura y controlada del código Java es una característica única, que no puede encontrarse en ninguna otra tecnología.

Es totalmente multiplataforma: Es un lenguaje sencillo, por lo que el entorno necesario para su ejecución es de pequeño tamaño y puede adaptarse incluso al interior de un navegador.

Existen muchas críticas a Java debido a su lenta velocidad de ejecución, aproximadamente unos 20 veces más lentos que un programa en lenguaje C. Sun está trabajando intensamente en crear versiones de Java con una velocidad mayor.

El problema fundamental de Java es que utiliza una representación intermedia denominada código de byte para solventar los problemas de portabilidad. Los códigos de byte posteriormente se tendrán que transformar en código máquina en cada máquina en que son utilizados, lo que ralentiza considerablemente el proceso de ejecución.

La solución que se deriva de esto parece bastante obvia: fabricar ordenadores capaces de comprender directamente los códigos de byte. Éstas serían unas máquinas que utilizaran Java como sistema operativo y que no requerirían en principio de disco duro porque obtendrían sus recursos de la red.

A los ordenadores que utilizan Java como sistema operativo se les llama Network Computer, WebPC o WebTop. La primera gran empresa que ha apostado por este tipo de máquinas ha sido Oracle, que en enero de 1996 presentó en Japón su primer NC (Network Computer), basado en un procesador RISC con 8 Megabytes de RAM. Tras Oracle, han sido compañías del tamaño de Sun, Apple e IBM las que han anunciado desarrollos similares.


La principal empresa en el mundo del software, Microsoft, que en los comienzos de Java no estaba a favor de su utilización, ha licenciado Java, lo ha incluido en Internet Explorer (versión 3.0 y posteriores), y ha lanzado un entorno de desarrollo para Java, que se denomina Visual J++.

El único problema aparente es la seguridad para que Java se pueda utilizar para transacciones críticas. Sun va a apostar por firmas digitales, que serán clave en el desarrollo no sólo de Java, sino de Internet.

Versiones de Java2

Java 1 o Java 1.0 (Enero 1996) - 8 paquetes, 212 clases - Primera versión pública. La presión hizo

que se hiciera pública demasiado pronto, lo cual significa que el diseño del lenguaje no es demasiado bueno y hay muchos errores. Respecto a seguridad, es restrictivo por defecto.

o Java 1.1 (Marzo 1997) - 23 paquetes, 504 clases - mejoras de rendimiento en la JVM, nuevo modelo de eventos en AWT, clases anidadas, serialización de objetos, API de JavaBeans, archivos jar, internacionalización, API Reflection (Reflexión), JDBC (Java Data base Connectivity), RMI (Remote Method Invocation). Se añade la firma del código y la autentificación. Es la primera versión lo suficientemente estable y robusta.

Java 2 o Java 1.2 (Diciembre 1998 ) - 59 paquetes, 1520 clases - JFC (Swing), Drag and Drop,

Java2D, Corba, API Collections. Se producen notables mejoras a todos los niveles. Para enfatizar esto Sun lo renombra como Java 2. El JDK (Java Development Kit) se renombra como SDK (Software Development Kit). Se divide en J2SE, J2EE y J2ME.

o Java 1.3 (Abril 2000) - 77 paquetes, 1595 clases - Orientada sobre todo a la resolución de errores y a la mejora del rendimiento; se producen algunos cambios menores como la inclusión de JNDI (Java Naming and Directory Interface) y la API Java Sound. También incluye un nuevo compilador de alto rendimiento JIT (Just In Time).

o Java 1.4 (2002) - 103 paquetes, 2175 clases - También conocido como Merlin, es la versión actual. Mejora notablemente el rendimiento y añade entre otros soporte de expresiones regulares, una nueva API de entrada/salida de bajo nivel (NIO, New I/O), clases para el trabajo con Collections, procesado de XML; y mejoras de seguridad como el soporte para la criptografía mediante las Java Cryptography Extension (JCE), la inclusión de la Java Secure Socket Extension (JSSE) y el Java Authentication and Authorization Service (JAAS).

o Java 1.5 (Octubre 2004) - 131 paquetes, 2656 clases - También conocido como Tiger, renombrado por motivos de marketing como Java 5.0. Incluye como principales novedades:

tipos genéricos (generics) autoboxing/unboxing conversiones impliticas entre tipos primitivos y los wrappers

correspondientes. Enumerados Bucles simplificados printf Funciones con número de parámetros variable Metadatos en clases y métodos.

1.2 Pasos para la instalación y configuración del kit J2SE

Configuración del Path en Windows XP

2 http://www.javahispano.org/news.item.action?id=987142393


a) Se activa el Panel de Control

b) Se selecciona Sistema

c) Se selecciona Opciones avanzadas

c) Se selecciona Variables de entorno


d) Se selecciona en Variables del sistema la variable Path y después se elige el botón Modificar

e) Se escribe la ruta correcta en donde quedó instalado el software de Java

Por ejemplo:

c:\archivos de programa\java\jdk1.5.0_06\bin (iniciando con un punto y coma para separar la configuración anterior)

2. Programación Orientada a Objetos

2.1. Entorno de Java


Programa1.java

class Programa1{

public static void main(String args[]){

System.out.println("Esta es una prueba");}

}Salida:

Comentarios:

Todo programa en Java consiste de, cuando menos, una declaración de clase que el programador debe de definir. Estas clases se conocen como clases definidas por el programador o clases definidas por el usuario. La palabra clave class introduce una declaración de clase en Java, la cual debe ir seguida inmediatamente por el nombre de la clase.

La línea.

public static void main(String args[])

Es el punto de inicio de toda aplicación en Java. Los paréntesis después de main indican que éste es un bloque de construcción del programa, al cual se le llama método. Las declaraciones de clases en Java generalmente contienen no o más métodos. En una aplicación en Java, sólo uno de esos métodos debe llamarse main y debe definirse como lo muestra el primer programa, de no ser así, el intérprete java no ejecutará la aplicación. La palabra clave void indica que este método realizará una tarea pero no devolverá ningún tipo de información cuando complete su tarea. System.out se conoce como el objeto de salida estándar, permite a las aplicaciones en Java mostrar

conjuntos de caracteres en la ventana de comandos, desde la cual se ejecuta la aplicación en Java.

Compilación y ejecución de una aplicación en Java

javac Programa1.java Esta instrucción compila el archivo de texto .java

Si el programa no contiene errores de sintaxis, el comando anterior crea un nuevo archivo llamado Programa1.class, el cual contiene los códigos de bytes de Java que representan la aplicación. Estos códigos de bytes serán interpretados por Java cuando se le indique que debe ejecutar el programa.

java Programa1 Esta instrucción ejecuta el programa

Programa2.java

class Programa2


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

System.out.println(args[0]);}

}

Salida:

Comentarios: El argumento de main recibe un vector de tipo objeto cadena desde la consola, en este caso recibe la

palabra Bienvenidos en la localidad 0 del vector, si existen otras cadenas (palabras) separadas por un espacio, las tomará en la localidad 1, 2, etc.

Programa3.java

class Programa3{

public static void main(String []vector){

System.out.println(vector[0]);}

}

La salida es la misma que el programa anterior, éste código nos demuestra que el vector args el cual almacena un arreglo de tipo cadena puede llamarse como sea y el orden de los corchetes puede cambiar con base a la sintaxis de los arreglos.

Programa4.java

class Programa4{

public static void main(String []vector){

System.out.println(vector[0]+" "+vector[1]+" "+vector[2]+" "+vector[3]);}

}

Salida:

Programa5.java

class Programa5


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

String a=args[0];System.out.println(a);

}}

Programa6.java

class Programa6{


System.out.println(args[0]);}

}

2.2. Tipos Primitivos

La siguiente tabla muestra los 8 tipos primitivos en Java. Al igual que sus lenguajes antecesores C y C++, Java requiere que todas las variables tengan un tipo. Es por esta razón que Java se conoce como un lenguaje fuertemente tipificado.

Cuando se declaran variables de alguno de los tipos primitivos fuera de un método, se les asignan automáticamente valores predeterminados, a menos que se inicialicen en forma explícita. Las variables de los tipos char, byte, short, int, long, flota y double reciben el valor de 0 de manera predeterminada. Las variables de tipo bolean reciben el valor de false de manera predeterminada.

Tipo Tamaño en bits Valoresboolean true o falseChar 16 0 hasta 65535Byte 8 -128 a +127Short 16 -32768 a 32767Int 32 -2147483648 hasta +2147483647long 64 -9223372036854775808 hasta +9223372036854775807Float 32 Rango negativo:

-3.4028234663852886E+38 hasta -1.40129846432481707E-45Rango positivo:1.40129846432481707E-45 hasta3.4028234663852886E+38

Double 64 Rango negativo:-1.7976931348623157E+308 hasta -4.94065645841246544E-324Rango positivo:4.94065645841246544E-324 hasta 1.7976931348623157E+308

Programa7.java


class Programa7{


int a=10;int b=30;int c=a+b;System.out.println("c="+c);

//una alternativa a este código es

/* int a,b,c;a=10;b=30;c=a+b;System.out.println("c="+c);

*/}

}

Programa8.java

class Programa8{


int a=7;int b=3;int s,r,m,d,modulo;s=a+b;r=a-b;m=a*b;d=a/b;modulo=a%b;System.out.println("La suma es="+s);System.out.println("La resta es="+r);System.out.println("La multiplicacion es="+m);System.out.println("La division es="+d);System.out.println("El residuo es="+modulo);

}}

Salida:

Programa9.java


class Programa9{


double a=7.453;double b=3.567;double s,r,m,d;s=a+b;r=a-b;m=a*b;d=a/b;System.out.println("La suma es="+s);System.out.println("La resta es="+r);System.out.println("La multiplicacion es="+m);System.out.println("La division es="+d);

}}

Salida:

Programa10.java

class Programa10{


String a="Java";int b=10;double c=3.1416;float d1=5.6F;float d2=(float)4.2;byte e=35;boolean f=true;char g='a';short h=100;System.out.println("a="+a+" b="+b+" c="+c);System.out.println("d1="+d1+" d2="+d2);System.out.println("e="+e+" f="+f+" g="+g+" h="+h);

}}

Salida:

2.3. Estructuras básicas de control en Java


2.3.1 Estructuras secuenciales

1) Ecuación 1

Ec1.java

class Ec1{


double y;double m;m=Double.parseDouble(args[0]);y=Math.sqrt(m);System.out.println("y="+y);

}}

Comentarios:

Los métodos estáticos parseInt, parseDouble, parseByte, parseBoolean, etc. de las clases respectivas convierten su argumento String en el tipo de datos deseado.

2) Ecuación 2

Ec2.java

class Ec2{


double a=Double.parseDouble(args[0]);double b=Double.parseDouble(args[1]);double d=Double.parseDouble(args[2]);double v1,v2,v3,z;v1=Math.pow(a,3);v2=b+2;v3=Math.pow(v2,1.0/3.0);z=v1/v2;System.out.println("z="+z);

}}

3) Ecuación 3


Ec3.java

class Ec3{

public static void main(String args[]){double a=Double.parseDouble(args[0]);double b=Double.parseDouble(args[1]);pdouble c=Double.parseDouble(args[2]);double t1,t2,t3,t4,t5,t6,t7,t8,p;t1=Math.pow(b,c);t2=Math.pow(a,t1);t3=Math.log(a+b);t4=t2/t3;t5=Math.log(a*b);t6=Math.exp(t5);t7=t4*t6;t8=Math.sqrt(a/b);p=t7-t8;System.out.println("p="+p);}

}

Ejercicios:

1. Escriba una aplicación que reciba tres enteros del usuario y evalué la siguiente ecuación:

2. Escriba una aplicación que reciba del usuario el radio de un círculo como un float y que imprima el diámetro, circunferencia y área de ese círculo. Utilice la constante predefinida Math.PI para el valor de p.

Diámetro=2rCircunferencia = 2pr

Area = pr2

Operadores.java

importjavax.swing.JOptionPane;public class Operadores{ public static void main(String rgs[]) { int c,d; c=10; d=c++; System.out.println(c); // 11 System.out.println(d); // 10 c=10;


d=++c; System.out.println(c); // 11 System.out.println(d); // 11 c=10; d=c--; System.out.println(c); // 9 System.out.println(d); // 10 c=10; d=--c; System.out.println(c); // 9 System.out.println(d); // 9 c=10; c+=5; System.out.println(c); // 15 c=10; c-=5; System.out.println(c); // 5 c=10; c*=5; System.out.println(c); // 50 c=10; c/=5; System.out.println(c); // 2 c=10; c%=5; System.out.println(c); // 0 }}

2.3.2 Estructuras alternativas


Simple

DecSimple.javaclass DecSimple{


int n=Integer.parseInt(args[0]);if(n>0)

System.out.println("positivo");}

}

Doble

DecDoble.javaclass DecDoble{


int n=Integer.parseInt(args[0]);if(n>0)

System.out.println("positivo");else

System.out.println("negativo");System.out.println("fin del programa");

}}

Múltiple

DecMultiple.javaclass DecMultiple{


int n=Integer.parseInt(args[0]);switch(n){

case 1:System.out.println("uno");break;

case 2:System.out.println("dos");break;

case 3:System.out.println("tres");break;

default:System.out.println("otra opcion");break;

}}}

2.3.3 Estructuras repetitivas


Do while

EstDoWhile.java

class EstDoWhile{


int n=Integer.parseInt(args[0]);int c=0;do{

c=c+1;System.out.println(c);

}while(c<n);

}}

While do

EstWhile.java

class EstWhile{


int n=Integer.parseInt(args[0]);int c=0;while(c<n){

c=c+1;System.out.println(c);

}

}}

Implementación de un contador y sumador

ContSumador.java

class ContSumador{


int n=Integer.parseInt(args[0]);int c=0;int s=0;do{

c=c+1;s=s+c;


}while(c<n);System.out.println(s);

}}

Ejercicios de series

1) no. de términos

2) no. de términos

3) no. de términos

4) no. de términos

5) no. de términos

6) no. de términos

Ciclo For

EstFor.java


class EstFor{


int n=Integer.parseInt(args[0]);for(int c=1;c<=n;c=c+1)

System.out.println(c);}

}

7) no. de términos

8) 1 x 2 x 3 x 4 x ….x no. de términos

9) no. de términos

2.3.4 Ejercicios adicionales de Estructuras de Control

1. Escribe una aplicación que calcule el factorial de un número n.

2. Escribe una aplicación que estime el valor de la constante matemática e, utilizando la fórmula

3. Escribe una aplicación que calcule el valor de ex, utilizando la fórmula

4. Escribe una aplicación que calcule el producto de los enteros impares del a al 15 y que muestre los resultados en un cuadro de diálogo de mensaje.

5. Un almacén de pedidos por correo vende cinco productos cuyos precios de venta son los siguientes: a. Producto 1 $2.98b. Producto 2 $4.50c. Producto 3 $9.98d. Producto 4 $4.49e. Producto 5 $6.87

Escribe una aplicación que lea una serie de pares de números, como se muestra a continuación:i. Número del producto

ii. Cantidad vendida

El programa debe utilizar una instrucción switch para determinar el precio de venta de cada producto. Use un ciclo controlado por centinela para determinar cuándo debe el programa dejar de iterar para mostrar los resultados.


6. Diseña una aplicación que pueda demostrar las tablas de verdad de los operadores AND (&&), OR (||), NOT (!) y XOR (^), de acuerdo a la siguiente referencia.

Operador ANDExpresión 1 Expresión 2 Resultado1 1 11 0 00 1 00 0 0

Operador ORExpresión 1 Expresión 2 Resultado1 1 11 0 10 1 10 0 0

Operador XORExpresión 1 Expresión 2 Resultado1 1 01 0 10 1 10 0 0

Operador NOTExpresión 1 Resultado1 00 1

7.Desarrolla una aplicación para calcular el valor de π a partir de la serie infinita

π

Visualiza una tabla que permita observar la evaluación de cada término hasta n.

2.4. Conceptos de Programación Orientada a Objetos


EJPoo1.java

class EjPoo1{

public int y=20;}

PruebaEJPoo1.java

class PruebaEjPoo1{


EjPoo1 obj=new EjPoo1();System.out.println("y="+obj.y);

}}

Salida:

EjPoo2.java


class EjPoo2{

void metodo1(){

int y=20;System.out.println("y="+y);

}}

PruebaEjPoo2.java

class PruebaEjPoo2{


EjPoo2 obj=new EjPoo2();obj.metodo1();

}}

EjPoo3.java

class EjPoo3{

int metodo1(){

int y=20;return y;

}}

PruebaEjPoo3.java

class PruebaEjPoo3{


EjPoo3 obj=new EjPoo3();System.out.println(obj.metodo1());

}}

EjPoo4.java

class EjPoo4{

int metodo1(int y){

return y;}

}

PruebaEjPoo4.java


class PruebaEjPoo4{


EjPoo4 obj=new EjPoo4();System.out.println(obj.metodo1(20));

}}

EjPoo5.java

class EjPoo5{

void metodo1(int y){

System.out.println("y="+y);}

}

PruebaEjPoo5.java

class PruebaEjPoo5{


EjPoo5 obj=new EjPoo5();obj.metodo1(20);

}}

Una característica importante de las llamadas a métodos es la promoción de argumentos (o coerción de argumentos); es decir, forzar a que se pasen argumentos del tipo apropiado a un método.

Las reglas de promoción se aplican a las expresiones que contienen valores de dos o más tipos primitivos (también conocidos como expresiones de tipo mixto) y a los valores de tipos primitivos que se pasan como argumentos a los métodos. La siguiente tabla muestra los tipos primitivos y los tipos a los que puede promoverse cada uno de ellos.

Tipo Promociones válidasDouble NingunaFloat DoubleLong float o doubleInt long,float o doubleChar int, long, float o doubleShort int, long, float o doubleByte short, int, long, float o doubleboolean Ninguno

Los siguientes ejemplos muestran la validez de las promociones


Demo.java

public class Demo{ public static void main(String args[]) {

float x=3.14;System.out.println(x);

}}

Salida:

Comentarios: Se puede observar que por default el valor de x que es 3.14 lo toma como double y por lo tanto la x

que está declarada como float no puede almacenar el valor. Si se agrega la letra F después del número se está obligando a convertir el dato en flotante y por lo

tanto ya no marca error en la compilación, tal como lo muestra el siguiente ejemplo.

Demo.java


float x=3.14F;System.out.println(x);

}}

Salida:

También se puede realizar de la siguiente forma:


float x=(float)3.14;System.out.println(x);

}}


Salida:

EjPoo6.java

class EjPoo6{


System.out.println("y="+y);}double metodo2(int a, float b){

return a*b;}String metodo3(String g){

return "prueba"+g;}

}

PruebaEjPoo6.java

class PruebaEjPoo6{


EjPoo6 obj1=new EjPoo6();obj1.metodo1(20);System.out.println(obj1.metodo2(100, 4.5F));System.out.println(obj1.metodo3("valor"));

}}

EjPoo7.java

class EjPoo7{


System.out.println("y="+y);}double metodo2(int a, float b){

return a*b;}String metodo3(String g){

return "prueba"+g;}

}PruebaEjPoo7.java


class PruebaEjPoo7{


EjPoo7 obj1=new EjPoo7();obj1.metodo1(20);System.out.println(obj1.metodo2(100, 4.5F));System.out.println(obj1.metodo3("valor"));EjPoo7 obj2=new EjPoo7();obj1.metodo1(40);System.out.println(obj1.metodo2(200, 4.5F));System.out.println(obj1.metodo3("valor"));

}}

Un Ejemplo alternativo Orientado a Objetos

Se diseñará una clase que encapsule información acerca de vehículos como autos, camionetas y camiones. Esta clase se llama Vehiculo y almacenará tres elementos de información acerca del vehículo: el número de pasajeros que puede llevar, su capacidad de combustible y su promedio de consumo de combustible.

Vehiculo.java

class Vehiculo{

int Pasajeros;int CapacidadCombustible;int ConsumoCombustible;

}

PruebaVehiculo.java

class PruebaVehiculo{ public static void main(String args[]){ Vehiculo minivan=new Vehiculo(); int rango; minivan.Pasajeros=7; minivan.CapacidadCombustible=16; minivan.ConsumoCombustible=21; rango=minivan.CapacidadCombustible*minivan.ConsumoCombustible; System.out.println("La Minivan puede llevar: "+minivan.Pasajeros+" Con un alcance de: "+rango);}}

Comentarios: La clase Vehiculo define tres variables de instancia, esta clase no contiene ningún método (por el

momento), así como está construida, es una clase de datos. Esta clase crea un nuevo tipo de datos llamado Vehiculo, este nombre se usará para declarar objetos de tipo Vehiculo. Esta clase es sólo una descripción, no crea un objeto real.

La línea:


Vehiculo minivan=new Vehiculo();

De la clase PruebaVehiculo crea un objeto minivan que es una instancia de Vehiculo. De esta manera, tendrá “realidad física”.

Cada vez que se cree una instancia de una clase, se estará creando un objeto con su propia copia de cada variable de instancia definida por la clase. Así, cada objeto de tipo Vehiculo contendrá sus propias copias de las variables de instancia: Pasajeros, CapacidadCombustible y ConsumoCombustible. Para acceder a estas variables se usará el operador de punto. Este operador enlaza el nombre de un objeto con el nombre de un miembro. El objeto se especifica a la izquierda y el miembro se coloca a la derecha.

En general se puede usar el operador de punto para acceder a las variables de instancia y a los métodos

Clase3.java

class Clase3{

int x;int y;int z;

}

InterfazClase3.java

class InterfazClase3{ public static void main(String args[]){ Clase3 obj1=new Clase3(); Clase3 obj2=new Clase3(); obj1.x=20; obj1.y=30; obj1.z=40; obj2.x=1; obj2.y=2; obj2.z=3; System.out.println("x="+obj1.x+" y="+obj1.y+" z="+obj1.z); System.out.println("x="+obj2.x+" y="+obj2.y+" z="+obj2.z);}}

Modificación de la interfaz para instanciar los dos objetos en una sola línea

class InterfazClase3Mod{ public static void main(String args[]){ Clase3 obj1=new Clase3(), obj2=new Clase3(); obj1.x=20; obj1.y=30; obj1.z=40; obj2.x=1; obj2.y=2; obj2.z=3;


System.out.println("x="+obj1.x+" y="+obj1.y+" z="+obj1.z); System.out.println("x="+obj2.x+" y="+obj2.y+" z="+obj2.z);

}}

Ejemplo 6. Creación de dos objetos tipo Vehiculo.

Vehiculo.java

class Vehiculo{


}

DosVehiculos.java

class DosVehiculos{ public static void main(String args[]){ int rango1,rango2;

Vehiculo minivan=new Vehiculo(); Vehiculo CarroDeportivo=new Vehiculo(); minivan.Pasajeros=7; minivan.CapacidadCombustible=16; minivan.ConsumoCombustible=21; CarroDeportivo.Pasajeros=2; CarroDeportivo.CapacidadCombustible=14; CarroDeportivo.ConsumoCombustible=12;

rango1=minivan.CapacidadCombustible*minivan.ConsumoCombustible; rango2=CarroDeportivo.CapacidadCombustible*CarroDeportivo.ConsumoCombustible;

System.out.println("La Minivan puede llevar :"+ minivan.Pasajeros + " con un alcance de : "+ rango1); System.out.println("El carro sport puede llevar:"+ CarroDeportivo.Pasajeros + " con un alcance de : "+ rango2); }}

Comentarios: La línea:

Vehiculo minivan=new Vehiculo();

Desempeña dos funciones: Primero, declara una variable de nombre minivan del tipo de clase Vehiculo. Esta variable no define un objeto, en cambio es simplemente una variable que puede referirse a un objeto. Segundo, la declaración crea una copia física del objeto y asigna a minivan una referencia a ese objeto. Esto se hace usando el operador new.


El operador new asigna dinámicamente memoria (asignada en tiempo de ejecución) para un objeto y le devuelve una referencia a éste. Esta referencia es almacenada en una variable. Así, en Java, todos los objetos clase son asignados dinámicamente.

La combinación de los dos pasos en el enunciado anterior se puede reescribir para mostrar cada paso individualmente como sigue:

Vehiculo minivan; // declara referencia al objeto minivan = new Vehiculo(); // asigna un objeto Vehiculo

La primera línea declara a minivan como una referencia a un objeto de tipo Vehiculo. De este modo, minivan es una variable que puede referirse a un objeto, pero no es un objeto por sí misma. En este momento minivan contiene el valor de null, que significa que no se refiere a un objeto. La segunda línea crea un nuevo objeto Vehiculo y asigna una referencia para minivan. Ahora, minivan se enlaza con un objeto.

El primer ejemplo se puede rediseñar para que la referencia al objeto esté en dos líneas:

Variables de referencia y asignación

Clase4.java

class Clase4{

int a;}

InterfazClase4.java

class InterfazClase4{ public static void main(String args[]){ Clase4 obj1=new Clase4(); obj1.a=10; Clase4 obj2=obj1; System.out.println("obj1.a="+obj1.a); System.out.println("obj2.a="+obj2.a); Clase4 obj3=new Clase4(); obj2=obj3; System.out.println("obj3.a="+obj3.a); System.out.println("obj2.a="+obj2.a); obj3=obj1; System.out.println("obj1.a="+obj1.a); System.out.println("obj3.a="+obj3.a);}}

Salida:

Variables de referencia y asignación con la clase Vehiculo


PruebaVehiculo5.java

class PruebaVehiculo5{ public static void main(String args[]){

Vehiculo carro1=new Vehiculo(); Vehiculo carro2=carro1;

carro1.Pasajeros=7; System.out.println(carro1.Pasajeros); // 7 System.out.println(carro2.Pasajeros); // 7

Vehiculo carro3 = new Vehiculo(); carro2=carro3; carro3.Pasajeros=10;

System.out.println(carro3.Pasajeros); // 10 System.out.println(carro2.Pasajeros); // 10

carro1=carro3;

System.out.println(carro1.Pasajeros); // 10 System.out.println(carro2.Pasajeros); // 10 System.out.println(carro3.Pasajeros); // 10

System.exit(0);}}

Comentarios: En una operación de asignación, las variables con referencia a objetos actúan diferente a como lo hacen

las variables de tipo simple, como int. Cuando se asigna una variable de tipo simple a otra, la situación es sencilla. La variable a la izquierda recibe una copia del valor de la variable de la derecha. Cuando se asigna una variable de referencia de un objeto a otro, se está cambiando el objeto al que se refiere la variable de referencia. En este ejemplo carro1 y carro2 se refieren a los mismos objetos, la asignación de carro1 a carro2 simplemente hace que carro2 se refiera al mismo objeto de carro1.

Uso de un método con la clase Vehiculo


Vehiculo.java

class Vehiculo{


void rango(){ System.out.println("El rango es: "+CapacidadCombustible*ConsumoCombustible);}}

Comentarios La línea:

void rango()

Declara un método de nombre rango sin parámetros. Su tipo de retorno es void. De este modo, rango() no retorna un valor a quien lo llama.

UsoMetodosVehiculo.java

class UsoMetodosVehiculo{ public static void main(String args[]){

Vehiculo minivan=new Vehiculo(); Vehiculo CarroDeportivo=new Vehiculo();

minivan.Pasajeros=7; minivan.CapacidadCombustible=16; minivan.ConsumoCombustible=21;

CarroDeportivo.Pasajeros=2; CarroDeportivo.CapacidadCombustible=4; CarroDeportivo.ConsumoCombustible=12;

System.out.println("La minivan puede llevar : " + minivan.Pasajeros); minivan.rango(); System.out.println("El carro Deportivo puede llevar : " + CarroDeportivo.Pasajeros); CarroDeportivo.rango();

System.exit(0);}}

Comentarios


La línea:

minivan.rango();

Invoca el método rango() de minivan. Es decir, llama al método rango() relativo al objeto minivan, usando el nombre del objeto seguido por el operador de punto. Cuando un método es llamado, el control del programa se transfiere al método; cuando el método termina, el control se transfiere a quien lo llama y se reanuda la ejecución de la línea de código siguiente al llamado.

Una introducción al alcance de datos

Clase8.java

class Clase8{public int a=15;

public int metodo1(int b, int c){ return b+c;}}

InterfazClase8.java

class InterfazClase8{ public static void main(String args[]){ int x,y,z; Clase8 obj = new Clase8(); obj.a=10; x=obj.a; y=20; z=obj.metodo1(x,y); System.out.println("z ="+z);}}

Comentarios:No existe variaición en la salida porque explícitamente e implícitamente son de alcance públicos

2.4.1 Una introducción al alcance de datos


Clase9.java

class Clase9{private int a=15;

public int metodo1(int b, int c){ return b+c;}}

InterfazClase9.java

class InterfazClase9{ public static void main(String args[]){ int x,y,z; Clase9 obj = new Clase9(); obj.a=10; x=obj.a; y=20; z=obj.metodo1(x,y); System.out.println("z ="+z);}}

Salida:

Comentarios:Marca un error por el acceso de la variable(miembro) a de tipo private

Manejo de datos privados


Clase10.javaclass Clase10{private int a=15;

public int metodo1(int c){ return a+c;}}

InterfazClase10.javaclass InterfazClase10{ public static void main(String args[]){ int y,z; Clase10 obj = new Clase10(); y=20; z=obj.metodo1(y); System.out.println("z ="+z); // z=35}}

Clase11.javaclass Clase11{private int a=15;

private int metodo1(int c){ return a+c;}}

InterfazClase11.javaclass InterfazClase11{ public static void main(String args[]){ int y,z;

Clase11 obj = new Clase11(); y=20; z=obj.metodo1(y); System.out.println("z ="+z);

}}Salida:

Métodos Constructores


MetConst1.java

class MetConst1{

MetConst1(){

System.out.println("Dentro del metodo constructor");}

}

PruebaMetConst1.java

class PruebaMetConst1{


MetConst1 obj = new MetConst1();}

}

Salida:

MetConst2.java

class MetConst2{

MetConst2(int a, int b){

System.out.println("a="+a+" b="+b);}

}

PruebaMetConst2.java

class PruebaMetConst2{


MetConst2 obj = new MetConst2(100,200);}

}

Salida:

Métodos Mutadores(set) y Accesotes(get)


Las clases a menudo proporcionan métodos public para permitir a los clientes establecer (es decir, asignar valores a ) u obtener (es decir, recibir los valores de) variables de instancia private. No es necesario llamar a estos métodos establecer y obtener pero a menudo así sucede.

Como ejemplo de nomenclatura, un método para establecer la variable de instancia tasaInteres se llamaría típicamente establecerTasaInteres, y un método para obtener la tasaDeInteres se llamaría típicamente obtenerTasaInteres. Los métodos establecer también se conocen comúnmente como métodos mutadores (set) (porque generalmente cambian un valor). Los métodos obtener también se conocen como métodos de acceso (get) o (métodos de consulta).

Parece ser que propocionar herramientas para establecer y obtener es esencialmente lo mismo que hacer que las variables de instancia públicas. Ésta es una sutileza de Java que hace del lenguaje algo tan deseable para la ingeniería de software. Si una variable de instancia se declara como public, cualquier método que tenga una referencia a un objeto de la clase en la que se declare esta variable de instancia podrá leer o escribir en ella. Si una variable de instancia se declara como private, un método obtener public eviden temente parece permitir a otros métodos el acceso a la variable; sin embargo, el método obtener controla la manera en que el cliente puede tener acceso a la variable.

SetGet1.java

class SetGet1{

private int x;SetGet1(int a){

set(a);}void set(int a){

if(a>0)x=a;

elsex=0;

}int get(){

return x;}

}

PruebaSetGet1.java

class PruebaSetGet1{


SetGet1 obj1 = new SetGet1(10);System.out.println(obj1.get());SetGet1 obj2 = new SetGet1(-10);System.out.println(obj2.get());

}}

SetGet2.java


class SetGet2{

private int x,y;SetGet2(int a, int b){

set(a,b);}void set(int a, int b){

if(a>0)x=a;

elsex=0;

if(b>0)y=b;

elsey=0;

}int getX(){

return x;}

int getY(){

return y;}

}

PruebaSetGet2.java

class PruebaSetGet2{


SetGet2 obj1 = new SetGet2(10,20);System.out.println(obj1.getX()+" "+obj1.getY());SetGet2 obj2 = new SetGet2(-10,20);System.out.println(obj2.getX()+" "+obj2.getY());SetGet2 obj3 = new SetGet2(10,-20);System.out.println(obj3.getX()+" "+obj3.getY());SetGet2 obj4 = new SetGet2(-10,-20);System.out.println(obj4.getX()+" "+obj4.getY());

}}

Salida:

Sobrecarga de métodos


En Java, dos o más métodos, dentro de la misma clase, pueden compartir el mismo nombre, con la condición de que sus declaraciones de parámetro sean diferentes. Cuando este sea el caso, se dice que los métodos son sobrecargados y el proceso se refiere a sobrecarga de métodos. Un método sobrecargado es una de las maneras cómo Java implementa el polimorfismo.

En general, para sobrecargar un método simplemente se declaran versiones diferentes de él, ya que el compilador se encarga del resto. Se debe observar una restricción importante: el tipo y/o número de los parámetros de cada método sobrecargado debe diferir. No es suficiente que dos métodos que difieran sólo en sus tipos de retornos. (Los tipos de retornos en todos los casos no dan suficiente información para que Java decida cuál método usar). El método sobrecargado puede también diferir en sus tipos de retornos. Cuando se llama un método sobrecargado, se ejecuta la versión del método cuyos parámetros coincidan con los argumentos.

Ejemplo 1. uso de métodos sobrecargados

DemoSobrecarga.javaclass DemoSobrecarga{ void Demo1() { System.out.println("Sin parámetros "); } void Demo1(int a) { System.out.println("Un parámetro: "+a); } int Demo1(int a, int b) { System.out.println("Dos parámetros :"+a+" "+b);

return a+b; } double Demo1(double a, double b) { System.out.println("Dos parámetros doubles : "+a+" "+b);

return a+b; }}

PruebaDemoSobrecarga.javaclass PruebaDemoSobrecarga{ public static void main(String args[]) { DemoSobrecarga ob =new DemoSobrecarga(); int res1; double res2; ob.Demo1(); ob.Demo1(2); res1=ob.Demo1(4,6); System.out.println("El resultado de ob.Demo1(4,6) es: "+res1); res2=ob.Demo1(1.1, 2.32); System.out.println("El resultado de ob.Demo1(1.1,2.32) es: "+res2); }}


Comentarios: El Método Demo1 es cuatro veces sobrecargado. La primera versión no lleva parámetros; la segunda

lleva un parámetro entero; la tercera, dos parámetros enteros y la cuarta, dos parámetros double. Se observa que las dos primeras versiones de Demo1 no retornan un valor y las dos siguientes retornan un valor. Esto es perfectamente válido, la sobrecarga no afecta de ninguna manera por el tipo de retorno de un método.La diferencia en los tipos de retorno es una diferencia insuficiente para los propósitos de la

sobrecarga.

Ejemplo 2. Los tipos de conversión automática pueden afectar la resolución de un método sobrecargado.

DemoSobrecarga2.java

class DemoSobrecarga2{

void Metodo1(int x){ System.out.println("Dentro de Metodo1(int x): "+x);}void Metodo1(double x){ System.out.println("Dentro de Metodo1(double x): "+x); }

}

PruebaDemoSobrecarga2.java

class PruebaDemoSobrecarga2{ public static void main(String args[]) { DemoSobrecarga2 ob =new DemoSobrecarga2(); int i=10; double d=10.1; byte b=99; short s=10; float f=11.5F;

ob.Metodo1(i);ob.Metodo1(d);ob.Metodo1(b);ob.Metodo1(s);ob.Metodo1(f);

}}

Salida:


Comentarios: En este ejemplo, sólo dos versiones de Método1() están definidas: una que tiene un parámetro int y

otra con un parámetro double. Sin embargo, es posible pasar Método1() a un valor byte, short o float. En el caso de byte y short, Java automáticamente las convierte a int. De modo que Método1(int) es invocada. En el caso de float, el valor se convierte a double y Método(double) es llamada.

Ejemplo 3. Agregar un método byte

DemoSobrecarga3.java

class DemoSobrecarga3{

void Metodo1(byte x){ System.out.println("Dentro de Metodo1(byte): "+x);}void Metodo1(int x){ System.out.println("Dentro de Metodo1(int): "+x);}

void Metodo1(double x){ System.out.println("Dentro de Metodo1(double): "+x); }

}

PruebaDemoSobrecarga3.java

class PruebaDemoSobrecarga3{ public static void main(String args[]) { DemoSobrecarga3 ob =new DemoSobrecarga3(); int i=10; double d=10.1;

byte b=99; short s=10; float f=11.5F;

ob.Metodo1(i);ob.Metodo1(d);ob.Metodo1(b);ob.Metodo1(s);ob.Metodo1(f);

}}

Salida:


Comentarios: Las conversiones automáticas se aplican sólo si no hay coincidencia directa entre un parámetro y un

argumento. El anterior programa se adiciona un método que especifica un parámetro byte. Puesto que hay una versión de Método1 que tiene un argumento byte, cuando Método1 se llama con un argumento byte, Método1(byte) se invoca y no ocurre la conversión automática a int.

Sobrecarga de métodos constructores


Los constructores de una clase pueden sobrecargarse. Los constructores sobrecargados permiten a los objetos de una clase inicializarse de distintas formas. Para sobrecargar constructores simplemente hay que proporcionar varias declaraciones del constructor con distintas líneas de parámetros.

Ejemplo 1

SobreCargaConstructores.java

class SobreCargaConstructores{

SobreCargaConstructores(){

System.out.println("Metodo constructor sin parametros");}SobreCargaConstructores(int a){

System.out.println("Metodo constructor con un parametro");System.out.println("a="+a);

}SobreCargaConstructores(int a, float b){

System.out.println("Metodo constructor con dos parametros");System.out.println("a="+a+" "+"b="+b);

}SobreCargaConstructores(Double a, String x, char z){

System.out.println("Metodo constructor con tres parametros");System.out.println("a="+a+" "+"x="+x+"z="+z);

}}

PruebaSobreCargaConstructores.java

public class PruebaSobreCargaConstructores{ public static void main(String args[])

{SobreCargaConstructores obj1 = new SobreCargaConstructores();SobreCargaConstructores obj2 = new SobreCargaConstructores(100);SobreCargaConstructores obj3 = new SobreCargaConstructores(30,60.9F);SobreCargaConstructores obj4 = new SobreCargaConstructores(5.8,"cadena1",'x');

}}

Salida:

Ejemplo 2. Inicialización de un objeto con otro.


DemoInicializacionObjetos.java

class DemoInicializacionObjetos{ int suma; DemoInicializacionObjetos (int num) { suma=0;

for(int i=1; i<=num;i++)suma+=1;

} DemoInicializacionObjetos (DemoInicializacionObjetos ob) { suma=ob.suma; }}

PruebaInicializacionObjetos.java

class PruebaInicializacionObjetos{ public static void main(String args[]) {

DemoInicializacionObjetos s1 = new DemoInicializacionObjetos(5);DemoInicializacionObjetos s2 = new DemoInicializacionObjetos(s1);

System.out.println("s1.suma: "+s1.suma);System.out.println("s2.suma: "+s2.suma);

}}

Salida:

Comentarios: Una de las razones más comunes para que los constructores sean sobrecargados es permitir que un

objeto inicialice a otro. Como se puede ver en el anterior ejemplo, una ventaja de proporcionar un constructor que usa un objeto para inicializar a otro es eficiencia. En este caso, cuando s2 es construida, no es necesario volver a calcular la suma.

Una introducción a la palabra clave this


Cuando se llama un método, automáticamente se pasa un argumento implícito que es la referencia al objeto invocado (esto es, el objeto en el cual el método se llama). Esta referencia se llama this. En otras palabras, si se tiene dos objetos del mismo tipo llamados a y b, se puede preguntar cómo es que se puede invocar un método f() para ambos objetos:

Ejemplo:

ImpMetodosThis1.java

class ImpMetodosThis1{

void f(int x){ System.out.println("dentro del método f"); System.out.println("x="+x);}

}

IntMetodosThis1.java

class IntMetodosThis1{ public static void main(String args[]){ ImpMetodosThis1 a=new ImpMetodosThis1(), b=new ImpMetodosThis1(); a.f(10); b.f(10);}}

En el ejemplo anterior, si sólo hay un método llamado f(). ¿Cómo puede este método saber si está siendo invocado para el objeto a o b?.

Para permitir la escritura de código con una sintaxis adecuada orientada a objetos en la que “se envia un mensaje a un objeto”, el compilador se encarga del código clandestino. Hay un primer parámetro secreto que se pasa al método f(), y ese parámetro es la referencia al objeto que está siendo manipulado. Por tanto, las dos llamadas a los métodos anteriores, se convierten en algo parecido a:

ImpMetodosThis1.f(a,10);ImpMetodosThis1.f(b,10);

Esto es interno y uno no puede escribir estas expresiones y hacer que el compilador las acepte, pero da una idea de lo que está corriendo.

Supóngase que uno está dentro de un método y que se desea conseguir la referencia al objeto actual. Dado que esa referencia se pasa de forma secreta al compilador, no hay un identificador para él. Sin embargo, para este propósito hay una palabra clave: this. Esta palabra clave –que puede usarse sólo dentro de un método- produce la referencia al objeto por el que se ha invocado al método. Se puede tratar esta referencia como cualquier otra referencia a un objeto. Por consiguiente se puede modificar el programa anterior a:

ImpMetodosThis2.java


class ImpMetodosThis2{ int x; ImpMetodosThis2(int i){ x=i;} int obtener() { System.out.println("x= "+x); System.out.println("this.x= "+this.x); return this.x; }}

IntMetodosThis2.java

class IntMetodosThis2{ public static void main(String args[]){ ImpMetodosThis2 a=new ImpMetodosThis2(10), b=new ImpMetodosThis2(10); System.out.println(a.obtener()); System.out.println(b.obtener());}}

Salida:

Ejemplo. Sin la utilización del this

DemoThis.java

class DemoThis{ int x; DemoThis(int i){ x=i;} int get() { return x; }}

PruebaThis.java


class PruebaThis{ public static void main(String args[]) { DemoThis obj1=new DemoThis(10); System.out.println(obj1.get()); }}

Ejemplo con la utilización de this

DemoThis.java

class DemoThis{ int x; DemoThis(int i){ x=i;} int get() { System.out.println("x= "+x); System.out.println("this.x= "+this.x); return this.x; }}

PruebaThis.java

class PruebaThis{ public static void main(String args[]) { DemoThis obj1=new DemoThis(10); DemoThis obj2=new DemoThis(20); System.out.println(obj1.get()); System.out.println(obj2.get()); }}

Ejemplo 2. Uso de this para diferenciar a las variables de instancia y los parámetros

DemoThis2.java

class DemoThis2{ int x,y; DemoThis2(int x, int y){

/* x=x; esta linea confunde */this.x=x;


this.y=y;} int get1() { System.out.println("this.x = "+ this.x); System.out.println("x = "+ x); return this.x; } int get2() { System.out.println("this.y = "+ this.y); System.out.println("y = "+ y); return this.y; }}

PruebaThis2.java

class PruebaThis2{ public static void main(String args[]) { DemoThis2 obj1=new DemoThis2(10,20); System.out.println(obj1.get1()+" "+obj1.get2()); }}

Control de acceso a los miembros de clase


En el soporte para encapsulación , la clase provee dos beneficios importantes. Primero enlaza los datos con el código que maneja. Segundo, provee los medios por los que el acceso a los miembros se puede controlar.

Aunque el enfoque de Java es un poco más sofisticado, en esencia, hay dos tipos básicos de miembros de clase: público y privado. Se puede tener acceso a un miembro público por un código definido fuera de su clase y se puede tener acceso a un miembro privado sólo por otros métodos que defina su clase. Se hace a través del uso de miembros privados donde se controla el acceso.

Una parte fundamental de la programación orientada a objetos es el acceso restringido de los miembros a una clase, esto ayuda a prevenir el mal uso de un objeto. Si se permite el acceso a datos privados sólo a través de un conjunto bien definido de métodos, se podría evitar que valores impropios se asignen a esos datos, por ejemplo, llevar a cabo un control de rango. Para códigos externos a la clase no es posible fijar directamente el valor de un miembro privado. También se puede controlar con precisión dónde y cuándo se usan los datos dentro de un objeto. De manera que cuando se ejecuta correctamente, una clase crea una caja negra que puede usarse, pero el funcionamiento interior no está disponible para manipularlo.

Java provee un acceso fijo por defecto, en el que los miembros de una clase están libremente disponibles para el otro código en el programa. (El acceso fijo por defecto es esencialmente público). Aunque es conveniente para clases simples, este acceso fijo por defecto no es apropiado para muchas situaciones en el mundo real.

El control de acceso a miembros se consigue a través del uso de tres especificadores de acceso: public, private y protected.

Cuando un miembro de una clase se modifica mediante el especificador public, se puede tener acceso a ese miembro por cualquier otro código en el programa. Esto incluye métodos definidos dentro de otras clases.

Cuando un miembro de una clase se especifica como private, se puede tener acceso a ese miembro sólo mediante otro miembro de su misma clase. Así, métodos en otras clases no pueden acceder a miembros private de otra clase.

Ejemplo. Accesos públicos vs. Accesos privados

Accesos.java

class Accesos{ private int alfa; // acceso privado public int beta; // acceso público int gamma; // acceso por defecto es público void setAlfa(int a)

{alfa=a;

}int getAlfa()

{return alfa;

}int getBeta()

{return beta;

}int getGamma()

{return gamma;

}}PruebaAccesos.java


class PruebaAccesos{ public static void main(String args[]){

Accesos obj1=new Accesos();obj1.setAlfa(100);System.out.println(obj1.getAlfa());

// obj1.alfa=200; Marca error en la compilaciónobj1.beta=300;obj1.gamma=500;System.out.println(obj1.getBeta());System.out.println(obj1.getGamma());

}}

Comentarios:

Como se puede ver en la clase Accesos, alfa se especifica como private, beta como public y gamma pública por defecto. Como alfa es privada, no se puede tener acceso a ella mediante código fuera de su clase. Por lo tanto, dentro de la clase PruebaAccesos, alfa no se puede usar directamente, se debe tener acceso a través de sus métodos de acceso públicos: setAlfa() y getAlfa().Aunque el acceso a alfa por un código fuera de Accesos no se permite, los métodos definidos dentro

de la clase Accesos pueden acceso libremente, como se puede apreciar con los métodos setAlfa() y getAlfa().Conclusión: un miembro privado puede libremente ser usado por otros miembros de su clase, pero

no puede tener acceso a ella mediante un código fuera de su clase.


Static

Cuando un miembro se declara static, se puede tener acceso a este antes de crear algunos objetos de su clase y sin referencia a ningún objeto. Se puede declarar los métodos y las variables como static. El ejemplo más común de un miembro static es main(). Este método se declara como static porque debe ser llamado por el sistema operativo cuando inicia una aplicación en Java.

Ejemplo 1.

ImpDemoStatic1.java

class ImpDemoStatic1{ static int y;}

IntDemoStatic1.java

class IntDemoStatic1{ public static void main(String args[]){ ImpDemoStatic1.y=20; System.out.println(ImpDemoStatic1.y);}}

Como se observa para usar un miembro static se necesita solamente especificar el nombre de la clase, seguido del operador punto, no se necesita crear un objeto.

Las variables declaradas como static son esencialmente variables globales.La diferencia entre un método static y un método normal consiste en que el método static puede ser

llamado mediante su nombre de clase, sin haber creado ningún objeto de esa clase. Como un ejemplo se tiene el método sqrt(), que es un método static dentro de la clase estándar Math de Java.

Ejemplo 2.

MetodoEstatico.java

class MetodoEstatico{

static int valor = 100;static int Dividir(){

return valor/2;}

}

DemoMetodoEstatico.java

class DemoMetodoEstatico{



System.out.println("El valor es "+MetodoEstatico.valor);System.out.println("Valor del metodo "+ MetodoEstatico.Dividir());MetodoEstatico.valor=200;System.out.println("El valor es "+MetodoEstatico.valor);System.out.println("Valor del metodo "+ MetodoEstatico.Dividir());

}}

Salida:

Los métodos declarados como static tienen varias restricciones:

1. Pueden llamar sólo a otros métodos static2. Deben acceder sólo a datos static3. No tienen una referencia this

Ejemplo 3. Error por la declaración de un dato static y public

class MetodoEstatico{

static int valor = 100;int d=2;static int Dividir(){

return valor/d;}

}

Salida al compilar:

Algunas veces una clase requiere algunos tipos de inicialización antes de estar lista para crear objetos. Por ejemplo, si se necesita establecer una conexión a un sitio remoto o inicializar ciertas variables static antes de que cualquier método de clase static sea usado.

Para manejar este tipo de situaciones, Java permite declarar un bloque static. Un bloque static es ejecutado cuando la clase se carga por primera vez. De este modo es ejecutado antes de que la clase pueda usarse para cualquier otro propósito.

Ejemplo 4. Demostración de la ejecución de un bloque static

BloqueEstatico.java

class BloqueEstatico{

static double raiz2;static double raiz3;


// metodo constructor

BloqueEstatico (String msg){

System.out.println(msg);}static{

System.out.println("Dentro de un bloque static");raiz2=Math.sqrt(2.0);raiz3=Math.sqrt(3.0);

}

}

DemoBloqueEstatico.java

class DemoBloqueEstatico{


BloqueEstatico objeto=new BloqueEstatico("Dentro del constructor");System.out.println("Raiz cuadrada de 2 ="+BloqueEstatico.raiz2);System.out.println("Raiz cuadrada de 3 ="+BloqueEstatico.raiz3);

}}

Salida:


PaquetesCada clase e interfaz en la API de Java pertenece a un paquete que contiene un grupo de clases e

interfaces relacionadas. A medida que las aplicaciones se vuelven más complejas, los paquetes ayudan a los programadores a manejar la complejidad de lo componentes de las aplicaciones. Los paquetes también facilitan la reutilización de software al permitir que los programas importen clases de otros paquetes. Otro beneficio de los paquetes es que proporcionan una convención para nombres de clase únicos.

Los pasos para crear una clase reutilizable son:

1. Se declara una clase como public. Si la clase no es public, sólo podrá ser utilizada por otras clases dentro del mismo paquete.

2. Se elije el nombre del paquete y se agrega una declaración package al archivo de código fuente para la declaración de la clase reutilizable. Sólo puede haber una declaración package en un archivo de código fuente en Java, y ésta debe ir antes de cualquier otra declaración o instrucción en el archivo.

3. Se compila la clase, de manera que se coloquen en la estructura de directorio del paquete apropiado.

4. Se importa la clase reutilizable en un programa y se utiliza.

Un paquete es lo que se obtiene al utilizar la palabra clave import para importar una biblioteca completa, como en:

import java.util.*;

Esto trae la biblioteca de utilidades entera, que es parte de la distribución estándar de Java.

Ejemplo 1.

Creación del paquete

EjemploPaquete.java

package paquetes;public class EjemploPaquete { private int x; private int y; private int z; public EjemploPaquete() { establecerVariables( 0, 0, 0 );

}

public void establecerVariables( int a, int b, int c ) { x = ( ( a >= 0 && a <=5 ) ? a : 0 ); y = ( ( b >= 0 && b <=10 ) ? b : 0 ); z = ( ( c >= 0 && c <=15) ? c : 0 ); } public int obtenerVariables() { return x+y+z; }


} Compilación:

Si es exitosa la compilación se crea un subdirectorio paquetes

Dentro de esta carpeta se encuentra el archivo EjemploPaquete.class. Después se codifica la interfaz (la clase que va a usar el paquete).

UsoEjemploPaquete.java

import paquetes.EjemploPaquete;

public class UsoEjemploPaquete{ public static void main( String args[] ) { EjemploPaquete objeto = new EjemploPaquete(); objeto.establecerVariables( 2,5,7 );

System.out.println(objeto.obtenerVariables()); objeto.establecerVariables( -5,12,20 );

System.out.println(objeto.obtenerVariables()); System.exit( 0 ); } }

Esta clase se compila normalmente con javac, al ejecutarlo se obtiene la siguiente salida:

Comentarios: Al colocar una declaración package al principio de un archivo de código fuente en Java, se indica

que la clase (o clases) declarada(s) en el archivo forma(n) parte del paquete especificado.

Sólo las declaraciones package, las declaraciones import y los comentarios pueden aparecer fuera de las llaves de la declaración de una clase.

Un archivo de código fuente en Java tiene el siguiente orden: primero una declaración package (si la hay), luego las declaraciones import (si las hay), y después las declaraciones de clase. Sólo una de las declaraciones de clase en un archivo puede ser pública. Las demás clases en el archivo se colocan también en el paquete, pero son reutilizables desde cualquier otra clase en ese paquete; no pueden


importarse en clases de otros paquetes. Se encuentran en el paquete para dar soporte a la clase reutilizable del archivo.

En un esfuerzo por proporcionar nombres únicos para cada paquete, Sun Microsystems especifica una convención para nombrar paquetes, que deben seguir todos los programadores en Java. Todos los nombres de paquetes que se vayan a crear deben empezar con el nombre del dominio de Internet en donde se este desarrollando el software en orden inverso. Por ejemplo, para el dominio de Internet: instituto.edu, el nombre del paquete debe empezar con edu.instituto. Una vez invertido el nombre de dominio se puede elegir otro nombre que se desee para el paquete, se puede elegir la ruta de la red y de la estación de trabajo para el nombre completo.

Cuando se compila un archivo en Java que contiene una declaración package, el archivo de clase resultante se coloca en la estructura de directorio especificado por la declaración package. Por ejemplo la declaración package:

package edu.instituto.mii1.f2c3.progjavapublic class Tiempo1 {…}

indica que la clase Tiempo1 debe colocarse en el directorio progjava, los otros nombres edu, instituto, mii1, f2c3, son también directorios. Los nombres de directorio en la declaración package especifican la ubicación exacta de las clases en el paquete. Si estos directorios no existen antes de compilar la clase, el compilador puede crearlos.

Al compilar una clase en un paquete, la opción de línea de comandos (-d) hace que el compilador javac cree los directorios apropiados, con base en la declaración package de la clase. Esta opción también especifica en dónde crear (o ubicar) los directorios. Por ejemplo al ejecutar la sentencia de compilación:

javac –d . Tiempo1

se creará una rama de directorios en donde existirá la clase Tiempo1 en el directorio progjava.

Si no se utiliza la opción –d, entonces se deberá copiar o mover el archivo de clase al directorio del paquete apropiado, después de compilarlo.

El nombre del paquete es parte del nombre de la clase, para el programa ejemplo, el nombre de la clase realmente es:

import ejemplopaquete.ejemplo.Tiempo1;

Este nombre de clase está completamente calificado y se puede utilizar así para diferenciar entre las clases en el programa y así evitar un conflicto de nombres, lo que se llama como colisión de nombres.

Al compilar PruebaTiempo1, javac debe localizar el archivo .class de Tiempo1 para asegurarse de que la clase PruebaTiempo1 utilice a la clase Tiempo1 correctamente. El compilador utiliza un objeto especial llamado cargador de clases para localizar las clases que necesita. El cargador de clases empieza buscando en las clases estándar de Java que se incluye con el J2SDK. Después busca los paquetes adicionales. Java 2 cuenta con un mecanismo de extensión que permite que se agreguen nuevos paquetes (opcionales) a Java para fines de desarrollo y ejecución. Si la clase no se encuentra en la clase estándar de Java ni en las clases de extensión, el cargador de clases busca en la ruta de clases, la cual contiene una lista de ubicaciones en las que se almacenan las clases. La ruta de clases consiste en una lista de directorios, cada uno


separado por un separador de directorio: un signo de punto y coma (;) en Windows o un signo de dos puntos (:) en UNIX/Linux/Mac OS X.

De manera predeterminada, la ruta de clases consiste sólo del directorio actual. Sin embargo, la ruta de clases puede modificarse de la siguiente manera:

1. Proporcionando la opción –classpath al compilador javac o2. estableciendo la variable de entorno CLASSPATH (variable de entorno que se define

en el sistema operativo).

Por otra parte se comenta acerca de las notaciones “oficiales” en diferentes plataformas:

Notaciones PlataformaPascal .NET JavaNombreMiembro

Ejemplo: DemoClase

ClasesMétodosPropiedadesEstructuras

Clases

CamellonombreMiembro

Ejemplo: demoMetodo

AtributosParámetros

MétodosAtributosParámetros

Ejemplo 3. fundamentos para la creación de una biblioteca a medida (respetando la nomenclatura de nombres:

P.java

package mx.edu.instituto.lab1.est01;public class P{ public static void sinSalto(String s)

{ System.out.print(s);}

public static void conSalto(String s){ System.out.println(s);}

}

PruebaHerramienta.java

import mx.edu.instituto.lab1.est01.P;public class PruebaHerramienta{ public static void main(String[] args) { P.sinSalto("hola, esta es un prueba "); P.sinSalto("esto esta en la misma linea "); P.conSalto(""+100); P.conSalto(""+100.05); P.conSalto(""+3.1416); }}


Salida:

Ejemplo 2. Uso de dos paquetes

P02.java

package mx.edu.instituto.lab1.est01;public class P02{ public static void elevarCuadrado(double valor)

{ System.out.println(Math.pow(valor,2));}

public static void elevarCubo(double valor){ System.out.println(Math.pow(valor,3));}

}

P03.java

package mx.edu.instituto.lab1.est01;public class P03{ public static void raizCuadrada(double valor)

{ System.out.println(Math.pow(valor,1.0/2.0));}

public static void raizCubica(double valor){ System.out.println(Math.pow(valor,1.0/3.0));}

}

PruebaFunciones.java

import mx.edu.instituto.lab1.est01.P02;import mx.edu.instituto.lab1.est01.P03;

public class PruebaFunciones{ public static void main(String[] args) {

P02.elevarCuadrado(2.0);P02.elevarCubo(2.0);P03.raizCuadrada(8.0);P03.raizCubica(8.0);


}}

Arreglos

La tecnología Java tiene dos maneras de declarar arreglos

La primera forma se puede hacer de la siguiente manera:

char vector1[];Punto vector2[]; //donde Punto es una clase

O de esta forma

char [] vector1;Punto [] vector2;

Después de declarar una referencia de una variable de tipo arreglo, el siguiente paso es crear el objeto arreglo e inicializar la referencia de la variable con la dirección del nuevo objeto creado:

vector1= new char[20];vector2 = new point [100];

En realidad ya hemos usado un arreglo de una dimensión en el momento de activar la entrada de datos por consola, usando el vector o arreglo de una dimensión args[] de tipo cadena, tal como lo muestra el siguiente ejemplo:

class Demo1Array{


String cad1=args[0];String cad2=args[1];String cad3=args[2];System.out.println("cad2="+cad2+" "+args[1]+"\n");for(int i=0; i<=2; i++)

System.out.println(args[i]+"\n");}

}

Salida:

La sintaxis para declarar e inicializar un arreglo se puede hacer de tres maneras:

1. tipo identificador_array []identificador_array = new tipo [longitud];

2. tipo identificador_array[] = new tipo[longitud]3. tipo [] identificador_array={lista de valores o expresiones separadas por comas}


Considerando que la posición de los corchetes puede cambiar de posición antes o después del identificador del arreglo.

Ejemplos

Arreglos Unidimensionales

Demo1Array.java

class Demo1Array{


String cad1=args[0];String cad2=args[1];String cad3=args[2];System.out.println("cad2="+cad2+" "+args[1]+"\n");for(int i=0; i<=2; i++)

System.out.println(args[i]+"\n");}

}

Demo2Array.java

class Demo2Array{

private int vector1[]=new int[100];private int x=0;void establecerDatos(int i){

vector1[x++]=i;System.out.println("vector1["+i+"]="+i);

}int obtenerDatos(){

return vector1[--x];}

}

PruebaDemo2Array.java

class PruebaDemo2Array{


int n=Integer.parseInt(args[0]);Demo2Array obj=new Demo2Array();for(int j=0;j<n;j++)

{obj.establecerDatos(j);

}int t=n;


System.out.println("Visualizar arreglo en forma inversa");for(int j=0;j<n;j++){

System.out.println("vector1["+--t+"]="+obj.obtenerDatos());}

}}

Demo3Array.java

class Demo3Array{ int vector1[] = {0,1,2,3,4,5,6,7,8,9};

int obtenerDatos(int i){

return vector1[i];}

}




int n=Integer.parseInt(args[0]);Demo3Array obj=new Demo3Array();for(int j=0;j<=n;j++)

{System.out.println(obj.obtenerDatos(j));

}}

}

Demo4Array.java

class Demo4Array{ private int vector1[] = {0,1,2,3,4,5,6,7,8,9}; Demo4Array(int arreglo[])

{for (int i=0;i<vector1.length; i++)

arreglo[i]=vector1[i];}int obtenerDatos(int i){

return vector1[i];}

}





int n=Integer.parseInt(args[0]);int numeros[]=new int [10];Demo4Array obj=new Demo4Array(numeros);for(int j=0;j<=n;j++)

{System.out.println(obj.obtenerDatos(j));

}}

}

Demo6Array.java

class Demo6Array{

private float vector1[]={1.0f,2.0f,3.3f,4.14f,5.8987f};int n=vector1.length;Demo6Array(float arreglo[]){

establecerDatos(arreglo);}void establecerDatos (float arreglo[]){

for(int j=0; j<n;j++){

arreglo[j]=vector1[j];}

}

}



public static void main(String args[]){ float vectorA[] = new float [5];

Demo6Array obj=new Demo6Array(vectorA);for(int j=0; j<vectorA.length;j++)

System.out.println(vectorA[j]);

}}


Demo7Array.java

class Demo7Array{

private String vector1[]={"lunes", "martes", "miercoles", "jueves", "viernes"};int n=vector1.length;Demo7Array(String arreglo[]){

establecerDatos(arreglo);}void establecerDatos (String arreglo[]){

for(int j=0; j<n;j++){

arreglo[j]=vector1[j];}

}

}



public static void main(String args[]){ String vectorA[] = new String [5];

Demo7Array obj=new Demo7Array(vectorA);for(int j=0; j<vectorA.length;j++)

System.out.println(vectorA[j]);}

}

SumaVectores.java

import javax.swing.*;class SumaVectores{

private int limite;SumaVectores(int l){

establecerLimite(l);}void establecerLimite(int l){

if (l<=0)limite=0;

elselimite=l;

}void leer(int arreglo[]){


for (int i=0;i<limite;i++){

arreglo[i]=Integer.parseInt(JOptionPane.showInputDialog("Introduce el elemento "+i));

}}void sumaVectores(int arreglo1[], int arreglo2[], int arreglo3[]){

for(int i=0;i<limite;i++){

arreglo3[i]=arreglo1[i]+arreglo2[i];}

}void visualizar(int arreglo[]){

for(int i=0;i<limite;i++){

System.out.println("Elemento ["+i+"]="+arreglo[i]);}

}

}

PruebaSumaVectores.java

class PruebaSumaVectores{

public static void main(String args[]){ int vectorA[] = new int [100];

int vectorB[] = new int [100];int vectorC[] = new int [100];int n=Integer.parseInt(args[0]);SumaVectores obj=new SumaVectores(n);obj.leer(vectorA);obj.leer(vectorB);obj.sumaVectores(vectorA,vectorB,vectorC);System.out.println("Datos del vector A ");obj.visualizar(vectorA);System.out.println("Datos del vector B ");obj.visualizar(vectorB);System.out.println("Resultado de la suma ");obj.visualizar(vectorC);

}}


Arreglos Bididimensionales

DemoBidi1.java

class DemoBidi1{

private int tabla1[][]={{1,2,3},{4,5,6},{7,8,9}};int n=tabla1.length;DemoBidi1(int arreglo[][]){

establecerDatos(arreglo);}void establecerDatos (int arreglo[][]){

for(int i=0;i<n;i++)for(int j=0; j<n;j++){

arreglo[i][j]=tabla1[i][j];}

}

}

PruebaDemoBidi1.java

class PruebaDemoBidi1{

public static void main(String args[]){ int tablaA[][] = new int [3][3];

DemoBidi1 obj=new DemoBidi1(vectorA);for(int i=0;i<tablaA.length;i++)for(int j=0; j<tablaA[i].length;j++)

System.out.println(tablaA[i][j]);

}}

DemoBidi2.java

class DemoBidi2{

private int tabla1[][]={{1,2,3},{4},{5,6},{7,8,9}};int n=tabla1.length;DemoBidi2(int arreglo[][]){


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


for(int j=0; j<tabla1[i].length;j++){


}

}

Otra manera de inicializar

class DemoBidi2{

//private int tabla1[][]={{1,2,3},{4},{5,6},{7,8,9}}; private int tabla1[][]=new int [][]{{1,2,3},{4},{5,6},{7,8,9}};int n=tabla1.length;DemoBidi2(int arreglo[][]){


for(int i=0;i<n;i++)for(int j=0; j<tabla1[i].length;j++){


}

}

PruebaDemoBidi2.java

class PruebaDemoBidi2{

public static void main(String args[]){ // int tablaA[][] = new int [4][4];

int tablaA[][]={{0,0,0},{0},{0,0},{0,0,0}};DemoBidi2 obj=new DemoBidi2(tablaA);for(int i=0;i<tablaA.length;i++)for(int j=0; j<tablaA[i].length;j++){

System.out.println(tablaA[i][j]);}

}}

DemoEmpleados.java

class DemoEmpleados{

int idEmpleado=0;String nombre="Nombre del empleado";char estadoCivil='c';


double salarioDiario=0.0;int edad=0;DemoEmpleados(int id,String n,char c, double s, int e){

idEmpleado=id;nombre=n;estadoCivil=c;salarioDiario=s;edad=e;

}void visualizarInformacion(){

System.out.println("La clave del empleado es:"+ idEmpleado);System.out.println("El nombre del empleado es:"+ nombre);System.out.println("El Estado Civil del empleado es:"+ estadoCivil);System.out.println("El salario del empleado es:"+ salarioDiario);System.out.println("La edad del empleado es:"+ edad);

}}

PruebaDemoEmpleados.java

class PruebaDemoEmpleados{


DemoEmpleados empleados[]=new DemoEmpleados[3];empleados[0]=new DemoEmpleados(111,"Juan",'c',45.00,40);empleados[1]=new DemoEmpleados(222,"Ana",'c',44.00,35);empleados[2]=new DemoEmpleados(333,"Rosa",'c',46.00,38);DemoEmpleados primerEmpleado=empleados [0];primerEmpleado.visualizarInformacion();DemoEmpleados segundoEmpleado=empleados [1];segundoEmpleado.visualizarInformacion();empleados[2].visualizarInformacion();

}}

Números aleatorios

import java.util.Random;public class PruebaRandom{ public static void main(String args[]) {

int x;Random rnd = new Random();for (int i = 0; i < 10; i++) {

x=((int) (Math.random()*5)+1); // x = (int)(rnd.nextDouble() * 5.0)+1; System.out.println(x); }


} }

PruebaRandom3.java

public class PruebaRandom2{ public static void main(String args[]) {

int x;for (int i = 0; i < 10; i++) {

x=((int) (Math.random()*5)+1); System.out.println(x); }

} }

Burbuja.java

import java.util.Arrays;public class Burbuja{

public static void main(String args[]){int aux;

int a[]={5,3,4,4,1,2,8,10,11};Arrays.sort(a);for(int i=0;i<a.length;i++)

System.out.println(a[i]);}

}

RestaConjuntos.java

public class RestaConjuntos{

public static void main(String args[]){ int v[]={1,4,2,2,3};

int s[]={1};int v_s[]={0,0,0};int i,j,k;System.out.println("Vector v");for(i=0;i<v.length;i++)

System.out.print("v["+i+"]="+v[i]);System.out.println("\n");System.out.println("Vector s");for(j=0;j<s.length;j++)

System.out.println("s["+j+"]="+s[j]);System.out.println("\n");

here:for(i=0;i<v.length;i++)


{System.out.println("i="+i);

k=0;j=0;while(j<s.length){

System.out.println("v["+i+"]="+v[i]+" "+"s["+j+"]="+s[j]);if(v[i]==s[j])

continue here;else

j++;}k++;v_s[k]=v[i];System.out.println("v_s[k]="+v_s[k]);

}

}}


Herencia

Al crear una clase, en vez de declarar miembros (variables y métodos) completamente nuevos, el programador puede designar que la nueva clase herede los miembros de una clase existente. Esta clase existente se conoce como superclase y la nueva clase se conoce como subclase. (Otros lenguajes de programación, como C++, se refieren a la superclase como la clase base y la subclase como clase derivada.). Una vez creada, cada subclase puede convertirse en superclase de futuras subclases. Una subclase generalmente agrega sus propias variables y métodos. Por lo tanto, una subclase es más específica que su superclase y representa a un grupo más especializado de objetos. Generalmente, la subclase exhibe los comportamientos de su superclase junto con comportamientos adicionales específicos de esta subclase. La superclase directa es la superclase a partir de la cual la subclase hereda en forma explícita. Una superclase indirecta se hereda de dos o más niveles arriba en la jerarquía de clases, la cual define las relaciones de herencia entre las clases. En Java, la jerarquía de clases empieza con la clase Object (en el paquete java.lang), a partir de la cual heredan todas las clases en Java, ya sea en forma directa o indirecta. En el caso de la herencia simple, una clase deriva de una superclase. Java a diferencia de C++, no soporta la herencia múltiple (que ocurre cuando una clase se deriva de más de una superclase directa).

La experiencia en la creación de sistemas de software indica que algunas cantidades considerables de código tratan con casos especiales, estrechamente relacionados. Cuando los programadores se preocupan con casos especiales, los detalles pueden oscurecer el panorama general. Con la programación orientada a objetos, los programadores se enfocan en los elementos comunes entre los objetos en el sistema, en vez de enfocarse en los casos especiales. A este proceso se le conoce como abstracción.

La relación “es un” representa a la herencia; en este tipo de relación, un objeto de una subclase puede tratarse también como un objeto de sus superclases. Por ejemplo, un auto es un vehículo.

En contraste, la relación “tiene un” identifica a la composición; en este tipo de relación, un objeto contiene una o más referencias a objetos como miembros. Por ejemplo, un auto tiene un volante de dirección.

A menudo, un objeto de una clase “es un” objeto de otra clase también. Por ejemplo, en la geometría un rectángulo es un cuadrilátero (al igual que los cuadrados, los paralelogramos y los trapezoides). Por lo tanto, en Java puede decirse que la clase Rectangulo es una subclase. Un rectángulo es un tipo específico de cuadrilátero, pero es incorrecto decir que todo cuadrilátero es un rectángulo.


Cada flecha (en UML la representación es con la punta de flecha vacía) en la jerarquía representa una relación “es un”. Por ejemplo, se puede decir: Un Círculo “es un(a)” FiguraBidimensional. Figura es una superclase directa de FiguraBidimensional y FiguraTridimensional y es una superclase indirecta de toda la demas clase

La clase FiguraBidimensional podría declararse en Java de la siguiente manera:

Public class FiguraBidimensional extends Figura

|Las relaciones de herencia forman estructuras jerárquicas en forma de árbol. Una superclase existe en una relación jerárquica con sus subclases. Aunque las clases pueden existir de manera independiente, cuando participan en relaciones de herencia se afilian con otras clases. Una clase se convierte ya sea en una superclase, proporcionando datos y comportamientos a otras clases, o en una subclase, heredando sus datos y comportamientos de otras clases.

Es posible tratar a los objetos de superclase y a los objetos de subclase de manera similar; sus similitudes se expresan en los miembros de la superclase. Los objetos de todas las clases que extienden a una superclase común pueden tratarse como objetos de esa superclase (es decir, dichos objetos tienen una relación “es un” con la superclase). Sin embargo, los objetos de una superclase no pueden tratarse como objetos de sus subclases. Por ejemplo, todos los autos son vehículos pero no todos los vehículos son autos.

Un problema con la herencia es que una subclase puede heredar métodos que no necesita, o que no debe tener. A pesar de que un método de superclase sea apropiado para una subclase, a menudo esa subclase requiere que el método realice su tarea de una manera específica para la subclase. En dichos casos, la subclase puede sobrescribir (redefinir) el método de la superclase con una implementación apropiada.

Miembros protected

El uso del acceso protected ofrece un nivel intermedio de acceso entre public y private. Los miembros protected de una superclase pueden ser utilizados por los miembros de esa superclase, por los miembros de cualquier clase que se derive de esa superclase y por los miembros de otras clases en el


Figura

FiguraBidimensional FiguraTridimensional

Círculo Cuadrado Triangulo Esfera Cubo Tetraedro

73

mismo paquete. (Los métodos de una subclase no pueden tener acceso a los miembros private de su superclase).

Los métodos de una subclase pueden referirise a los miembros public y protected que se hereden de la superclase con sólo utilizar los nombres de los miembros. Cuando un método de la subclase sobreescribe al método de la superclase, éste último puede utilizarse desde la subclase si se antepone a su nombre la palabra clave super y un punto.

Otro punto de vista de la herencia

En algunas ocasiones se necesita crear un modelo más especializado, por ejemplo:El siguiente modelo muestra la duplicación de datos entre las clases Empleado y Administrador.

Como se observa se duplican los datos de las dos clases. Por lo tanto, una clase para minimizar este “error” llamada sublclase


Empleado

+nombre : String = “ “+salario : double+fechaCump : Date

+obtenerDetalles() : String

public class Empleado { public String nombre = “ “; public double salario; public Date fechaCump;

public String obtenerDetalles(){ . . .}

}

Administrador

+nombre : String = “ “+salario : double+fechaCump : Date+departamento : String


public class Administrador { public String nombre = “ “; public double salario; public Date fechaCump;public String departamento;


}

74

En los lenguajes orientados a objetos existen mecanismos especiales que permiten definir una clase en términos de una definición de clase previa.

Java permite extender una sola clase a otra. Esta restricción es llamada herencia simple.La siguiente figura muestra la clase base Empleado y tres subclases: Ingeniero, Administrador y

Secretaria. La clase Administrador tiene una subclase Director.


Empleado



public class Empleado { public String nombre = “ “; public double salario; public Date fechaCump;


}

Administrador

+departamento : String

public class Administrador extends Empleado {public String departamento;

75

Control de acceso

Las variables y los métodos pueden tener cuatro niveles de acceso: public, protected, default o private. Las clases pueden ser públicas o default.

Una variable o método que está marcado como private es accesible únicamente por métodos que son miembros de la misma clase como las variables y métodos private.

Una variable, método o clase tiene una accesibilidad por default si no tiene un modificador de protección explícito como parte de su declaración . Tal accesibilidad significa que el acceso es permitido desde cualquier método en las clases que son miembros del mismo paquete. Esto es frecuentemente llamado “package-friendly”.

Un método o variable protected es accesible desde el método en las clases que son miembros del mismo paquete y desde cualquier método en cualquier subclase.

Una variable o método marcado con el modificador public es universalmente accesible.

Criterios de Accesibilidad

Modificador Misma clase Mismo paquete subclase UniversalPrivate SiDefault Si SiProtected Si Si SiPublic Si Si Si Si

Métodos overriding

Una subclase puede modificar su comportamiento heredado de una clase principal


Empleado



Administrador

+departamento : String

Director

+adjudicarVehiculo : double

+incrementarConcesion()

IngenieroSecretaria

76

Una subclase puede crear un método con diferente funcionalidad que el método de su clase principal pero con el mismo:

o Nombreo Tipo de retornoo Lista de argumentos.

Ejemplos de herencia

Padre.java

class Padre{

Padre(){

System.out.println("Este es el constructor de la clase Padre");}

}

Hijo.java

class Hijo extends Padre{

Hijo(){

System.out.println("Este es el constructor de la clase Hijo");}

}

PruebaPadreHijo.java

class PruebaPadreHijo{


Hijo objHijo = new Hijo();}

}

Salida:

Animal.java

class Animal{

Animal(){

System.out.println("Este es el constructor de la clase Animal");}

}


Perro.java

class Perro extends Animal{

Perro(){

System.out.println("Este es el constructor de la clase Perro");}

}

PruebaAnimalPerro.java

class PruebaAnimalPerro{


Perro objPerro = new Perro();}

}

Salida:

Padre2.java

class Padre2{

Padre2(){


}

Hijo2.java

class Hijo2 extends Padre2{

}

PruebaPadreHijo2.java

class PruebaPadreHijo2{


Hijo2 objHijo = new Hijo2();}

}

Salida:


Padre3.java

class Padre3{

Padre3(){


}

Hijo3.java

class Hijo3 extends Padre3{

Hijo3(){

super();System.out.println("Este es el constructor de la clase Hijo");

}}





}

Salida:

Padre4.java

class Padre4 extends object{

Padre4(){

super();System.out.println("Este es el constructor de la clase Padre");

}}


Hijo4.java

class Hijo4 extends Padre{

Hijo4(){

super();System.out.println("Este es el constructor de la clase hijo");

}}





}

Salida:

SuperClase.java

class SuperClase{

SuperClase(){

System.out.println("Constructor de la superclase");}void metodoSuper(){

System.out.println("Dentro del metodoSuper");}

}

SubClase.java

class SubClase extends SuperClase{

SubClase(){

System.out.println("Constructor de la subclase");}void metodoSuper(){

super.metodoSuper();System.out.println("Dentro del metodoSuper de la subclase");

}}


PruebaSuperClase.java

public class PruebaSuperClase{


SubClase obj = new SubClase();obj.metodoSuper();

}}

Salida:

SuperClase2.java

class SuperClase2{

SuperClase2(){

System.out.println("Constructor de la superclase");}String metodoSuper(){

return "Metodo de la SuperClase";}

}

SubClase2.java

class SubClase2 extends SuperClase2{

SubClase2(){

System.out.println("Constructor de la subclase");}String metodoSuper(){

return super.metodoSuper()+" y dentro del metodoSuper de la subclase";}}

PruebaSuperClase2.java

public class PruebaSuperClase2{


SubClase2 obj = new SubClase2();System.out.println(obj.metodoSuper());

}}


Salida:

Empleado5.java

public class Empleado5{

protected String nombre;protected double salario;

Empleado5(String n, double s){ establecerValores(n,s);}

public void establecerValores(String n, double s){

nombre=n;salario=s;

}public String obtenerDetalles(){

return "Nombre: "+nombre+"\n"+"Salario: "+salario;}

}

Administrador5.java

public class Administrador5 extends Empleado5{

protected String departamento;Administrador5(String n, double s,String d){ super(n,s); establecerValores(d);}public void establecerValores(String d){

departamento=d;}

public String obtenerDetalles(){

return "Nombre: "+nombre+"\n"+"Salario: "+salario+"\n"+"Administrador

de:"+departamento;}

}


PruebaEmpleado5.java

class PruebaEmpleado5{


Empleado5 empleado = new Empleado5("Alfa",50.0);Administrador5 administrador = new Administrador5("Lolo",5.6,"Produccion");System.out.println(administrador.obtenerDetalles());System.out.println(empleado.obtenerDetalles());

}}

Salida:

Empleado6.java

public class Empleado6 extends Object{

protected String nombre;protected double salario;

Empleado6(String n, double s){ establecerValores(n,s);}

public void establecerValores(String n, double s){

nombre=n;salario=s;


return "Nombre: "+nombre+"\n"+"Salario: "+salario;}

}

Administrador6.java


protected String departamento;Administrador6(String n, double s,String d){ super(n,s); establecerValores(d);}public void establecerValores(String d){


departamento=d;}

public String obtenerDetalles(){ return super.obtenerDetalles()+"\n"+"Administrador de:"+departamento;}

}




String nombreEmpleado=args[0];double salarioEmpleado=Double.parseDouble(args[1]);String deptoEmpleado=args[2];Administrador6 administrador = new

Administrador6(nombreEmpleado,salarioEmpleado,deptoEmpleado);System.out.println(administrador.obtenerDetalles());

}}

Salida:


A.java

class A extends Object{

A(){

super();System.out.println("constructor de A");

}}

class B extends A{

B(){

super();System.out.println("constructor de B");

}}

class PruebaB extends B{

PruebaB(){

super();System.out.println("constructor de PruebaB");

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

final String L="_________________________________";PruebaB obj1 = new PruebaB();System.out.println(L);B obj2 = new B();System.out.println(L);A obj3 = new A();

}}

Salida:


Composición

A.java

public class A{

A(){

System.out.println("Dentro del constructor A");}

}

B.java

public class B extends A{

private C v1;B(C var2){

System.out.println("Dentro del constructor B");System.out.println(var2.obtener());

}}

C.java

public class C{

private int dato;C(int d){

establecer(d);}void establecer(int d){

dato=d;}int obtener(){

return dato;}

}

PruebaA.java

public class PruebaA{


C var2=new C(10);B obj = new B(var2);System.out.println(var2.obtener());

}


}

Salida:

Herencia y Composición

Empleado7.java

public class Empleado7 extends Object{

protected String nombre;protected double salario;protected Fecha2 fechaCont;protected Fecha2 fechaNac;

Empleado7(String n, double s,Fecha2 c, Fecha2 na){ establecerValores(n,s,c,na);}

public void establecerValores(String n, double s,Fecha2 c, Fecha2 na){

nombre=n;salario=s;fechaCont=c;fechaNac=na;


return "Nombre: "+nombre+"\n"+"Salario: "+salario+"\n"+fechaCont.obtenerFecha()+"\n"+fechaNac.obtenerFecha();

}}

Administrador7.java


private String departamento;

Administrador7(String n, double s,String d,Fecha2 c, Fecha2 na){ super(n,s,c,na); establecerValores(d);}public void establecerValores(String d)


{departamento=d;


return super.obtenerDetalles()+"\n"+"Administrador de:"+departamento;}

}

Fecha2.java

public class Fecha2{

private int dia;private int mes;private int annio;Fecha2(int d, int m, int a){

establecerDatos(d,m,a);}void establecerDatos(int d, int m, int a){

if(d>=0 && d<=31)dia=d;

elsedia=0;

if(m>=0 && m<=12)mes=m;

elsemes=0;

if(a>=2000 && a<=2010)annio=a;

elseannio=0;

}String obtenerFecha(){

return dia+"/"+mes+"/"+annio;}

}




String nombreEmpleado=args[0];double salarioEmpleado=Double.parseDouble(args[1]);String deptoEmpleado=args[2];

int diaCont=Integer.parseInt(args[3]);int mesCont=Integer.parseInt(args[4]);int annioCont=Integer.parseInt(args[5]);


int diaNac=Integer.parseInt(args[6]);int mesNac=Integer.parseInt(args[7]);int annioNac=Integer.parseInt(args[8]);

Fecha2 cont = new Fecha2(diaCont,mesCont,annioCont);Fecha2 nac = new Fecha2(diaNac,mesNac,annioNac);

Administrador7 administrador = new Administrador7(nombreEmpleado,salarioEmpleado,deptoEmpleado,cont,nac);

System.out.println(administrador.obtenerDetalles());Empleado7 empleado = new Empleado7(nombreEmpleado,salarioEmpleado,cont,nac);System.out.println(empleado.obtenerDetalles());

}}

Salida:

Clases y métodos abstractos

Existen casos en los que es conveniente declarar clases para los cuales el programador no pretende instanciar objetos. Dichas clases se denominan clases abstractas. Debido a que éstas se utilizan sólo como superclases en las jerarquías de herencias, se refiere a esas clases como superclases abstractas. Estas clases no pueden utilizarse para instanciar objetos porque, las clases abstractasestán incompletas. Las subclases deben declarar las partes faltantes.

El propósito de una clase abstracta es proporcionar una superclase apropiada, a partir de la cual puedan heredar otras clases. Las clases que puedan usarse para instanciar objetos se conocen como clases concretas. Dichas clases proporcionan implementaciones de todos los métodos que declaran. Las clases abstractas son demasiado genéricas como para crear objetos reales; sólo especifican lo que las subclases tienen en común.

Una jerarquía de herencia no necesita contener clases abstractas. Sin embargo, comúnmente se utilizan jerarquías de clase encabezadas por superclases abstractas para reducir las dependencias de código cliente en tipos de subclases específicas.

Para que una clase sea abstracta, se debe declarar con la palabra clave abstract. Una clase abstracta normalmente contiene uno o más métodos abstractos (los métodos static no pueden ser abstractos). Un método abstracto es un método con la palabra clave abstract en su declaración.

Los métodos abstractos no proporcionan implementaciones. Una clase que contiene métodos abstractos debe declararse como una clase abstracta. Cada subclase concreta de una superclase abstracta debe proporcionar implementaciones concretas de los métodos abstractos de la superclase. Los constructores no se heredan, por lo que no pueden declararse como abstract.

Una clase abstracta declara los atributos y comportamientos de las diversas clases en una jerarquía de clases: además, generalmente contiene uno o más métodos abstractos que las subclases debe sobrescribir. Las variables de instancia y los métodos concretos de una clase abstracta se sujetan a las reglas normales de herencia.

Al tratar de instanciar un objeto de una clase abstracta se produce un error de compilación. El no poder implementar un método abstracto de la superclase en una subclase es un error de

compilación, a menos que la subclase también se declare como abstract.


PruebaClasesAbstractas.java

abstract class A{

abstract void metodoA();void metodoB(){

System.out.println("Dentro del metodo B de la clase A");}abstract int metodoC();

}class B extends A{

void metodoA(){

System.out.println("Dentro del metodo A de la clase B");}void metodoB(){

super.metodoB();System.out.println("Dentro del metodo B de la clase B -sobreescribiendo-");

}int metodoC(){

System.out.println("Dentro del metodo C de la clase B");return 10;

}}class PruebaClasesAbstractas{


B obj=new B();obj.metodoA();obj.metodoB();System.out.println(obj.metodoC());

}}

Salida:


InterfacesLa palabra clave interfaz lleva el concepto de abstracción un paso más allá. Se podría pensar que es

una clase abstracta “pura”. Permite establecer la forma de una clase: nombre de métodos, listas de parámetros y tipos de retorno, pero no cuerpos de métodos. Una interfaz también puede contener campos, pero éstos son implícitamente estáticos y constantes. Una interfaz proporciona sólo la forma, pero no la implementación.

Una interfaz dice: “Esta es la apariencia que tendrán todas las clases que implementen esta interfaz”. Por consiguiente, cualquier código que use una interfaz particular sabe qué métodos deberían ser invocados por esa interfaz y eso es todo. Por tanto se usa la interfaz para establecer “un protocolo” entre clases.

Para crear una interfaz, se usa la palabra clave interface en vez de la palabra clave class. Al igual que una clase, se le puede anteponer la palabra public a interface.

Para hacer una clase que se ajuste a una interfaz particular (o a un grupo de interfaces), se usa la palabra clave implements. Se está diciendo “La interfaz contiene la apariencia, pero ahora voy a decir cómo funciona”. Por lo demás, es como la herencia.

Si la clase no implementa a ninguno de los métodos de la interfaz, significa que la clase es abstracta y debe declararse como abstract. Implementar una interfaz es como firmar un contrato con el compilador que diga: “Declararé todos los métodos específicados por la interfaz.”

El no implementar uno de los métodos de una interfaz en una clase que implemente a esa interfaz resulta en un error de compilación, el cual indica que la clase debe declararse como abstract.

Una interaz se utiliza generalmente en lugar de una clase abstracta, cuando no hay una implementación predeterminada que heredar (es decir, no hay variables de instancia ni implementaciones de métodos predeterminados).

PruebaClaseInterfaz.java

interface A{

public void metodoA();public void metodoB();public int metodoC();

}class B implements A{

public void metodoA(){

System.out.println("Dentro del metodo A de la clase B");}public void metodoB(){

System.out.println("Dentro del metodo B de la clase B ");}public int metodoC(){


}}class PruebaClasesInterfaz{


B obj=new B();obj.metodoA();


obj.metodoB();System.out.println(obj.metodoC());

}}

Salida:

Simulación de la Herencia múltiple

PruebaHerenciaMultiple.java

interface A1{


}class A2{

void metodoD(){

System.out.println("Dentro del metodo B de la clase A2");}String metodoE(){

return "MetodoE()";}

}class B extends A2 implements A1{





}public void metodoD(){

super.metodoD();System.out.println("Dentro del metodo D de la clase B");

}public String metodoE(){

return super.metodoE()+" Dentro del metodo E de la clase A2";


}}class PruebaHerenciaMultiple{


B obj=new B();obj.metodoA();obj.metodoB();System.out.println(obj.metodoC());obj.metodoD();System.out.println(obj.metodoE());

}}

Salida:

Herencia múltiple con una clase abstracta

PruebaHerenciaMultiple.java

interface A1{


}abstract class A2{

abstract void metodoD();abstract String metodoE();

}class B extends A2 implements A1{




System.out.println("Dentro del metodo C de la clase B");


return 10;}public void metodoD(){

System.out.println("Dentro del metodo D de la clase B");}public String metodoE(){

return " Dentro del metodo E de la clase B";



B obj=new B();obj.metodoA();obj.metodoB();System.out.println(obj.metodoC());obj.metodoD();System.out.println(obj.metodoE());

}}

Salida:

interface A1{


}class A2{

public void metodoD(){}public String metodoE(){

return "metodoE()";}

}interface A3{

public void metodoF();}


class B extends A2 implements A1, A3{





}public void metodoD(){

System.out.println("Dentro del metodo D de la clase B");}public String metodoE(){

return super.metodoE()+" Dentro del metodo E de la clase B";

}public void metodoF(){

System.out.println("metodoF()");



B obj=new B();obj.metodoA();obj.metodoB();System.out.println(obj.metodoC());obj.metodoD();System.out.println(obj.metodoE());obj.metodoF();

}}

Salida:


PolimorfismoEjemplo 1

PruebaCastingPadreHijo2.javapublic class CastingPadre{ CastingPadre() {

System.out.println("Constructor Clase Padre"); }public void visualizarPadre() { System.out.println("Visualizar metodo Padre"); } public void visualizar(){ System.out.println("Metodo visualizar() Padre");}}

public class CastingHijo extends CastingPadre{ CastingHijo() {

System.out.println("Constructor Clase Hijo"); } public void visualizarHijo() { System.out.println("Visualizar metodo Hijo"); }public void visualizar(){

super.visualizar(); System.out.println("Metodo visualizar() Hijo");}}

public class PruebaCastingPadreHijo2{ public static void main(String args[]) {

System.out.println("CastingHijo objHijo = new CastingHijo()");CastingHijo objHijo = new CastingHijo();objHijo.visualizarPadre();objHijo.visualizar();

System.out.println("\n");// Marca error de tipos incompatibles// CastingHijo obj = new CastingPadre();// obj.visualizarPadre();


// obj.visualizar();

System.out.println("CastingPadre obj = new CastingHijo()");CastingPadre obj = new CastingHijo();obj.visualizarPadre();obj.visualizar();System.out.println("\n");System.out.println("CastingPadre objPadre = new CastingPadre()");CastingPadre objPadre = new CastingPadre();objPadre.visualizarPadre();objPadre.visualizar();System.out.println("\n");

System.out.println("objPadre=objHijo");objPadre=objHijo;objPadre.visualizarPadre();objPadre.visualizar();

// Marca un error//objPadre.visualizarHijo();System.out.println("\n");

//Marca error esta asignación//objHijo=objPadre;System.out.println("objHijo=(CastingHijo)objPadre");objHijo=(CastingHijo)objPadre;objHijo.visualizarHijo();objHijo.visualizar();objHijo.visualizarPadre();System.out.println("\n");

System.out.println("objPadre=(CastingPadre)objHijo");objPadre=(CastingPadre)objHijo;objPadre.visualizar();System.out.println("\n");

}}

Salida:


Ejemplo 2

Una compañía3 paga a sus empleados en forma semanal. La compañía tiene cuatro tipos de empleados:

Empleados asalariados que reciben un salario semanal fijo, sin importar el número de horas trabajadas.

Empleados por horas, que reciben un sueldo por hora y pago por tiempo extra. Empleados por comisión, que reciben un porcentaje de sus ventas. Empleados asalariados por comisión, que reciben un salario base más un porcentaje de sus ventas.

Para este periodo de pago la compañía ha decidido compensara a los empleados asalariados por comisión, agregando un 10% a sus salarios.

La compañía desea implementar una aplicación en Java que realice sus cálculos de nómina en forma polimórfica.

Diagrama UML que representa las clases involucradas en el problema

3 Ejemplo tomado del libro de Deitel & Deitel pag. 408


Empleado.java

public abstract class Empleado{

private String primerNombre, apellidoPaterno, numeroSeguroSocial;public Empleado(String nombre, String apellido, String ssn){

primerNombre=nombre;apellidoPaterno=apellido;numeroSeguroSocial=ssn;

}public void establecerPrimerNombre(String nombre){

primerNombre=nombre;}public String obtenerPrimerNombre(){

return primerNombre;}public void establecerApellidoPaterno(String apellido){

apellidoPaterno=apellido;}


public String obtenerApellidoPaterno(){

return apellidoPaterno;}public void establecerNumeroSeguroSocial(String numero){

numeroSeguroSocial=numero;}public String obtenerNumeroSeguroSocial(){

return numeroSeguroSocial;}public String toString(){

return obtenerPrimerNombre()+" "+obtenerApellidoPaterno()+"\nnumero de seguro social: " + obtenerNumeroSeguroSocial();

}public abstract double ingresos();

}

EmpleadoAsalariado.java

public class EmpleadoAsalariado extends Empleado{

private double salarioSemanal;public EmpleadoAsalariado(String nombre, String apellido, String numeroSeguroSocial, double

salario){

super(nombre,apellido,numeroSeguroSocial);establecerSalarioSemanal(salario);

}public void establecerSalarioSemanal(double salario){

salarioSemanal=salario<0.0?0.0:salario;}public double obtenerSalarioSemanal(){

return salarioSemanal;}public double ingresos(){

return obtenerSalarioSemanal();}public String toString(){

return "\nempleado asalariado: " +super.toString();}

}

EmpleadoPorComision.java

public class EmpleadoPorComision extends Empleado{


private double ventasTotales, tasaComision;public EmpleadoPorComision(String nombre, String apellido, String numeroSeguroSocial, double

ventasTotalesSemana, double porcentaje){

super(nombre,apellido,numeroSeguroSocial);establecerVentasTotales(ventasTotalesSemana);establecerTasaComision(porcentaje);

}public void establecerTasaComision(double tasa){

tasaComision=(tasa>0.0 && tasa <1.0) ? tasa:0.0;}public double obtenerTasaComision(){

return tasaComision;}public void establecerVentasTotales(double ventas){

ventasTotales=ventas < 0.0 ? 0.0 : ventas;}public double obtenerVentasTotales(){

return ventasTotales;}public double ingresos(){

return obtenerTasaComision() * obtenerVentasTotales();}public String toString(){

return "\nempleado por comision: " +super.toString();}}

EmpleadoPorHoras.java

public class EmpleadoPorHoras extends Empleado{

private double sueldo,horas;public EmpleadoPorHoras(String nombre, String apellido, String numeroSeguroSocial, double

sueldoPorHora, double horasTrabajadas){

super(nombre,apellido,numeroSeguroSocial);establecerSueldo(sueldoPorHora);establecerHoras(horasTrabajadas);

}public void establecerSueldo(double cantidadSueldo){

sueldo=cantidadSueldo<0.0 ? 0.0 : cantidadSueldo;}public double obtenerSueldo(){

return sueldo;}public void establecerHoras(double horasTrabajadas)


{horas=(horasTrabajadas>=0.0 && horasTrabajadas <= 168.0 ) ? horasTrabajadas:0.0;

}public double obtenerHoras(){

return horas;}public double ingresos(){

if(horas<=40)return sueldo*horas;

elsereturn 40*sueldo+(horas-40)*sueldo*1.5;

}public String toString(){

return "\nempleado por horas: "+super.toString();}

}

EmpleadoBaseMasComision.java

public class EmpleadoBaseMasComision extends EmpleadoPorComision{

private double salarioBase;public EmpleadoBaseMasComision(String nombre, String apellido, String numeroSeguroSocial,

double cantidadVentasTotales, double tasa, double cantidadSalarioBase){

super(nombre,apellido,numeroSeguroSocial,cantidadVentasTotales,tasa);establecerSalarioBase(cantidadSalarioBase);

}public void establecerSalarioBase(double salario){

salarioBase=salario<0.0 ?0.0 :salario;}public double obtenerSalarioBase(){

return salarioBase;}public double ingresos(){

return obtenerSalarioBase() + super.ingresos();}public String toString(){

return "\nempleado con salario base mas comision: " + super.obtenerPrimerNombre()+ " "+ super.obtenerApellidoPaterno()+ "\nnumero de Seguro Social: " + super.obtenerNumeroSeguroSocial();

}}

PruebaSistemaNomina.java

import java.text.DecimalFormat;import javax.swing.JOptionPane;


public class PruebaSistemaNomina{


DecimalFormat dosDigitos=new DecimalFormat("0.00");Empleado empleados[]=new Empleado[4];empleados[0]=new EmpleadoAsalariado("Juan","Perez","111-11-1111",800.00);empleados[1]=new EmpleadoPorComision("Alicia","Rodriguez","222-22-

2222",10000,0.06);empleados[2]=new EmpleadoBaseMasComision("Alfonso","Romero","333-33-

3333",5000,0.04,300);empleados[3]=new EmpleadoPorHoras("Isabel","Romero","444-44-4444",16.75,40);String salida="";for(int i=0;i<empleados.length;i++){

salida+=empleados[i].toString();

// determinar si el elemento es un EmpleadoBaseMasComisionif(empleados[i] instanceof EmpleadoBaseMasComision){

// conversión descendente de referencia a Empleado a referencia a EmpleadoBaseMasComision

EmpleadoBaseMasComision empleadoActual=(EmpleadoBaseMasComision) empleados[i];

double salarioBaseAnterior = empleadoActual.obtenerSalarioBase();salida+="\nsalario base anterior: $"+salarioBaseAnterior;empleadoActual.establecerSalarioBase(1.10*salarioBaseAnterior);salida+="\nel nuevo salario base con aumento del 10% es:

$"+empleadoActual.obtenerSalarioBase();}salida+="\ngano $"+empleados[i].ingresos()+"\n";

}for(int j=0; j<empleados.length;j++)

salida+="\nEl empleado " + j +" es un " + empleados[j].getClass().getName();JOptionPane.showMessageDialog(null,salida);System.exit(0);

}}

Salida:


Comentarios: En este ejemplo se desea realizar un procesamiento especial en los objetos

EmpleadoBaseMasComision; al encontrarse con estos objetos, se desea incrementar su salario base en un 10%. Como los empleados se procesan en forma polimórfica, no se puede estar seguro en cuanto al tipo de Empleado que se está manipulando en un momento dado. Esto crea un problema, ya que se deben identificar los empleados EmpleadoBaseMasComision para poderles pagar correctamente. Se utliza el operador instanceof para determinar si el tipo de cada objeto es compatible con el tipo EmpleadoBaseMasComision. La condición es verdadera si el objeto referenciado por empleados[i] es un EmpleadoBaseMasComision. Esto también sería verdadero para cualquier objeto de una subclase de EmpleadoBaseMasComision.

La línea

EmpleadoBaseMasComision empleadoActual=(EmpleadoBaseMasComision) empleados[i];

Realiza una conversión descendente de empleados[i], del tipo Empleado al tipo EmpleadoBaseMasComision. Esta conversión se permite solamente si el objeto tiene una relación del tipo es un con EmpleadoBaseMasComision.

Si el valor devuelto por la instrucción instanceof es true, la instrucción if realiza el procesamiento especial requerido para el objeto EmpleadoBaseMasComision.

Todo objeto en Java conoce su propia clase y puede acceder a esta información a través del método getClass, el cual heredan de la clase Object todas las clases. El método getClass devuelve un objeto de tipo Class (paquete java.lang), el cual contiene información acerca del tipo del obejto, incluyendo el nombre de su clase.

En la línea:

salida+="\nEl empleado " + j +" es un " + empleados[j].getClass().getName();

se invoca el método getClass en el objeto para obtener la clase en tiempo de ejecución (objeto Class) de ese objeto. Luego se invoca al método getName en el objeto devuelto por getClass, para obtener el nombre de la clase.

Clases internas


class Alfa{

Alfa(){

Beta obj=new Beta();obj.imprimir();

}class Beta{

public void imprimir(){

System.out.println("En el interior de b");}

}}public class PruebaAlfa{


Alfa obj = new Alfa();}

}

Salida:

3. Manejo de excepciones

Definición: Una excepción es un evento que ocurre durante la ejecución del programa que interrumpe el flujo normal de las sentencias.

Muchas clases de errores pueden utilizar excepciones desde serios problemas de hardware, como la avería de un disco duro, a los simples errores de programación, como tratar de acceder a un elemento de un array fuera


de sus límites. Cuando dicho error ocurre dentro de un método Java, el método crea un objeto 'exception' y lo maneja fuera, en el sistema de ejecución. Este objeto contiene información sobre la excepción, incluyendo su tipo y el estado del programa cuando ocurrió el error. El sistema de ejecución es el responsable de buscar algún código para manejar el error. En terminología java, crear una objeto exception y manejarlo por el sistema de ejecución se llama lanzar una excepción. Después de que un método lance una excepción, el sistema de ejecución entra en acción para buscar el manejador de la excepción. El conjunto de "algunos" métodos posibles para manejar la excepción es el conjunto de métodos de la pila de llamadas del método donde ocurrió el error. El sistema de ejecución busca hacia atrás en la pila de llamadas, empezando por el método en el que ocurrió el error, hasta que encuentra un método que contiene el "manejador de excepción" adecuado. Un manejador de excepción es considerado adecuado si el tipo de la excepción lanzada es el mismo que el de la excepción manejada por el manejador. Así la excepción sube sobre la pila de llamadas hasta que encuentra el manejador apropiado y una de las llamadas a métodos maneja la excepción, se dice que el manejador de excepción elegido captura la excepción. Si el sistema de ejecución busca exhaustivamente por todos los métodos de la pila de llamadas sin encontrar el manejador de excepción adecuado, el sistema de ejecución finaliza (y consecuentemente y el programa Java también).

Mediante el uso de excepciones para manejar errores, los programas Java tienen las siguientes ventajas frente a las técnicas de manejo de errores tradicionales:

1: Separar el Manejo de Errores del Código "Normal"

Por ejemplo, supongamos que tenemos una función que lee un archivo completo dentro de lamemoria. En pseudo-código, la función se podría parecer a esto:

leerArchivo{abrir el archivo;determinar su tamaño;asignar suficiente memoria;leer el archivo a la memoria;cerrar el archivo;}

A primera vista esta función parece bastante sencilla, pero ignora todos aquellos errores potenciales:¿Qué sucede si no se puede abrir el archivo? ¿Qué sucede si no se puede determinar la longitud del archivo? ¿Qué sucede si no hay suficiente memoria libre? ¿Qué sucede si la lectura falla? ¿Qué sucede si no se puede cerrar el archivo? Para responder a estas cuestiones dentro de la función, se tendría que añadir mucho código para la detección y el manejo de errores. El aspecto final de la función se parecería esto:

codigodeError leerArchivo {inicializar codigodeError = 0;abrir el archivo;if (archivoAbierto) {

determinar la longitud del archivo;if (obtenerLongitudDelArchivo) {

asignar suficiente memoria;if (obtenerSuficienteMemoria) {

leer el archivo a memoria;if (falloDeLectura) {

codigodeError = -1;}

} else {codigodeError = -2;}


} else {codigodeError = -3;

}cerrar el archivo;if (archivoNoCerrado && codigodeError == 0) {

codigodeError = -4;} else {

codigodeError = codigodeError and -4;}} else {

codigodeError = -5;}

return codigodeError;}

Se observa en el código anterior que existe exagerados caminos para determinar y controlar los errores

Java proporciona una solución elegante al problema del tratamiento de rrores: las excepciones. Las excepciones le permiten escribir el flujo principal de su código y tratar los casos excepcionales en otro lugar. Si la función leerArchivo utilizara excepciones en lugar de las técnicas demanejo de errores tradicionales se podría parecer a esto:

leerArchivo {try {

abrir el archivo;determinar su tamaño;asignar suficiente memoria;leer el archivo a la memoria;cerrar el archivo;

} catch (falloAbrirArchivo) {hacerAlgo;

} catch (falloDeterminacionTamaño) {hacerAlgo;

} catch (falloAsignaciondeMemoria) {hacerAlgo;

} catch (falloLectura) {hacerAlgo;

} catch (falloCerrarArchivo) {hacerAlgo;

}}

Se observa que las excepciones no evitan el esfuerzo de hacer el trabajo de detectar, informar y manejar errores. Lo que proporcionan las excepciones es la posibilidad de separar los detalles oscuros de qué hacer cuando ocurre algo fuera de la normal. Además, el factor de aumento de código es de un 250% -- comparado con el 400% del ejemplo anterior.

2: Propagar los Errores sobre la Pila de Llamadas

Una segunda ventaja de las excepciones es la posibilidad del propagar el error encontrado sobre la pila de llamadas a métodos. Supongamos que el método leerArchivo es el cuarto método en una serie de llamadas a métodos anidadas realizadas por un programa principal: metodo1 llamaa metodo2, que llama a metodo3, que finalmente llama a leerArchivo.

metodo1 {


call metodo2;}metodo2 {

call metodo3;}metodo3 {

call leerArchivo;}

Supongamos también que metodo1 es el único método interesado en el error que ocurre dentro de leerArchivo. Tradicionalmente las técnicas de notificación del error forzarían a metodo2 y metodo3 a propagar el código de error devuelto por leerArchivo sobre la pila de llamadas hasta que el código de error llegue finalmente a metodo1 -- el único métodoque está interesado en él.

metodo1 {codigodeErrorType error;error = call metodo2;if (error)

procesodelError;else

proceder;}codigodeErrorType metodo2 {codigodeErrorType error;error = call metodo3;if (error)

return error;else

proceder;}codigodeErrorType metodo3 {codigodeErrorType error;error = call leerArchivo;if (error)

return error;else

proceder;}

Como se aprendió anteriormente, el sistema de ejecución Java busca hacia atrás en la pila de llamadas para encontrar cualquier método que esté interesado en manejar una excepción particular. Un método Java puede "esquivar" cualquier excepción lanzada dentro de él, por lo tanto permite a los métodos que están por encima de él en la pila de llamadas poder capturarlo. Sólo los métodos interesados en el error deben preocuparse de detectarlo.

metodo1 {try {

call metodo2;} catch (excepcion) {

procesodelError;}}metodo2 throws excepcion {

call metodo3;}


metodo3 throws excepcion {call leerArchivo;

}

Sin embargo, como se puede ver desde este pseudo-código, requiere cierto esfuerzo por parte de los métodos centrales. Cualquier excepción verificada que pueda ser lanzada dentro de un método forma parte del interface de programación público del método y debe ser especificado en la clausula throws del método. Así el método informa a su llamador sobre las excepciones que puede lanzar, para que el llamador pueda decidir consciente e inteligentemente qué hacer con esa excepción.Se observa de nuevo la diferencia del factor de aumento de código y el factor de incertitumbre entre las dos técnicas de manejo de errores. El código que utiliza excepciones es más compacto y más fácil de entender.

3: Agrupar Errores y Diferenciación

Frecuentemente las excepciones se dividen en categorías o grupos. Por ejemplo, podríamos imaginar un grupo de excepciones, cada una de las cuales representara un tipo de error específico que pudiera ocurrir durante la manipulación de un array: el índice está fuera del rango del tamaño del array, el elemento que se quiere insertar en el array no es del tipo correcto, o el elemento que se está buscando no está en el array. Además, podemos imaginar que algunos métodos querrían manejar todas las excepciones de esa categoría (todas las excepciones de array), y otros métodos podría manejar sólo algunas excepcionesespecíficas (como la excepción de índice no válido).

Como todas las excepciones lanzadas dentro de los programas Java son objetos de primera clase, agrupar o categorizar las excepciones es una salida natural de las clases y las superclases. Las excepciones Java deben ser ejemplares de la clase Throwable, o de cualquier descendiente de ésta. Como de las otras clases Java, se pueden crear subclases de la clase Throwable y subclases de estas subclases. Cada clase 'hoja' (una clase sin subclases) representa un tipo específico de excepción y cada clase 'nodo' (una clase con una o más subclases) representa un grupo de excepciones relacionadas.

InvalidIndexException, ElementTypeException, y NoSuchElementException son todas clases hojas. Cada una representa un tipo específico de error que puede ocurrir cuando se manipula un array. Un método puede capturar una excepción basada en su tipo específico (su clase inmediata o interface). Por ejemplo, un manejador de excepción que sólo controle la excepción de índice no válido, tiene una sentencia catch como esta:

catch (InvalidIndexException e) {. . .}

ArrayException es una clase nodo y representa cualquier error que pueda ocurrir durante la manipulación de un objeto array, incluyendo aquellos errores representados específicamente por una de sus subclases. Un método puede capturar una excepción basada en este grupo o tipo general especificando cualquiera de las superclases de la excepción en la sentencia catch. Por ejemplo, para capturar todas las excepciones dearray, sin importar sus tipos específicos, un manejador de excepción especificaría un argumento ArrayException:

catch (ArrayException e) {. . .}

Este manejador podría capturar todas las excepciones de array, incluyendo InvalidIndexException, ElementTypeException, y NoSuchElementException. Se puede descubrir el tipo de excepción preciso que ha ocurrido comprobando el parámetro del manejador e.

Incluso podríamos seleccionar un manejador de excepciones que controlara cualquier excepción con este manejador:


catch (Exception e) {. . .}

Los manejadores de excepciones que son demasiado generales, como el mostrado aquí, pueden hacer que el código sea propenso a errores mediante la captura y manejo de excepciones que no se hubieran anticipado y por lo tanto no son manejadas correctamente dentro de el manejador. Como regla no se recomienda escribir manejadores de excepciones generales.

Como se ha visto, se pueden crear grupos de excepciones y manejarlas de una forma general, o se puede especificar un tipo de excepción específico para diferenciar excepciones y manejarlas de un modo exacto.

Ejemplos

PruebaExcep1.java

class PruebaExcep1{


//int a=100/0; Marca error en tiempo de ejecución con los tipos enterosfloat b=(float) 100.0/0;double c=100.0/0;System.out.println("b="+b+" "+"c="+c);

}}

Salida:

PruebaExcep2.java

class PruebaExcep2{


int a;try{

a=100/0;}catch (ArithmeticException m){

System.out.println("error mensaje= "+m.getMessage());System.out.println("\n"+"Division entre cero");

}

}}

Salida:


PruebaExcep3.java

class PruebaExcep3{


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

int a=(int) (Math.random()*100);int b=(int) (Math.random()*4);try{

int c=a/b;System.out.println("iteracion No. "+i+" "+a+"/"+b+"="+c);

}catch (ArithmeticException m){

System.out.println("se detecto una division entre cero");i--;

}}

}}

Salida:


PruebaExcep4.java

public class PruebaExcep4 { public static void main(String[] args) {

if (args.length != 1) System.out.println("Debe introducir un entero a la entrada"); try

{ int enteroLeido = stringToInt(args[0]); System.out.println("Ha introducido el entero " + enteroLeido); }

catch (NumberFormatException e) {

System.out.println("La cadena " + args[0] + " no es un entero. Ten mas cuidado la proxima vez"); } System.out.println("Ahora el programa puede continuar"); }

private static int stringToInt(String entero) { int resultado = Integer.parseInt(entero); return resultado; }}Salida:


PruebaExcep5.java

class PruebaExcep5{

public static void main(String args[]){int a[]={1,2,3};

try{

if(Boolean.parseBoolean(args[0]))System.out.println(a[4]);

elseSystem.out.println(5/0);

}catch (ArithmeticException o){

System.out.println(o.getMessage());}catch (ArrayIndexOutOfBoundsException o2){

System.out.println(o2);}

}}


Salida:

PruebaExcep6.java

class PruebaExcep6{


try{

evaluarEntero(Boolean.parseBoolean(args[0]));

}

catch (ArithmeticException o){

System.out.println(o.getMessage());}catch (Exception o){

System.out.println(o);}

}static void evaluarEntero(boolean v){int a[]={1,2,3};

if(v)System.out.println(a[4]);


}}

Salida:

PruebaExcep7.java


class PruebaExcep7{


try{


}


System.out.println(o.getMessage());}catch (ArrayIndexOutOfBoundsException o){

System.out.println(o);}

}static void evaluarEntero(boolean v) throws

ArithmeticException,ArrayIndexOutOfBoundsException{int a[]={1,2,3};



}}

Salida:

PruebaExcep8.java

class PruebaExcep8{


try{


}

catch (Exception o){

System.out.println(o);


}

}static void evaluarEntero(boolean v) throws Exception{int a[]={1,2,3};



}}Salida:

class PruebaExcep9{


try{


}



System.out.println(o);}finally{

System.out.println("Metodo finally");}

}static void evaluarEntero(boolean v) throws

ArithmeticException,ArrayIndexOutOfBoundsException{int a[]={1,2,3};



}}

Salida:


PruebaExcep10.java

class ClaseExcepcion{

static void evaluarEntero(boolean v) throws ArithmeticException,ArrayIndexOutOfBoundsException

{int a[]={1,2,3};



}}

class PruebaExcep10{


try{

ClaseExcepcion.evaluarEntero(Boolean.parseBoolean(args[0]));

}



System.out.println(o);}finally{

System.out.println("Metodo finally");}

}}

Salida:


4. Interfaz Gráfica de Usuario (GUI). Parte I. AWT

GUIAbstract Windowing Toolkit (AWT)

La AWT prove components básicos GUI que son usados en el diseño de applets y aplicaciones. Un componente es un objeto que tiene una representación gráfica el cual puede ser desplegado en la pantalla y los usuarios pueden interactuar con él. Algunos ejemplos de componentes son: botones, campos de texto, cajas de verificación.

El paquete AWT consiste de un conjunto de components heredados, en muchos casos de la clase abstracta java.awt.Component, esta clase prove variables y métodos requeridos por todos los componentes AWT.

Tal vez el más importante de estos componentes sea la clase Container. Un contenedor es un componente que puede contener otros componentes o contenedores. Los contenedores se usan para distribuir los componentes GUI en la pantalla. Las clases Panel y Frame son los contenedores que más frecuentemente se usan.

Componentes GUI

Rl paquete java.awtEste paquete contiene las clases que generan los componentes GUI. La siguiente figura muestra la distribución de este paquete.


Contenedores

Existen dos tipos principales de contenedores: la clase Window y la clase Panel

La clase Window es una ventana nativa que es independiente de otros contenedores. Hay dos tipos importantes de objetos Window.

1. Frame- es una ventana con título y esquinas en donde se puede fácilmente rediseñar la estructura2. Dialog- es una ventana simple que no tiene una barra de menú.

Un objeto Panel debe estar contenido dentro de otro objeto Container o estar incluido en una ventana de un navegador Web.

Existen varios componentes contenedores que son frecuentemente usados en el lenguaje de programación Java.

Frames Panels Applets Dialogs

4.1 Frames

La clase Frame es una subclase de la clase Window. Es una ventana con un título y esquinas para redefinir el tamaño. La clase Frame hereda sus características de la clase Container, de esta manera se pueden agregar objetos con el método add.

El constructor Frame(String) permite asignar el título al Frame.

Frame

DemoFrame1.java

import java.awt.*;class DemoFrame1{

private Frame f;public DemoFrame1(String titulo){

f=new Frame(titulo);}public void ejecutar(){

f.setSize(200,200);f.setBackground(Color.BLUE);//f.setBackground(Color.blue);f.setVisible(true);


DemoFrame1 demo = new DemoFrame1("Demostracion del Frame");demo.ejecutar();

}}

Salida:


DemoFrame2.java


private Frame f1;private Frame f2;public DemoFrame2(String titulo){

f1=new Frame(titulo); f2=new Frame(titulo);

}public void ejecutar1(){

f1.setSize(200,200);f1.setBackground(Color.pink);f1.setVisible(true);

}public void ejecutar2(){

f2.setSize(300,300);f2.setBackground(Color.yellow);f2.setVisible(true);


DemoFrame2 demo = new DemoFrame2("Demostracion del Frame1");demo.ejecutar2();demo.ejecutar1();

}}

Salida:

DemoFrame3.java


import java.awt.*;class DemoFrame3 extends Frame{

public void paint(Graphics g){

g.drawString("prueba",60,100);setBackground(Color.red);g.drawLine(60,105,100,105);

}}

class PruebaDemoFrame3{


DemoFrame3 f = new DemoFrame3();f.setSize(200,200);f.show();

}}

Salida:

DemoFrame4.java


private Frame f;private Label letrero;public DemoFrame4(String titulo){

f=new Frame(titulo);

}

public void ejecutar(){

f.setSize(300,300);f.setBackground(Color.yellow);f.setVisible(true);letrero = new Label("Letrero 1");f.add(letrero);f.pack();



DemoFrame4 demo = new DemoFrame4("Demostracion del Frame1");demo.ejecutar();

}}


4.2 Panels

Un panel es un objeto que prove un espacio en donde se pueden colocar cualquier componente GUI, incluyendo otros panels cada Panel el cual hereda de la clase Container puede tener su propio layout manager.

Después de que se crea un objeto Panel se debe agregar a un objeto Window o Framw, esto se hace usando el método add de la clase Container. Para visualizar el frame y el panel, se debe establecer el frame a visible.

DemoPanel1.java

import java.awt.*;public class DemoPanel1{

private Frame f;private Panel p;public DemoPanel1(String titulo){

f = new Frame(titulo);p=new Panel();

}public void ejecutar(){

p.setSize(100,100);p.setBackground(Color.blue);f.setLayout(null);f.setSize(300,300);f.setBackground(Color.red);f.add(p);f.setVisible(true);


DemoPanel1 demo = new DemoPanel1("Demo de un Panel");demo.ejecutar();

}}

Salida:


DemoPanel2.java

import java.awt.*;public class DemoPanel2{

private Frame f;private Panel p1;private Panel p2;public DemoPanel2(String titulo){

f = new Frame(titulo);p1=new Panel();p2=new Panel();


p1.setSize(100,100);p1.setBackground(Color.yellow);p1.setVisible(true);

p2.setSize(50,50);p2.setBackground(Color.red);p2.setVisible(true);

f.setSize(300,300);f.setBackground(Color.blue);f.setLayout( null ) ;f.add(p2);f.add(p1);f.setVisible(true);


DemoPanel2 demo = new DemoPanel2("Demo de un Panel");demo.ejecutar();

}}

Salida:


4.3 Dialogs

Un componente Dialog esta asociado con un contenedor Frame. Es una ventana de libre posición con algunos detalles decorativos.

DemoDialog.java

import java.awt.*;class DemoDialog{

private Frame f;private Dialog d;private Label et;public DemoDialog(String titulo){

f=new Frame(titulo); d = new Dialog(f, "Dialogo", true);

et = new Label("Hola, este es un dialogo");}


d.setSize(150,50);d.add(et);d.setVisible(true);


DemoDialog demo = new DemoDialog("Demostracion del Frame1");demo.ejecutar();

}}

Salida:

DemoDialog2.java

import java.awt.*;class DemoDialog2{

private Frame f;private Dialog d;private Label et;private Dialog d2;private Label et2;public DemoDialog2(String titulo){


et = new Label("Hola, este es un dialogo");et2 = new Label("Hola, este es otro dialogo");

}



d.setLayout(new GridLayout(2,1));d.setSize(150,50);d.add(et);d.add(et2);d.setVisible(true);


DemoDialog2 demo = new DemoDialog2("Demostracion del Frame1");demo.ejecutar();

}}

Salida:

DemoDialog2.java

import java.awt.*;class DemoDialog2{

private Frame f;private Dialog d;private Label et;private Dialog d2;private Label et2;public DemoDialog2(String titulo){


et = new Label("Hola, este es un dialogo");et2 = new Label("Hola, este es otro dialogo");

}


d.setSize(150,50);d.add(et,BorderLayout.NORTH);d.add(et2,BorderLayout.SOUTH);d.setVisible(true);


DemoDialog2 demo = new DemoDialog2("Demostracion del Frame1");

demo.ejecutar();}

}


Salida:


Tipos de Layout Managers

Los siguientes Layout Managers están incluidos en el lenguaje de programación Java FlowLayout BorderLayout GridLayout CardLayout GridBagLayout

La siguiente figura muestra los Managers por default

El Administrador BorderLayout

Una disposisicón (arreglo) BorderLayout sitúa a los componetes dentro de áreas geográficas. Un componente puede ser agregado a una de estas cinco regiones.

DemoBorderLayout.java

import java.awt.*;public class DemoBorderLayout{

private Frame f;private Button boton1;private Button boton2;public DemoBorderLayout(){

f = new Frame("Demo del FlowLayout");boton1 = new Button ("Presioname");boton2 = new Button ("No me presiones");


f.setLayout(new BorderLayout());// esta linea no es// necesaria ya que por default un Frame es un BorderLayout

f.add(boton1,BorderLayout.NORTH);f.add(boton2,BorderLayout.SOUTH);f.pack();f.setVisible(true);



DemoBorderLayout demo=new DemoBorderLayout();demo.ejecutar();

}}

DemoBorderLayout2.java

import java.awt.*;public class DemoBorderLayout2{

private Frame f;private Button boton1;private Button boton2;private Button boton3;private Button boton4;private Button boton5;public DemoBorderLayout2(){

f = new Frame("Demo del FlowLayout");boton1 = new Button ("Arriba");boton2 = new Button ("Abajo");boton3 = new Button ("Derecha");boton4 = new Button ("Izquierda");boton5 = new Button ("Centro");


f.setLayout(new BorderLayout());// esta linea no es// necesaria ya que por default un Frame es un BorderLayout

f.add(boton1,BorderLayout.NORTH);f.add(boton2,BorderLayout.SOUTH);f.add(boton3,BorderLayout.WEST);f.add(boton4,BorderLayout.EAST);f.add(boton5,BorderLayout.CENTER);f.pack();f.setVisible(true);


DemoBorderLayout2 demo=new DemoBorderLayout2();demo.ejecutar();

}}

Salida:


DemoBorderLayout3.java

import java.awt.*;public class DemoBorderLayout3{

private Frame f;

private Panel p1;private Panel p2;private Panel p3;private Panel p4;private Panel p5;

public DemoBorderLayout3(String titulo){

f = new Frame(titulo);

p1=new Panel();p2=new Panel();p3=new Panel();p4=new Panel();p5=new Panel();


p1.setSize(100,100);p1.setBackground(Color.yellow);p1.setVisible(true);

p2.setSize(50,50);p2.setBackground(Color.red);p2.setVisible(true);

p3.setSize(50,50);p3.setBackground(Color.green);p3.setVisible(true);

p4.setSize(50,50);p4.setBackground(Color.gray);p4.setVisible(true);

p5.setSize(50,50);p5.setBackground(Color.white);p5.setVisible(true);

f.setSize(300,300);f.setBackground(Color.blue);


f.add(p2,BorderLayout.NORTH);f.add(p1,BorderLayout.SOUTH);f.add(p3,BorderLayout.EAST);f.add(p4,BorderLayout.WEST);f.add(p5,BorderLayout.CENTER);

f.setVisible(true);


DemoBorderLayout3 demo = new DemoBorderLayout3("Demo de un BorderLayout");demo.ejecutar();

}}

El Administrador FlowLayout


La distribución FlowLayout distribuye los componentes en forma similar a un texto en procesador de textos. Los componentes aparecen de izquierda a derecha hasta que termina el renglón y los componentes son agregados a otro renglón. El efecto es idéntico al que se tiene en una navegador Web.

A FlowLayout manager arranges components similar to text in a word processing document. Components appear from left to right until they run out of room, after which they wrap around to the next row. The effect is identical to that of a web browser.

DemoFlowLayout.java

import java.awt.*;public class DemoFlowLayout{

private Frame f;

private Button boton1;private Button boton2;private Button boton3;private Button boton4;private Button boton5;

private Panel p;

public DemoFlowLayout(){

f = new Frame("Demo del FlowLayout");

boton1 = new Button ("Boton 1");boton2 = new Button ("Boton 2");boton3 = new Button ("Boton 3");boton4 = new Button ("Boton 4");boton5 = new Button ("Boton 5");

p=new Panel(); }


p.setSize(100,100);p.setBackground(Color.yellow);p.setVisible(true);

// en un Panel la distribucion es FlowLayout por default//p.setLayout(new BorderLayout()); con esta instruccionse puede // cambiar la distribucion de un panel a BorderLayout

p.add(boton1);p.add(boton2);p.add(boton3);p.add(boton4);p.add(boton5);


f.add(p,BorderLayout.CENTER);

f.pack();f.setVisible(true);


DemoFlowLayout demo=new DemoFlowLayout();demo.ejecutar();

}}

Salida:

El administrador GridLayout


Una distribución de este tipo coloca los componentes en una tabla y cada componente ocupa una celda de igual tamaño.

The GridLayout manager arranges components into a table of rows and columns, one component per cell, each of equal size.

DemoGrid.java

import java.awt.*;public class DemoGrid{

private Frame f;private Button elBoton[];public DemoGrid(String titulo){

f=new Frame(titulo);elBoton = new Button[9];for(int i=0;i<elBoton.length;i++)

elBoton[i]=new Button(""+i);}public void ejecutar(){

f.setLayout(new GridLayout(3,3));

for(int i=0; i<elBoton.length;i++)f.add(elBoton[i]);

f.pack();f.setVisible(true);


DemoGrid demo=new DemoGrid("Demo de un GridLayout");demo.ejecutar();

}}

Salida:

Las siguientes reglas gobiernan al administrador Grid Layout


Los componente son agregados secuencialmente de izquierda a derecha, de arriba hacia abajo. Si el número de componentes agregados es menor que el número de componentes designados en el constructor para la clase GridLayout, el espacio reservado para estos componentes quedará vacante.

Todos los componentes tienen el mismo tamaño.

Cuando se redimensiona las relaciones horizontales y verticales entre los componentes no cambia, esto es importante si se desea persentar al usuario un vista consistente.

Ejemplos varios

Procesador1.java

import java.awt.*;public class Procesador1{

private Frame f;private Panel p1;private Panel p2;

private Button botonLimpiar;private Button botonSalir;

private TextField campo1;private TextArea area1;

public Procesador1(String titulo){


p1=new Panel();p2=new Panel();

botonLimpiar=new Button("Clear");botonSalir=new Button("Quit");

campo1=new TextField(40);area1=new TextArea(5,40);


p1.setLayout(new BorderLayout());p1.add(campo1,BorderLayout.NORTH);p1.add(area1,BorderLayout.SOUTH);

p2.add(botonLimpiar);p2.add(botonSalir);

f.add(p1,BorderLayout.NORTH);f.add(p2,BorderLayout.SOUTH);

f.pack();f.setVisible(true);f.setBackground(Color.blue);



Procesador1 demo=new Procesador1("Procesador");demo.ejecutar();

}}

Salida:

Chat1.java

import java.awt.*;public class Chat1{

private Frame f;

private Panel p1;private Panel p2;private Panel p3;

private Button botonEnviar;private Button botonSalir;private Button botonGuardar;private Button botonImprimir;

private Label letrero1;private Label letrero2;

private TextArea areaEntrada;private TextArea areaSalida;

public Chat1(String titulo){


p1=new Panel();p2=new Panel();p3=new Panel();

letrero1=new Label("Mensaje a enviar");letrero2=new Label("Mensaje recibido");

botonEnviar=new Button("Enviar");botonSalir=new Button("Salir");


botonGuardar=new Button("Guardar");botonImprimir=new Button("Imprimir");

areaEntrada=new TextArea(20,40);areaSalida=new TextArea(20,40);

p1.setLayout(new BorderLayout());p1.add(letrero1,BorderLayout.NORTH);p1.add(areaEntrada,BorderLayout.SOUTH);

p2.setLayout(new BorderLayout());p2.add(letrero2,BorderLayout.NORTH);p2.add(areaSalida,BorderLayout.SOUTH);

p3.add(botonEnviar);p3.add(botonSalir);p3.add(botonGuardar);p3.add(botonImprimir);

f.add(p1,BorderLayout.EAST);f.add(p2,BorderLayout.WEST);f.add(p3,BorderLayout.SOUTH);


f.pack();f.setVisible(true);f.setBackground(Color.red);


Chat1 demo=new Chat1("Messenger");demo.ejecutar();

}}

Salida:


Ejercicios

ExamenGui.java

import java.awt.*;

public class ExamenGui

{

private TextField campo1,campo2,campo3, campo4;

private Button b1,b2,b3,b4,b5;

private Label txt1,txt2,txt3,txt4;

private Frame f;

private Panel p1, p2, p3,p4;

private TextArea ta1, ta2;

ExamenGui()

{

Campo1 = new TextField(10);

campo2 = new TextField(10);



txt1 = new Label(" Valor alfa ");

txt2 = new Label("Valor beta ");

txt3 = new Label("Valor gamma ");

txt4 = new Label("Valor epsilon ");


b1 = new Button ("Request");

b2 = new Button ("Response");

b3 = new Button ("Write");

b4 = new Button ("Submit");

b5 = new Button ("Exit");

ta1 = new TextArea(5,40);

ta2 = new TextArea(5,40);

f = new Frame("Primer Examen de GUI");

p1 = new Panel();

p2=new Panel();

p3=new Panel();

p4=new Panel();

}

void pegarObjetos()

{

p1.add(txt1);

p1.add(txt2);

p1.add(txt3);

p1.add(txt4);

p2.add(campo1);

p2.add(campo2);

p2.add(campo3);

p2.add(campo4);

p4.setLayout(new GridLayout(5,1));

p4.add(b1);


p4.add(b2);

p4.add(b3);

p4.add(b4);

p4.add(b5);

p3.add(ta1);

p3.add(p4);

p3.add(ta2);

f.add(p1,BorderLayout.NORTH);

f.add(p2,BorderLayout.CENTER);

f.add(p3,BorderLayout.SOUTH);

f.setVisible(true);

f.pack();

}


{

ExamenGui obj=new ExamenGui();

obj.pegarObjetos();

}

}

Salida:


5. Manejo de eventos

Para implementer el manejo de eventos en una GUI se necesitan 4 pasos:

1. Identificar la fuente del evento2. Determinar el tipo de interfaz requerida para el tipo de evento

3. definir una clase que implemente la interfaz requerida

4. registra el manejador con el evento

Ejemplo 1

DemoEvento1.java

import java.awt.* ;import java.awt.event.* ;public class ManejadorBotonClick implements ActionListener {

private int count ;public void actionPerformed( ActionEvent e) {

Button boton = ( Button ) e.getSource() ;boton.setLabel( "Clicks : " + ++count ) ;

}}

import java.awt.* ;import java.awt.event.* ;public class DemoEvento1 {

private Frame frame ;private Button boton ;DemoEvento1() {

frame = new Frame( "Demo " ) ;boton = new Button( "Clicks : 0" ) ;

}public void ejecutar() {

boton.setFont( new Font( "Serif",Font.BOLD, 16 ) ) ;boton.addActionListener( new ManejadorBotonClick() ) ;frame.add( boton, BorderLayout.CENTER ) ;frame.setSize( 125, 125 ) ;frame.setVisible( true ) ;

}public static void main( String [] args )

{DemoEvento1 demo = new DemoEvento1() ;demo.ejecutar() ;

}


}

Salida:

Ejemplo 2

DemoEventoVentana.java

import java.awt.event.* ;public class ManejadorVentana implements WindowListener

{public void windowClosing( WindowEvent evento ) {

System.exit( 0 ) ;}public void windowOpened( WindowEvent w ) {}public void windowIconified( WindowEvent w ) {}public void windowDeiconified( WindowEvent w ) {}public void windowClosed( WindowEvent w ) {}public void windowActivated( WindowEvent w ) {}public void windowDeactivated( WindowEvent w ) {}

}

import java.awt.* ;import java.awt.event.* ;public class DemoEventoVentana {

Frame frame ;Label etiqueta ;public DemoEventoVentana() {

frame = new Frame( "Demo Evento Ventana" ) ;etiqueta = new Label( "Cerrando la ventana", Label.CENTER ) ;


etiqueta.setFont( new Font( "Serif", Font.BOLD, 16 ) ) ;frame.addWindowListener( new ManejadorVentana() ) ;frame.add( etiqueta, BorderLayout.CENTER ) ;frame.setSize( 400, 100 ) ;frame.setVisible( true ) ;

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

DemoEventoVentana demo = new DemoEventoVentana() ;demo.ejecutar() ;


}}

Salida:

Ejemplo 3

DemoEventoVentana.java

import java.awt.* ;import java.awt.event.* ;public class ManejadorBotonClick implements ActionListener {

private int count ;public void actionPerformed( ActionEvent e) {


}}

import java.awt.event.* ;public class ManejadorVentana implements WindowListener

{public void windowClosing( WindowEvent theEvent ) {

System.exit( 0 ) ;}

public void windowOpened( WindowEvent w ) {}public void windowIconified( WindowEvent w ) {}public void windowDeiconified( WindowEvent w ) {}public void windowClosed( WindowEvent w ) {}public void windowActivated( WindowEvent w ) {}public void windowDeactivated( WindowEvent w ) {}

}

import java.awt.* ;import java.awt.event.* ;public class DemoEventoVentana{

Frame frame ;Label etiqueta ;Button boton;public DemoEventoVentana() {

frame = new Frame( "Demo Evento Ventana" ) ;


etiqueta = new Label( "Para cerrar esta ventana de un click en el cuadro respectivo", Label.CENTER ) ;

boton = new Button( "Clicks : 0" ) ;}public void ejecutar() {

boton.setFont( new Font( "Serif",Font.BOLD, 16 ) ) ;boton.addActionListener( new ManejadorBotonClick() ) ;frame.add( boton, BorderLayout.WEST ) ;

etiqueta.setFont( new Font( "Serif", Font.BOLD, 16 ) ) ;frame.addWindowListener( new ManejadorVentana() ) ;frame.add( etiqueta, BorderLayout.EAST) ;frame.setVisible( true ) ;frame.pack();


DemoEventoVentana demo = new DemoEventoVentana() ;demo.ejecutar() ;

}}

Salida:

Ejemplo 4

En este ejemplo se integran dos métodos a la clase para controlar el evento del Mouse y el de la ventana, usando una implementación (herencia múltiple) y el this para activar los métodos

DemoEventos.java

import java.awt.* ;import java.awt.event.* ;public class DemoEventos implements ActionListener,WindowListener {

Frame frame ;Label etiqueta ;Button boton;

private int count ;public DemoEventos() {

frame = new Frame( "Demo Evento Ventana" ) ;etiqueta = new Label( "Para cerrar esta ventana de un click en el cuadro respectivo",

Label.CENTER ) ;boton = new Button( "Clicks : 0" ) ;count=0 ;


boton.setFont( new Font( "Serif",Font.BOLD, 16 ) ) ;


boton.addActionListener(this) ;frame.add( boton, BorderLayout.WEST ) ;

etiqueta.setFont( new Font( "Serif", Font.BOLD, 16 ) ) ;frame.addWindowListener(this) ;frame.add( etiqueta, BorderLayout.EAST) ;frame.setVisible( true ) ;frame.pack();


DemoEventos demo = new DemoEventos() ;demo.ejecutar() ;

}

public void actionPerformed( ActionEvent e) {


}

public void windowClosing( WindowEvent theEvent ) {

System.exit( 0 ) ;}


}

Salida:


5.1 Categorías de los eventos

Categoría Nombre de la interfaz MétodosAction ActionListener actionPerformed(ActionEvent)Item ItemListener itemStateChanged(itemEvent)

Mouse MouseListener

mousePressed(mouseEvent)mouseReleases(mouseEvent)mouseEntered(mouseEvent)mouseExited(mouseEvent)mouseClicked(mouseEvent)

Mouse Motion MouseMotionListenermouseDragged(mouseEvent)mouseMoved(MouseEvent)

Key KeyListener

keyPressed(KeyEvent)keyReleased(KeyEvent)keyTyped(KeyEvent)

Focus FocusListenerfocusGained(FocusEvent)focusLost(FocusEvent)

Adjustment AdjustmentListener adjustmentValueChanged(Adjustment)

Component ComponentListener

componentMoved(ComponentEvent)componentHidden (ComponentEvent)componentResized(ComponentEvent)componentShown(ComponentEvent)

Window WindowListener

windowClosing(WindowEvent)windowOpened(WindowEvent)windowIconified(WindowEvent)windowDeiconified(WindowEvent)windowClosed(WindowEvent)windowActivated(WindowEvent)windowDeactivated(WindowEvent)

Container ContainerListenercomponentAdded(ContainerEvent)componentRemoved(ContainerEvent)

Text TextListener textValueChanged(TextEvent)


Ejemplo 5

DemoEventosMoverMouse.java

import java.awt.* ;import java.awt.event.* ;public class EventosMoverMouse implements MouseMotionListener, MouseListener {

private TextField textX ;private TextField textY ;private TextField textLocalizar ;private TextField textPresionar ;

public EventosMoverMouse( TextField textX,TextField textY,TextField textLocalizar,TextField textPresionar )

{this.textX = textX ;this.textY = textY ;this.textLocalizar = textLocalizar ;this.textPresionar = textPresionar ;

}

public void mouseDragged( MouseEvent evento ) {mouseMoved( evento ) ;}

public void mouseMoved( MouseEvent evento ) {textX.setText( "" + evento.getX() ) ;textY.setText( "" + evento.getY() ) ;}

public void mouseEntered( MouseEvent evento ) {

textLocalizar.setText( "Sobre la etiqueta" ) ;}

public void mouseExited( MouseEvent evento ) {

textLocalizar.setText( "No está sobre la etiqueta" ) ;}

public void mousePressed( MouseEvent evento ) {

textPresionar.setText( "Presionado" ) ;}


public void mouseReleased( MouseEvent evento ) {

textPresionar.setText( "No se ha presionado" ) ;}

public void mouseClicked( MouseEvent evento ) {}}

import java.awt.* ;import java.awt.event.* ;public class DemoEventosMoverMouse {

private Frame frame ;private Panel panelNorte ;private Label etiquetaX ;private Label etiquetaY ;private Label etiquetaLocalizar ;private Label etiquetaPresionar ;private Label instruccion ;private TextField textX ;private TextField textY ;private TextField textLocalizar ;private TextField textPresionar ;

public DemoEventosMoverMouse() {

frame = new Frame( "DualListenerDemo" ) ;panelNorte = new Panel() ;etiquetaX = new Label( "Coordenada X " ) ;etiquetaY = new Label( "Coordenada Y " ) ;etiquetaLocalizar = new Label( "Status de Localizacion" ) ;etiquetaPresionar = new Label( "Status" ) ;instruccion = new Label( "Mover el raton sobre la etiqueta", Label.CENTER ) ;textX = new TextField( 20 ) ;textY = new TextField( 20 ) ;textLocalizar = new TextField( "No sobre la etiqueta", 20 ) ;textPresionar = new TextField( "No se ha presionado", 20 ) ;

}

public void ejecutar() {etiquetaX.setBackground( Color.lightGray ) ;etiquetaY.setBackground( Color.lightGray ) ;etiquetaLocalizar.setBackground( Color.lightGray ) ;etiquetaPresionar.setBackground( Color.lightGray ) ;instruccion.setBackground( Color.lightGray ) ;

// esta serie de instrucciones permite simplificar la llamada// a la clase tal como se muestra en las lineas comentadas

EventosMoverMouse procesa = new EventosMoverMouse( textX, textY, textLocalizar, textPresionar ) ;

instruccion.addMouseListener( procesa ) ;instruccion.addMouseMotionListener( procesa ) ;


//instruccion.addMouseListener( new EventosMoverMouse( textX, textY, textLocalizar, textPresionar ) ) ;

//instruccion.addMouseMotionListener( new EventosMoverMouse( textX, textY, textLocalizar, textPresionar ) ) ;

panelNorte.setLayout( new GridLayout( 4, 2 ) ) ;panelNorte.add( etiquetaX ) ;panelNorte.add( textX ) ;panelNorte.add( etiquetaY ) ;panelNorte.add( textY ) ;panelNorte.add( etiquetaLocalizar ) ;panelNorte.add( textLocalizar ) ;panelNorte.add( etiquetaPresionar ) ;panelNorte.add( textPresionar ) ;frame.add( panelNorte, BorderLayout.NORTH ) ;frame.add( instruccion, BorderLayout.CENTER ) ;frame.setSize( 300, 200 ) ;frame.setVisible( true ) ;}

public static void main( String [] args ) {

DemoEventosMoverMouse demo = new DemoEventosMoverMouse() ;demo.ejecutar() ;

}}

Salida:


5.2 Clases adaptadoras

Se puede usar una clase adaptadora en lugar de una interfaz para que de esta manera no se tenga la necesidad de implementar todos los métodos tanto los que se usan como los que no

Pseudocódigo con una clase interaz1. package java.awt.event ;2.3.4.5. public abstract class WindowAdapter implements6.7. WindowListener {8.9. public void windowOpened( WindowEvent e ) {}10.11. public void windowClosing( WindowEvent e ) {}12.13. public void windowClosed( WindowEvent e ) {}14.15. public void windowIconified( WindowEvent e ) {}16.17. public void windowDeiconified( WindowEvent e ) {}18.19. public void windowActivated( WindowEvent e ) {}20.21. public void windowDeactivated( WindowEvent e ) {}22.23. }

Pseudocódigo con una clase adaptadora1. import java.awt.event.* ;2.3.4.5. public class WindowHandler extends WindowAdapter {6.7. public void windowClosing( WindowEvent theEvent ) {8.9. System.exit( 0 ) ;10.11. }12.13. }14.


5.3 Manejando eventos con una clase interna

Ejemplo 6

DemoEventosMoverMouse2.java

import java.awt.* ;import java.awt.event.* ;public class DemoEventosMoverMouse2 {

private Frame frame ;private Panel panelNorte ;private Label etiquetaX ;private Label etiquetaY ;private Label etiquetaLocalizar ;private Label etiquetaPresionar ;private Label instruccion ;private TextField textX ;private TextField textY ;private TextField textLocalizar ;private TextField textPresionar ;

public DemoEventosMoverMouse2() {

frame = new Frame( "DualListenerDemo" ) ;panelNorte = new Panel() ;etiquetaX = new Label( "Coordenada X " ) ;etiquetaY = new Label( "Coordenada Y " ) ;etiquetaLocalizar = new Label( "Status de Localizacion" ) ;etiquetaPresionar = new Label( "Status" ) ;instruccion = new Label( "Mover el raton sobre la etiqueta", Label.CENTER ) ;textX = new TextField( 20 ) ;textY = new TextField( 20 ) ;textLocalizar = new TextField( "No sobre la etiqueta", 20 ) ;textPresionar = new TextField( "No se ha presionado", 20 ) ;

}

public void ejecutar() {etiquetaX.setBackground( Color.lightGray ) ;etiquetaY.setBackground( Color.lightGray ) ;etiquetaLocalizar.setBackground( Color.lightGray ) ;


etiquetaPresionar.setBackground( Color.lightGray ) ;instruccion.setBackground( Color.lightGray ) ;

EventosMoverMouse2 procesa = new EventosMoverMouse2( textX, textY, textLocalizar, textPresionar ) ;

instruccion.addMouseListener( procesa ) ;instruccion.addMouseMotionListener( procesa ) ;

panelNorte.setLayout( new GridLayout( 4, 2 ) ) ;panelNorte.add( etiquetaX ) ;panelNorte.add( textX ) ;panelNorte.add( etiquetaY ) ;panelNorte.add( textY ) ;panelNorte.add( etiquetaLocalizar ) ;panelNorte.add( textLocalizar ) ;panelNorte.add( etiquetaPresionar ) ;panelNorte.add( textPresionar ) ;frame.add( panelNorte, BorderLayout.NORTH ) ;frame.add( instruccion, BorderLayout.CENTER ) ;frame.setSize( 300, 200 ) ;frame.setVisible( true ) ;}


DemoEventosMoverMouse2 demo = new DemoEventosMoverMouse2() ;demo.ejecutar() ;

}

// inserción de la clase interna

public class EventosMoverMouse2 implements MouseMotionListener, MouseListener {

private TextField textX ;private TextField textY ;private TextField textLocalizar ;private TextField textPresionar ;public EventosMoverMouse2( TextField textX,TextField textY,TextField

textLocalizar,TextField textPresionar ) {

this.textX = textX ;this.textY = textY ;this.textLocalizar = textLocalizar ;this.textPresionar = textPresionar ;

}

public void mouseDragged( MouseEvent evento ) {mouseMoved( evento ) ;}

public void mouseMoved( MouseEvent evento ) {textX.setText( "" + evento.getX() ) ;textY.setText( "" + evento.getY() ) ;}



textLocalizar.setText( "Sobre la etiqueta" ) ;}

public void mouseExited( MouseEvent evento ) {

textLocalizar.setText( "No está sobre la etiqueta" ) ;}


textPresionar.setText( "Presionado" ) ;}

public void mouseReleased( MouseEvent evento ) {

textPresionar.setText( "No se ha presionado" ) ;}

public void mouseClicked( MouseEvent evento ) {

textLocalizar.setText( "se ha presionado el ratón sobre la etiqueta" ) ;}

}

}

Archivos que se generan:

La salida es similar al ejemplo 5


Existen varios componentes AWT y los eventos que escuchan y que se muestran en la siguiente tabla

Tipo de componentte

Act Adj Cmp Cnt Foc Itm Key Mou MM Text Win

Button X X X X X X

Canvas X X X X X

Checkbox X X X X X X

CheckboxMenuItem X

Choice X X X X X X

Component X X X X X

Container X X X X X X

Dialog X X X X X X X

Frame X X X X X X X

Label X X X X X

List X X X X X X X

MenuItem X

Panel X X X X X X

Scrollbar X X X X X X

ScrollPane X X X X X X

TextArea X X X X X X

TextField X X X X X X X

Window X X X X X X X

Act - ActionListener Adj - AdjustmentListener Cmp - ComponentListener Cnt - ContainerListener Foc - FocusListener Itm - ItemListener Key - KeyListener Mou - MouseListener MM - MouseMotionListener


Text - TextListener Win – WindowListener

5.4 Ejemplos

Ejemplo 1

EjerGui1.java

import java.awt.event.*;import java.awt.*;class ManejadorEventos implements WindowListener, FocusListener, ActionListener{ private TextField campo1; private TextField campo2; private Button bot1; private TextField campo3; private TextArea area;

ManejadorEventos(){

}ManejadorEventos(TextArea a)

{area=a;

}

ManejadorEventos(Button b1, TextField c3){

bot1=b1;campo3=c3;

} ManejadorEventos(TextField c1, TextField c2)

{campo1=c1;campo2=c2;

}public void windowClosing( WindowEvent e ) {

System.exit( 0 ) ;}


public void focusGained(FocusEvent e){

area.append("Esta es una prueba para agregar texto a una area de texto");


}public void focusLost(FocusEvent e)

{campo2.setText(campo1.getText());

}public void actionPerformed( ActionEvent e)

{bot1.setLabel( "ha dado un click" ) ;campo3.setText(bot1.getLabel());

}

import java.awt.* ;import java.awt.event.* ;public class EjerGui1{

private Frame f;private Label et1, et2,et3;private TextField txtCampo1, txtCampo2, txtCampo3;private TextArea txtArea;private Button b1;EjerGui1(){

f=new Frame ("Mi primer GUI con eventos");et1=new Label("Introduzca el primer valor",Label.CENTER);et2=new Label("Introduzca el segundo valor",Label.CENTER);et3=new Label("Introduzca el tercer valor",Label.CENTER);txtCampo1=new TextField(10);txtCampo2=new TextField(10);txtCampo3=new TextField(10);txtArea=new TextArea(3,30);b1=new Button("Presiona aquí");

}void visualizarGUI(){


et1.setFont( new Font("",Font.BOLD, 16 ) ) ;f.add(et1);

txtCampo1.setFont( new Font( "",Font.ITALIC, 12 ) ) ;f.add(txtCampo1);

et2.setFont( new Font( "",Font.BOLD, 14 ) ) ;f.add(et2);


et3.setFont( new Font( "",Font.ROMAN_BASELINE, 16 ) ) ;f.add(et3);



f.addWindowListener( new ManejadorEventos() ) ;

txtCampo1.addFocusListener(new ManejadorEventos(txtCampo1,txtCampo2));

f.add(b1);b1.addActionListener(new ManejadorEventos(b1, txtCampo3));

f.add(txtArea);txtArea.addFocusListener(new ManejadorEventos(txtArea));

f.setSize(400,300);f.setVisible(true);


EjerGui1 gui=new EjerGui1();gui.visualizarGUI();

}}

Salida:


Ejemplo con dos botones

EjerGui1.java

import java.awt.event.*;

import java.awt.*;

class ManejadorEventos implements WindowListener, FocusListener, ActionListener

{

private TextField campo1;


private Button bot1;

private Button bot2;


private TextArea area;

ManejadorEventos()

{

}

ManejadorEventos(TextField c1, TextField c2, TextField c3, Button b1, Button b2, TextArea a)

{

campo1=c1;

campo2=c2;

campo3=c3;

bot1=b1;


bot2=b2;

area=a;

}

public void windowClosing( WindowEvent e )

{

System.exit( 0 ) ;

}

public void windowOpened( WindowEvent w ) {}

public void windowIconified( WindowEvent w ) {}

public void windowDeiconified( WindowEvent w ) {}

public void windowClosed( WindowEvent w ) {}

public void windowActivated( WindowEvent w ) {}

public void windowDeactivated( WindowEvent w ) {}

public void focusGained(FocusEvent e)

{

area.append("Esta es una prueba para agregar texto a una area de texto");

}

public void focusLost(FocusEvent e)

{

campo2.setText(campo1.getText());

}

public void actionPerformed( ActionEvent evento)

{

Button b = ( Button ) evento.getSource() ;

String text = b.getActionCommand() ;


if ( text.equals( bot1.getActionCommand() ) )

{

bot1.setLabel( "ha dado un click" ) ;

campo3.setText(bot1.getLabel());

}

else

{

if(text.equals( bot2.getActionCommand() ))

campo1.setText("esta es una prueba");

}

}

}

import java.awt.* ;

import java.awt.event.* ;

public class EjerGui1

{

private Frame f;

private Label et1, et2,et3;

private TextField txtCampo1, txtCampo2, txtCampo3;

private TextArea txtArea;

private Button b1;

private Button b2;

EjerGui1()


{

f=new Frame ("Mi primer GUI con eventos");

et1=new Label("Introduzca el primer valor",Label.CENTER);

et2=new Label("Introduzca el segundo valor",Label.CENTER);

et3=new Label("Introduzca el tercer valor",Label.CENTER);

txtCampo1=new TextField(10);



txtArea=new TextArea(3,30);

b1=new Button("Presiona aquí");

b2=new Button("Boton 2");

}

void visualizarGUI()

{


et1.setFont( new Font("",Font.BOLD, 16 ) ) ;

f.add(et1);

txtCampo1.setFont( new Font( "",Font.ITALIC, 12 ) ) ;

f.add(txtCampo1);

et2.setFont( new Font( "",Font.BOLD, 14 ) ) ;

f.add(et2);


f.add(txtCampo2);

et3.setFont( new Font( "",Font.ROMAN_BASELINE, 16 ) ) ;

f.add(et3);



f.add(txtCampo3);

ManejadorEventos objeto =new ManejadorEventos(txtCampo1,txtCampo2,txtCampo3,b1,b2,txtArea);

f.addWindowListener( new ManejadorEventos() ) ;

txtCampo1.addFocusListener(objeto);

f.add(b1);

b1.addActionListener(objeto);

f.add(b2);

b2.addActionListener(objeto);

f.add(txtArea);

txtArea.addFocusListener(objeto);

f.setSize(400,300);

f.setVisible(true);

}


{

EjerGui1 gui=new EjerGui1();

gui.visualizarGUI();

}

}

Salida :


Ejemplo 3

DemoBoton.java

import java.awt.* ; import java.awt.event.* ; public class DemoBoton extends WindowAdapter implements ActionListener { private Frame f ; private Button botonContador ; // Declare a button private Button botonSalir ; // Declare a button private int contador ; public DemoBoton() { f = new Frame( "DemoBoton" ) ; botonContador = new Button( "contador : 0" ) ; botonSalir = new Button( "Salir" ) ; } public void ejecutar() { botonContador.addActionListener( this ) ; botonSalir.addActionListener( this ) ; f.addWindowListener( this ) ; f.setLayout( new GridLayout( 2, 1 ) ) ; f.add( botonContador ) ; f.add( botonSalir ) ; f.setSize( 175, 175 ) ; f.setVisible( true ) ; } public static void main( String [] args ) { DemoBoton demo = new DemoBoton() ; demo.ejecutar() ; }

public void actionPerformed( ActionEvent evento ) { Button b = ( Button ) evento.getSource() ; String text = b.getActionCommand() ; if ( text.equals( botonSalir.getActionCommand() ) ) System.exit( 0 ) ; else { contador++ ; botonContador.setLabel( "contador : " + contador ) ; }


}

public void windowClosing( WindowEvent evento ) { System.exit( 0 ) ; } }

Salida:

Los siguientes ejemplos están divididos en tres clases para implementar y modificar más rápido

Ejemplo

EventoBoton.java Contiene el procesamiento de los eventos

import java.awt.* ;import java.awt.event.* ;public class EventoBoton extends WindowAdapter implements ActionListener{

private Button bSalir, bContador; private int c=0;

EventoBoton(Button b1, Button b2){

bSalir=b1;bContador=b2;

} public void actionPerformed( ActionEvent evento )

{

Button b = ( Button ) evento.getSource() ;

String text = b.getActionCommand() ;

if ( text.equals( bSalir.getActionCommand() ) )

System.exit( 0 ) ;

else


{ c++ ; bContador.setLabel( "contador : " + c ) ; } }


System.exit( 0 ) ;}

}

DemoBoton2 Contiene la implementación de la GUI y y los Listeners

import java.awt.* ;import java.awt.event.* ;

class DemoBoton2 {

private Frame f ; private Button botonContador ; private Button botonSalir ; private int contador ;

public DemoBoton2() {

f = new Frame( "DemoBoton" ) ;

botonContador = new Button( "contador : 0" ) ;

botonSalir = new Button( "Salir" ) ;

}public void ejecutar()

{EventoBoton objeto = new EventoBoton(botonSalir, botonContador);

botonContador.addActionListener( objeto ) ; botonSalir.addActionListener( objeto ) ;

f.addWindowListener( objeto ) ;

f.setLayout( new GridLayout( 2, 1 ) ) ; f.add( botonContador ) ; f.add( botonSalir ) ; f.setSize( 175, 175 ) ; f.setVisible( true ) ; }}

PruebaDemoBoton2.java Contiene la ejecución de la interfaz y de los eventos


class PruebaDemoBoton2{


DemoBoton2 demo = new DemoBoton2() ; demo.ejecutar() ; }

}

5.5 Posicionamiento Absoluto

Los Componentes se pueden colocar en Contenedores utilizando cualquiera de los controladores de posicionamiento, o utilizando posicionamiento absoluto para realizar esta función. La primera forma de colocar los Componentes se considera más segura porque automáticamente serán compensadas las diferencias que se puedan encontrar entre resoluciones de pantalla de plataformas distintas.

La clase Component proporciona métodos para especificar la posición y tamaño de un Componente en coordenadas absolutas indicadas en pixels:

setBounds( int,int,int,int );setBounds( Rectangle );

La posición y tamaño si se especifica en coordenadas absolutas, puede hacer más difícil la consecución de una apariencia uniforme, en diferentes plataformas, del interfaz, según algunos autores; pero, a pesar de ello, es interesante saber cómo se hace.

Hay dos versiones sobrecargadas de setBounds(). Una de ellas permite que tamaño y posición se indiquen a través de cuatro enteros: ordenadas, abscisas, ancho y alto. La otra versión requiere que se utilice un objeto Rectangle, que se pasa como parámetro al método. Esta última versión es más flexible, porque la clase Rectangle tiene siete constructores diferentes que pueden ser utilizados para crear la caja que indicará la posición y tamaño del componente.

Ejemplo

import java.awt.*;class PruebaSetBounds{

private Button b1,b2,b3;private Frame f;PruebaSetBounds(){

b1 = new Button("boton 1");b2 = new Button("boton 2");b3 = new Button("boton 3");


f= new Frame ("Prueba de setBounds");

}void visualizar(){

f.setLayout(null);

// el primer par de números establece el origen del objeto en pixels// el segundo par de números establece la anchura y la altura del objeto

b1.setBounds(20,20,50,30);f.add(b1);

b2.setBounds(new Rectangle(100,75,100,75));f.add(b2);

b3.setBounds(300,100,50,80);f.add(b3);

f.setSize(400,200);f.setBackground(Color.BLUE);f.setVisible(true);


PruebaSetBounds obj = new PruebaSetBounds();obj.visualizar();

}}

Salida:


Ejemplo para seleccionar varios botones

GuiVariosBotones.java


class GuiVariosBotones {

private Frame f ; private Button b1,b2,b3 ; private TextField t1,t2,t3;

public GuiVariosBotones() {


b1 = new Button( "boton 1" ) ;b2 = new Button( "boton 2" ) ;b3 = new Button( "boton 3" ) ;t1=new TextField(20);t2=new TextField(20);t3=new TextField(20);


{f.setLayout( new GridLayout( 6, 1 ) ) ;EventoVariosBoton obj = new EventoVariosBoton(b1,b2,b3,t1,t2,t3);

f.addWindowListener( new EventoVariosBoton()) ;

f.add( b1 ) ;

f.add( t1 ) ;f.add( b2 ) ;f.add( t2 ) ;


f.add( b3 ) ;f.add( t3 ) ;

b1.addActionListener( obj ) ;b2.addActionListener( obj ) ;b3.addActionListener( obj ) ;

f.setVisible( true ) ;

f.pack(); }}

EventoVariosBoton.java

import java.awt.* ;import java.awt.event.* ;public class EventoVariosBoton extends WindowAdapter implements ActionListener{

private Button b1,b2,b3;private TextField t1,t2,t3;

EventoVariosBoton(){}EventoVariosBoton(Button b1, Button b2, Button b3, TextField t1, TextField t2, TextField t3){

this.b1=b1;this.b2=b2;this.b3=b3;this.t1=t1;this.t2=t2;this.t3=t3;


{

// esta instrucción permite almacenar el caracter de la posición 6 de la// etiqueta del botón que permite diferenciar a cada uno

char operador = evento.getActionCommand().charAt(6);

switch (operador){

case '1':t1.setText("boton 1");break;

case '2':t2.setText("boton 2");


break;case '3':

t3.setText("boton 3");break;

} }

public void windowClosing( WindowEvent evento ) {

System.exit( 0 ) ;}

}

PruebaVariosBotones.java

class PruebaVariosBotones{


GuiVariosBotones demo = new GuiVariosBotones() ; demo.ejecutar() ; }

}

Ejemplo 2

GuiVariosBotones2.java


class GuiVariosBotones2 {

private Frame f ; private Button b1,b2,b3 ; private TextField t1,t2,t3;

public GuiVariosBotones2() {


b1 = new Button( "boton 1" ) ;b2 = new Button( "boton 2" ) ;b3 = new Button( "boton 3" ) ;


t1=new TextField(20);t2=new TextField(20);t3=new TextField(20);


{f.setLayout( new GridLayout( 6, 1 ) ) ;EventosVariosBotones2 obj = new EventosVariosBotones2(b1,b2,b3,t1,t2,t3);

f.addWindowListener( new EventosVariosBotones2()) ;

f.add( b1 ) ;

f.add( t1 ) ;f.add( b2 ) ;f.add( t2 ) ;f.add( b3 ) ;f.add( t3 ) ;

b1.addActionListener( obj ) ;b2.addActionListener( obj ) ;b3.addActionListener( obj ) ;

f.setVisible( true ) ;

f.pack(); }}

EventosVariosBotones2.java

import java.awt.* ;import java.awt.event.* ;public class EventosVariosBotones2 extends WindowAdapter implements ActionListener{

private Button b1,b2,b3;private TextField t1,t2,t3;

EventosVariosBotones2(){}EventosVariosBotones2(Button b1, Button b2, Button b3, TextField t1, TextField t2, TextField t3){

this.b1=b1;this.b2=b2;this.b3=b3;this.t1=t1;this.t2=t2;this.t3=t3;


{Object fuente = evento.getSource();if(fuente==b1)

t1.setText("boton 1");else if(fuente==b2)


t2.setText("boton 2");else if(fuente==b3)

t3.setText("boton 3");

}


System.exit( 0 ) ;}

}

PruebaVariosBotones2.java

class PruebaVariosBotones2{


GuiVariosBotones2 demo = new GuiVariosBotones2() ; demo.ejecutar() ; }

}


5.6 Checkbox

GuiCheckbox.java

import java.awt.* ; import java.awt.event.* ;

public class GuiCheckbox { private Frame f ; private Label et ; private Checkbox leer ; private Checkbox pintar ; private Checkbox correr ;

public GuiCheckbox() {

f = new Frame( "GuiCheckbox" ) ; et = new Label( "Pasatiempos : " ) ; leer = new Checkbox( "leer ", false ) ; pintar = new Checkbox( "pintar", false ) ; correr = new Checkbox( "correr ", false ) ; }

public void ejecutar() {EventoCheckbox procesar = new EventoCheckbox();

leer.addItemListener( procesar ) ; pintar.addItemListener( procesar ) ; correr.addItemListener( procesar ) ; f.addWindowListener( procesar ) ;

f.setLayout( new FlowLayout() ) ;

f.add( et ) ;


f.add( leer ) ; f.add( pintar ) ; f.add( correr ) ;

f.pack() ; f.setVisible( true ) ; }

}

EventoCheckbox.java

import java.awt.*;import java.awt.event.*;public class EventoCheckbox extends WindowAdapter implements ItemListener

{

public void itemStateChanged( ItemEvent evento ) {

Checkbox cbox = ( Checkbox ) evento.getSource() ; System.out.println( cbox.getLabel() + " : " +

cbox.getState() ) ; }


System.exit( 0 ) ;}

}

PruebaDemoCheckbox.java

class PruebaDemoCheckbox{


GuiCheckbox demo = new GuiCheckbox() ;

demo.ejecutar() ;

}}

Salida:


5.7 Componentes Choice y List

Choice

GuiChoice.java

import java.awt.* ;import java.awt.event.* ;public class GuiChoice{

private Frame f ; private Choice sel ;

private TextField t1;private String [] diasDeLaSemana =

{"Domingo","Lunes","Martes","Miercoles","Jueves","Viernes","Sabado"}; public GuiChoice()

{ f = new Frame( "Gui Choice" ) ; sel = new Choice() ;

t1 = new TextField(20); } public void ejecutar()

{ for ( int i = 0 ; i < diasDeLaSemana.length ; i++ )

sel.addItem( diasDeLaSemana[ i ] ) ; EventosChoice obj =new EventosChoice(sel,t1);

sel.addItemListener( obj ) ; f.addWindowListener( new EventosChoice() ) ; f.add( sel,BorderLayout.NORTH ) ;


f.add(t1,BorderLayout.CENTER); f.pack() ; f.setVisible( true ) ;

}}

EventosChoice.java

import java.awt.* ;import java.awt.event.* ; public class EventosChoice extends WindowAdapter implements ItemListener {

private Choice sel;private TextField t1;private int c=0;EventosChoice(){

}EventosChoice(Choice sel, TextField t1){

this.sel=sel;this.t1=t1;

} public void itemStateChanged( ItemEvent evento )

{ String etiqueta = ( String ) evento.getItem() ;

System.out.println( "Seleccion : " + etiqueta ) ;

if ( etiqueta.equals( "Lunes" ) )

t1.setText("Se ha seleccionado Lunes");else

if ( etiqueta.equals( "Martes" ) )

t1.setText("Se ha seleccionado Martes");else

if ( etiqueta.equals( "Miercoles" ) )

t1.setText("Se ha seleccionado Miercoles");else

if ( etiqueta.equals( "Jueves" ) )

t1.setText("Se ha seleccionado Jueves");else

if ( etiqueta.equals( "Viernes" ) )

t1.setText("Se ha seleccionado Viernes");else

if ( etiqueta.equals( "Sabado" ) )

t1.setText("Se ha seleccionado Sabado");else


if ( etiqueta.equals( "Domingo" ) )

t1.setText("Se ha seleccionado Domingo");

} public void windowClosing( WindowEvent theEvent )

{ System.exit( 0 ) ; }

}

PruebaChoice.java

class PruebaChoice{

public static void main( String [] args ) { GuiChoice demo = new GuiChoice() ; demo.ejecutar() ;}

}

List

GuiList.java

import java.awt.* ;import java.awt.event.* ;public class GuiList{

private Frame f ; private List lista;

private String [] diasDeLaSemana = {"Domingo","Lunes","Martes","Miercoles","Jueves","Viernes","Sabado"}; public GuiList()

{ f = new Frame( "GuiList" ) ; lista = new List(4,true) ; } public void ejecutar()

{ for ( int i = 0 ; i < diasDeLaSemana.length ; i++ )

lista.addItem( diasDeLaSemana[ i ] ) ; EventosLista obj =new EventosLista(lista);

lista.addItemListener( obj ) ; f.addWindowListener( new EventosLista() ) ; f.add( lista) ; f.pack() ; f.setVisible( true ) ;

}


}

EventosLista.java

import java.awt.* ;import java.awt.event.* ; public class EventosLista extends WindowAdapter implements ItemListener {

private List lista;private int c=0;EventosLista(){

}EventosLista(List lista){

this.lista=lista;}

public void itemStateChanged( ItemEvent evento ) {

String [] itemsSeleccionados = lista.getSelectedItems() ;

System.out.println( "items actualmente seleccionados" ) ;

for ( int i = 0 ; i < itemsSeleccionados.length ; i++ )

System.out.println( itemsSeleccionados[ i ] ) ;

System.out.println() ;

}


System.exit( 0 ) ; }

}

PruebaList.java

class PruebaList{

public static void main( String [] args ) { GuiList demo = new GuiList() ; demo.ejecutar() ;}

}


5.8 Componentes de Texto

GuiText1.java

import java.awt.* ;import java.awt.event.* ;public class GuiText1{ private Frame f ; private Label etiqueta ; private Label etiquetaPassword ; private TextField nombreCampo ; private TextField campoPassword ; private Button botonLimpiar ; private Button botonEnviar ; private final static int WIDTH = 20 ;

public GuiText1( String titulo ) { f = new Frame( titulo ) ; etiqueta = new Label( "Nombre" ) ; etiquetaPassword = new Label( "Password" ) ; nombreCampo = new TextField( WIDTH ) ; campoPassword = new TextField( WIDTH ) ; botonLimpiar = new Button( "Limpiar" ) ; botonEnviar = new Button( "Enviar" ) ; }


public void ejecutar() {

EventosGuiText1 obj = new EventosGuiText1(nombreCampo,campoPassword,botonLimpiar,botonEnviar);

nombreCampo.addActionListener( obj ) ; campoPassword.addActionListener( obj ) ; botonLimpiar.addActionListener( obj ) ; botonEnviar.addActionListener( obj ) ; f.addWindowListener( obj) ; campoPassword.setEchoChar( '*' ) ; etiqueta.setBackground( Color.lightGray ) ; etiquetaPassword.setBackground( Color.lightGray ) ; f.setLayout( new GridLayout( 3, 2 ) ) ; f.add( etiqueta ) ; f.add( nombreCampo ) ; f.add( etiquetaPassword ) ; f.add( campoPassword ) ; f.add( botonLimpiar ) ; f.add( botonEnviar ) ; f.pack() ; f.setVisible( true ) ;}

}

EventosGuiText1.java

import java.awt.* ;import java.awt.event.* ;public class EventosGuiText1 extends WindowAdapter implements ActionListener

{private TextField nombreCampo ;

private TextField campoPassword ; private Button botonLimpiar ; private Button botonEnviar ;

EventosGuiText1(TextField nombreCampo, TextField campoPassword, Button botonLimpiar, Button botonEnviar)

{this.nombreCampo=nombreCampo ;

this.campoPassword=campoPassword ; this.botonLimpiar=botonLimpiar ; this.botonEnviar=botonEnviar ;

} public void actionPerformed( ActionEvent evento)

{ Object fuente = evento.getSource() ; if ( fuente instanceof TextField )

{ if ( fuente == nombreCampo )


campoPassword.requestFocus() ; else

nombreCampo.requestFocus() ; } else

{ if ( fuente == botonLimpiar )

{ nombreCampo.setText( "" ) ; campoPassword.setText( "" ) ;

} else

{ System.out.println( "Nombre : " + nombreCampo.getText() ) ;

System.out.println( "Password : " + campoPassword.getText() ) ; System.exit( 0 ) ;

} } } public void windowClosing( WindowEvent theEvent )

{ System.exit( 0 ) ;

} }

PruebaGuiText1.java

public class PruebaGuiText1{

public static void main( String args [] ) {

GuiText1 demo =new GuiText1( "Demo de TextFiled" ) ;demo.ejecutar() ;

}}

Salida:


GuiText2.java

import java.awt.* ; import java.awt.event.* ; import java.io.* ; import java.awt.*;import java.awt.event.*; public class GuiText2{ private Frame f ; private Label etiquetaDirectorio ;

private TextField entradaDirectorio ;private Label etiquetaArchivo ;private TextField entradaArchivo ;private TextArea cuerpoArchivo;private Button botonLlamar ;private Button botonLimpiar ;private Button botonSalir ;private Panel northPanel ;private Panel southPanel ;private final static int ALTURA = 20 ;private final static int ANCHURA= 40 ;

public GuiText2( String titulo ) {

f = new Frame( titulo ) ; etiquetaDirectorio = new Label( "Directorio" ) ; entradaDirectorio = new TextField( ANCHURA) ; etiquetaArchivo = new Label( "Nombre del Archivo" ) ; entradaArchivo = new TextField( ANCHURA) ; cuerpoArchivo= new TextArea( ALTURA, ANCHURA) ; botonLlamar = new Button( "Llamar" ) ; botonLimpiar = new Button( "Limpiar" ) ; botonSalir = new Button( "Salir" ) ; northPanel = new Panel() ; southPanel = new Panel() ; }


EventosGuiText2 obj =new EventosGuiText2(entradaDirectorio,entradaArchivo,botonLlamar,botonLimpiar,botonSalir,cuerpoArchivo);

entradaDirectorio.addActionListener( obj ) ; entradaArchivo.addActionListener( obj ) ; botonLlamar.addActionListener( obj ) ; botonLimpiar.addActionListener( obj ) ; botonSalir.addActionListener( obj ) ; f.addWindowListener( obj) ; cuerpoArchivo.setEditable( false ) ; etiquetaDirectorio.setBackground( Color.lightGray ) ; etiquetaArchivo.setBackground( Color.lightGray ) ; northPanel.setLayout( new GridLayout( 2, 2 ) ) ; northPanel.add( etiquetaDirectorio ) ; northPanel.add( entradaDirectorio ) ; northPanel.add( etiquetaArchivo ) ; northPanel.add( entradaArchivo ) ;


southPanel.setLayout( new GridLayout( 1, 3 ) ) ; southPanel.add( botonLlamar ) ; southPanel.add( botonLimpiar ) ; southPanel.add( botonSalir ) ; f.add( northPanel, BorderLayout.NORTH ) ; f.add( cuerpoArchivo, BorderLayout.CENTER ) ; f.add( southPanel, BorderLayout.SOUTH ) ; f.pack() ; f.setVisible( true ) ; }

}

EventosGuiText2.java

import java.awt.*;import java.awt.event.*; import java.io.* ; public class EventosGuiText2 extends WindowAdapter implements ActionListener {

private TextField entradaDirectorio ;private TextField entradaArchivo ;private Button botonLlamar ;private Button botonLimpiar ;private Button botonSalir ;private TextArea cuerpoArchivo;

EventosGuiText2(TextField entradaDirectorio, TextField entradaArchivo, Button botonLlamar, Button botonLimpiar, Button botonSalir, TextArea cuerpoArchivo)

{ this.cuerpoArchivo=cuerpoArchivo; this.entradaDirectorio=entradaDirectorio; this.entradaArchivo=entradaArchivo; this.botonLlamar=botonLlamar; this.botonLimpiar=botonLimpiar; this.botonSalir=botonSalir;


}

private String obtenerArchivo( String directoryName, String fileName ) throws IOException { FileReader file = null ; char [] buffer = new char[ 128 ] ; String content = "" ; if ( fileName.length() + directoryName.length() > 0 )

{ String path = directoryName ; if ( ! path.equals( "" ) ) path += System.getProperty( "file.separator" ) ; path += fileName ; file = new FileReader( path ) ;

int bytes = 0 ; while ( file.read( buffer ) != -1 ) content += new String( buffer ) ; file.close() ; }

return content ; }

public void actionPerformed( ActionEvent evento ) { Object fuente = evento.getSource() ; if ( fuente == entradaDirectorio ) entradaArchivo.requestFocus() ; else if ( fuente == entradaArchivo ) entradaDirectorio.requestFocus() ; else if ( fuente == botonLlamar ) { try

{ String contenido = obtenerArchivo( entradaDirectorio.getText(),

entradaArchivo.getText() ) ; cuerpoArchivo.setText( contenido ) ;

}catch ( IOException io )

{ cuerpoArchivo.setText( "Error en la lectura del archivo" ) ; } cuerpoArchivo.setCaretPosition( 0 ) ; entradaDirectorio.requestFocus() ; } else if ( fuente == botonLimpiar )

{ entradaDirectorio.setText( "" ) ; entradaArchivo.setText( "" ) ; cuerpoArchivo.setText( "" ) ; entradaDirectorio.requestFocus() ; } else System.exit( 0 ) ; }

public void windowClosing( WindowEvent evento )


{ System.exit( 0 ) ; }}

PruebaGuiText2.java

class PruebaGuiText2{ public static void main( String args [] ) {

GuiText2 demo = new GuiText2( "Demo 2 de textos" ) ; demo.ejecutar() ;

}}

Salida:

5.9 Componentes Canvas y Scrollpane

Un canvas es un área rectangular vacia de la pantalla dentro de la cual una aplicación puede dibujar, desplegar textos, banderizar imágenes y atrapar entradas de eventos.

Canvas

DemoCanvas.java

import java.awt.* ; import java.awt.event.* ; import java.util.* ; public class DemoCanvas extends WindowAdapter implements ActionListener { private Frame f ; private SketchCanvas canvas; private Button boton ;

public DemoCanvas() {

f = new Frame( "Demo Canvas" ) ; canvas= new SketchCanvas() ;


boton = new Button( "Limpiar" ) ; }


boton.addActionListener( this ) ; f.addWindowListener( this ) ; f.add( canvas, BorderLayout.CENTER ) ; f.add( boton, BorderLayout.SOUTH ) ; f.pack() ; f.setVisible( true ) ; }


DemoCanvas demo = new DemoCanvas() ; demo.ejecutar() ;

}

public void actionPerformed( ActionEvent evento ) {

canvas.limpiar() ; }

public void windowClosing( WindowEvent evento ) { System.exit( 0 ) ;

}

/////////////////////////////////////////////////////

public class SketchCanvas extends Canvas implements MouseListener, MouseMotionListener {

private Vector vector ; private int inicioX ; private int inicioY ;

public SketchCanvas() {

vector = new Vector() ; setSize( 200, 200 ) ; addMouseMotionListener( this ) ; addMouseListener( this ) ; }

private void drawLine( Graphics graficos, int [] puntos ) {

graficos.drawLine( puntos[ 0 ], puntos[ 1 ],puntos[ 2 ], puntos[ 3 ] ) ; }

public void limpiar() {


Graphics graficos = getGraphics() ; Dimension dimension = getSize() ; int altura = ( int ) dimension.getHeight() ; int anchura = ( int ) dimension.getWidth() ; graficos.clearRect( 0, 0, anchura, altura ) ; vector.clear() ; }

public void paint( Graphics graficos ) {

Iterator iteracion = vector.iterator() ; while ( iteracion.hasNext() )

{ int [] puntos = ( int [] ) iteracion.next() ;

drawLine( graficos, puntos ) ; } }


inicioX = evento.getX() ; inicioY = evento.getY() ; }

public void mouseDragged( MouseEvent evento ) {

Graphics graficos = getGraphics() ; int finX = evento.getX() ; int finY = evento.getY() ; int [] puntos = {inicioX, inicioY, finX, finY} ; drawLine( graficos, puntos ) ; vector.add( puntos ) ; inicioX = finX ; inicioY = finY ; }

public void mouseMoved( MouseEvent evento ) {}

public void mouseClicked( MouseEvent evento ) {}

public void mouseEntered( MouseEvent evento ) {}

public void mouseExited( MouseEvent evento ) {}

public void mouseReleased( MouseEvent evento ) {}

} }

Salida:


ScrollPane

DemoScrollPane.java

import java.awt.* ; import java.awt.event.* ; import java.awt.image.* ;

public class DemoScrollPane extends WindowAdapter { private Frame f ; private ScrollPane scrollPane ; private ImageCanvas canvas ;

public DemoScrollPane( String titulo, String gif ) {

f = new Frame( titulo ) ; scrollPane = new ScrollPane() ; canvas = new ImageCanvas( gif ) ; }



f.addWindowListener( this ) ; scrollPane.add( canvas ) ; f.add( scrollPane ) ; f.setSize( 400, 400 ) ; f.setVisible( true ) ; }



public class ImageCanvas extends Canvas {

private Image imagen ; public ImageCanvas( String gif )

{ imagen = f.getToolkit().getImage( gif ) ; MediaTracker tracker = new MediaTracker( this ) ; tracker.addImage( imagen, 0 ) ; try

{ tracker.waitForID( 0 ) ;

}

catch ( Exception theException ) {} this.imagen = imagen ;

}

public void paint( Graphics graphics ) {

graphics.drawImage( imagen, 0, 0, this ) ; }

public void update( Graphics graphics ) {

paint( graphics ) ; }

public Dimension getPreferredSize() {

return new Dimension(imagen.getWidth( this ),imagen.getHeight( this ) ) ; }

}

}

PruebaDemoScrollPane.java


public class PruebaDemoScrollPane{ public static void main( String [] args )

{

DemoScrollPane demo =

new DemoScrollPane( "Demo ScrollPane", "prueba.gif" ) ;

demo.ejecutar() ;

}}

Salida:

Dialogos

DemoVentanaDialogo.java

import java.awt.* ; import java.awt.event.* ; import java.io.* ;

public class DemoVentanaDialogo extends WindowAdapter implements ActionListener { private Frame f ; private Label etiquetaDirectorio ; private TextField entradaDirectorio ; private Label etiquetaArchivo ; private TextField entradaArchivo ; private TextArea cuerpoArchivo ; private Button botonLlamar ; private Button botonLimpiar ; private Button botonSalir ; private Panel panelNorte ; private Panel panelSur ;


private Dialog dialogo ; private Panel panel ; private Label advertencia; private Button desconocido ; private FileDialog archivoDialogo ; private final static int ALTURA = 20 ; private final static int ANCHURA = 40 ;

public DemoVentanaDialogo( String titulo ) {

f = new Frame( titulo ) ; etiquetaDirectorio = new Label( "Directorio" ) ; entradaDirectorio = new TextField( ANCHURA ) ; etiquetaArchivo = new Label( "Nombre del archivo" ) ; entradaArchivo = new TextField( ANCHURA ) ; cuerpoArchivo = new TextArea( ALTURA, ANCHURA ) ; botonLlamar = new Button( "Llamar" ) ; botonLimpiar = new Button( "Limpiar" ) ; botonSalir = new Button( "Salir" ) ; panelNorte = new Panel() ; panelSur = new Panel() ; dialogo = new Dialog( f, "Warning", true ) ; panel = new Panel() ; advertencia= new Label("Error al llamar el archivo", Label.CENTER ) ; desconocido = new Button( "OK" ) ; archivoDialogo = new FileDialog( f, "Browse", FileDialog.LOAD ) ; }


entradaDirectorio.addActionListener( this ) ; entradaArchivo.addActionListener( this ) ; botonLlamar.addActionListener( this ) ; botonLimpiar.addActionListener( this ) ; botonSalir.addActionListener( this ) ; f.addWindowListener( this ) ; cuerpoArchivo.setEditable( false ) ; etiquetaDirectorio.setBackground( Color.lightGray ) ; etiquetaArchivo.setBackground( Color.lightGray ) ; panelNorte.setLayout( new GridLayout( 2, 2 ) ) ; panelNorte.add( etiquetaDirectorio ) ; panelNorte.add( entradaDirectorio ) ; panelNorte.add( etiquetaArchivo ) ; panelNorte.add( entradaArchivo ) ; panelSur.setLayout( new GridLayout( 1, 3 ) ) ; panelSur.add( botonLlamar ) ; panelSur.add( botonLimpiar ) ; panelSur.add( botonSalir ) ; f.add( panelNorte, BorderLayout.NORTH ) ; f.add( cuerpoArchivo, BorderLayout.CENTER ) ; f.add( panelSur, BorderLayout.SOUTH ) ; f.pack() ; f.setVisible( true ) ; desconocido.addActionListener( this ) ; dialogo.addWindowListener( this ) ; dialogo.setLayout( new GridLayout( 2, 1 ) ) ;


dialogo.add( advertencia) ; panel.add( desconocido ) ; dialogo.add( panel ) ; dialogo.pack() ; dialogo.setResizable( false ) ; }

private String getFile( String nombreDirectorio, String nombreArchivo ) throws IOException {

FileReader archivo = null ; char [] buffer = new char[ 128 ] ; String contenido = "" ; if ( nombreArchivo.length() + nombreDirectorio.length() > 0 )

{ String path = nombreDirectorio ; if ( ! path.equals( "" ) ) path += System.getProperty( "archivo.separator" ) ; path += nombreArchivo ; archivo = new FileReader( path ) ; int bytes = 0 ; while ( archivo.read( buffer ) != -1 ) contenido += new String( buffer ) ; archivo.close() ; } return contenido ; }

public void actionPerformed( ActionEvent theEvent ) { Object fuente = theEvent.getSource() ; if ( fuente == entradaDirectorio ) entradaArchivo.requestFocus() ; else if ( fuente == entradaArchivo )

entradaDirectorio.requestFocus() ; else if ( fuente == botonLlamar )

{ if ( entradaArchivo.getText().length() + entradaDirectorio.getText().length() == 0 )

{ archivoDialogo.setVisible( true ) ; entradaDirectorio.setText ( archivoDialogo.getDirectory() ) ; entradaArchivo.setText( archivoDialogo.getFile() ) ; } try

{ String contenido = getFile( entradaDirectorio.getText(), entradaArchivo.getText()

) ; cuerpoArchivo.setText( contenido ) ; } catch ( IOException io )

{ cuerpoArchivo.setText( "" ) ;


int altura = ( f.getHeight() -dialogo.getHeight() ) / 2 ; int anchura = ( f.getWidth() -dialogo.getWidth() ) / 2 ;

Point punto =f.getLocationOnScreen() ; int x = ( int ) punto.getX() + anchura ; int y = ( int ) punto.getY() + altura ; dialogo.setLocation( x, y ) ; dialogo.setVisible( true ) ; } cuerpoArchivo.setCaretPosition( 0 ) ; entradaDirectorio.requestFocus() ; } else if ( fuente == botonLimpiar )

{ entradaDirectorio.setText( "" ) ; entradaArchivo.setText( "" ) ; cuerpoArchivo.setText( "" ) ; entradaDirectorio.requestFocus() ;

} else if ( fuente == desconocido )

dialogo.dispose() ; else System.exit( 0 ) ; }

public void windowClosing( WindowEvent theEvent ) { Object fuente = theEvent.getSource() ; if ( fuente == dialogo ) dialogo.dispose() ; else System.exit( 0 ) ; }

}

PruebaDemoVentanaDialogo.java

public class PruebaDemoVentanaDialogo{ public static void main( String args [] )

{ DemoVentanaDialogo demo = new DemoVentanaDialogo( "DemoVentanaDialogo" ) ; demo.ejecutar() ;

}}

Salida:


5.10 Componentes Menu


Ejemplo

GuiDemoMenu1.java

import java.awt.* ; import java.awt.event.* ;public class GuiDemoMenu1{ private Frame f ; private TextArea textArea ; private MenuBar BarraMenu ; private Menu MenuArchivo ; private MenuItem llamar ; private MenuItem guardar ; private MenuItem salir ; private Menu menuBuscar ; private MenuItem encontrar ; private MenuItem reemplazar ; private Menu menuPropiedades ; private CheckboxMenuItem checar ; private CheckboxMenuItem todo ; private Menu menuHelp ; private MenuItem indexar ; private final static int ALTURA = 20 ; private final static int ANCHURA = 40 ; public GuiDemoMenu1( String titulo )

{ f = new Frame( titulo ) ; textArea = new TextArea( ALTURA, ANCHURA ) ;


indexar = new MenuItem( "indexar" ) ; menuHelp = new Menu( "Ayuda" ) ; checar = new CheckboxMenuItem( "checar opcion" ) ; todo = new CheckboxMenuItem( "reemplazar todo" ) ; menuPropiedades = new Menu( "Properties" ) ; encontrar = new MenuItem( "encontrar" ) ; reemplazar = new MenuItem( "reemplazar" ) ; menuBuscar = new Menu( "Buscar" ) ; llamar = new MenuItem( "llamar" ) ; guardar = new MenuItem( "guardar" ) ; salir = new MenuItem( "salir" ) ; MenuArchivo = new Menu( "Archivo" ) ; BarraMenu = new MenuBar() ; } public void ejecutar()

{ EventosDemoMenu1 obj =new EventosDemoMenu1(llamar,guardar,salir,encontrar,reemplazar,indexar,checar,todo); llamar.addActionListener( obj ) ; guardar.addActionListener( obj ) ; salir.addActionListener( obj ) ; encontrar.addActionListener( obj ) ; reemplazar.addActionListener( obj ) ; indexar.addActionListener( obj ) ; checar.addActionListener( obj ) ; todo.addActionListener( obj ) ; f.addWindowListener( obj ) ; f.add( textArea, BorderLayout.CENTER ) ; MenuArchivo.add( llamar ) ; MenuArchivo.add( guardar ) ; MenuArchivo.addSeparator() ; MenuArchivo.add( salir ) ; menuBuscar.add( encontrar ) ; menuBuscar.add( reemplazar ) ; menuBuscar.addSeparator() ; menuBuscar.add( menuPropiedades ) ; menuPropiedades.add( checar ) ; menuPropiedades.add( todo ) ; menuHelp.add( indexar ) ; BarraMenu.add( MenuArchivo ) ; BarraMenu.add( menuBuscar ) ; BarraMenu.setHelpMenu( menuHelp ) ; f.setMenuBar( BarraMenu ) ; f.pack() ; f.setVisible( true ) ; }}

EventosDemoMenu1.java

import java.awt.* ; import java.awt.event.* ; public class EventosDemoMenu1 extends WindowAdapter implements ActionListener

{ private MenuItem llamar ;


private MenuItem guardar ; private MenuItem salir ; private MenuItem encontrar ; private MenuItem reemplazar ; private CheckboxMenuItem checar ; private CheckboxMenuItem todo ; private MenuItem indexar ;

public EventosDemoMenu1(MenuItem llamar,MenuItem guardar, MenuItem salir,MenuItem encontrar, MenuItem reemplazar, MenuItem indexar,CheckboxMenuItem checar,CheckboxMenuItem todo)

{this.llamar=llamar;this.guardar=guardar;this.salir=salir;this.encontrar=encontrar;this.reemplazar=reemplazar;this.checar=checar;this.todo=todo;

} public void actionPerformed( ActionEvent evento ) { String command = evento.getActionCommand() ; if ( ! command.equals( "salir" ) ) System.out.println( command ) ; else System.exit( 0 ) ; } public void windowClosing( WindowEvent evento )

{ System.exit( 0 ) ; }

}

PruebaDemoMenu1.java

public class PruebaDemoMenu1{public static void main( String [] args )

{

GuiDemoMenu1 demo = new GuiDemoMenu1( "Demo Menu" ) ;

demo.ejecutar() ;

}}

Salida:


5.11 Controlando colores y fuentes

Ejemplo1 Colores

GuiDemoColor.java

import java.awt.* ;import java.awt.event.* ;public class GuiDemoColor{ private Frame f ; private Button botonIzquierdo ; private Button botonDerecho; public final static Color brillante = Color.lightGray ; public final static Color oscuro = new Color( 160, 160, 160 ) ; public GuiDemoColor( String titulo )

{ f = new Frame( titulo ) ; botonIzquierdo = new Button( "Presiona" ) ; botonDerecho= new Button( "Salir" ) ; } public void ejecutar()

{EventosDemoColor obj = new EventosDemoColor(botonIzquierdo,

botonDerecho); botonIzquierdo.addMouseListener( obj ) ; botonDerecho.addMouseListener( obj ) ; botonIzquierdo.setBackground( oscuro ) ; botonDerecho.setBackground( oscuro ) ; f.addWindowListener( new EventosDemoColor()) ; f.setLayout( new GridLayout( 1, 2 ) ) ; f.add( botonIzquierdo ) ; f.add( botonDerecho) ; f.setSize( 200, 100 ) ; f.setVisible( true ) ; } }


EventosDemoColor.java

import java.awt.* ;import java.awt.event.* ;public class EventosDemoColor extends WindowAdapter implements MouseListener {

private Button botonIzquierdo;private Button botonDerecho;EventosDemoColor(){}EventosDemoColor(Button botonIzquierdo, Button botonDerecho){

this.botonIzquierdo=botonIzquierdo;this.botonDerecho=botonDerecho;

}public void mousePressed( MouseEvent evento ) {}

public void mouseExited( MouseEvent evento ) { Button boton = ( Button ) evento.getSource() ; boton.setBackground( GuiDemoColor.oscuro) ;

} public void mouseReleased( MouseEvent evento )

{}


Button boton = ( Button ) evento.getSource() ; boton.setBackground( GuiDemoColor.brillante ) ; boton.requestFocus() ; }public void mouseClicked( MouseEvent evento )

{ Button fuente = ( Button ) evento.getSource() ; if ( fuente.getActionCommand().equals( "Salir" ) ) System.exit( 0 ) ; }



}

PruebaDemoColor.java

public class PruebaDemoColor{public static void main( String args [] ) { GuiDemoColor demo = new GuiDemoColor( "Demo Color" ) ; demo.ejecutar() ; }}


Salida:

Ejemplo 2 Fuentes

GuiDemoFuente.java

import java.awt.* ;import java.awt.event.* ;public class GuiDemoFuente{

private Frame f;private Panel panel;private List nombreLista ;private List tamanoLista ;private List estiloLista ;private Label etiqueta ;public static int fuenteIndex ;public static int estiloIndex ;public static int tamanoIndex ;public final static String [] nombreFuente = {"SansSerif", "Serif", "Monospaced"} ;public final static String [] estiloFuente = {"Plain", "Bold", "Italic", "BoldItalic"} ;public final static int [] tamanoFuente = {8, 12, 14, 16, 18, 24, 48, 64} ;private final static int TAMANO = 4 ;

GuiDemoFuente( String titulo) { f= new Frame( titulo) ; etiqueta = new Label( "Hola", Label.CENTER ) ; panel= new Panel() ; nombreLista = new List( TAMANO ) ; estiloLista = new List( TAMANO ) ; tamanoLista = new List( TAMANO ) ;}public void ejecutar() {

EventosDemoFuente obj=new EventosDemoFuente(nombreLista,estiloLista,tamanoLista,etiqueta);

nombreLista.addItemListener( obj ) ; estiloLista.addItemListener( obj ) ; tamanoLista.addItemListener( obj ) ;

f.addWindowListener( new EventosDemoFuente() ) ;

for ( int i = 0 ; i < nombreFuente.length ; i++ ) nombreLista.add( nombreFuente[ i ] ) ;

for ( int i = 0 ; i < estiloFuente.length ; i++ )


estiloLista.add( estiloFuente[ i ] ) ;

for ( int i = 0 ; i < tamanoFuente.length ; i++ ) tamanoLista.add( "" + tamanoFuente[ i ] ) ;

nombreLista.select( fuenteIndex ) ; estiloLista.select( estiloIndex ) ; tamanoLista.select( tamanoIndex ) ;

Font fuente = new Font( nombreFuente[ fuenteIndex ],estiloIndex,tamanoFuente[ tamanoIndex ] ) ;

etiqueta.setFont( fuente ) ; f.setLayout( new GridLayout( 2, 1 ) ) ; panel.setLayout( new GridLayout( 1, 3 ) ) ; panel.add( nombreLista ) ; panel.add( estiloLista ) ; panel.add( tamanoLista ) ; f.add( etiqueta ) ; f.add( panel) ; f.pack() ; f.setVisible( true ) ;}

}

EventosDemoFuente.java

import java.awt.* ;import java.awt.event.* ; public class EventosDemoFuente extends WindowAdapter implements ItemListener

{private List nombreLista;private List estiloLista;private List tamanoLista;private Label etiqueta;

EventosDemoFuente(){

}EventosDemoFuente(List nombreLista, List estiloLista, List tamanoLista,Label etiqueta){

this.nombreLista=nombreLista;this.estiloLista=estiloLista;this.tamanoLista=tamanoLista;this.etiqueta=etiqueta;

} public void itemStateChanged( ItemEvent evento)

{ List fuente = ( List ) evento.getItemSelectable() ; if ( fuente == nombreLista ) GuiDemoFuente.fuenteIndex = fuente.getSelectedIndex() ; else if ( fuente == estiloLista ) GuiDemoFuente.estiloIndex = fuente.getSelectedIndex() ; else GuiDemoFuente.tamanoIndex = fuente.getSelectedIndex() ;


Font fuente2 = new Font( GuiDemoFuente.nombreFuente[ GuiDemoFuente.fuenteIndex ], GuiDemoFuente.estiloIndex, GuiDemoFuente.tamanoFuente[ GuiDemoFuente.tamanoIndex ] ) ;

etiqueta.setFont( fuente2 ) ; } public void windowClosing( WindowEvent evento)

{ System.exit( 0 ) ; } }

PruebaDemoFuente.java

public class PruebaDemoFuente{public static void main( String [] args ) { GuiDemoFuente demo = new GuiDemoFuente( "Demo Fuente" ) ; demo.ejecutar() ; }}

Salida:


6. Interfaz Gráfica de Usuario (GUI). Parte II. Swing4

Las GUIs se crean a partir de componentes de la GUI (también conocidos como controles o widgets [accesorios de ventana]). Un componente de la GUI es un objeto con el cual interactúa el usuario mediante el ratón, el teclado u otra forma de entrada, como el reconocimiento de voz.

Los componentes de la GUI de Swing del paquete javax.swing están escritos, se manipulan y muestran completamente en Java (los denominados componentes puros de Java). Los componentes de Swing son parte de la JFC (Java Foundation Classes), las bibliotecas de Java para el desarrollo de GUIs para múltiples plataformas.

Los componentes originales de la GUI del paquete java.awt del AWT (Abstract Windows Toolkit) están enlazados directamente con las herramientas de interfaz gráfica de usuario de la plataforma local. Cuando se ejecuta un programa de Java con una GUI del AWT en distintas plataformas Java, los componentes de la GUI del programa se muestran de manera distinta en cada plataforma. Por ejemplo un programa que muestra un objeto de tipo Button (paquete java.awt), en una computadora que ejecuta el sistema operativo Microsoft Windows, el objeto Button tendrá la misma apariencia visual que los botones de otras aplicaciones Windows. De manera similar, en una computadora que ejecuta el sistema operativo MacOS, de Apple, el objeto Button tendrá la misma apariencia visual que los botones de otras aplicaciones Macintosh. En ocasiones, la forma en que un usuario puede interactuar con un componente AWT específico es distinta entre las plataformas.

En conjunto, la apariencia y la manera en que el usuario interactúa con el programa se conocen como la vista y el sentido de ese programa. Los componentes de Swing permiten al programador especificar una vista y sentido uniformes entre todas las plataformas, o proporcionar una vista y sentido personalizado para cada plataforma. Un programa puede incluso cambiar la vista y el sentido durante su ejecución. Por ejemplo, un programa podría permitir a los usuarios elegir su vista y sentido preferidos.

Los componentes de Swing se implementan en Java, por lo que proporcionan un mayor nivel de protabilidad y flexibilidad que los componentes originales de la GUI del paquete java.awt.

Los componentes de Swing comúnmente seconocen como componentes ligeros; están escritos completamente en Java, por lo que no son abrumados por las complejas herramientas de la GUI de la plataforma en que se utilicen. Sin embargo, a los componentes de AWT (muchos de los cuales se comparan con los componentes de Swing), que están enlazados a la plataforma local, se les llama componentes pesados; éstos dependen del sistema de ventanas de la plataforma local para determinar su funcionalidad y su vista y sentido. Cada componente pesado tiene un igual (del paquete java.awt.peer) que es responsable de las interacciones entre el componente y la plataforma local que muestra y manipula a ese componente. Varios componentes de Swing son componentes pesados, como las subclases de java.awt.Window (por ejemplo, Jframe) que muestran ventanas en la pantalla, y las sublcases de java.applet.Applet (como JApplet). Estos componentes aún requieren de una interacción directa con el sistema de ventanas local. Como tal, la apariencia y funcionalidad de un componente pesado de la GUI de Swing están restringidas por el sistema de ventanas local.

Superclases comunes de muchos de los componentes de Swing

4 Resumen de los capítulos 13,14 del libro de Deitel & Deitel


Una clase Container administra una colección de componentes relacionados. En aplicaciones con objetos Jframe y en subprogramas, se adjuntan componentes al panel de contenido, que es un objeto de la clase Container. Esta clase declara los atributos y comportamientos comunes para todas las subclases de Container. Un método que se origina en la clase Container es add, el cual se utiliza para adjuntar componentes al panel de contenido (un objeto Container). Otro método que se origina en la clase Container es setLayout, el cual permite a un programa especificar el administrador de esquemas que ayuda a un Container a posicionar y ajustar el tamaño de sus componentes.

La clase Jcomponent es la superclase de la mayoría de los componentes de Swing. Esta clase declara los atributos y comportamientos comunes de todas las subclases de Jcomponent.


Object

Component

Container

JComponent

204

6.1. Campos y etiquetas

Ejemplo 1

GuiDemoEtiqueta.java

import java.awt.*;import java.awt.event.*;import javax.swing.*;public class GuiDemoEtiqueta extends JFrame{

private JLabel et1, et2, et3;private Icon imagen;GuiDemoEtiqueta(){

super("Prueba de JLabel");et1=new JLabel("Etiqueta con texto");imagen=new ImageIcon("imagen.gif");et2=new JLabel("Etiqueta con texto e icono", imagen,SwingConstants.LEFT);et3=new JLabel();

}void visualizar(){

Container contenedor = getContentPane();contenedor.setLayout(new FlowLayout());

et1.setToolTipText("Esta es la etiqueta1");et2.setToolTipText("Esta es la etiqueta2");et3=new JLabel();et3.setText("Etiqueta con icono y texto en parte inferior");et3.setIcon(imagen);et3.setHorizontalTextPosition(SwingConstants.CENTER);et3.setVerticalTextPosition(SwingConstants.BOTTOM);et3.setToolTipText("Esta es la etiqueta3");

contenedor.add(et1);contenedor.add(et2);contenedor.add(et3);setSize(275,250);setVisible(true);

}}

PruebaDemoEtiqueta.java

public class PruebaDemoEtiqueta{


GuiDemoEtiqueta obj = new GuiDemoEtiqueta();obj.visualizar();

}}


Salida:

Ejemplo 2

GuiDemoCampo.java

import java.awt.*;import java.awt.event.*;import javax.swing.*;public class GuiDemoCampo extends JFrame{

private JTextField campoTexto1, campoTexto2, campoTexto3;private JPasswordField campoPassword;GuiDemoCampo(){

super("Prueba de JTextield y PasswordField");campoTexto1=new JTextField(10);campoTexto2=new JTextField("Escriba el texto aqui");campoTexto3=new JTextField("Campo de texto no editable",20);campoPassword=new JPasswordField("Texto oculto");

}void ejecutar(){


campoTexto3.setEditable(false);

EventosDemoCampo obj=new EventosDemoCampo(campoTexto1,campoTexto2,campoTexto3,campoPassword);

campoTexto1.addActionListener(obj);campoTexto2.addActionListener(obj);campoTexto3.addActionListener(obj);campoPassword.addActionListener(obj);

contenedor.add(campoTexto1);contenedor.add(campoTexto2);contenedor.add(campoTexto3);contenedor.add(campoPassword);

setSize(275,250);setVisible(true);

}}


EventosDemoCampo.java

import java.awt.*;import java.awt.event.*;import javax.swing.*;public class EventosDemoCampo implements ActionListener{

private JTextField campoTexto1, campoTexto2, campoTexto3;private JPasswordField campoPassword;

EventosDemoCampo(JTextField campoTexto1,JTextField campoTexto2,JTextField campoTexto3,JPasswordField campoPassword)

{this.campoTexto1=campoTexto1;this.campoTexto2=campoTexto2;this.campoTexto3=campoTexto3;this.campoPassword=campoPassword;

}public void actionPerformed(ActionEvent evento){

String cadena="";

if(evento.getSource()==campoTexto1)cadena="campoTexto1: " +evento.getActionCommand();

else if(evento.getSource()==campoTexto2)cadena="campoTexto2: " +evento.getActionCommand();

else if(evento.getSource()==campoTexto3)cadena="campoTexto3: " +evento.getActionCommand();

else if(evento.getSource()==campoPassword){cadena="campoPassword: " +new String (campoPassword.getPassword());}

JOptionPane.showMessageDialog(null,cadena);}

}

PruebaDemoCampo.java

import javax.swing.*;public class PruebaDemoCampo{


GuiDemoCampo obj = new GuiDemoCampo();obj.ejecutar();obj.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

}}


Salida:

6.2. Botones

GuiDemoBoton.java

import java.awt.*;import java.awt.event.*;import javax.swing.*;public class GuiDemoBoton extends JFrame{

private JButton botonSimple, botonElegante;private Icon imagen1;private Icon imagen2;

GuiDemoBoton(){

super("Prueba de botones");

imagen1 = new ImageIcon("imagen1.gif");imagen2=new ImageIcon("imagen2.gif");

botonSimple=new JButton("Boton Simple");botonElegante=new JButton("Boton Elegante",imagen1);

}void ejecutar(){


EventosDemoBoton obj=new EventosDemoBoton(botonSimple, botonElegante);

botonSimple.addActionListener(obj);botonElegante.addActionListener(obj);

contenedor.add(botonSimple);botonElegante.setRolloverIcon(imagen2);contenedor.add(botonElegante);


}}


EventosDemoBoton.java

import java.awt.*;import java.awt.event.*;import javax.swing.*;public class EventosDemoBoton implements ActionListener{

private JButton botonSimple, botonElegante;

EventosDemoBoton(JButton botonSimple, JButton botonElegante){

this.botonSimple=botonSimple;this.botonElegante=botonElegante;

}public void actionPerformed(ActionEvent evento){

JOptionPane.showMessageDialog(null,"Se oprimio: "+evento.getActionCommand());}

}

PruebaDemoBoton.java

import javax.swing.*;public class PruebaDemoBoton{


GuiDemoBoton obj = new GuiDemoBoton();obj.ejecutar();obj.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

}}

Salida:


6.3. CheckBox y RadioButton

Ejemplo1

GuiDemoCasillaVerificacion.java

import java.awt.*;import java.awt.event.*;import javax.swing.*;public class GuiDemoCasillaVerificacion extends JFrame{

private JTextField campo;private JCheckBox negrita,cursiva;

GuiDemoCasillaVerificacion(){

super("Prueba de Checkbox");

campo=new JTextField("Observe el cambio en el estilo de tipo de letra",25);campo.setFont(new Font("Serif",Font.PLAIN,14));negrita=new JCheckBox("Negrita");cursiva=new JCheckBox("Cursiva");

}void ejecutar(){


EventosDemoCasillaVerificacion obj=new EventosDemoCasillaVerificacion(negrita, cursiva,campo);

negrita.addItemListener(obj);cursiva.addItemListener(obj);

contenedor.add(campo);contenedor.add(negrita);contenedor.add(cursiva);


}}

EventosDemoCasillaVerificacion.java

import java.awt.*;import java.awt.event.*;import javax.swing.*;public class EventosDemoCasillaVerificacion implements ItemListener{

private int valNegrita=Font.PLAIN;private int valCursiva=Font.PLAIN;


private JTextField campo;private JCheckBox negrita,cursiva;

EventosDemoCasillaVerificacion(JCheckBox negrita,JCheckBox cursiva,JTextField campo){

this.negrita=negrita;this.cursiva=cursiva;this.campo=campo;

}public void itemStateChanged(ItemEvent evento){

if(evento.getSource()==negrita)valNegrita=negrita.isSelected() ? Font.BOLD : Font.PLAIN;

if(evento.getSource()==cursiva)valCursiva=cursiva.isSelected() ? Font.ITALIC : Font.PLAIN;

campo.setFont(new Font("Serif",valNegrita+valCursiva,14));}

}

PruebaDemoCasillaVerificacion.java

import javax.swing.*;public class PruebaDemoCasillaVerificacion{


GuiDemoCasillaVerificacion obj = new GuiDemoCasillaVerificacion();obj.ejecutar();obj.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

}}

Salida:


Ejemplo 2

DemoBotonOpcion.java

import java.awt.*;import java.awt.event.*;import javax.swing.*;

public class DemoBotonOpcion extends JFrame { private JTextField campo; private Font tipoLetraSimple, tipoLetraNegrita, tipoLetraCursiva, tipoLetraNegritaCursiva; private JRadioButton botonSimple, botonNegrita, botonCursiva, botonNegritaCursiva; private ButtonGroup grupoBotonesOpcion;

public DemoBotonOpcion() { super( "Prueba de RadioButton" );

Container contenedor = getContentPane(); contenedor.setLayout( new FlowLayout() ); campo = new JTextField( "Observe cómo cambia el estilo del tipo de letra", 30 ); botonSimple = new JRadioButton( "Simple", true ); botonNegrita = new JRadioButton( "Negrita", false ); botonCursiva = new JRadioButton( "Cursiva", false ); botonNegritaCursiva = new JRadioButton( "Negrita/Cursiva", false ); contenedor.add( campo ); contenedor.add( botonSimple ); contenedor.add( botonNegrita ); contenedor.add( botonCursiva ); contenedor.add( botonNegritaCursiva );

grupoBotonesOpcion = new ButtonGroup(); grupoBotonesOpcion.add( botonSimple ); grupoBotonesOpcion.add( botonNegrita ); grupoBotonesOpcion.add( botonCursiva ); grupoBotonesOpcion.add( botonNegritaCursiva );

tipoLetraSimple = new Font( "Serif", Font.PLAIN, 14 ); tipoLetraNegrita = new Font( "Serif", Font.BOLD, 14 ); tipoLetraCursiva = new Font( "Serif", Font.ITALIC, 14 ); tipoLetraNegritaCursiva = new Font( "Serif", Font.BOLD + Font.ITALIC, 14 ); campo.setFont( tipoLetraSimple ); // establecer tipo de letra inicial botonSimple.addItemListener( new ManejadorBotonOpcion( tipoLetraSimple ) ); botonNegrita.addItemListener( new ManejadorBotonOpcion( tipoLetraNegrita ) ); botonCursiva.addItemListener( new ManejadorBotonOpcion( tipoLetraCursiva ) ); botonNegritaCursiva.addItemListener(new ManejadorBotonOpcion( tipoLetraNegritaCursiva ) );

setSize( 350, 100 );


setVisible( true );

}

// clase interna privada para manejar eventos de botón de opción private class ManejadorBotonOpcion implements ItemListener

{ private Font tipoDeLetra;

public ManejadorBotonOpcion( Font f ) { tipoDeLetra = f; } public void itemStateChanged( ItemEvent evento ) { campo.setFont( tipoDeLetra ); } } }

PruebaBotonOpcion.java

import javax.swing.*;class PruebaBotonOpcion{ public static void main( String args[] ) { DemoBotonOpcion aplicacion = new DemoBotonOpcion(); aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); } }

Salida:


6.4. JComboBox implementado con una clase interna anónima

DemoCuadroComb.java


public class DemoCuadroComb extends JFrame { private JComboBox cuadroCombImagenes; private JLabel etiqueta;

private String nombres[] = { "Imagen1.gif", "Imagen2.gif", "Imagen3.gif", "Imagen4.gif" }; private Icon iconos[] = { new ImageIcon( nombres[ 0 ] ),new ImageIcon( nombres[ 1 ] ), new ImageIcon( nombres[ 2 ] ),new ImageIcon( nombres[ 3 ] ) };

public DemoCuadroComb() { super( "Prueba de JComboBox" ); // obtener panel de contenido y establecer su esquema Container contenedor = getContentPane(); contenedor.setLayout( new FlowLayout() );

// establecer objeto JComboBox y registrar su manejador de eventos con una clase interna anónima

cuadroCombImagenes = new JComboBox( nombres ); cuadroCombImagenes.setMaximumRowCount( 3 );

cuadroCombImagenes.addItemListener(new ItemListener() {

public void itemStateChanged( ItemEvent evento ) { // determinar si la casilla de verificación está

seleccionada if ( evento.getStateChange() ==

ItemEvent.SELECTED )

etiqueta.setIcon( iconos[cuadroCombImagenes.getSelectedIndex() ] ); }

} // fin de la clase interna anónima

); // fin de la llamada a addItemListener

contenedor.add( cuadroCombImagenes );

// establecer objeto JLabel para mostrar objetos ImageIcon etiqueta = new JLabel( iconos[ 0 ] ); contenedor.add( etiqueta );


setSize( 350, 150 ); setVisible( true ); } }

PruebaCuadroComb.java

import javax.swing.*;class PruebaCuadroComb{public static void main( String args[] ) { DemoCuadroComb aplicacion = new DemoCuadroComb(); aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); }}

Salida:


6.5. Jlist

Ejemplo 1

DemoList.java

import java.awt.*;import javax.swing.*;import javax.swing.event.*;

public class DemoList extends JFrame { private JList listaColores; private Container contenedor; private final String nombresColores[] = { "Negro", "Azul", "Cyan", "Gris oscuro", "Gris", "Verde", "Gris claro",

"Magenta", "Naranja", "Rosa", "Rojo", "Blanco", "Amarillo" };

private final Color colores[] = { Color.BLACK, Color.BLUE, Color.CYAN, Color.DARK_GRAY, Color.GRAY, Color.GREEN, Color.LIGHT_GRAY, Color.MAGENTA, Color.ORANGE, Color.PINK, Color.RED, Color.WHITE,Color.YELLOW }; public DemoList() { super( "Prueba de JList" );

contenedor = getContentPane(); contenedor.setLayout( new FlowLayout() );

// crear una lista con elementos del arreglo nombresColores listaColores = new JList( nombresColores ); listaColores.setVisibleRowCount( 5 ); // no permitir selecciones múltiples listaColores.setSelectionMode( ListSelectionModel.SINGLE_SELECTION );

//contenedor.add(listaColores); esto genera la salida 1 sin el JScrollPane

// esto genera la salida 2 //agregar un objeto JScrollPane, que contiene a JList, al panel de contenido

contenedor.add( new JScrollPane( listaColores ) );

listaColores.addListSelectionListener(new ListSelectionListener() {

public void valueChanged( ListSelectionEvent evento ) {

contenedor.setBackground(colores[ listaColores.getSelectedIndex() ] );


}

} // fin de la clase interna anónima ); // fin de la llamada a addListSelectionListener setSize( 350, 350 ); setVisible( true ); } }

PruebaList.java

import javax.swing.*;class PruebaList{public static void main( String args[] ) { DemoList aplicacion = new DemoList(); aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); }}

Salida 1 sin agregar el JScrollPane

Salida 2 agregando el JScrollPane


Ejemplo 2

DemoSeleccionMultiple.java

import java.awt.*;import java.awt.event.*;import javax.swing.*;public class DemoSeleccionMultiple extends JFrame { private JList listaColores, listaCopia; private JButton botonCopiar; private final String nombresColores[] = { "Negro", "Azul", "Cyan", "Gris oscuro", "Gris", "Verde", "Gris claro", "Magenta", "Naranja", "Rosa", "Rojo", "Blanco", "Amarillo" };

public DemoSeleccionMultiple() { super( "Listas de selección múltiple" );

Container contenedor = getContentPane(); contenedor.setLayout( new FlowLayout() );

// establecer objeto JList listaColores listaColores = new JList( nombresColores ); listaColores.setVisibleRowCount( 5 ); listaColores.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION ); contenedor.add( new JScrollPane( listaColores ) );

botonCopiar = new JButton( "Copiar >>>" ); contenedor.add( botonCopiar );

// establecer objeto JList listaCopia listaCopia = new JList( ); listaCopia.setVisibleRowCount( 5 ); listaCopia.setFixedCellWidth( 100 ); listaCopia.setFixedCellHeight( 15 ); listaCopia.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION ); contenedor.add( new JScrollPane( listaCopia ) );

botonCopiar.addActionListener(new ActionListener() {

public void actionPerformed( ActionEvent evento ) { // colocar valores seleccionados en listaCopia

listaCopia.setListData( listaColores.getSelectedValues() ); }

} // fin de clase interna anónima

); // fin de la llamada a addActionListener


setSize( 325, 130 ); setVisible( true ); } }

PruebaSeleccionMultiple.java

import javax.swing.*;

class PruebaSeleccionMultiple{public static void main( String args[] ) { DemoSeleccionMultiple aplicacion = new DemoSeleccionMultiple(); aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); }}

Salida:

Comentarios: El método setSelectionMode de JList esepcifica el modo de selección de la lista. La clase

ListSelectionModel (del paquete javax.swing) declara tres constantes que especifican el modo de selección de un objeto JList:

o SINGLE_SELECTION permite seleccionar solamente un elemento en un momento dado.

o SINGLE_SELECTION es para una lista de selección múltiple y permite la selección de varios elementos contiguos

o MULTIPLE_INTERVAL_SELECTION es para una lista de selección múltiple que no restringe el número de elementos que pueden seleccionarse.


6.6. Eventos del Mouse

Ejemplo 1

EventoMouse.java


public class EventosMouse extends JFrame implements MouseListener, MouseMotionListener {

private JLabel barraEstado;

// configurar GUI y registrar manejadores de eventos de Mouse public EventosMouse() { super( "Demostración de los eventos de Mouse" );

barraEstado = new JLabel(); getContentPane().add( barraEstado, BorderLayout.SOUTH ); addMouseListener( this ); // escucha sus propios eventos de Mouse addMouseMotionListener( this ); // y de movimiento de Mouse

setSize( 300, 125 ); setVisible( true ); }

// Manejadores de eventos de MouseListener // manejar el evento cuando el botón del Mouse se suelta inmediatamente después de oprimir public void mouseClicked( MouseEvent evento ) { barraEstado.setText( "Se hizo clic en [" + evento.getX() + ", " + evento.getY() + "]" ); }

// manejar evento cuando se oprime el botón del Mouse public void mousePressed( MouseEvent evento ) { barraEstado.setText( "Se oprimió en [" + evento.getX() + ", " + evento.getY() + "]" ); }

// manejar evento cuando se suelta el Mouse después de arrastrar public void mouseReleased( MouseEvent evento ) { barraEstado.setText( "Se soltó en [" + evento.getX() + ", " + evento.getY() + "]" ); }


// manejar el evento cuando el Mouse entra al área public void mouseEntered( MouseEvent evento ) { barraEstado.setText( "Mouse entro en [" + evento.getX() + ", " + evento.getY() + "]" ); getContentPane().setBackground( Color.GREEN ); }

// manejar evento cuando el Mouse sale del área public void mouseExited( MouseEvent evento ) { barraEstado.setText( "Mouse fuera de la ventana" ); getContentPane().setBackground( Color.WHITE ); }

// Manejadores de eventos de MouseMotionListener // manejar el evento cuando el usuario arrastra el Mouse con el botón oprimido public void mouseDragged( MouseEvent evento ) { barraEstado.setText( "Se arrastró en [" + evento.getX() + ", " + evento.getY() + "]" ); }

// manejar el evento cuando el usuario mueve el Mouse public void mouseMoved( MouseEvent evento ) { barraEstado.setText( "Se movió en [" + evento.getX() + ", " + evento.getY() + "]" ); } }

PruebaEventosMouse.java

import javax.swing.*;class PruebaEventosMouse{public static void main( String args[] ) { EventosMouse aplicacion = new EventosMouse(); aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); }}

Salida:

Ejemplo 2. Uso de una clase adaptadora

DemoPintor.java



public class DemoPintor extends JFrame { private int cuentaPuntos = 0;

// arreglo de 1000 referencias a java.awt.Point private Point puntos[] = new Point[ 1000 ];

// configurar GUI y registrar manejador de eventos de ratón public DemoPintor() { super( "Un programa simple de dibujo" );

// crear una etiqueta y colocarla en la parte SOUTH del esquema BorderLayout getContentPane().add( new JLabel( "Arrastre el ratón para dibujar" ),BorderLayout.SOUTH );

addMouseMotionListener(new MouseMotionAdapter() {

// almacenar coordenadas de arrastre y llamar a repaint public void mouseDragged( MouseEvent evento )

{ if ( cuentaPuntos < puntos.length )

{ puntos[ cuentaPuntos ] = evento.getPoint(); ++cuentaPuntos; repaint();

} }


); // fin de la llamada a addMouseMotionListener

setSize( 300, 150 ); setVisible( true );

} // fin del constructor de DemoPintor

// dibujar óvalo en un cuadro delimitador de 4 por 4 en ubicación especificada en ventana public void paint( Graphics g ) { super.paint( g ); // borra el área de dibujo

for ( int i = 0; i < puntos.length && puntos[ i ] != null; i++ ) g.fillOval( puntos[ i ].x, puntos[ i ].y, 4, 4 ); }

} // fin de la clase DemoPintor

PruebaPintor.java

import javax.swing.*;class PruebaPintor{public static void main( String args[] )


{ DemoPintor aplicacion = new DemoPintor(); aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); }}

Salida:

Comentarios Clases adaptadoras de eventos y las interfaces que implementan en el paquete java.awt.event

Clase adaptadora de eventos Implementa a la interfazComponentAdapter ComponentListenerContainerAdapter ContainerListenerFocusAdapter FocusListenerKeyAdapter KeyListenerMouseAdapter MouseListenerMouseMotionAdapter MouseMotionListener WindowAdapter WindowListener

El programador puede extender la clase adaptadora para heredar la implementación predeterminada de cada método y, por ende, sobrescribir el (los) método(s) necesario(s) para el manejo de eventos. La implementación de cada método en la clase adaptadora tiene un cuerpo vacío.

En este ejemplo se utiliza un arreglo de 1000 objetos java.awt.Point para almacenar la ubicación en la que ocurre cada evento del arrastre del Mouse. Esto permite al método Saint dibujar un pequeño óvalo en cada ubicación almacenada en el arreglo.

Cuando se invoca un método utilizando sólo su nombre, en realidad se invoca mediante la referencia this, indicando que ese método es llamado para la instancia actual de la clase en tiempo de ejecución.

La línea:

if ( cuentaPuntos < puntos.length )

se asegura que se almacenen lascoordenadas del evento solamente si hay elementos vacíos en el arreglo de ser así la línea:

puntos[ cuentaPuntos ] = evento.getPoint();

invoca al método getPoint() del objeto MouseEvent para obtener el objeto Point en donde ocurrió el evento y lo guarda en el arreglo, en el índice cuentaPuntos.En la línea:

++cuentaPuntos;

Se incrementa la cuentaPuntos y después se hace una llamada a repaint para empezar a dibujar.


Se observa que paint itera a través de todos los objetos Point en el arreglo y dibuja un óvalo en cada ubicación. La clase Point tiene dos variables de instancia públicas (x y y) que se utilizan directamente en la línea:

g.fillOval( puntos[ i ].x, puntos[ i ].y, 4, 4 );

para especificar la esquina superior izquierda del cuadro delimitador del óvalo. El ciclo termina, ya sea cuando se encuentra una referencia null en el arreglo o cuando se llega al final del mismo.

Ejemplo 3. Demostración de los clics del mouse y de cómo se diferencian los botones del mouse

DetallesMouse.java


public class DetallesMouse extends JFrame { private int xPos, yPos;

// establecer cadena barra título; registrar escucha ratón; ajustar tamaño y mostrar ventana public DetallesMouse() { super( "Clics y botones del ratón" );

addMouseListener( new ManejadorClicsRaton() );

setSize( 350, 150 ); setVisible( true ); }

// dibujar objeto String en la ubicación donde se hizo clic con el ratón public void paint( Graphics g ) { // llamar al método paint de la superclase super.paint( g );

g.drawString( "Se hizo clic en: [" + xPos + ", " + yPos + "]", xPos, yPos ); }

// clase interna para manejar eventos de ratón private class ManejadorClicsRaton extends MouseAdapter

{

// manejar evento de clic del ratón y determinar cuál botón se oprimió public void mouseClicked( MouseEvent evento ) { xPos = evento.getX(); yPos = evento.getY();

String titulo = "Se hizo clic " + evento.getClickCount() + " Veces";


if ( evento.isMetaDown() ) // botón derecho del ratón titulo += " con el botón derecho del ratón"; else if ( evento.isAltDown() ) // botón de en medio del ratón titulo += " con el botón central del ratón"; else // botón izquierdo del ratón titulo += " con el botón izquierdo del ratón";

setTitle( titulo ); // establecer barra de título de la ventana repaint();

} // fin del método mouseClicked

} // fin de la clase interna privada ManejadorClicsRaton

} // fin de la clase DetallesMouse

PruebaDetallesMouse.java

import javax.swing.*;class PruebaDetallesMouse{public static void main( String args[] ) { DetallesMouse aplicacion = new DetallesMouse(); aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); }}

Salida:

Comentarios: La clase MouseEvent hereda varios métodos de la clase InputEvent, los cuales pueden diferenciar

entre los botones del mouse. Tal como lo describe la siguiente tabla:

Método de InputEvent DescripciónisMetaDown() Devuelve true cuando el usuario hace clic con el botón derecho del mouse, en un

mouse con dos o tres botones. Para simular un clic con el botón derecho en un mouse con un botón, el usuario puede mantener presionada la tecla Meta y hacer clic en el botón del mouse.

isAltDown() Devuelve true cuando el usuario hace clic con el botón de en medio del mouse, en un mouse con dos o tres botones. Para simular un clic con el botón de en medio en un mouse con un botón, el usuario puede mantener presionada la tecla Alt y hacer


clic en el botón del mouse, o el botón izquierdo del mouse, respectivamente.

6.7. Manejo de eventos de teclas

DemoTeclas.java


public class DemoTeclas extends JFrame implements KeyListener { private String linea1 = "", linea2 = "", linea3 = ""; private JTextArea areaTexto;

// configurar GUI public DemoTeclas() { super( "Demostración de eventos de pulsación de tecla" );

// establecer objeto JTextArea areaTexto = new JTextArea( 10, 15 ); areaTexto.setText( "Oprima cualquier tecla en el teclado..." ); areaTexto.setEnabled( false ); areaTexto.setDisabledTextColor( Color.BLACK ); getContentPane().add( areaTexto );

addKeyListener( this ); // permitir al marco procesar eventos de teclas setSize( 350, 100 ); setVisible( true );

} // fin del constructor de DemoTeclas

// manejar evento de pulsación de cualquier tecla public void keyPressed( KeyEvent evento ) { linea1 = "Se oprimió tecla: " + evento.getKeyText( evento.getKeyCode() ); establecerLineas2y3( evento ); }

// manejar evento de liberación de cualquier tecla public void keyReleased( KeyEvent evento ) { linea1 = "Se soltó tecla: " + evento.getKeyText( evento.getKeyCode() );


establecerLineas2y3( evento ); }

// manejar evento de pulsación de una tecla de acción public void keyTyped( KeyEvent evento ) { linea1 = "Se escribió tecla: " + evento.getKeyChar(); establecerLineas2y3( evento ); }

// establecer segunda y tercera líneas de salida private void establecerLineas2y3( KeyEvent evento ) { linea2 = "Esta tecla " + ( evento.isActionKey() ? "" : "no " ) + "es una tecla de acción";

String temp = evento.getKeyModifiersText( evento.getModifiers() );

linea3 = "Teclas modificadoras oprimidas: " + ( temp.equals( "" ) ? "ninguna" : temp );

areaTexto.setText( linea1 + "\n" + linea2 + "\n" + linea3 + "\n" ); }

} // fin de la clase DemoTeclas

PruebaDemoTeclas.java

import javax.swing.*;class PruebaDemoTeclas{public static void main( String args[] ) { DemoTeclas aplicacion = new DemoTeclas(); aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); }}

Salida:

Comentarios: Una clase que implementa a KeyListener debe proporcionar declaraciones para los métodos

keyPressed, keyReleased y keyTyped, cada uno de los cuales recibe un objeto KeyEvent como argumento.

La clase KeyEvent es una subclase de InputEvent. El método keyPressed es llamado en respuesta a la acción de oprimir cualquier tecla.


El método keyTyped es llamado en respuesta a la acción de oprimir una tecla que no sea una tecla de acción. (las teclas de acción son cualquier tecla de dirección: Inicio, Fin, Re Pág, Av Pág, cualquier tecla de función: loq Num, Impr Pant, loq Despl, Bloq Mayús y Pausa).

El método keyReleased es llamado cuando la tecla se suelta despúes de un evento keyPressed o keyTyped.

Los métodos keyPressed y keyReleased utilizan el método getKeyCode de KeyEvent para obtener el código de tecla virtual de la tecla oprimida.

La clase Keyvent mantiene un conjunto de constantes (las constantes de código de tecla virtual) que representan a todas las teclas en el teclado. Estas constantes pueden compararse con el valor de retorno de getKeyCode para probar teclas individuales del teclado. El valor devuelto por getKeyCode se pasa al método getKeyText de KeyEvent, el cual devuelve una cadena que contiene el nombre de la tecla que se oprimió.

El método isActionKey de KeyEvent determina si la tecla en el evento fue una tecla de acción. Además hace una llamada al método getModifiers de InputEvent para determinar si se oprimió alguna tecla modificadora como Mayús, Alt y Ctrl, cuando ocurrió el evento de tecla. El resultado de este método se pasa al método getKeyModifiersText de KeyEvent, el cual produce una cadena que contiene los nombres de las teclas que se oprimieron.

6.8. JTextArea

DemoAreaTexto.java


public class DemoAreaTexto extends JFrame { private JTextArea areaTexto1, areaTexto2; private JButton botonCopiar;

// configurar GUI public DemoAreaTexto() { super( "Demostración de JTextArea" );

Box cuadro = Box.createHorizontalBox();

String cadena = "Ésta es una cadena de\ndemostración para\n ilustrar cómo copiar texto\nde un área de texto a \n" + "otra, utilizando un\nevento externo\n";

// establecer areaTexto1 areaTexto1 = new JTextArea( cadena, 10, 15 ); cuadro.add( new JScrollPane( areaTexto1 ) );

// establecer botonCopiar botonCopiar = new JButton( "Copiar >>>" ); cuadro.add( botonCopiar ); botonCopiar.addActionListener(new ActionListener()

{ // establecer en areaTexto2 el texto seleccionado de areaTexto1 public void actionPerformed( ActionEvent evento )

{


areaTexto2.setText( areaTexto1.getSelectedText() ); }



// establecer areaTexto2 areaTexto2 = new JTextArea( 10, 15 ); areaTexto2.setEditable( false ); cuadro.add( new JScrollPane( areaTexto2 ) );

// agregar cuadro al panel de contenido Container contenedor = getContentPane(); contenedor.add( cuadro ); // colocar en in BorderLayout.CENTER

setSize( 425, 200 ); setVisible( true ); } // fin del constructor de DemoAreaTexto} // fin de la clase DemoAreaTexto

PruebaDemoAreaTexto.java

import javax.swing.*;class PruebaDemoAreaTexto{public static void main( String args[] ) { DemoAreaTexto aplicacion = new DemoAreaTexto(); aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); }}

Salida:

Comentarios: La clase Box es una subclase de Container que utiliza un administrador de esquemas BoxLayout para

ordenar los componentes de la GUI, ya sea en forma horizontal o vertical. La clase Box proporciona el método estático createHorizontalBox para crear un objeto Box que acomode los componentes de izquierda a derecha en que éstos se adjunten.

De manera predeterminada JScrollPane muestra barras de desplazamiento solamente si se requieren. Se puede establecer las políticas de barra de desplazamiento horizontal y vertical para el objeto JscrollPane al momento de su creación. Si un programa tiene una referencia a un objeto JscrollPane, el programa puede utilizar los métodos setHorizontalScrollBarPolicy y setVerticalScrollBarPolicy de JscrollPane para cambiar las políticas de barra de desplazamiento en cualquier momento. La clase JscrollPane declara las constantes:


JscrollPane.VERTICAL_SCROLLBAR_ALWAYSJscrollPane.HORIZONTALL_SCROLLBAR_ALWAYS. Para indicar que siempre debe aparecer la barra de desplazamiento.

Las constantes:

JscrollPane.VERTICAL_SCROLLBAR_AS_NEEDEDJscrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED. Indican que debe aparecer la barra de desplazamiento sólo si es necesario (los valores predeterminados).

Las constantes:

JscrollPane.VERTICAL_SCROLLBAR_NEVERJscrollPane.HORIZONTAL_SCROLLBAR_NEVER. Indican que nunca debe aparecer una barra de desplazamiento.

6.9. Panel personalizado

PanelPersonalizado.java

import java.awt.*;import javax.swing.*;

public class PanelPersonalizado extends JPanel { public final static int CIRCULO = 1, CUADRADO = 2; private int figura;

// usar figura para dibujar un óvalo o rectángulo public void paintComponent( Graphics g ) { super.paintComponent( g );

if ( figura == CIRCULO ) g.fillOval( 50, 10, 60, 60 ); else if ( figura == CUADRADO ) g.fillRect( 50, 10, 60, 60 ); }

// establecer valor de figura y repintar PanelPersonalizado public void dibujar( int figuraADibujar ) { figura = figuraADibujar; repaint(); }} // fin de la clase PanelPersonalizado

PruebaPanelPersonalizado.java


public class PruebaPanelPersonalizado extends JFrame {


private JPanel panelBotones; private PanelPersonalizado miPanel; private JButton botonCirculo, botonCuadrado;

// configurar GUI public PruebaPanelPersonalizado() { super( "Prueba de PanelPersonalizado" );

// crear área personalizada de dibujo miPanel = new PanelPersonalizado(); miPanel.setBackground( Color.GREEN );

// establecer botonCuadrado botonCuadrado = new JButton( "Cuadrado" ); botonCuadrado.addActionListener(new ActionListener()

{ // dibujar un cuadrado public void actionPerformed( ActionEvent evento ) {

miPanel.dibujar( PanelPersonalizado.CUADRADO ); }



botonCirculo = new JButton( "Círculo" );

botonCirculo.addActionListener(new ActionListener() {

// dibujar un círculo public void actionPerformed( ActionEvent evento ) { miPanel.dibujar( PanelPersonalizado.CIRCULO ); }

} // fin de la clase interna anónima ); // fin de la llamada a addActionListener

// establecer panel con botones panelBotones = new JPanel(); panelBotones.setLayout( new GridLayout( 1, 2 ) ); panelBotones.add( botonCirculo ); panelBotones.add( botonCuadrado );

// adjuntar panel de botones y área personalizada de dibujo al panel de contenido Container contenedor = getContentPane(); contenedor.add( miPanel, BorderLayout.CENTER ); contenedor.add( panelBotones, BorderLayout.SOUTH );


} // fin del constructor PruebaPanelPersonalizado


public static void main( String args[] ) { PruebaPanelPersonalizado aplicacion = new PruebaPanelPersonalizado(); aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); }} // fin de la clase PruebaPanelPersonalizado

Salida:

6.10. Menús

La clase JMenuBar (una subclase de JComponent) contiene los métodos necesarios para dministrar una barra de menús, la cual es un contenedor para los menús. La clase JMenu (una subclase de javax.swing.JMenuItem) contiene los métodos necesarios para administrar menús. Los menús contienen elementos de menú y pueden agregarsea barras de menús o a otros menús, como submenús. Cuando se hace clic en un menú, éste se expande para mostrar su lista de elementos de menú.La clase JMenuItem (una subclase de javax.swing.AbstractButton) contiene los métodos necesarios para administrar elementos de menú. Un elemento de menú es un componente de la GUI que está dentro de un menú y que, cuando se selecciona, produce un evento de acción. Un elemento de menú puede usarse para iniciar una acción, o puede ser un submenú que proporcione más elementos de menú que el usuario pueda seleccionar.La clase JCheckBoxItem (una subclase de javax.swing.JMenuItem), contiene los métodos necesarios para administrar los elementos de menú que pueden activarse o desactivarse. Cuando se selecciona un objeto JCheckBoxItem, aparece una marca de verificación a la izquierda del elemento de menú. Cuando se selecciona de nuevo el mismo objeto, se quita la marca de verificación a la izquierda del elemento de menú.La clase JRadioButtonMenuItem (una subclase de javax.swing.JMenuItem) contiene los métodos necesarios para administrar elementos de menú que pueden activarse o desactivarse, de manera parecida a los objetos JCheckBoxItem. Cuando se mantienen varios objetos JRadioButtonMenuItem como parte de un objeto ButtonGroup, sólo puede seleccionarse un elemento en el grupo a la vez. Cuando se selecciona otro objeto se quita el círculo relleno a la izquierda del elemento de menú previamente seleccionado.

PruebaMenu.java


public class PruebaMenu extends JFrame { private final Color valoresColor[] = { Color.black, Color.blue, Color.red, Color.green }; private JRadioButtonMenuItem elementosColor[], tiposLetra[]; private JCheckBoxMenuItem elementosEstilo[]; private JLabel pantallaEtiqueta; private ButtonGroup grupoTiposLetra, grupoColores; private int estilo;


// configurar GUI public PruebaMenu() { super( "Uso de objetos JMenu" );

// establecer menú Archivo y sus elementos de menú JMenu menuArchivo = new JMenu( "Archivo" ); menuArchivo.setMnemonic( 'A' );

// establecer elemento de menú Acerca de... JMenuItem elementoAcerca = new JMenuItem( "Acerca de..." ); elementoAcerca.setMnemonic( 'c' ); menuArchivo.add( elementoAcerca ); elementoAcerca.addActionListener(new ActionListener()

{ // mostrar cuadro de diálogo de mensaje cuando el usuario seleccione Acerca de... public void actionPerformed( ActionEvent evento ) {

JOptionPane.showMessageDialog( PruebaMenu.this,"Éste es un ejemplo\ndel uso de menús","Acerca de", JOptionPane.PLAIN_MESSAGE ); }


); // fin de la llamada a addActionListener // establecer elemento de menú Salir JMenuItem elementoSalir = new JMenuItem( "Salir" ); elementoSalir.setMnemonic( 'S' ); menuArchivo.add( elementoSalir ); elementoSalir.addActionListener(new ActionListener()

{ // terminar la aplicación cuando el usuario haga clic en

elementoSalir public void actionPerformed( ActionEvent evento )

{ System.exit( 0 ); }


// crear barra de menús y adjuntarla a la ventana PruebaMenu JMenuBar barra = new JMenuBar(); setJMenuBar( barra ); barra.add( menuArchivo );

// crear menú Formato, con sus submenús y elementos de menú JMenu menuFormato = new JMenu( "Formato" ); menuFormato.setMnemonic( 'F' );

// crear submenú Color String colores[] = { "Negro", "Azul", "Rojo", "Verde" };

JMenu menuColor = new JMenu( "Color" );


menuColor.setMnemonic( 'C' );

elementosColor = new JRadioButtonMenuItem[ colores.length ]; grupoColores = new ButtonGroup(); ManejadorEventos manejadorEventos = new ManejadorEventos();

// crear elementos de menú tipo botones de opción para el menú Color for ( int cuenta = 0; cuenta < colores.length; cuenta++ )

{ elementosColor[ cuenta ] = new JRadioButtonMenuItem( colores[ cuenta ] );

menuColor.add( elementosColor[ cuenta ] ); grupoColores.add( elementosColor[ cuenta ] );

elementosColor[ cuenta ].addActionListener( manejadorEventos ); }

// seleccionar primer elemento del menú Color elementosColor[ 0 ].setSelected( true );

// agregar el menú Formato a la barra de menús menuFormato.add( menuColor ); menuFormato.addSeparator();

// crear submenú Tipo de letra String nombresTiposLetra[] = { "Serif", "Monospaced", "SansSerif" };

JMenu menuTiposLetra = new JMenu( "Tipo de letra" ); menuTiposLetra.setMnemonic( 'T' );

tiposLetra = new JRadioButtonMenuItem[ nombresTiposLetra.length ]; grupoTiposLetra = new ButtonGroup();

// crear elementos de menú tipo botones de opción para el menú Tipos de letra for ( int cuenta = 0; cuenta < tiposLetra.length; cuenta++ )

{ tiposLetra[ cuenta ] = new JRadioButtonMenuItem( nombresTiposLetra[ cuenta ] );

menuTiposLetra.add( tiposLetra[ cuenta ] ); grupoTiposLetra.add( tiposLetra[ cuenta ] );

tiposLetra[ cuenta ].addActionListener( manejadorEventos ); }

// seleccionar el primer elemento del menú Tipo de letra tiposLetra[ 0 ].setSelected( true );

menuTiposLetra.addSeparator();

// establecer elementos del menú Estilo String nombresEstilo[] = { "Negrita", "Cursiva" };

elementosEstilo = new JCheckBoxMenuItem[ nombresEstilo.length ]; ManejadorEstilo manejadorEstilo = new ManejadorEstilo();

// crear elementos de menú tipo casilla de verificación para el menú Estilo for ( int cuenta = 0; cuenta < nombresEstilo.length; cuenta++ )

{ elementosEstilo[ cuenta ] = new JCheckBoxMenuItem( nombresEstilo[ cuenta ] );

menuTiposLetra.add( elementosEstilo[ cuenta ] );


elementosEstilo[ cuenta ].addItemListener( manejadorEstilo ); }

// colocar menú Tipo de letra en el menú Formato menuFormato.add( menuTiposLetra );

// agregar menú Formato a la barra de menús barra.add( menuFormato ); // establecer etiqueta para mostrar texto pantallaEtiqueta = new JLabel( "Texto de ejemplo", SwingConstants.CENTER ); pantallaEtiqueta.setForeground( valoresColor[ 0 ] ); pantallaEtiqueta.setFont( new Font( "Serif", Font.PLAIN, 72 ) );

getContentPane().setBackground( Color.CYAN ); getContentPane().add( pantallaEtiqueta, BorderLayout.CENTER );


} // fin del constructor

public static void main( String args[] ) { PruebaMenu aplicacion = new PruebaMenu(); aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); }

// clase interna para manejar eventos de acción de los elementos de menú private class ManejadorEventos implements ActionListener {

// procesar selecciones de color y tipo de letra public void actionPerformed( ActionEvent evento ) { // procesar selección de color for ( int cuenta = 0; cuenta < elementosColor.length; cuenta++ ) if ( elementosColor[ cuenta ].isSelected() )

{ pantallaEtiqueta.setForeground( valoresColor[ cuenta ] ); break; } // procesar selección de tipo de letra for ( int cuenta = 0; cuenta < tiposLetra.length; cuenta++ )

if ( evento.getSource() == tiposLetra[ cuenta ] ) {

pantallaEtiqueta.setFont(new Font( tiposLetra[ cuenta ].getText(), estilo, 72 ) ); break; }

repaint();

} // fin del método actionPerformed


} // fin de la clase ManejadorEventos

// clase interna para manejar eventos de los elementos de menú tipo casilla de verificación private class ManejadorEstilo implements ItemListener

{

// procesar selecciones de estilo de tipo de letra public void itemStateChanged( ItemEvent e ) { estilo = 0;

// checar selección de negrita if ( elementosEstilo[ 0 ].isSelected() ) estilo += Font.BOLD;

// checar selección de cursiva if ( elementosEstilo[ 1 ].isSelected() ) estilo += Font.ITALIC;

pantallaEtiqueta.setFont(new Font( pantallaEtiqueta.getFont().getName(), estilo, 72 ) ); repaint(); }

} // fin de la clase ManejadorEstilo

} // fin de la clase PruebaMenu

Comentarios:

En la mayoría de los usos anteriores de showMessageDialog, el primer argumento ha sido null. El propósito del primer argumento es especificar la ventana padre para el cuadro de diálogo. La ventana padre ayuda a determinar en dónde va a mostrarse el cuadro de diálogo. Si la ventana padre se especifica como null, el cuadro de díalogo aparece en el centro de la pantalla. Si la ventana padre se especifica como null, el cuadro de diálogo aparece centrado sobre la ventana padre especificada, en este programa, se especifica la ventana padre con PruebaMenu.this; la referencia this del objeto PruebaMenu. Al utilizar la referencia this en una clase interna, si se especifica la palabra this por sí sola, se hace referencia al objeto de la clase interna. Para hacer referencia a la referencia this del objeto de la clase externa, debe calificar a this con el nombre de la clase externa y un punto.


6.11. JPopupMenu

Muchas de las aplicaciones de computadora de la actualidad proporcionan lo que se conoce como menús contextuales sensibles al contexto. En Swing, tales menús se crean con la clase JpopupMenu (una subclase de Jcomponent). Estos menús proporcionan opciones específicas al componente para el cual se generó el evento de desencadenamiento de menú contextual. En la mayoría de los sistemas, este evento de desencadenamiento ocurre cuando el usuario oprime y suelta el botón derecho del ratón.El eveneto de desencadenamiento del menú contextual es específico para cada plataforma. En la mayoría de las plataformas que utilizan un ratón con varios botones, el evento de desencadenamiento del menú contextual ocurre cuando el usuario hace clic con el botón derecho del ratón en un componente que tiene soporte para un menú contextual.

Ejemplo

DemoContextual.java


public class DemoContextual extends JFrame { private JRadioButtonMenuItem elementos[]; private final Color valoresColor[] = { Color.BLUE, Color.YELLOW, Color.RED }; private JPopupMenu menuContextual;

// configurar GUI public DemoContextual() { super( "Uso de objetos JPopupMenu" );

ManejadorEventos manejador = new ManejadorEventos();

String colores[] = { "Azul", "Amarillo", "Rojo" };

// establecer menú contextual y sus elementos ButtonGroup grupoColores = new ButtonGroup(); menuContextual = new JPopupMenu();


elementos = new JRadioButtonMenuItem[ 3 ];

// construir cada elemento de menú y agregarlo al menú contextual; además // permitir el manejo de eventos para cada elemento de menú for ( int cuenta = 0; cuenta < elementos.length; cuenta++ )

{ elementos[ cuenta ] = new JRadioButtonMenuItem( colores[ cuenta ] );

menuContextual.add( elementos[ cuenta ] ); grupoColores.add( elementos[ cuenta ] );

elementos[ cuenta ].addActionListener( manejador ); }

getContentPane().setBackground( Color.WHITE );

// declarar un objeto MouseListener para la ventana que muestra // un objeto JPopupMenu cuando ocurre el evento de desencadenamiento del menú contextual addMouseListener(new MouseAdapter()

{ // manejar evento de oprimir botón del ratón public void mousePressed( MouseEvent evento ) { checkForTriggerEvent( evento ); }

// manejar evento de soltar el botón del ratón public void mouseReleased( MouseEvent evento ) { checkForTriggerEvent( evento ); }

// determinar si evento debe desencadenar el menú contextual private void checkForTriggerEvent( MouseEvent evento ) { if ( evento.isPopupTrigger() ) menuContextual.show(evento.getComponent(), evento.getX(), evento.getY() ); }


); // fin de la llamada a addMouseListener


} // fin del constructor de PruebaContextual

// clase interna privada para manejar eventos de elemento de menú private class ManejadorEventos implements ActionListener

{

// procesar selecciones de elementos de menú public void actionPerformed( ActionEvent evento ) { // determinar cuál elemento de menú fue seleccionado


for ( int i = 0; i < elementos.length; i++ ) if ( evento.getSource() == elementos[ i ] )

{ getContentPane().setBackground( valoresColor[ i ] ); return; } }

} // fin de la clase interna privada ManejadorEventos

} // fin de la clase PruebaContextual

PruebaContextual.java

import javax.swing.*;class PruebaContextual{public static void main( String args[] ) { DemoContextual aplicacion = new DemoContextual(); aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); }}

Salida:

Comentarios: Los métodos mousePressed y mouseReleased comprueban el evento de desencadenamiento del menú

contextual. Cada método llama al método utilitario privado checkForTriggerEvent para determinar si ocurrió el evento de desencadenamiento del menú contextual.

El método isPopupTrigger de MouseEvent devuelve truesi ocurrió el evento de desencadenamiento del menú contextual. De ser así, el método show de JpopMenu muestra el objeto JpopupMenu. El primer argumento del método showespecifica el componente de origen, cuya posición ayuda a determinar en dónde aparecerá el objeto Jpopupenu en la pantalla. Los últimos dos argumentos son la coordenada x-y en donde debe aparecer el objeto JpopupMenu.


6.12. Apariencia visual

Los componentes de la GUI ligeros de Swing eliminan muchas cuestiones de portabilidad, al proporcionar una funcionalidad uniforme entre plataformas, y al definir una apariencia visual uniforme entre plataformas (a la que se conoce como la apariencia visual metálica). Swing también proporciona la flexibilidad de personalizar la apariencia visual, para que un programa tenga la apariencia visual al estilo Microsoft Windows, al estilo Motif (UNIX) o al estilo Mac.Al ejecutar el siguiente ejemplo la primera ventana muestra la apariencia visual metálica estándar, la segunda ventana de salida muestra la apariencia visual Motif y la tercera ventana muestra la apariencia visual Windows.

DemoAparienciaVisual.java


public class DemoAparienciaVisual extends JFrame { private final String cadenas[] = { "Metal", "Motif", "Windows" }; private UIManager.LookAndFeelInfo apariencias[]; private JRadioButton opcion[]; private ButtonGroup grupo; private JButton boton; private JLabel etiqueta; private JComboBox cuadroCombinado;

// configurar la GUI public DemoAparienciaVisual() { super( "Demo de apariencia visual" );

Container contenedor = getContentPane();

// establecer panel para región NORTH de esquema BorderLayout JPanel panelNorte = new JPanel(); panelNorte.setLayout( new GridLayout( 3, 1, 0, 5 ) );


// establecer etiqueta para panel NORTH etiqueta = new JLabel( "Ésta es la apariencia visual Metal seleccionada", SwingConstants.CENTER ); panelNorte.add( etiqueta );

// establecer botón para panel NORTH boton = new JButton( "JButton" ); panelNorte.add( boton );

// establecer cuadro combinado para panel NORTH cuadroCombinado = new JComboBox( cadenas ); panelNorte.add( cuadroCombinado ); // crear arreglo para botones de opción opcion = new JRadioButton[ cadenas.length ];

// establecer panel para región SOUTH de esquema BorderLayout JPanel panelSur = new JPanel(); panelSur.setLayout( new GridLayout( 1, opcion.length ) );

// establecer botones de opción para panel SOUTH grupo = new ButtonGroup(); ManejadorEventos manejador = new ManejadorEventos();

for ( int cuenta = 0; cuenta < opcion.length; cuenta++ ) {

opcion[ cuenta ] = new JRadioButton( cadenas[ cuenta ] ); opcion[ cuenta ].addItemListener( manejador ); grupo.add( opcion[ cuenta ] ); panelSur.add( opcion[ cuenta ] ); }

// adjuntar paneles NORTH y SOUTH al panel de contenido contenedor.add( panelNorte, BorderLayout.NORTH ); contenedor.add( panelSur, BorderLayout.SOUTH );

// obtener información de la apariencia visual instalada apariencias = UIManager.getInstalledLookAndFeels();


opcion[ 0 ].setSelected( true );

} // fin del constructor de DemoAparienciaVisual

// usar UIManager para cambiar la apariencia visual de la GUI private void cambiarLaAparienciaVisual( int valor ) { // cambiar la apariencia visual try

{ UIManager.setLookAndFeel( apariencias[ valor ].getClassName() );

SwingUtilities.updateComponentTreeUI( this ); }


// procesar problemas al cambiar la apariencia visual catch ( Exception excepcion )

{ excepcion.printStackTrace(); } }

// clase interna privada para manejar eventos de botones de opción private class ManejadorEventos implements ItemListener {

// procesar selección de apariencia visual del usuario public void itemStateChanged( ItemEvent evento ) { for ( int cuenta = 0; cuenta < opcion.length; cuenta++ )

if ( opcion[ cuenta ].isSelected() ) {

etiqueta.setText( "Ésta es la apariencia visual " + cadenas[ cuenta ] + " seleccionada" );

cuadroCombinado.setSelectedIndex( cuenta ); cambiarLaAparienciaVisual( cuenta ); } }

} // fin de la clase interna privada ManejadorEventos

} // fin de la clase DemoAparienciaVisual

PruebaAparienciaVisual.java

import javax.swing.*;class PruebaAparienciaVisual{public static void main( String args[] ) { DemoAparienciaVisual aplicacion = new DemoAparienciaVisual(); aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); }}

Salida:

Comentarios La clase UIManager (paquete javax.swing) contiene la clase anidada LookAndFeelInfo (una clase

public static) que mantiene la información acerca de una apariencia visual.


En la línea:

private UIManager.LookAndFeelInfo apariencias[];

se declara un areglo de tipo UIManager.LookAndFeelInfo.

En la línea:

apariencias = UIManager.getInstalledLookAndFeels();

se usa el método estático getInstalledLookAndFeels() para obtener el arreglo de objetos UIManager.LookAndFeelInfo que describe cada una de las apariencias visuales disponibles en su sistea.

Cada apariencia visual se representa mediante una clase de Java. El método getInstalledLookAndFeels no carga a cada una de esas clases. En vez de ello, proporciona los nombres de las clases de apariencia visual disponibles, de manera que pueda seleccionarse una de ellas. Esto reduce la sobrecargaque se genera al cargar clases adicionales que el programa no va a utilizar.

En la línea:

UIManager.setLookAndFeel( apariencias[ valor ].getClassName() );

Se utliza el método estático setLookAndFeel para cambiar la apariencia visual.

El método getClassName de la clase UIManager.LookAndFeelInfo determina el nombre de la clase de apariencia visual que corresponde al objeto UIManager.LookAndFeelInfo. Si la clase de apariencia visual no se ha cargado ya, se cargará como parte de la llamada a setLookAndFeel.

En la línea:

SwingUtilities.updateComponentTreeUI( this );

Se utiliza el método estático updateComponentTreeUI para cambiar la apariencia visual de todos loscomponentes adjuntos a suargumento.


6.13. Interfaz de múltiples documentos

Muchas de las aplicaciones utilizan una interfaz de múltiples documentos (MDI), es decir, una ventana principal (ventana padre) que contiene otras ventanas (ventanas hijas), para administrar varios documentos abiertos que se procesan en paralelo.

Ejemplo 1:

DemoEscritorio.java


public class DemoEscritorio extends JFrame { private JDesktopPane elEscritorio;

// configurar GUI public DemoEscritorio() { super( "Uso de un objeto JDesktopPane" );

// crear barra de menús, menu y elemento de menú JMenuBar barra = new JMenuBar(); JMenu menuAgregar = new JMenu( "Agregar" ); JMenuItem nuevoMarco = new JMenuItem( "Marco interno" );

menuAgregar.add( nuevoMarco ); barra.add( menuAgregar );

setJMenuBar( barra );

// establecer escritorio elEscritorio = new JDesktopPane(); getContentPane().add( elEscritorio ); // establecer componente de escucha para elemento de menú nuevoMarco


nuevoMarco.addActionListener(new ActionListener() {

// mostrar nueva ventana interna public void actionPerformed( ActionEvent evento )

{ // crear marco interno JInternalFrame marco = new JInternalFrame("Marco

interno", true, true, true, true ); // adjuntar panel al panel de contenido del marco interno Container contenedor = marco.getContentPane(); MiJPanel panel = new MiJPanel(); contenedor.add( panel, BorderLayout.CENTER );

// establecer tamaño de marco interno en el tamaño de su contenido

marco.pack();

// adjuntar marco interno al escritorio y mostrarlo elEscritorio.add( marco ); marco.setVisible( true );

}




} // fin de la clase DemoEscritorio

// clase para mostrar un objeto ImageIcon en un panelclass MiJPanel extends JPanel { private ImageIcon iconoImagen; private String[] imagenes = { "floresamarillas.png", "florespurpura.png","floresrojas.png", "floresrojas2.png", "floreslavanda.png" };

// cargar imagen public MiJPanel() { int numeroAleatorio = ( int ) ( Math.random() * 5 ); iconoImagen = new ImageIcon( imagenes[ numeroAleatorio ] ); }

// mostrar iconoImagen en el panel public void paintComponent( Graphics g ) { // llamar al método paintComponent de la superclase super.paintComponent( g );

// mostrar icono iconoImagen.paintIcon( this, g, 0, 0 );


}

// devolver dimensiones de la imagen public Dimension getPreferredSize() { return new Dimension( iconoImagen.getIconWidth(), iconoImagen.getIconHeight() ); }

} // fin de la clase MiJPanel

PruebaEscritorio.java

import javax.swing.*;class PruebaEscritorio{

public static void main( String args[] ) { DemoEscritorio aplicacion = new DemoEscritorio(); aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); }}

Salida:

Comentarios: En la línea:

elEscritorio = new JDesktopPane();


se asigna la referencia JdesktopPane (paquete javax.swing), que apunta a la variable elEscritorio, a un nuevo objeto JdesktopPane que se utilizará paraadministrar las ventanas hijas JinternalFrame.

En la línea:

getContentPane().add( elEscritorio );

se agrega el objeto al panel de contenido de la ventana de aplicación. De manera predeterminada, el objeto JdesktopPane se agrega al centro del layout BorderLayout del panel de contenido, por lo que el objeto se expande para rellenar toda la ventana de aplicación.

El constructor JinternalFrame requiere cinco argumentos: una cadena para la barra de título de la ventana interna, un valor boolean para indicar si el usuario puede:

o reajustar el tamaño del marco internoo cerrar ,el marco internoo maximizar el marco internoo minimizar el marco interno

Ejemplo 2:

DemoJTabbedPane.java

import java.awt.*;import javax.swing.*;

public class DemoJTabbedPane extends JFrame {

// configurar GUI public DemoJTabbedPane() { super( "Demo de JTabbedPane " );

// crear objeto JTabbedPane JTabbedPane panelConFichas = new JTabbedPane();

// establecer pane11 y agregarlo al objeto JTabbedPane JLabel etiqueta1 = new JLabel( "panel uno", SwingConstants.CENTER ); JPanel panel1 = new JPanel(); panel1.add( etiqueta1 ); panelConFichas.addTab( "Ficha uno", null, panel1, "Primer panel" ); // establecer panel2 y agregarlo al objeto JTabbedPane JLabel etiqueta2 = new JLabel( "panel dos", SwingConstants.CENTER ); JPanel panel2 = new JPanel(); panel2.setBackground( Color.YELLOW ); panel2.add( etiqueta2 ); panelConFichas.addTab( "Ficha dos", null, panel2, "Segundo panel" );

// establecer panel3 y agregarlo al objeto JTabbedPane JLabel etiqueta3 = new JLabel( "panel tres" ); JPanel panel3 = new JPanel(); panel3.setLayout( new BorderLayout() ); panel3.add( new JButton( "Norte" ), BorderLayout.NORTH ); panel3.add( new JButton( "Oeste" ), BorderLayout.WEST ); panel3.add( new JButton( "Este" ), BorderLayout.EAST );


panel3.add( new JButton( "Sur" ), BorderLayout.SOUTH ); panel3.add( etiqueta3, BorderLayout.CENTER ); panelConFichas.addTab( "Ficha tres", null, panel3, "Tercer panel" );

// agregar objeto JTabbedPane al contenedor getContentPane().add( panelConFichas );


} // fin del constructor} // fin de la clase DemoJTabbedPane

PruebaDemoJTabbedPane.java

import javax.swing.*;class PruebaDemoJTabbedPane{

public static void main( String args[] ) { DemoJTabbedPane demoPanelConFichas = new DemoJTabbedPane(); demoPanelConFichas.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); }}

Salida:

Comentarios: Un objeto JtabbedPane ordena los componentes de la GUI en capas, en donde sólo una capa está

visible en un momento dado. Los usuarios acceden a cada una de las capas mediante una ficha. Cuando los usuarios hacen clic en una ficha, se muestra la capa apropiada.

El primer argumento del método addTab es una cadena que especifica el título de la ficha, el segundo es una referencia Icon que especifica un icono a mostrar en la ficha. Si el objeto Icon es una referencia null, no se muestra una imagen. El tercer argumento es una referencia Component que representa el componente de la GUI a mostrar cuando el usuario hace clic en la ficha.


6.14. Administradores de esquemas: BoxLayout y GridBagLayout

Ejemplo 1 BoxLayout

Ordena los componentes de la GUI en forma horizontal a lo largo del eje x, o en forma vertical a lo largo del eje y de un contenedor. La clase Box declara un contenedor con BoxLayout como su administrador de esquemas predeterminado, y proporciona métodos estáticos para crear un objeto Box con un esquema BoxLayout horizontal o vertical.

DemoBoxLayout.java


public class DemoBoxLayout extends JFrame {

// configurar GUI public DemoBoxLayout() { super( "Demo de BoxLayout" );

// crear contenedores Box con esquema BoxLayout Box horizontal1 = Box.createHorizontalBox(); Box vertical1 = Box.createVerticalBox(); Box horizontal2 = Box.createHorizontalBox(); Box vertical2 = Box.createVerticalBox();

final int TAMANIO = 3; // número de botones en cada contenedor Box

// agregar botones al objeto Box horizontal1 for ( int cuenta = 0; cuenta < TAMANIO; cuenta++ ) horizontal1.add( new JButton( "Botón " + cuenta ) );

// crear montante y agregar botones al objeto Box vertical1


for ( int cuenta = 0; cuenta < TAMANIO; cuenta++ ) { vertical1.add( Box.createVerticalStrut( 25 ) ); vertical1.add( new JButton( "Botón " + cuenta ) ); }

// crear pegamento horizontal y agregar botones al objeto Box horizontal2 for ( int cuenta = 0; cuenta < TAMANIO; cuenta++ ) { horizontal2.add( Box.createHorizontalGlue() ); horizontal2.add( new JButton( "Botón " + cuenta ) ); }

// crear área rígida y agregar botones al objeto Box vertical2 for ( int cuenta = 0; cuenta < TAMANIO; cuenta++ ) { vertical2.add( Box.createRigidArea( new Dimension( 12, 8 ) ) ); vertical2.add( new JButton( "Botón " + cuenta ) ); }

// crear pegamento vertical y agregar botones al panel JPanel panel = new JPanel(); panel.setLayout( new BoxLayout( panel, BoxLayout.Y_AXIS ) );

for ( int cuenta = 0; cuenta < TAMANIO; cuenta++ ) { panel.add( Box.createGlue() ); panel.add( new JButton( "Botón " + cuenta ) ); }

// crear un objeto JTabbedPane JTabbedPane fichas = new JTabbedPane( JTabbedPane.TOP, JTabbedPane.SCROLL_TAB_LAYOUT );

// colocar cada contendor en panel con fichas fichas.addTab( "Cuadro horizontal", horizontal1 ); fichas.addTab( "Cuadro vertical con montantes", vertical1 ); fichas.addTab( "Cuadro horizontal con pegamento", horizontal2 ); fichas.addTab( "Cuadro vertical con áreas rígidas", vertical2 ); fichas.addTab( "Cuadro vertical con pegamento", panel );

getContentPane().add( fichas ); // colocar panel con fichas en el panel de contenido



} // fin de la clase DemoBoxLayout

PruebaDemoBoxLayout.java

import javax.swing.*;class PruebaDemoBoxLayout


{public static void main( String args[] ) { DemoBoxLayout aplicacion = new DemoBoxLayout(); aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); }}

Salida:

Comentarios:

En la línea:

vertical1.add( Box.createVerticalStrut( 25 ) );

se agrega un montante vertical al contenedor, mediante el método estático createVerticalStrut. Un montante vertical es un componente de la GUI invisible, el cual tiene una altura fija en píxeles y se utiliza para garantizar una cantidad fija de espacio entre los componentes de la GUI. El argumento determina la altura del montante en píxeles. Cuando se cambia el tamaño del contenedor, la distancia entre los componentes de la GUI que están separados por montantes no cambia. La clase Box también declara el método createHorizontalStrut para esquemas BoxLayout horizontales.

En la línea:

horizontal2.add( Box.createHorizontalGlue() );

se agrega el pegamento horizontal al contenedor, mediante el método estático createHorizontalGlue. El pegamento horizontal es un componente de la GUI invisible que puede usarse entre los componentes de la GUI de tamaño fijo para ocupar el espacio adicional. Generalmente, el espacio adicional aparece a la derecha del último componente de la GUI horizontal, o debajo del último componente de la GUI vertical, en un esquema BoxLayout. El pegamento permite que se agregue espacio adicional entre los componentes de la GUI. Cuando se cambia el tamaño del contenedor, los componentes separados por pegamento conservan el mismo tamaño, pero el pegamento se estira o se contrae para ocupar el espacio entre los demás componentes. La clase Box también declara el método createVerticalGlue para esquemas BoxLayout verticales.

En la línea:

vertical2.add( Box.createRigidArea( new Dimension( 12, 8 ) ) );

se agrega un área rígidaal contenedor, mediante el método estático createRigidArea. Un área rígida es un componente de la GUI invisible, el cual siempre tiene una anchura y altura fija en píxeles, el argumento es un objeto Dimension que especifica la anchura y la altura del área rígida.

En la línea:


panel.add( Box.createGlue() );

se agrega un componente pegamento al contenedor, mediante el método estático createGlue. Este componente se expande o se contrae con base al tamaño del objeto Box.

Ejemplo 2 GridBagLayout

Este esquema es similar a GridLayout, ya que también ordena los componentes en una cuadrícula. Sin embargo, es más flexible. Los componentes pueden variar en tamaño (es decir, pueden ocuapr varias filas y columnas) y pueden agregarse en cualquier orden.

El primer paso es determinar la apariencia de la GUI (esbozo en papel). Primero dibuje la GUI, después dibuje una cuadrícula sobre la GUI, dividiendo los componentes en filas y columnas.

Ejemplo

Un objeto GridBagConstraints describe cómo colocar un componente en un esquema GridBagLayout.

Campo de GridBagConstraints Descripciónfill Ajusta el tamaño del componente en la dirección especificada (NONE,

HORIZONTAL, VERTICAL, BOTH) cuando el área en pantalla es más grande que el componente

gridx La columna en la que se colocará el componentegridy La fila en la que se colocará el componentegridWidth El número de columnas que ocupa el componente


gridheight El número de filas que ocupa el componenteweightx La porción de espacio adicional que se asignará horizontalmente. La

ranura de la cuadrícula puede hacerse más ancha cuando hay espacio adicional disponible

weighty La porción de espacio adicional que se asignará verticalmente. La ranura de la cuadrícula puede hacerse más alta cuando hay espacio adicional disponible

DemoGridBag.java


public class DemoGridBag extends JFrame { private Container contenedor; private GridBagLayout esquema; private GridBagConstraints restricciones; // configurar GUI public DemoGridBag() { super( "GridBagLayout" );

contenedor = getContentPane(); esquema = new GridBagLayout(); contenedor.setLayout( esquema );

// instanciar restricciones de GridBagLayout restricciones = new GridBagConstraints();

// crear componentes de GUI JTextArea areaTexto1 = new JTextArea( "AreaTexto1", 5, 10 ); JTextArea areaTexto2 = new JTextArea( "AreaTexto2", 2, 2 );

String nombres[] = { "Hierro", "Acero", "Cobre" }; JComboBox cuadroCombinado = new JComboBox( nombres );

JTextField campoTexto = new JTextField( "CampoTexto" ); JButton boton1 = new JButton( "Botón 1" ); JButton boton2 = new JButton( "Botón 2" ); JButton boton3 = new JButton( "Botón 3" );

// weightx y weighty para areaTexto1 son 0: el valor predeterminado // anchor para todos los componentes es CENTER: el valor predeterminado restricciones.fill = GridBagConstraints.BOTH; agregarComponente( areaTexto1, 0, 0, 1, 3 ); // weightx y weighty para boton1 son 0: el valor predeterminado restricciones.fill = GridBagConstraints.HORIZONTAL; agregarComponente( boton1, 0, 1, 2, 1 ); // weightx y weighty para cuadroCombinado son 0: el valor predeterminado // fill es HORIZONTAL


agregarComponente( cuadroCombinado, 2, 1, 2, 1 );

// boton2 restricciones.weightx = 1000; // puede hacerse más ancho restricciones.weighty = 1; // puede hacerse más largo restricciones.fill = GridBagConstraints.BOTH; agregarComponente( boton2, 1, 1, 1, 1 ); // fill es BOTH para boton3 restricciones.weightx = 0; restricciones.weighty = 0; agregarComponente( boton3, 1, 2, 1, 1 ); // weightx y weighty para campoTexto son 0, fill es BOTH agregarComponente( campoTexto, 3, 0, 2, 1 );

// weightx y weighty para areaTexto2 son 0, fill es BOTH agregarComponente( areaTexto2, 3, 2, 1, 1 );


} // fin del constructor de DemoGridBag

// método para establecer restricciones private void agregarComponente( Component componente, int fila, int columna, int anchura, int altura ) { // establecer gridx y gridy restricciones.gridx = columna; restricciones.gridy = fila;

// establecer gridwidth y gridheight restricciones.gridwidth = anchura; restricciones.gridheight = altura;

// establecer restricciones y agregar componente esquema.setConstraints( componente, restricciones ); contenedor.add( componente ); }

} // fin de la clase DemoGridBag

PruebaDemoGridBag.java

import javax.swing.*;class PruebaDemoGridBag{public static void main( String args[] ) { DemoGridBag aplicacion = new DemoGridBag(); aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); }}


Salida:

Ejemplo 3 GridBagLayout

DemoGridBag2.java


public class DemoGridBag2 extends JFrame { private GridBagLayout esquema; private GridBagConstraints restricciones; private Container contenedor; // configurar GUI public DemoGridBag2() { super( "GridBagLayout" );

contenedor = getContentPane(); esquema = new GridBagLayout(); contenedor.setLayout( esquema );

// instanciar restricciones de GridBagLayout restricciones = new GridBagConstraints();

// crear componentes de GUI String metales[] = { "Cobre", "Aluminio", "Plata" }; JComboBox cuadroCombinado = new JComboBox( metales );

JTextField campoTexto = new JTextField( "CampoTexto" );

String tiposLetra[] = { "Serif", "Monospaced" }; JList lista = new JList( tiposLetra );

String nombres[] = { "cero", "uno", "dos", "tres", "cuatro" }; JButton botones[] = new JButton[ nombres.length ];

for ( int cuenta = 0; cuenta < botones.length; cuenta++ ) botones[ cuenta ] = new JButton( nombres[ cuenta ] );

// definir restricciones del componente de GUI campoTexto restricciones.weightx = 1; restricciones.weighty = 1; restricciones.fill = GridBagConstraints.BOTH; restricciones.gridwidth = GridBagConstraints.REMAINDER;


agregarComponente( campoTexto );

// botones[0] -- weightx y weighty son 1: fill es BOTH restricciones.gridwidth = 1; agregarComponente( botones[ 0 ] );

// botones[1] -- weightx y weighty son 1: fill es BOTH restricciones.gridwidth = GridBagConstraints.RELATIVE; agregarComponente( botones[ 1 ] );

// botones[2] -- weightx y weighty son 1: fill es BOTH restricciones.gridwidth = GridBagConstraints.REMAINDER; agregarComponente( botones[ 2 ] );

// cuadroCombinado -- weightx es 1: fill es BOTH restricciones.weighty = 0; restricciones.gridwidth = GridBagConstraints.REMAINDER; agregarComponente( cuadroCombinado ); // botones[3] -- weightx es 1: fill es BOTH restricciones.weighty = 1; restricciones.gridwidth = GridBagConstraints.REMAINDER; agregarComponente( botones[ 3 ] );

// botones[4] -- weightx y weighty son 1: fill es BOTH restricciones.gridwidth = GridBagConstraints.RELATIVE; agregarComponente( botones[ 4 ] );

// lista -- weightx y weighty son 1: fill es BOTH restricciones.gridwidth = GridBagConstraints.REMAINDER; agregarComponente( lista );

setSize( 300, 200 ); setVisible( true ); } // fin del constructor

// agregar un componente al contenedor private void agregarComponente( Component componente ) { esquema.setConstraints( componente, restricciones ); contenedor.add( componente ); // agregar componente }

} // fin de la clase DemoGridBag2

PruebaDemoGridBag2.java

import javax.swing.*;class PruebaDemoGridBag2{ public static void main( String args[] ) { DemoGridBag2 aplicacion = new DemoGridBag2();


aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); }

}

Salida:

Comentarios:

Hay una variación de GridBagLayout que no utiliza a las variables gridx y gridy. En vez de estas variables, se utilizan las constantes RELATIVE y REMAINDER de GridBagConstraints.RELATIVE especifica que el penúltimo componente de cierta fila deberá colocarse a la derecha del componente anterior en esa fila. REMAINDER especifica que un componente es el último en una fila. Cualquier componente que no sea el penúltimo o el último en una fila, deberá especificar valores para las variables gridWidth y gridheight.

7. Proyecto Cliente-Servidor

Por último se agrega dos proyectos de una conexión Cliente-Servidor implementado por el alumno: Juan Carlos Cerón Guerrero de la carrera de Ingeniería en Sistemas

Proyecto 1

InterfazGraficaChat.java

////////////////////////// IMPORTANDO PAQUETES /////////////////////////////////import java.net.*;import java.io.*;import java.awt.*;public class InterfazGraficaChat extends Frame implements Runnable { /////////////////////////// DECLARANDO VARIABLES ////////////////////////////// protected DataInputStream i; protected DataOutputStream o; protected MenuBar menuBar1; protected Menu opciones; protected MenuItem salir; protected static TextArea salida; protected static TextArea usuarios;


protected TextField entrada; protected Thread listener; /////////// CONSTRUCTOR CON IMPLEMENTACION IMPLICITA DE GUI ////////////////// public InterfazGraficaChat(String title, InputStream i, OutputStream o) { super (title); this.i = new DataInputStream (new BufferedInputStream (i)); this.o = new DataOutputStream (new BufferedOutputStream (o)); setLayout (new BorderLayout ()); setMenuBar(menuBar1 = new MenuBar()); menuBar1.add(opciones = new Menu("OPCIONES")); opciones.add(salir = new MenuItem("SALIR")); add ("West",usuarios = new TextArea (20,23)); add ("East",salida = new TextArea (20,50)); usuarios.setEditable (false); usuarios.setBackground( Color.yellow) ; salida.setBackground( Color.green) ; salida.setEditable (false); add ("South", entrada = new TextField (30)); usuarios.setText(" USUARIOS CONECTADOS \n --------------------------- \n"); salida.setText( " JUAN CARLOS CERON GUERRERO \n"+ " 2-C ING.SISTEMAS.COMP \n"+ " APLICACION CHAT BASADA EN \n"+" ChatApplet DE MERLIN HUGHES \n"+ " PARA EFECTOS DE ESTUDIO \n--------------------------------------------"+ "\n CONECTANDO CON EL SERVIDOR \n INICIALIZANDO \n CONECTADO"+ " \n BIENBENIDO AL CHAT DE ITSOEH.COM.MX \n ----------------------------"+ "---------------------------------------------------------------------\n"); EventosChat obj = new EventosChat(salir); salir.addActionListener(obj); pack (); show (); entrada.requestFocus (); listener = new Thread (this);///// INSTANCIANDO THREAD-HEBRA-HILO ////////// listener.start ();//////////////// INICIANDO EL THREAD-HEBRA-HILO ////////// } ///////////////////////////////////////////////////////////////////////////// public static void actualizar(String linea) { salida.append(linea); }//InterfazGraficaChat.actualizar(String)// LLAMA AL METODO ESTATICO //QUE ESCRIBE EN EL GUI ///////////////////////////////////////////////////////////////////////////// public static void actualizarUsuarios(String linea1) { usuarios.append(linea1); }//InterfazGraficaChat.actualizarUsuarios(String)/ LLAMA AL METODO ESTATICO //QUE ESCRIBE EN EL GUI ///////////////////////////////////////////////////////////////////////////// ////////////THREAD-HEBRA-HILO//////////////////////////////////////////////// /////SE EJECUTA PARALELO A ESTOS PROCESOS /////////////////////////////////// public void run() { try { while (true) {


String line = i.readUTF(); salida.appendText (line + "\n"); } }

catch (IOException ex) { ex.printStackTrace (); } finally { listener = null; entrada.hide (); validate (); try { o.close (); } catch (IOException ex) { ex.printStackTrace (); } } } public boolean handleEvent (Event e) { if ((e.target == entrada) && (e.id == Event.ACTION_EVENT)) { try { o.writeUTF ((String) e.arg); o.flush (); } catch (IOException ex) { ex.printStackTrace(); listener.stop (); } entrada.setText (""); return true; }/////////// TRATANDO EVENTO DE CIERRE DE VENTANA MEDIANTE HERENCIA //////// else if ((e.target == this) && (e.id == Event.WINDOW_DESTROY)) { System.out.println("HA CERRADO LA VENTANA"); System.out.println("CESION TERMINADA \n FIN DEL PROGRAMA"+ " \n JUAN CARLOS CERON GUERRERO\n"+ " 2-C ING.SISTEMAS COMP."); System.exit(0); if (listener != null) listener.stop ();/////////DETENIENDO EL THREAD-HEBRA-HILO ////////////// hide (); /////////////Y PASANDO A ESTADO MUERTO ///////////////// return true; } return super.handleEvent (e);


}}///////////////////////////// FIN DEL CODIGO //////////////////////////////////

EventosChat.java

////////////////////////// IMPORTANDO PAQUETES /////////////////////////////////import java.net.*;import java.io.*;import java.util.*;import java.awt.event.*;import java.awt.*;public class EventosChat extends Thread implements ActionListener{ //////////////////////// DECLARANDO VARIABLES ///////////////////////////////// protected Socket s; protected DataInputStream i; protected DataOutputStream o; private MenuItem salir; private Frame servidor; //CONSTRUCTOR QUE RECIBE EL #DE SOCKET Y ASIGNA ENTRADA Y SALIDA PARA LOS DATOS public EventosChat(Socket s) throws IOException { this.s = s; i = new DataInputStream (new BufferedInputStream (s.getInputStream ())); o = new DataOutputStream (new BufferedOutputStream (s.getOutputStream ())); } ////// SOBRECARGANDO AL METODO CONSTRUCTOR PARA RECIBIR EL MENU ////////// public EventosChat(MenuItem salir) { this.salir=salir; } ////// IMPLEMENTANDO UNICO METODO DE INTERFAZ ActionListener ///////////////// public void actionPerformed(ActionEvent e) { System.out.println("HA ELEGIDO SALIR"); System.out.println(" SESION FINALIZADA \n FIN DEL PROGRAMA \n "); System.out.println("JUAN CARLOS CERON GUERRERO \n 2-C ING. SISTEMAS"); System.exit(0); } ////////////////////// INICIANDO EL THREAD-HEBRA-HILO ///////////////////////// protected static Vector handlers = new Vector(); public void run () { String name = s.getInetAddress ().toString (); try { broadcast (" EL USUARIO "+name + " HA ENTRADO "); handlers.addElement(this); while (true) { String msg = i.readUTF (); broadcast (name + " - " + msg); InterfazGraficaServidor.actualizar(" EL USUARIO "+name +


"/ HA ENVIADO EL MENSAJE.\n"+msg+"\n");// LLAMANDO AL METODO ESTATICO } // QUE ESCRIBE SOBRE LA SALIDA DEL SERVIDOR// } catch (IOException ex)// RECIBIENDO Y TRATANDO POSIBLE ECEPCION DE //////// { ///// COMUNICACION ENTRE CLIENTE Y SERVIDOR//////////// ex.printStackTrace (); } finally { handlers.removeElement (this);// DETECTANDO SI EL USUARIO FINALIZA /////// broadcast (name + " HA SALIDO ");///////LA APLICACION CLIENTE //////////// InterfazGraficaServidor.actualizar("EL USUARIO "+name +"/ HA SALIDO.\n"); try { s.close (); } catch (IOException ex) { ex.printStackTrace(); } } } protected static void broadcast (String message) { synchronized (handlers) { Enumeration e = handlers.elements (); while (e.hasMoreElements ()) { EventosChat c = (EventosChat) e.nextElement (); try { synchronized (c.o) { c.o.writeUTF (message); } c.o.flush (); } catch (IOException ex) { c.stop ();//DETENIENDO EL THREAD-HEBRA-HILO Y PASANDO A ESTADO MUERTO/ } } } }}///////////////////////////// FIN DEL CODIGO //////////////////////////////////

PruebaChat.java


import java.util.*;import java.net.*;import java.io.*;import java.awt.*;import java.awt.event.*;public class PruebaChat { public static void main (String args[]) throws IOException { System.out.println(" SESION INICIADA "); Socket s = new Socket ("192.10.1.32",4321);//-ESPECIFICAR EL IP DEL HOST new InterfazGraficaChat("PROYECTO (1) UNIDAD 5 SALA DE CHAT " + "127.0.0.1" + ":" +4321,s.getInputStream (), s.getOutputStream ()); InterfazGraficaChat.actualizar("- SESION INICIADA -\n"); InterfazGraficaChat.actualizarUsuarios(s.getInetAddress().toString());//--------- } }

InterfazGraficaServidor.java

import java.awt.*;public class InterfazGraficaServidor{ private Frame ventana; private Panel panel1, panel2; private MenuBar menuBar1; private Menu opciones; private MenuItem salir; private Label label1; private static TextArea consola;

public InterfazGraficaServidor() { ventana = new Frame(" PROYECTO (1) UNIDAD 5: CONSOLA DEL SERVIDOR"); menuBar1 = new MenuBar(); opciones = new Menu("OPCIONES"); salir = new MenuItem(" SALIR "); panel1 = new Panel(); panel2 = new Panel(); label1= new Label(" JUAN CARLOS CERON GUERRERO \n 2-C ING.SISTEMAS COMP.");

consola = new TextArea(25,58); menuBar1.add(opciones);

opciones.add(salir); } void visualizar() { ventana.setBackground( Color.blue ) ; consola.setBackground( Color.green) ; panel1.setBackground( Color.orange ) ; panel2.setBackground( Color.black ) ; panel2.setLayout(new FlowLayout()); label1.setBackground( Color.orange) ;


consola.setEditable(false); consola.append("SERVIDOR DE CHAT - CHAT SENTINEL - V 1.0 \n INICIALIZANDO"+ "... \n ---------------------------------------------------------------\n"+ "EN LINEA \n"); ventana.setMenuBar(menuBar1); panel1.add(label1); panel2.add(consola); ventana.add(panel1,BorderLayout.NORTH); ventana.add(panel2,BorderLayout.SOUTH); EventosServidor obj=new EventosServidor(ventana,salir); ventana.addWindowListener(obj); salir.addActionListener(obj); ventana.setVisible(true);// ventana.setSize(499,570); ventana.pack(); } public static void actualizar(String linea) { consola.append(linea); }//InterfazGraficaServidor.actualizar(String)// LLAMA AL METODO ESTATICO } //QUE ESCRIBE EN EL GUI

EventosServidor.java

import java.net.*;import java.io.*;import java.util.*;import java.awt.*;import java.awt.event.*;public class EventosServidor implements WindowListener, ActionListener{

Frame servidor;MenuItem salir;///////////// CONSTRUCTOR QUE RECIBE LA VENTANA DEL SERVIDOR /////////////// public EventosServidor(Frame servidor, MenuItem salir)

{ this.servidor=servidor; this.salir=salir; } public EventosServidor(int port) throws IOException { ServerSocket server = new ServerSocket(port); while (true) { Socket cliente = server.accept (); System.out.println (" \n EL USUARIO " + cliente.getInetAddress ()+ "/ SE HA CONECTADO "); String linea=(" EL USUARIO " + cliente.getInetAddress ()+ "/ SE HA CONECTADO \n"); String linea1=(""+ cliente.getInetAddress ()+"");//------------- InterfazGraficaServidor.actualizar(linea); System.out.println ("Accepted from " + cliente.getInetAddress ()); EventosChat c = new EventosChat (cliente); c.start ();


} } public void actionPerformed(ActionEvent e) { System.out.println("HA ELEGIDO SALIR"); System.out.println(" SESION FINALIZADA \n FIN DEL PROGRAMA \n "); System.out.println("JUAN CARLOS CERON GUERRERO \n 2-C ING. SISTEMAS"); System.exit(0); } public void windowClosing(WindowEvent e) //--- CERRADO DE VENTANA { System.out.println("HA CERRADO LA VENTANA"); System.out.println(" SESION FINALIZADA \n FIN DEL PROGRAMA \n "); System.out.println("JUAN CARLOS CERON GUERRERO \n 2-C ING. SISTEMAS"); System.exit(0); } public void windowOpened(WindowEvent e) {} public void windowIconified(WindowEvent e) {} public void windowDeiconified(WindowEvent e) {} public void windowClosed(WindowEvent e) {} public void windowActivated(WindowEvent e) {} public void windowDeactivated(WindowEvent e) { } }

PruebaServidor.java

import java.net.*;import java.io.*;import java.util.*;import java.awt.event.*;public class PruebaServidor{ public static void main (String args[]) throws IOException { InterfazGraficaServidor consolaServidor=new InterfazGraficaServidor(); consolaServidor.visualizar(); InterfazGraficaServidor.actualizar("EN ESPERA DE USUARIOS \n"); System.out.println(" EN ESPERA DE USUARIOS "); new EventosServidor(4321); } }

Proyecto 2


InterfazGraficaServidor.java

import java.awt.*;public class InterfazGraficaServidor{ private Frame ventana; private Panel panel1, panel2; private MenuBar menuBar1; private Menu opciones; private MenuItem salir; private Label label1; private static TextArea consola;

public InterfazGraficaServidor() { ventana = new Frame(" PROYECTO (3) UNIDAD 7: CONSOLA DEL SERVIDOR"); menuBar1 = new MenuBar(); opciones = new Menu("OPCIONES"); salir = new MenuItem(" SALIR "); panel1 = new Panel(); panel2 = new Panel(); label1= new Label(" JUAN CARLOS CERON GUERRERO \n 2-C ING.SISTEMAS COMP.");


opciones.add(salir); } void visualizar() { ventana.setBackground( Color.black ) ; consola.setBackground( Color.green) ; panel1.setBackground( Color.red ) ; panel2.setBackground( Color.black ) ; panel2.setLayout(new FlowLayout()); label1.setBackground( Color.green) ; consola.setEditable(false); consola.append(" SERVIDOR V 1.0 \n INICIALIZANDO"+ "... \n -------------------------------------------------------------"+ "------------------------------------------------------------------\n"+ " EN LINEA"); ventana.setMenuBar(menuBar1); panel1.add(label1); panel2.add(consola); ventana.add(panel1,BorderLayout.NORTH); ventana.add(panel2,BorderLayout.SOUTH); EventosServidor obj=new EventosServidor(ventana,salir); ventana.addWindowListener(obj); salir.addActionListener(obj); ventana.setVisible(true);// ventana.setSize(499,570); ventana.pack(); } public static void actualizar(String linea) { consola.append(linea); }//InterfazGraficaServidor.actualizar(String);// LLAMA AL METODO ESTATICO


} //QUE ESCRIBE EN EL GUI

EventosServidor.java

////////////////////////// IMPORTANDO PAQUETES /////////////////////////////////import java.net.*;import java.io.*;import java.util.*;import java.awt.event.*;import java.awt.*;import java.util.Date;import java.sql.*;public class EventosServidor extends WindowAdapter implements ActionListener{

private Frame ventana;private MenuItem salir;

EventosServidor() { }

EventosServidor(Frame ventana, MenuItem salir){

this.ventana=ventana; this.salir=salir;

}

public void comenzar() { try {

// Creamos un Socket Servidor. String f1,f2,f3;

ServerSocket servidor=new ServerSocket(4321); Date hora= new Date(); int s = hora.getSeconds(); int m = hora.getMinutes(); int h = hora.getHours();

// Esperamos que se conecte un cliente. System.out.println("Esperando la conexion de un cliente ...."); InterfazGraficaServidor.actualizar("\n Esperando la conexion de un cliente ...."); Socket cliente=servidor.accept(); //Este metodo es bloqueante System.out.println("ip"+ cliente.getInetAddress()); System.out.println("nom cli"+ cliente.getInetAddress().getHostName()); System.out.println("Recibida la conexion de un cliente\n"); InterfazGraficaServidor.actualizar("\n Recibida la conexion de un cliente \n"); System.out.println("Sirvo al cliente " + cliente.getInetAddress()); InterfazGraficaServidor.actualizar("\n Sirvo al cliente " + cliente.getInetAddress()); BufferedReader entrada; PrintWriter salida,salida1,salida2;


// Creamos el buffer para recibir datos, a traves del socket asignado // a la conexion del cliente. entrada= new BufferedReader(new InputStreamReader(cliente.getInputStream())); // Creamos el buffer para enviar al cliente informacion a traves del socket. salida =new PrintWriter(cliente.getOutputStream(),true); salida1 =new PrintWriter(cliente.getOutputStream(),true); salida2 =new PrintWriter(cliente.getOutputStream(),true); String msg; while (true) { // Bucle infinito msg=entrada.readLine(); // Leemos una linea recibida por el socket. System.out.println("Mensaje del cliente: "+msg); InterfazGraficaServidor.actualizar("\n Mensaje del cliente: "+msg); int opcion= Integer.parseInt(msg); switch(opcion) { case 1: // hora de inicio del servidor salida.println(hora.getHours()+":"+hora.getMinutes()+":"+hora.getSeconds()); break; case 2: salida.println(hora.getDay()+"/"+hora.getMonth()+"/"+hora.getYear()); //salida.println(msg.toUpperCase()); // Enviamos al cliente la informacion recibida, pero en letra mayuscula. break; case 3: Date hora2= new Date(); int s2 = hora2.getSeconds(); int m2 = hora2.getMinutes(); int h2 = hora2.getHours(); if (s > s2) { s2 = (60-s)+s2; m2--; } else s2 = s2 - s; if (m > m2) { m2 = (60-m)+m2; h2--; } else m2 = m2 -m; if (h > h2) h2 = (24-h)+h2; else h2= h2 - h; // en segundos, minutos y horas esta el tiempo de ejecucion del servidor salida.println(h2+":"+m2+":"+s2);


break; case 4: Date horaactual= new Date(); salida.println(horaactual.getHours()+":"+horaactual.getMinutes()+":"+horaactual.getSeconds()); break; } } // Fin del bucle infinito }

// Tratamos las excepciones

catch (SocketException e) { System.err.println("Error en una operacion de socket"); } catch (IOException e) { System.err.println("Error en una operacion de entrada/salida"); } } public void actionPerformed(ActionEvent e) { System.out.println("HA ELEGIDO SALIR"); System.out.println(" SESION FINALIZADA \n FIN DEL PROGRAMA \n "); System.out.println("JUAN CARLOS CERON GUERRERO \n 2-C ING. SISTEMAS"); System.exit(0); } public void windowClosing(WindowEvent e) //--- CERRADO DE VENTANA { System.out.println("HA CERRADO LA VENTANA"); System.out.println(" SESION FINALIZADA \n FIN DEL PROGRAMA \n "); System.out.println("JUAN CARLOS CERON GUERRERO \n 2-C ING. SISTEMAS"); System.exit(0); } }

InterfazGraficaCliente.java

import java.awt.*;public class InterfazGraficaCliente{ private Frame ventana; private Panel panel1, panel2,panel3,panel4; private MenuBar menuBar1; private Menu opciones; private MenuItem salir; private Label label1; private static TextArea consola; private Button boton1,boton2,boton3,boton4;


public InterfazGraficaCliente() { ventana = new Frame(" PROYECTO (3) UNIDAD 7: MENU CLIENTE "); menuBar1 = new MenuBar(); opciones = new Menu("OPCIONES"); salir = new MenuItem(" SALIR "); panel1 = new Panel(); panel2 = new Panel(); panel3 = new Panel(); panel4 = new Panel(); label1 = new Label(" JUAN CARLOS CERON GUERRERO \n 2-C ING.SISTEMAS COMP."); boton1 = new Button(" HORA DE INICIO DEL SERVIDOR "); boton2 = new Button(" OBTENER LA FECHA "); boton3 = new Button(" TIEMPO DE SERVICIO SERVIDOR "); boton4 = new Button(" HORA ACTUAL ");


opciones.add(salir); } void visualizar() { ventana.setBackground( Color.black) ; consola.setBackground( Color.green) ; panel1.setBackground( Color.red) ; panel2.setBackground( Color.black ) ; panel3.setBackground( Color.red) ; panel2.setLayout(new GridLayout(4,1,20,20)); label1.setBackground( Color.green) ; boton1.setBackground( Color.green) ; boton2.setBackground( Color.green) ; boton3.setBackground( Color.green) ; boton4.setBackground( Color.green) ;

consola.setEditable(false); consola.append(" APLICACION CLIENTE \n INICIALIZANDO"+ "... \n ----------------------------------------------------------------"+ "-------------\n"+ "EN LINEA \n"); ventana.setMenuBar(menuBar1); panel1.add(label1) ; panel2.add(boton1) ; panel2.add(boton2) ; panel2.add(boton3) ; panel2.add(boton4) ; panel3.add(consola); panel4.add(panel2) ; panel4.add(panel3) ;

ventana.add(panel1,BorderLayout.NORTH); ventana.add(panel4,BorderLayout.SOUTH);

EventosCliente obj=new EventosCliente(boton1,boton2,boton3,boton4,salir,ventana); ventana.addWindowListener(obj); salir.addActionListener(obj); boton1.addActionListener(obj); boton2.addActionListener(obj);


boton3.addActionListener(obj); boton4.addActionListener(obj); ventana.setVisible(true);// ventana.setSize(499,570); ventana.pack(); } public static void actualizar(String linea) { consola.append(linea); }//InterfazGraficaCliente.actualizar(String);// LLAMA AL METODO ESTATICO } //QUE ESCRIBE EN EL GUI EventosCliente.java

////////////////////////// IMPORTANDO PAQUETES /////////////////////////////////import java.net.*;import java.io.*;import java.util.*;import java.awt.event.*;import java.awt.*;public class EventosCliente extends WindowAdapter implements ActionListener{

private static Socket socket;private static BufferedReader lectura; private static PrintWriter escritura;private static String a;

EventosCliente()throws IOException{ socket=new Socket ("192.10.1.32",4321);//Soket enlazado al servidor lectura=new BufferedReader(new InputStreamReader (socket.getInputStream())); }

private Button boton1,boton2,boton3,boton4; private MenuItem salir; Frame ventana; EventosCliente(Button boton1,Button boton2,Button boton3,Button boton4,MenuItem salir,Frame ventana) { this.boton1=boton1; this.boton2=boton2; this.boton3=boton3; this.boton4=boton4; this.salir = salir; this.ventana=ventana; } static void enviar(String a)throws IOException { escritura=new PrintWriter (socket.getOutputStream(),true); escritura.println(a); // Leemos lo que nos llega del servidor, y lo mostramos por pantalla. InterfazGraficaCliente.actualizar("Mensaje del servidor: \n"+lectura.readLine()+"\n"); }


public void actionPerformed(ActionEvent x){

Button b=(Button) x.getSource();String text=b.getActionCommand();if(text.equals(boton1.getActionCommand()))

{ System.out.println("1"); try{

EventosCliente.enviar("1"); }

catch (Exception y) {} }

else if(text.equals(boton2.getActionCommand())) { System.out.println("2"); try{

EventosCliente.enviar("2");} catch (Exception y) {}

} else if(text.equals(boton3.getActionCommand())) { System.out.println("3"); try{


} else if(text.equals(boton4.getActionCommand())) { System.out.println("4"); try{


} else// if(text.equals(salir.getActionCommand())) {

System.out.println("HA ELEGIDO SALIR"); System.out.println(" SESION FINALIZADA \n FIN DEL PROGRAMA \n "); System.out.println("JUAN CARLOS CERON GUERRERO \n 2-C ING. SISTEMAS"); System.exit(0);

} }

public void windowClosing(WindowEvent e)

{ System.out.println("HA CERRADO LA VENTANA");

System.out.println(" SESION FINALIZADA \n FIN DEL PROGRAMA \n "); System.out.println("JUAN CARLOS CERON GUERRERO \n 2-C ING. SISTEMAS"); System.exit(0);

}

}

PruebaServidor.java


import java.net.*;import java.io.*;public class PruebaServidor{ public static void main (String args[]) throws IOException { InterfazGraficaServidor consolaServidor=new InterfazGraficaServidor(); consolaServidor.visualizar(); EventosServidor x=new EventosServidor(); x.comenzar() ; } }

PruebaCliente.java

import java.net.*;import java.io.*;public class PruebaCliente { public static void main (String args[]) throws IOException { InterfazGraficaCliente Gui = new InterfazGraficaCliente(); Gui.visualizar(); Gui.actualizar("- SESION INICIADA -\n"); EventosCliente x=new EventosCliente(); // x.comenzar(); } }

8.0 BIBLIOGRAFÍA

Análisis y Diseño Orientado a Objetos con aplicacionesGrady BoochAddison Wesley. Longman

Java 2. Fundamentos de programaciónHerbert SchildtMcGraw-Hill


Java Cómo ProgramarDeitel/DeitelPrentice Hall

Curso en Programación Avanzada en Java en Español (documento .pdf)

Java 2Steven HolznerCoriolis

Manual práctico en Español Java 2 (documento .pdf)

Java Sun Español (documento .pdf)


Manual JAVA

Documents

Transcript of Manual JAVA