ManualJavaVersion1 0

Elaborado por: Ing.
Jesús Pando Barrón
“Excelencia Tecnológica, Fortaleza de México”
Versión 1.0
Elaboró: Ing. Jesús Pando Barrón(Mocis) 1

INDICE
Temas Subtemas Página
Introducción 5
1. Generalidades
1.1 Antecedentes 6
1.2 Pasos para la
instalación y
9
configuración del
kit J2SE
2.Programación
Orientada a Objetos
2.1 Entorno de Java 11
2.2 Tipos primitivos 13
2.3 Estructuras básicas
de control en Java
2.3.1 Estructuras
16
secuenciales
2.3.2 Estructuras
19
alternativas
2.3.3 Estructuras
20
repetitivas
2.4 Conceptos de
Programación Orientada 24
a Objetos
2.4.1 Una
introducción al 36
alcance de datos
2.4.2 Manejo de
37
datos privados
2.4.3 Métodos
38
constructores
2.4.4 Métodos
mutadores (set) y 39
accesores (get)
2.4.5 Sobrecarga de
41
métodos
2.4.6 Sobrecarga de
métodos 45
constructores
2.4.7 Una
introducción a la 47
palabra clave this
2.4.8 Control de
acceso a los 51
miembros de clase
2.4.9 Static 53
2.4.10 Paquetes 56
2.4.11 Arreglos 61
2.4.12 Herencia 72
2.4.12.1 otro punto de
74
vista de la herencia

2.4.12.2 Ejemplos de
77
herencia
2.4.12.3 Composición 86
2.4.12.4 Herencia y
87
composición
2.4.12.5 Clases y métodos
89
abstractos
2.4.12.6 Interfaces 91
2.4.12.7 Simulación de la
92
herencia múltiple
2.4.12.8 Herencia
múltiple con una clase 93
abstracta
2.4.12.9 Polimorfismo 96
2.4.12.10 Clases internas 104
3. Manejo de
105
excepciones
3.1 Ejemplos 109
4. Interfaz Gráfica de
Usuario (GUI) Parte I. 117
AWT
4.1 Frames 118
4.2 Panels 122
4.3 Dialogs 124
4.4 Tipos de Layout
127
Managers
4.4.1 El
administrador 127
BorderLayout
4.4.2 El
administrador 131
FlowLayout
4.4.3 El
administrador 133
GridLayout
4.4.4 Ejemplos
134
varios
5. Manejo de eventos 139
5.1 Categorías de los
144
eventos
5.2 Clases adaptadoras 149
5.3 Manejando eventos
150
con una clase interna
5.4 Ejemplos 154
5.5 posicionamiento
165
absoluto
5.6 Checkbox 172
5.7 Choice y List 174
5.8 Componentes de
178
texto
5.9 Componentes
184
canvas y ScrollPane
5.10 Componentes 193

Menu
5.11Controlando
196
colores y fuentes
6. Interfaz Gráfica de
Usuario (GUI). Parte II. 201
Swing
6.1 Campos y etiquetas 203
6.2 Botones 206
6.3 CheckBox y
208
RadioButton
6.4 JcomboBox
implementado con una 212
clase interna anónima
6.5 JList 214
6.6 Eventos del mouse 218
6.7 Manejo de eventos
224
de teclas
6.8 JTextArea 226
6.9 Panel personalizado 228
6.10 Menús 230
6.11 JPopupMenu 235
6.12 Apariencia visual 238
6.13 Interfaz de
múltiples documentos 242
(MDI)
6.14 Administradores de
esquemas BoxLayout y 246
GridBagLayout
7.0 Proyecto Cliente-
255
Servidor
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.

Java
1. Generalidades
1.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

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.
2
http://www.javahispano.org/news.item.action?id=987142393

1.2 Pasos para la instalación y configuración del kit J2SE
Configuración del Path en Windows XP
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.
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
{
{
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
{
{
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 Valores

boolean true o false
Char 16 0 hasta 65535
Byte 8 -128 a +127
Short 16 -32768 a 32767
Int 32 -2147483648 hasta +2147483647
long 64 -9223372036854775808 hasta +9223372036854775807
Float 32 Rango negativo:
-3.4028234663852886E+38 hasta -1.40129846432481707E-45
Rango positivo:
1.40129846432481707E-45 hasta
3.4028234663852886E+38
Double 64 Rango negativo:
-1.7976931348623157E+308 hasta -4.94065645841246544E-324
Rango 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
y= m
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
a3
z= 3
b+d
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
 a b  ln( ab )
c
p= e{ } −
a
 ln(a + b)  b
Ec3.java
class Ec3
{
{
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:
z = (a + b * c) 2
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=2r
Circunferencia = 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;
c=10;
d=c--;
c=10;
d=--c;
c=10;
c+=5;
c=10;
c-=5;
c=10;
c*=5;
c=10;
c/=5;
c=10;
c%=5;
}
}

2.3.2 Estructuras alternativas
Simple
DecSimple.java
class DecSimple
{
{
int n=Integer.parseInt(args[0]);
if(n>0)
System.out.println("positivo");
}
}
Doble
DecDoble.java
class DecDoble
{
{
if(n>0)
System.out.println("positivo");
else
System.out.println("negativo");
System.out.println("fin del programa");
}
}
Múltiple
DecMultiple.java
class DecMultiple
{
{
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 c=0;
do
{
c=c+1;
System.out.println(c);
}
while(c<n);
}
}
While do
EstWhile.java
class EstWhile
{
{
int c=0;
while(c<n)
{
c=c+1;
}
}
}
Implementación de un contador y sumador
ContSumador.java
class ContSumador
{
{

int c=0;
int s=0;
do
{
c=c+1;
s=s+c;
}
while(c<n);
System.out.println(s);
}
}
Ejercicios de series
1 1 1 1
1) 1+ + + + + ... + no. de términos
2 3 4 5
5 10 15 20 25
2) , , , , ,..., no. de términos
2 4 6 8 10
3) 2 2 + 4 2 + 6 2 + 8 2 + .... + no. de términos
1 3 5
2 4 6
4)   +   +   + .... + no. de términos
3 6 9
51 10 2 15 3
5) + + + .... + no. de términos
4 2 8 4 12 6
 0.12   0.2 4   .036 

6)  3  +  6  +  9  + ... + no. de términos
 .02   .04   .06 

Ciclo For
EstFor.java
class EstFor
{
{
for(int c=1;c<=n;c=c+1)
}
}
7) 21 + 4 2 + 6 3 + 8 4 + .... + no. de términos
8) 1 x 2 x 3 x 4 x ….x no. de términos
1 2 3
9) + + + .... + no. de términos
1! 2! 3!
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
1 1 1
e = 1+ + + + ...
1! 2! 3!
3. Escribe una aplicación que calcule el valor de ex, utilizando la fórmula
x x2 x3
e = 1+ +
x
+ + ...
1! 2! 3!
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.98
b. Producto 2  $4.50

c. Producto 3  $9.98
d. Producto 4  $4.49
e. 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 AND
Expresión 1 Expresión 2 Resultado
1 1 1
1 0 0
0 1 0
0 0 0
Operador OR
1 1 1
1 0 1
0 1 1
0 0 0
Operador XOR
1 1 0
1 0 1
0 1 1
0 0 0
Operador NOT
Expresión 1 Resultado
1 0
0 1
7.
Desarrolla una aplicación para calcular el valor de π a partir de la serie infinita
4 4 4 4 4
π= 4− + − + − + ...
3 5 7 9 11
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;
}
}
PruebaEjPoo2.java
class PruebaEjPoo2
{
{
obj.metodo1();
}
}
EjPoo3.java
class EjPoo3
{
int metodo1()
{
int y=20;
return y;
}
}
PruebaEjPoo3.java
class PruebaEjPoo3
{
{
System.out.println(obj.metodo1());
}
}
EjPoo4.java
class EjPoo4

{
int metodo1(int y)
{
return y;
}
}
PruebaEjPoo4.java
class PruebaEjPoo4
{
{
System.out.println(obj.metodo1(20));
}
}
EjPoo5.java
class EjPoo5
{
void metodo1(int y)
{
}
}
PruebaEjPoo5.java
class PruebaEjPoo5
{
{
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álidas

Double Ninguna
Float Double
Long float o double
Int long,float o double
Char int, long, float o double
Short int, long, float o double

Byte short, int, long, float o double
boolean Ninguno
Los siguientes ejemplos muestran la validez de las promociones
Demo.java
public class Demo

{
{
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
public class Demo

{
{
float x=3.14F;
}
}
Salida:
También se puede realizar de la siguiente forma:

public class Demo
{
{
float x=(float)3.14;
}
}
Salida:
EjPoo6.java
class EjPoo6
{
void metodo1(int 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
{
void metodo1(int y)
{

}
double metodo2(int a, float b)
{
return a*b;
}
String metodo3(String g)
{
return "prueba"+g;
}
}
PruebaEjPoo7.java
class PruebaEjPoo7
{
{
obj1.metodo1(20);
obj1.metodo1(40);
}
}
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
{
{
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:
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
{
{
Clase3 obj1=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);
}
}
Modificación de la interfaz para instanciar los dos objetos en una sola línea

class InterfazClase3Mod
{
{
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;
}
}
Ejemplo 6. Creación de dos objetos tipo Vehiculo.
Vehiculo.java
class Vehiculo
{
int Pasajeros;
}
DosVehiculos.java
class DosVehiculos
{
{
int rango1,rango2;

Vehiculo CarroDeportivo=new Vehiculo();
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:
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
{
{
obj1.a=10;
Clase4 obj2=obj1;
System.out.println("obj1.a="+obj1.a);
obj2=obj3;
obj3=obj1;
}

}
Salida:
Variables de referencia y asignación con la clase Vehiculo
PruebaVehiculo5.java
class PruebaVehiculo5
{
{
Vehiculo carro1=new Vehiculo();

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

carro2=carro3;
carro3.Pasajeros=10;
carro1=carro3;
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
{
int Pasajeros;
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
{
{

Vehiculo CarroDeportivo=new Vehiculo();
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
{
{
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
{
{
int x,y,z;
obj.a=10;
x=obj.a;
y=20;
z=obj.metodo1(x,y);
}
}
Salida:
Comentarios:
Marca un error por el acceso de la variable(miembro) a de tipo private

Manejo de datos privados
Clase10.java
class Clase10
{
private int a=15;
public int metodo1(int c)

{
return a+c;
}
}
InterfazClase10.java
{
{
int y,z;
y=20;
z=obj.metodo1(y);
System.out.println("z ="+z); // z=35
}
}
Clase11.java
class Clase11
{
private int a=15;
private int metodo1(int c)

{
return a+c;
}
}
InterfazClase11.java
{
{
int y,z;

y=20;
z=obj.metodo1(y);
}
}
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;
else
x=0;
}
int get()
{
return x;
}
PruebaSetGet1.java

class PruebaSetGet1
{
{
SetGet1 obj1 = new SetGet1(10);
System.out.println(obj1.get());
SetGet1 obj2 = new SetGet1(-10);
}
}
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;
else
x=0;
if(b>0)
y=b;
else
y=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);
SetGet2 obj3 = new SetGet2(10,-20);

SetGet2 obj4 = new SetGet2(-10,-20);
}
}
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.java
class 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.java
class PruebaDemoSobrecarga
{

{
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
{
{
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
{
{
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

{
{
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
{
{
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
{
{
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
{
{
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
{
{
DemoThis obj1=new DemoThis(10);
}
}
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
{
{

}
}
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
{
{
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
{
{
Accesos obj1=new Accesos();
obj1.setAlfa(100);
System.out.println(obj1.getAlfa());
// obj1.alfa=200; Marca error en la compilación

obj1.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
{
{
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 static

2. Deben acceder sólo a datos static
3. 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:

Paquetes
Cada 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.progjava
public 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 o

2. 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 Plataforma
Pascal .NET Java
NombreMiembro Clases Clases
Métodos
Ejemplo: DemoClase Propiedades
Estructuras
Camello
nombreMiembro Atributos Métodos
Parámetros Atributos
Ejemplo: demoMetodo Pará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
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
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];
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
{
{
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
{
{
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];
}
}
{
{
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 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];
}
}

}
{
{
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[])
{
}
void establecerDatos (String arreglo[])
{
{
arreglo[j]=vector1[j];
}
}
{
{
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;
else
limite=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
{
{
int vectorA[] = new int [100];
int vectorB[] = new int [100];
int vectorC[] = new int [100];
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[][])
{
}
void establecerDatos (int arreglo[][])
{
for(int i=0;i<n;i++)
{
arreglo[i][j]=tabla1[i][j];
}
}
PruebaDemoBidi1.java
class PruebaDemoBidi1
{
{
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}};
{
}
{
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}};
{
}
{
for(int j=0; j<tabla1[i].length;j++)
{
}
}
PruebaDemoBidi2.java
class PruebaDemoBidi2
{
{

// 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
{
{
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;
}
}
}
PruebaRandom3.java
public class PruebaRandom2

{
{
int x;
for (int i = 0; i < 10; i++) {
x=((int) (Math.random()*5)+1);
}
}
}
Burbuja.java
import java.util.Arrays;
public class Burbuja
{
{
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
{
{
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]);
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.

Figura
FiguraBidimensional FiguraTridimensional
Círculo Cuadrado Triangulo Esfera Cubo Tetraedro
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
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.
Empleado
public class Empleado {
public String nombre = “ “;
+nombre : String = “ “
public double salario;
+salario : double
public Date fechaCump;
+fechaCump : Date
public String obtenerDetalles()
{
+obtenerDetalles() : String
...
}
}
Administrador public class Administrador {

+salario : double
+fechaCump : Date
public String departamento;
+departamento : String
+obtenerDetalles() : String {
...
}
}
Como se observa se duplican los datos de las dos clases. Por lo tanto, una clase para minimizar
este “error” llamada sublclase

Empleado
public class Empleado {
+salario : double
+fechaCump : Date
{
...
}
}
Administrador
public class Administrador extends Empleado {
+departamento : String public String departamento;
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
+salario : double
+fechaCump : Date
Administrador
Ingeniero
+departamento : String Secretaria
Director
+adjudicarVehiculo : double
+incrementarConcesion()
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 Universal

Private Si
Default Si Si
Protected Si Si Si
Public Si Si Si Si
Métodos overriding

• Una subclase puede modificar su comportamiento heredado de una clase principal
• Una subclase puede crear un método con diferente funcionalidad que el método de su clase principal
pero con el mismo:
o Nombre
o Tipo de retorno
o 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();
}
}

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;
}
{
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;
}
{
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

{
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);
}

{
departamento=d;
}
{ 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);
}
}
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");
}
{
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 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);
}

{
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;
else
dia=0;
if(m>=0 && m<=12)
mes=m;
else
mes=0;
if(a>=2000 && a<=2010)
annio=a;
else
annio=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);
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:

Interfaces
La 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()
{
}
public void metodoB()
{
System.out.println("Dentro del metodo B de la clase B ");
}
public int metodoC()
{
return 10;
}
}
class PruebaClasesInterfaz
{
{
B obj=new B();

obj.metodoA();
obj.metodoB();
}}
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
{
{
}
{
}
{
return 10;
}
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();
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
{
{
}
{
}
{

return 10;
}
{
}
{
return " Dentro del metodo E de la clase B";
}
}
{
{
B obj=new B();
obj.metodoA();
obj.metodoB();
obj.metodoD();
}
}
Salida:
interface A1
{
}
class A2
{
{
}
{
return "metodoE()";
}
}
interface A3
{
public void metodoF();

}
class B extends A2 implements A1, A3
{
{
}
{
}
{
return 10;
}
{
}
{
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();
obj.metodoD();
obj.metodoF();
}
}
Salida:

Polimorfismo
Ejemplo 1
PruebaCastingPadreHijo2.java
public 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

{
{
System.out.println("CastingHijo objHijo = new CastingHijo()");
CastingHijo objHijo = new CastingHijo();
objHijo.visualizarPadre();
objHijo.visualizar();
// 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("CastingPadre objPadre = new CastingPadre()");
CastingPadre objPadre = new CastingPadre();
objPadre.visualizarPadre();
objPadre.visualizar();
System.out.println("objPadre=objHijo");
objPadre=objHijo;
objPadre.visualizarPadre();
// Marca un error
//objPadre.visualizarHijo();
//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("objPadre=(CastingPadre)objHijo");
objPadre=(CastingPadre)objHijo;
}}
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

<<abstract>>
Empleado
EmpleadoAsalariado EmpleadoPorComision EmpleadoPorHoras
EmpleadoBaseMasComision
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();
}
{
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)
{
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;
}
{
return obtenerTasaComision() * obtenerVentasTotales();
}
{
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)
{
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;
}
{
if(horas<=40)
return sueldo*horas;
else
return 40*sueldo+(horas-40)*sueldo*1.5;
}
{
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;
}
{
return obtenerSalarioBase() + super.ingresos();
}
{
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 EmpleadoBaseMasComision

if(empleados[i] instanceof EmpleadoBaseMasComision)
{
// conversión descendente de referencia a Empleado a referencia a

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 la
memoria. 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) {
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 de
manejo de errores tradicionales se podría parecer a esto:
leerArchivo {
try {
abrir el archivo;
determinar su tamaño;
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 llama
a 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étodo
que está interesado en él.
metodo1 {
codigodeErrorType error;
error = call metodo2;
if (error)
procesodelError;
else
proceder;
}
codigodeErrorType metodo2 {
error = call metodo3;
if (error)
return error;
else
proceder;
}
codigodeErrorType metodo3 {
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 excepciones
especí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 de
array, 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 enteros
float 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
{
{
int a[]={1,2,3};
try
{
if(Boolean.parseBoolean(args[0]))
System.out.println(a[4]);
else
System.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 (Exception o)
{
System.out.println(o);
}
}
static void evaluarEntero(boolean v)
{
int a[]={1,2,3};
if(v)
else
}
}
Salida:
PruebaExcep7.java

class PruebaExcep7
{
{
try
{
{
}
catch (ArrayIndexOutOfBoundsException o)
{
}
}
static void evaluarEntero(boolean v) throws
ArithmeticException,ArrayIndexOutOfBoundsException
{
int a[]={1,2,3};
if(v)
else
}
}
Salida:
PruebaExcep8.java
class PruebaExcep8
{
{
try
{
catch (Exception o)
{

}
}
static void evaluarEntero(boolean v) throws Exception
{
int a[]={1,2,3};
if(v)
else
}
}
Salida:
class PruebaExcep9
{
{
try
{
{
}
{
}
finally
{
System.out.println("Metodo finally");
}
}
{
int a[]={1,2,3};
if(v)
else
}
}
Salida:

PruebaExcep10.java
class ClaseExcepcion
{
{
int a[]={1,2,3};
if(v)
else
}
}
class PruebaExcep10
{
{
try
{
ClaseExcepcion.evaluarEntero(Boolean.parseBoolean(args[0]));
{
}
{
}
finally
{
System.out.println("Metodo finally");
}
}
}
Salida:

4. Interfaz Gráfica de Usuario (GUI). Parte I. AWT
GUI
Abstract 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.awt
Este 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 estructura
2. 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
import java.awt.*;
class DemoFrame2
{
private Frame f1;
private Frame f2;
{
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
import java.awt.*;
class DemoFrame4
{
private Frame f;
private Label letrero;
{

}

{
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();
}
{
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)
{
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);
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)
{
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)
{
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)
{
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;

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;
public DemoBorderLayout2()
{
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)

{
p1=new Panel();
p2=new Panel();
p3=new Panel();
p4=new Panel();
p5=new Panel();
}
{
p1.setSize(100,100);
p1.setBackground(Color.yellow);
p2.setSize(50,50);

p2.setBackground(Color.red);
p3.setSize(50,50);
p3.setBackground(Color.green);
p4.setSize(50,50);
p4.setBackground(Color.gray);
p5.setSize(50,50);
p5.setBackground(Color.white);
f.setSize(300,300);
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 Panel p;
public DemoFlowLayout()
{
boton1 = new Button ("Boton 1");

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)
{
elBoton = new Button[9];
for(int i=0;i<elBoton.length;i++)
elBoton[i]=new Button(""+i);
}
{
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.pack();
f.setVisible(true);
}
{
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.add(letrero1,BorderLayout.NORTH);
p1.add(areaEntrada,BorderLayout.SOUTH);
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.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(p2,BorderLayout.CENTER);
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 evento

2. 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.* ;
public class DemoEvento1
{
private Frame frame ;
private Button boton ;
DemoEvento1()
{
frame = new Frame( "Demo " ) ;
boton = new Button( "Clicks : 0" ) ;

}
{
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
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.* ;
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 ) ;
}
{
DemoEventoVentana demo = new DemoEventoVentana() ;
demo.ejecutar() ;
}
}
Salida:
Ejemplo 3
DemoEventoVentana.java
import java.awt.* ;
public class ManejadorBotonClick implements ActionListener
{
private int count ;
{
}
}
public class ManejadorVentana implements WindowListener
{
public void windowClosing( WindowEvent theEvent )
{
System.exit( 0 ) ;
}

}
import java.awt.* ;
public class DemoEventoVentana
{
Frame frame ;
Label etiqueta ;
Button boton;
public DemoEventoVentana()
{
etiqueta = new Label( "Para cerrar esta ventana de un click en el cuadro respectivo",
Label.CENTER ) ;
}
{
boton.addActionListener( new ManejadorBotonClick() ) ;
frame.add( boton, BorderLayout.WEST ) ;

frame.addWindowListener( new ManejadorVentana() ) ;
frame.add( etiqueta, BorderLayout.EAST) ;
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.* ;
public class DemoEventos implements ActionListener,WindowListener
{
Frame frame ;
Label etiqueta ;

Button boton;
private int count ;

public DemoEventos()
{
etiqueta = new Label( "Para cerrar esta ventana de un click en el cuadro respectivo",
Label.CENTER ) ;
count=0 ;
}
{
boton.addActionListener(this) ;
frame.add( boton, BorderLayout.WEST ) ;

frame.addWindowListener(this) ;
frame.add( etiqueta, BorderLayout.EAST) ;
frame.pack();
}
{
DemoEventos demo = new DemoEventos() ;
demo.ejecutar() ;
}

{
}

{
System.exit( 0 ) ;
}
}
Salida:

5.1 Categorías de los eventos
Categoría Nombre de la interfaz Métodos

Action ActionListener actionPerformed(ActionEvent)
Item ItemListener itemStateChanged(itemEvent)
mousePressed(mouseEvent)
mouseReleases(mouseEvent)
Mouse MouseListener mouseEntered(mouseEvent)
mouseExited(mouseEvent)
mouseClicked(mouseEvent)
mouseDragged(mouseEvent)
Mouse Motion MouseMotionListener
mouseMoved(MouseEvent)
keyPressed(KeyEvent)
keyReleased(KeyEvent)
Key KeyListener
keyTyped(KeyEvent)
focusGained(FocusEvent)
Focus FocusListener
focusLost(FocusEvent)
Adjustment AdjustmentListener adjustmentValueChanged(Adjustment)
componentMoved(ComponentEvent)
componentHidden (ComponentEvent)
Component ComponentListener
componentResized(ComponentEvent)
componentShown(ComponentEvent)
windowClosing(WindowEvent)
windowOpened(WindowEvent)
windowIconified(WindowEvent)
Window WindowListener windowDeiconified(WindowEvent)
windowClosed(WindowEvent)
windowActivated(WindowEvent)
windowDeactivated(WindowEvent)
componentAdded(ContainerEvent)
Container ContainerListener
componentRemoved(ContainerEvent)

Text TextListener textValueChanged(TextEvent)
Ejemplo 5
DemoEventosMoverMouse.java
import java.awt.* ;
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.* ;
public class DemoEventosMoverMouse {

private Panel panelNorte ;
private Label etiquetaX ;
private Label etiquetaY ;
private Label etiquetaLocalizar ;
private Label etiquetaPresionar ;
private Label instruccion ;
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 ) ;
}

{
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 ) ;
}

{
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 interaz
1. package java.awt.event ;
2.
3.
4.
5. public abstract class WindowAdapter implements
6.
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 adaptadora
1. 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.* ;
public class DemoEventosMoverMouse2 {

private Label etiquetaX ;
private Label etiquetaY ;
private Label etiquetaLocalizar ;
private Label etiquetaPresionar ;
private Label instruccion ;
public DemoEventosMoverMouse2()
{
frame = new Frame( "DualListenerDemo" ) ;

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 ) ;
}

{
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.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 ) ;
}

{
DemoEventosMoverMouse2 demo = new DemoEventosMoverMouse2() ;
demo.ejecutar() ;
}
// inserción de la clase interna
public class EventosMoverMouse2 implements MouseMotionListener, MouseListener

{
public EventosMoverMouse2( TextField textX,TextField textY,TextField
textLocalizar,TextField textPresionar )

{
this.textX = textX ;
this.textY = textY ;
this.textLocalizar = textLocalizar ;
this.textPresionar = textPresionar ;
}

{
mouseMoved( evento ) ;
}

{
textX.setText( "" + evento.getX() ) ;
textY.setText( "" + evento.getY() ) ;
}

{
textLocalizar.setText( "Sobre la etiqueta" ) ;
}

{
textLocalizar.setText( "No está sobre la etiqueta" ) ;
}

{
textPresionar.setText( "Presionado" ) ;
}

{
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 Button bot1;
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());
}
{
bot1.setLabel( "ha dado un click" ) ;
campo3.setText(bot1.getLabel());
import java.awt.* ;
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);
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);

f.add(txtCampo2);
et3.setFont( new Font( "",Font.ROMAN_BASELINE, 16 ) ) ;

f.add(et3);

f.add(txtCampo3);
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.*;
class ManejadorEventos implements WindowListener, FocusListener, ActionListener
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 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.* ;
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);
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);

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.* ;
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 ) {
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.* ;
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 )
{

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.* ;
class DemoBoton2
{
private Frame f ;
private Button botonContador ;
private Button botonSalir ;
private int contador ;
public DemoBoton2()
{
botonContador = new Button( "contador : 0" ) ;
}
{
EventoBoton objeto = new EventoBoton(botonSalir, botonContador);
botonContador.addActionListener( objeto ) ;
botonSalir.addActionListener( objeto ) ;
f.addWindowListener( objeto ) ;

f.add( botonContador ) ;
f.add( botonSalir ) ;
f.setSize( 175, 175 ) ;
}
}
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");
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
import java.awt.* ;
class GuiVariosBotones
{
private Frame f ;
private Button b1,b2,b3 ;
private TextField t1,t2,t3;
public GuiVariosBotones()
{
b1 = new Button( "boton 1" ) ;

t1=new TextField(20);
}

{
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 ) ;
f.pack();
}
}
EventoVariosBoton.java
import java.awt.* ;
public class EventoVariosBoton extends WindowAdapter implements ActionListener
{

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':
break;
case '3':
break;
}
}

{
System.exit( 0 ) ;
}
}
PruebaVariosBotones.java
class PruebaVariosBotones
{

{
GuiVariosBotones demo = new GuiVariosBotones() ;

demo.ejecutar() ;
}
}
Ejemplo 2
GuiVariosBotones2.java
import java.awt.* ;
class GuiVariosBotones2
{
private Frame f ;
private Button b1,b2,b3 ;

public GuiVariosBotones2()
{

}
{
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 ) ;
f.pack();
}
}
EventosVariosBotones2.java
import java.awt.* ;
public class EventosVariosBotones2 extends WindowAdapter implements ActionListener
{

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)
else if(fuente==b2)
else if(fuente==b3)

{
System.exit( 0 ) ;
}
}
PruebaVariosBotones2.java
class PruebaVariosBotones2
{

{
GuiVariosBotones2 demo = new GuiVariosBotones2() ;

demo.ejecutar() ;
}
}

5.6 Checkbox
GuiCheckbox.java
import java.awt.* ;
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 ) ;
}

{

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() ;
}
}
EventoCheckbox.java
import java.awt.*;
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.* ;
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);
}
{
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() ;
}
}
EventosChoice.java
import java.awt.* ;
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;
}
{
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");
}
{
System.exit( 0 ) ;
}
}
PruebaChoice.java
class PruebaChoice
{
{
GuiChoice demo = new GuiChoice() ;
demo.ejecutar() ;
}
}
List
GuiList.java
import java.awt.* ;
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) ;
}
{
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() ;
}
}
EventosLista.java
import java.awt.* ;
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
{
{
GuiList demo = new GuiList() ;
demo.ejecutar() ;
}
}

5.8 Componentes de Texto
GuiText1.java
import java.awt.* ;
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" ) ;
}
{
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.add( etiqueta ) ;
f.add( nombreCampo ) ;
f.add( etiquetaPassword ) ;
f.add( campoPassword ) ;
f.add( botonLimpiar ) ;
f.add( botonEnviar ) ;
f.pack() ;
}
}
EventosGuiText1.java
import java.awt.* ;
public class EventosGuiText1 extends WindowAdapter implements ActionListener
{
private TextField nombreCampo ;
private TextField campoPassword ;
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 ) ;
}
}
}
{
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.io.* ;
import java.awt.*;
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 Panel northPanel ;
private Panel southPanel ;
private final static int ALTURA = 20 ;
private final static int ANCHURA= 40 ;
public GuiText2( String 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" ) ;
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() ;
}
EventosGuiText2.java
import java.awt.*;
import java.io.* ;
public class EventosGuiText2 extends WindowAdapter implements ActionListener
{
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 ;
}

{
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 ) ;
}
else if ( fuente == botonLimpiar )
{
entradaDirectorio.setText( "" ) ;
entradaArchivo.setText( "" ) ;
cuerpoArchivo.setText( "" ) ;

}
else
System.exit( 0 ) ;
}

{
System.exit( 0 ) ;
}}
PruebaGuiText2.java
class PruebaGuiText2
{
{
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.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.add( canvas, BorderLayout.CENTER ) ;
f.add( boton, BorderLayout.SOUTH ) ;
f.pack() ;
}

{
DemoCanvas demo = new DemoCanvas() ;
demo.ejecutar() ;
}

{
canvas.limpiar() ;
}

{
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() ;
}

{
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.image.* ;
public class DemoScrollPane extends WindowAdapter

{
private Frame f ;
private ScrollPane scrollPane ;
private ImageCanvas canvas ;
public DemoScrollPane( String titulo, String gif )

{
scrollPane = new ScrollPane() ;
canvas = new ImageCanvas( gif ) ;
}

{
scrollPane.add( canvas ) ;
f.add( scrollPane ) ;
f.setSize( 400, 400 ) ;
}

{
System.exit( 0 ) ;
}
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

{
{
DemoScrollPane demo =
new DemoScrollPane( "Demo ScrollPane", "prueba.gif" ) ;
demo.ejecutar() ;
}
}
Salida:
Dialogos
DemoVentanaDialogo.java
import java.awt.* ;
import java.io.* ;
public class DemoVentanaDialogo extends WindowAdapter implements ActionListener

{
private Frame f ;
private Label etiquetaDirectorio ;
private Label etiquetaArchivo ;

private TextArea cuerpoArchivo ;
private Panel panelSur ;
private Dialog dialogo ;
private Panel panel ;
private Label advertencia;
private Button desconocido ;
private FileDialog archivoDialogo ;
private final static int ANCHURA = 40 ;
public DemoVentanaDialogo( String 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" ) ;
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 ) ;
cuerpoArchivo.setEditable( false ) ;
etiquetaDirectorio.setBackground( Color.lightGray ) ;
etiquetaArchivo.setBackground( Color.lightGray ) ;
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() ;
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 )
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 )
{
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 ) ;
}
else if ( fuente == botonLimpiar )
{
entradaDirectorio.setText( "" ) ;
entradaArchivo.setText( "" ) ;
}
else if ( fuente == desconocido )
dialogo.dispose() ;
else
System.exit( 0 ) ;
}

{
Object fuente = theEvent.getSource() ;
if ( fuente == dialogo )
dialogo.dispose() ;
else
System.exit( 0 ) ;
}
PruebaDemoVentanaDialogo.java
public class PruebaDemoVentanaDialogo

{
{
DemoVentanaDialogo demo = new DemoVentanaDialogo( "DemoVentanaDialogo" ) ;
demo.ejecutar() ;
}
}

Salida:
5.10 Componentes Menu

Ejemplo
GuiDemoMenu1.java
import java.awt.* ;
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 ANCHURA = 40 ;
public GuiDemoMenu1( String 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() ;
}
{
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() ;
}
}
EventosDemoMenu1.java
import java.awt.* ;
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;
}
{
String command = evento.getActionCommand() ;
if ( ! command.equals( "salir" ) )
System.out.println( command ) ;
else
System.exit( 0 ) ;
}
{
System.exit( 0 ) ;
}
PruebaDemoMenu1.java
public class PruebaDemoMenu1

{
GuiDemoMenu1 demo = new GuiDemoMenu1( "Demo Menu" ) ;
demo.ejecutar() ;
}
}
Salida:

5.11 Controlando colores y fuentes
Ejemplo1 Colores
GuiDemoColor.java
import java.awt.* ;
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 )
{
botonIzquierdo = new Button( "Presiona" ) ;
botonDerecho= new Button( "Salir" ) ;
}
{
EventosDemoColor obj = new EventosDemoColor(botonIzquierdo,
botonDerecho);
botonIzquierdo.addMouseListener( obj ) ;
botonDerecho.addMouseListener( obj ) ;
botonIzquierdo.setBackground( oscuro ) ;
botonDerecho.setBackground( oscuro ) ;
f.addWindowListener( new EventosDemoColor()) ;
f.add( botonIzquierdo ) ;
f.add( botonDerecho) ;
f.setSize( 200, 100 ) ;
}
}

EventosDemoColor.java
import java.awt.* ;
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;
}
{
}
{
Button boton = ( Button ) evento.getSource() ;
boton.setBackground( GuiDemoColor.oscuro) ;
}
{
}
{
Button boton = ( Button ) evento.getSource() ;
boton.setBackground( GuiDemoColor.brillante ) ;
boton.requestFocus() ;
}
{
Button fuente = ( Button ) evento.getSource() ;
if ( fuente.getActionCommand().equals( "Salir" ) )
System.exit( 0 ) ;
}

{
System.exit( 0 ) ;
}
}
PruebaDemoColor.java
public class PruebaDemoColor

{
{
GuiDemoColor demo = new GuiDemoColor( "Demo Color" ) ;
demo.ejecutar() ;
}}

Salida:
Ejemplo 2 Fuentes
GuiDemoFuente.java
import java.awt.* ;
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 ) ;
}
{
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 ) ;
panel.setLayout( new GridLayout( 1, 3 ) ) ;
panel.add( nombreLista ) ;
panel.add( estiloLista ) ;
panel.add( tamanoLista ) ;
f.add( etiqueta ) ;
f.add( panel) ;
f.pack() ;
}
}
EventosDemoFuente.java
import java.awt.* ;
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

{
{
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

Object
Component
Container
JComponent
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.

6.1. Campos y etiquetas
Ejemplo 1
GuiDemoEtiqueta.java
import java.awt.*;
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");
et3=new JLabel();
et3.setText("Etiqueta con icono y texto en parte inferior");
et3.setIcon(imagen);
et3.setHorizontalTextPosition(SwingConstants.CENTER);
et3.setVerticalTextPosition(SwingConstants.BOTTOM);
contenedor.add(et1);
setSize(275,250);
setVisible(true);
}
}
PruebaDemoEtiqueta.java
public class PruebaDemoEtiqueta

{
{
GuiDemoEtiqueta obj = new GuiDemoEtiqueta();
obj.visualizar();
}
}

Salida:
Ejemplo 2
GuiDemoCampo.java
import java.awt.*;
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);
campoPassword.addActionListener(obj);
contenedor.add(campoTexto1);
contenedor.add(campoPassword);
setSize(275,250);
setVisible(true);
}}

EventosDemoCampo.java
import java.awt.*;
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.campoPassword=campoPassword;
}
public void actionPerformed(ActionEvent evento)
{
String cadena="";
if(evento.getSource()==campoTexto1)
cadena="campoTexto1: " +evento.getActionCommand();
else if(evento.getSource()==campoTexto2)
else if(evento.getSource()==campoTexto3)
else if(evento.getSource()==campoPassword)
{
cadena="campoPassword: " +new String (campoPassword.getPassword());
}
JOptionPane.showMessageDialog(null,cadena);
}
}
PruebaDemoCampo.java
public class PruebaDemoCampo
{
{
GuiDemoCampo obj = new GuiDemoCampo();
obj.ejecutar();
obj.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}

Salida:
6.2. Botones
GuiDemoBoton.java
import java.awt.*;
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);
setSize(275,250);
setVisible(true);
}
}

EventosDemoBoton.java
import java.awt.*;
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
public class PruebaDemoBoton
{
{
GuiDemoBoton obj = new GuiDemoBoton();
obj.ejecutar();
}
}
Salida:

6.3. CheckBox y RadioButton
Ejemplo1
GuiDemoCasillaVerificacion.java
import java.awt.*;
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);
setSize(275,250);
setVisible(true);
}
}
EventosDemoCasillaVerificacion.java
import java.awt.*;
public class EventosDemoCasillaVerificacion implements ItemListener
{
private int valNegrita=Font.PLAIN;
private int valCursiva=Font.PLAIN;

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
public class PruebaDemoCasillaVerificacion
{
{
GuiDemoCasillaVerificacion obj = new GuiDemoCasillaVerificacion();
obj.ejecutar();
}
}
Salida:

Ejemplo 2
DemoBotonOpcion.java
import java.awt.*;
public class DemoBotonOpcion extends JFrame

{
private Font tipoLetraSimple, tipoLetraNegrita, tipoLetraCursiva, tipoLetraNegritaCursiva;
private JRadioButton botonSimple, botonNegrita, botonCursiva, botonNegritaCursiva;
private ButtonGroup grupoBotonesOpcion;
public DemoBotonOpcion()
{
super( "Prueba de RadioButton" );

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;
}

{
campo.setFont( tipoDeLetra );
}
}
}
PruebaBotonOpcion.java
class PruebaBotonOpcion
{
{
DemoBotonOpcion aplicacion = new DemoBotonOpcion();
aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
}
}
Salida:

6.4. JComboBox implementado con una clase interna anónima
DemoCuadroComb.java
import java.awt.*;
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

// 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()
{
{
// 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
class PruebaCuadroComb
{
{
DemoCuadroComb aplicacion = new DemoCuadroComb();
}
}
Salida:

6.5. Jlist
Ejemplo 1
DemoList.java
import java.awt.*;
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();
// 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 llamada a addListSelectionListener
setSize( 350, 350 );
setVisible( true );
}
}
PruebaList.java
class PruebaList
{
{
DemoList aplicacion = new DemoList();
}
}
Salida 1 sin agregar el JScrollPane
Salida 2 agregando el JScrollPane

Ejemplo 2
DemoSeleccionMultiple.java
import java.awt.*;
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" );

// 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()
{
{
// 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
class PruebaSeleccionMultiple
{
{
DemoSeleccionMultiple aplicacion = new DemoSeleccionMultiple();
}
}
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
import java.awt.*;
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
{
barraEstado.setText( "Se hizo clic en [" + evento.getX() + ", " + evento.getY() + "]" );
}
// manejar evento cuando se oprime el botón del Mouse

{
barraEstado.setText( "Se oprimió en [" + evento.getX() + ", " + evento.getY() + "]" );
}
// manejar evento cuando se suelta el Mouse después de arrastrar

{
barraEstado.setText( "Se soltó en [" + evento.getX() + ", " + evento.getY() + "]" );
}

// manejar el evento cuando el Mouse entra al área
{
barraEstado.setText( "Mouse entro en [" + evento.getX() + ", " + evento.getY() + "]" );
getContentPane().setBackground( Color.GREEN );
}
// manejar evento cuando el Mouse sale del área

{
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
{
barraEstado.setText( "Se arrastró en [" + evento.getX() + ", " + evento.getY() + "]" );
}
// manejar el evento cuando el usuario mueve el Mouse

{
barraEstado.setText( "Se movió en [" + evento.getX() + ", " + evento.getY() + "]" );
}
}
PruebaEventosMouse.java
class PruebaEventosMouse
{
{
EventosMouse aplicacion = new EventosMouse();
}
}
Salida:
Ejemplo 2. Uso de una clase adaptadora
DemoPintor.java
import java.awt.*;

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
{
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
class PruebaPintor
{

{
DemoPintor aplicacion = new DemoPintor();
}
}
Salida:
Comentarios
• Clases adaptadoras de eventos y las interfaces que implementan en el paquete java.awt.event
Clase adaptadora de eventos Implementa a la interfaz

ComponentAdapter ComponentListener
ContainerAdapter ContainerListener
FocusAdapter FocusListener
KeyAdapter KeyListener
MouseAdapter MouseListener
MouseMotionAdapter 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
import java.awt.*;
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ó

{
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
class PruebaDetallesMouse
{
{
DetallesMouse aplicacion = new DetallesMouse();
}
}
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ón

isMetaDown() 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
import java.awt.*;
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() );

}
// manejar evento de pulsación de una tecla de acción

public void keyTyped( KeyEvent evento )
{
linea1 = "Se escribió tecla: " + evento.getKeyChar();
}
// 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
class PruebaDemoTeclas
{
{
DemoTeclas aplicacion = new DemoTeclas();
}
}
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
import java.awt.*;
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

{
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

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
class PruebaDemoAreaTexto
{
{
DemoAreaTexto aplicacion = new DemoAreaTexto();
}
}
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_ALWAYS
JscrollPane.HORIZONTALL_SCROLLBAR_ALWAYS. Para indicar que siempre debe
aparecer la barra de desplazamiento.
Las constantes:
JscrollPane.VERTICAL_SCROLLBAR_AS_NEEDED
JscrollPane.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_NEVER
JscrollPane.HORIZONTAL_SCROLLBAR_NEVER. Indican que nunca debe
aparecer una barra de desplazamiento.
6.9. Panel personalizado

PanelPersonalizado.java
import java.awt.*;
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
import java.awt.*;

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
{
miPanel.dibujar(
PanelPersonalizado.CUADRADO );
}
botonCirculo = new JButton( "Círculo" );
botonCirculo.addActionListener(new ActionListener()
{
// dibujar un círculo
{
miPanel.dibujar( PanelPersonalizado.CIRCULO );
}
// 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

contenedor.add( miPanel, BorderLayout.CENTER );
contenedor.add( panelBotones, BorderLayout.SOUTH );
setSize( 300, 150 );

setVisible( true );

} // fin del constructor PruebaPanelPersonalizado

{
PruebaPanelPersonalizado aplicacion = new PruebaPanelPersonalizado();
}
} // 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
import java.awt.*;
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...
{
JOptionPane.showMessageDialog(
PruebaMenu.this,"Éste es un ejemplo\ndel uso de menús","Acerca de", JOptionPane.PLAIN_MESSAGE );
}
// 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
{
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 );
setSize( 550, 200 );

setVisible( true );
} // fin del constructor

{
PruebaMenu aplicacion = new PruebaMenu();
}
// 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

{
// 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
import java.awt.*;
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
{
checkForTriggerEvent( evento );
}
// manejar evento de soltar el botón del ratón

{
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
setSize( 300, 200 );

setVisible( true );
} // 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ú


{
// 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
class PruebaContextual
{
{
DemoContextual aplicacion = new DemoContextual();
}
}
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
import java.awt.*;
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" );
// 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();
setSize( 300, 200 );

setVisible( true );
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

{
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
class PruebaAparienciaVisual
{
{
DemoAparienciaVisual aplicacion = new DemoAparienciaVisual();
}
}
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
import java.awt.*;
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
{
// 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 );
}

setSize( 600, 460 );

setVisible( true );
} // fin de la clase DemoEscritorio
// clase para mostrar un objeto ImageIcon en un panel

class 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
class PruebaEscritorio
{
{
DemoEscritorio aplicacion = new DemoEscritorio();
}
}
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 interno
o cerrar ,el marco interno
o maximizar el marco interno
o minimizar el marco interno
Ejemplo 2:
DemoJTabbedPane.java
import java.awt.*;
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 );
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" );

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 );
setSize( 250, 200 );

setVisible( true );

} // fin de la clase DemoJTabbedPane
PruebaDemoJTabbedPane.java
class PruebaDemoJTabbedPane
{
{
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
import java.awt.*;
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

{
vertical1.add( Box.createVerticalStrut( 25 ) );
vertical1.add( new JButton( "Botón " + cuenta ) );
}
// crear pegamento horizontal y agregar botones al objeto Box horizontal2

{
horizontal2.add( Box.createHorizontalGlue() );
horizontal2.add( new JButton( "Botón " + cuenta ) );
}
// crear área rígida y agregar botones al objeto Box vertical2

{
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 ) );

{
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
setSize( 400, 220 );

setVisible( true );
} // fin de la clase DemoBoxLayout

PruebaDemoBoxLayout.java
class PruebaDemoBoxLayout
{
{
DemoBoxLayout aplicacion = new DemoBoxLayout();
}
}
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ón

fill 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 componente
gridy La fila en la que se colocará el componente
gridWidth El número de columnas que ocupa el componente
gridheight El número de filas que ocupa el componente
weightx 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
import java.awt.*;
public class DemoGridBag extends JFrame

{
private GridBagLayout esquema;
private GridBagConstraints restricciones;
// configurar GUI
public DemoGridBag()
{
super( "GridBagLayout" );
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" );
// 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
// fill es BOTH para boton3

restricciones.weightx = 0;
restricciones.weighty = 0;
// 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 );
setSize( 300, 150 );

setVisible( true );
} // 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
class PruebaDemoGridBag
{
{

DemoGridBag aplicacion = new DemoGridBag();
}
}
Salida:
Ejemplo 3 GridBagLayout
DemoGridBag2.java
import java.awt.*;
public class DemoGridBag2 extends JFrame

{
private GridBagLayout esquema;
private GridBagConstraints restricciones;
// configurar GUI
public DemoGridBag2()
{
super( "GridBagLayout" );
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.gridwidth = GridBagConstraints.REMAINDER;
agregarComponente( campoTexto );
// botones[0] -- weightx y weighty son 1: fill es BOTH

restricciones.gridwidth = 1;
agregarComponente( botones[ 0 ] );

restricciones.gridwidth = GridBagConstraints.RELATIVE;

// cuadroCombinado -- weightx es 1: fill es BOTH

agregarComponente( cuadroCombinado );
// botones[3] -- weightx es 1: fill es BOTH


restricciones.gridwidth = GridBagConstraints.RELATIVE;
// lista -- weightx y weighty son 1: fill es BOTH

agregarComponente( lista );
setSize( 300, 200 );

setVisible( true );
// 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

class PruebaDemoGridBag2
{
{
DemoGridBag2 aplicacion = new DemoGridBag2();
}
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 ();
}

{
}
}
}
public boolean handleEvent (Event e)

{
if ((e.target == entrada) && (e.id == Event.ACTION_EVENT))
{
try
{
o.writeUTF ((String) e.arg);
o.flush ();
}
{
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

import java.net.*;
import java.io.*;
import java.util.*;
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////////////
}
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 ();
}

{
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 ();
}

{
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.*;
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 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();
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);
ventana.setVisible(true);
// ventana.setSize(499,570);
ventana.pack();
}
{
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.*;
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 ();
}
}

{
System.exit(0);
}
public void windowClosing(WindowEvent e) //--- CERRADO DE VENTANA

{
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.*;
public class PruebaServidor
{
{
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 Panel panel1, panel2;
public InterfazGraficaServidor()
{
ventana = new Frame(" PROYECTO (3) UNIDAD 7: CONSOLA DEL SERVIDOR");
label1= new Label(" JUAN CARLOS CERON GUERRERO \n 2-C ING.SISTEMAS COMP.");
}
void visualizar()
{
ventana.setBackground( Color.black ) ;
panel1.setBackground( Color.red ) ;
panel2.setLayout(new FlowLayout());
label1.setBackground( Color.green) ;
consola.append(" SERVIDOR V 1.0 \n INICIALIZANDO"+
"... \n -------------------------------------------------------------"+
"------------------------------------------------------------------\n"+
" EN LINEA");
panel1.add(label1);
EventosServidor obj=new EventosServidor(ventana,salir);

ventana.pack();
}
{
}//InterfazGraficaServidor.actualizar(String);// LLAMA AL METODO ESTATICO
EventosServidor.java

import java.net.*;
import java.io.*;
import java.util.*;
import java.awt.*;
import java.util.Date;
import java.sql.*;
public class EventosServidor extends WindowAdapter implements ActionListener
{
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");
}

{
System.exit(0);
}
public void windowClosing(WindowEvent e) //--- CERRADO DE VENTANA

{
System.exit(0);
}
}
InterfazGraficaCliente.java
import java.awt.*;
public class InterfazGraficaCliente
{
private Panel panel1, panel2,panel3,panel4;

private Button boton1,boton2,boton3,boton4;
public InterfazGraficaCliente()
{
ventana = new Frame(" PROYECTO (3) UNIDAD 7: MENU CLIENTE ");
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 ");
}
void visualizar()
{
ventana.setBackground( Color.black) ;
panel1.setBackground( Color.red) ;
panel3.setBackground( Color.red) ;
panel2.setLayout(new GridLayout(4,1,20,20));
label1.setBackground( Color.green) ;
boton1.setBackground( Color.green) ;
consola.append(" APLICACION CLIENTE \n INICIALIZANDO"+
"... \n ----------------------------------------------------------------"+
"-------------\n"+
"EN LINEA \n");
panel1.add(label1) ;
panel2.add(boton1) ;
panel4.add(panel2) ;
panel4.add(panel3) ;

EventosCliente obj=new EventosCliente(boton1,boton2,boton3,boton4,salir,ventana);
boton1.addActionListener(obj);
ventana.pack();
}
{
}//InterfazGraficaCliente.actualizar(String);// LLAMA AL METODO ESTATICO
EventosCliente.java

import java.net.*;
import java.io.*;
import java.util.*;
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;

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()))
{
try{
EventosCliente.enviar("2");}
}
{
try{
}
{
try{
}
else// if(text.equals(salir.getActionCommand()))
{
System.out.println("JUAN CARLOS CERON GUERRERO \n 2-C ING.
SISTEMAS");
System.exit(0);
}
}
public void windowClosing(WindowEvent e)

{
System.exit(0);
}

}
PruebaServidor.java
import java.net.*;
import java.io.*;
public class PruebaServidor
{
{
InterfazGraficaServidor consolaServidor=new InterfazGraficaServidor();
consolaServidor.visualizar();
EventosServidor x=new EventosServidor();
x.comenzar() ;
}
}
PruebaCliente.java
import java.net.*;
import java.io.*;
public class PruebaCliente
{
{
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 aplicaciones

Grady Booch
Addison Wesley. Longman

• Java 2. Fundamentos de programación
Herbert Schildt
McGraw-Hill
• Java Cómo Programar

Deitel/Deitel
Prentice Hall
• Curso en Programación Avanzada en Java en Español (documento .pdf)
• Java 2
Steven Holzner
Coriolis
• Manual práctico en Español Java 2 (documento .pdf)
• Java Sun Español (documento .pdf)

ManualJavaVersion1 0

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

ManualJavaVersion1 0

Cargado por

Copyright:

Formatos disponibles

Elaborado por: Ing.

Jesús Pando Barrón

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

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

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

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

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

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

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

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

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

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

a) Se activa el Panel de Control

c) Se selecciona Opciones avanzadas

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

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

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

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

2.1. Entorno de Java

public static void main(String args[])

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

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

java Programa1 Esta instrucción ejecuta el programa

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

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

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

2.2. Tipos Primitivos

Tipo Tamaño en bits Valores

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

//una alternativa a este código es

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

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

2.3.1 Estructuras secuenciales

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

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

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

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

Implementación de un contador y sumador

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

3) 2 2 + 4 2 + 6 2 + 8 2 + .... + no. de términos

 0.12   0.2 4   .036 

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

7) 21 + 4 2 + 6 3 + 8 4 + .... + no. de términos

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

2.3.4 Ejercicios adicionales de Estructuras de Control

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

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

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

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

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

Una característica importante de las llamadas a métodos es la promoción de argumentos (o coerción de

Tipo Promociones válidas

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

Los siguientes ejemplos muestran la validez de las promociones

public class Demo

public class Demo

También se puede realizar de la siguiente forma:

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

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

Un Ejemplo alternativo Orientado a Objetos

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

Vehiculo minivan=new Vehiculo();

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