Libro Java

UNIVERSIDAD CONTINENTAL
DE CIENCIAS E INGENIERIA
PROGRAMACIÓN JAVA
MG. RUBÉN GALEAS ARANA
HUANCAYO – PERU
2006
CAPÍTULO I
PROGRAMACIÓN ORIENTADA A OBJETOS
1.1 INTRODUCCIÓN.
Un programa tradicional, que sigue el paradigma estructurado, se basa

fundamentalmente en la ecuación de Wirth:
Algoritmos + Estructuras de Datos = Programas
Esta ecuación se interpreta como que los algoritmos y los datos se tratan por
separado. De esta forma las funciones o procedimientos que tratan estos datos
los van procesando y pasando de unos a otros hasta obtener el resultado
deseado. Pero cuando se lanzó la programación orientada a objetos (POO),
revolucionó la historia de la programación; se introdujeron al lenguaje diario de
los profesionales del área de computación e informática, conceptos tales como
abstracción, encapsulamiento, herencia y polimorfismo; que hicieron que el
modo de pensar y concebir el desarrollo de sistemas informáticos, fuera muy
diferente a lo que había sido hasta ese momento con la programación
estructurada.
La POO es el paradigma de programación más utilizado en la actualidad. Su

consistente base teórica y la amplia gama de herramientas, permiten crear
código a través de diseños orientados a objetos, y esto lo convierte en la
alternativa más adecuada para el desarrollo de aplicaciones avanzadas de
sistemas informáticos de calidad. En la POO se tiene dos elementos
fundamentales, las clases y los objetos.
1.2 CLASES.
Una clase es aquella que describe las características (atributos) y el

comportamiento (métodos) de un conjunto de objetos similares. Se dice que
es un conjunto de objetos, porque varios objetos de características similares
pueden pertenecer a una misma clase. Por lo tanto podemos decir que una
clase es una plantilla implementada en software que describe un conjunto de
objetos con atributos y comportamientos similares.
1.3 OBJETOS.
Cuando hablamos de un objeto, hablamos de pequeños elementos bien

definidos, representaciones verdaderas de objetos que tenemos en la vida real.
Los objetos son aquellos que tienen sus propios atributos y sus propios
comportamientos; es decir cada objeto es único y no puede confundirse con
otro. En la Figura 1.1 se muestra algunas clases y objetos del mundo real.
Mg. Rubén Galeas Arana -2-

Figura 1.1. Ejemplos de clases y objetos del mundo real.
Entonces mediante el uso e implementación de la metodología de

“Programación Orientada a Objetos” intentamos crear objetos de software que
tengan correlación con los objetos del mundo real; por ejemplo en un módulo de
facturación de un sistema de gestión comercial, vamos a crear nuestro objeto
Factura, que tendrá relaciones con nuestro objeto Cliente, y Producto; la
aplicación de esta concepción de trabajo es la que nos permiten aislar cada
componente del resto de la aplicación y de esa forma aprovechar en mayor
medida nuestro esfuerzo, nuestra concentración en el buen funcionamiento de
dichos componentes, nuestro control sobre ellos, más control en la codificación
y por sobre todas las cosas, reutilizar el código escrito.
Definido lo que es una clase y un objeto, ahora podemos definir las cuatro
características principales de la POO que son necesarias para denominarse
como tal.
1.4 ABSTRACCIÓN.
La abstracción se puede definir como la capacidad de examinar algo sin

preocuparse de los detalles internos.
La abstracción es la capacidad de un objeto de cumplir sus funciones

independientemente del contexto en el que se lo utilice; por ejemplo, un objeto
Cliente siempre expondrá sus mismas propiedades y dará los mismos
resultados a través de sus eventos, sin importar el ámbito en el cual se lo haya
creado.
1.5 ENCAPSULAMIENTO.
Esta característica es la que denota la capacidad del objeto de responder a

peticiones a través de sus métodos sin la necesidad de exponer los medios
utilizados para llegar a brindar estos resultados. Por ejemplo el método
MostrarSaldo() del objeto Cliente antes mencionado, siempre nos va a dar el
saldo de la cuenta de un cliente, sin necesidad de tener conocimiento de cuáles
son los recursos que ejecuta para llegar a brindar este resultado.
1.6 HERENCIA.
La herencia es la propiedad que permite a los objetos construirse a partir de otros

objetos.
Una clase se puede dividir en subclases. Las subclases pueden heredar código
y datos de su clase base añadiendo su propio código y datos a la misma.
La herencia impone una relación jerárquica entre clases, en la cual una clase
hija hereda de su clase padre. Si una clase sólo puede recibir características de
otra clase base, la herencia se denomina herencia simple.
Si una clase recibe propiedades de más de una clase base, la herencia se

denomina herencia múltiple.
1.7 POLIMORFISMO.
En un sentido literal, polimorfismo significa la cualidad de tener más de una

forma. En el contexto de POO, el polimorfismo se refiere al hecho de que una
misma operación puede tener diferente comportamiento en diferentes objetos.
Por ejemplo, consideremos la operación sumar. El operador “+” realiza la suma
de dos números de diferente tipo. Además se puede definir la operación de
concatenar dos cadenas mediante el operador “+”.
El término de polimorfismo define la capacidad de que más de un objeto puedan

crearse usando la misma clase de base para lograr dos conceptos de objetos
diferentes.

CAPÍTULO II
PROGRAMACIÓN ORIENTADA A OBJETOS EN
JAVA
2.1 INTRODUCCIÓN.
El lenguaje de programación Java fue desarrollado por Sun Microsystems en

1991. Nace como parte de un proyecto de investigación para desarrollar
software para comunicación entre aparatos electrónicos de consumo como
vídeos, televisores, equipos de música. etc. Durante la fase de investigación
surgió un problema que dificultaba enormemente el proyecto iniciado: cada
aparato tenía un microprocesador diferente y muy poco espacio de memoria:
esto provocó un cambio en el rumbo de la investigación que desembocó en la
idea de escribir un nuevo lenguaje de programación independiente del
dispositivo que fue bautizado inicialmente como Oak y que posteriormente los
propios investigadores lo rebautizaron como JAVA.
Java es un lenguaje de programación de alto nivel con el que se pueden escribir

tanto programas convencionales como para Internet.
Una de las ventajas significativas de Java sobre otros lenguajes de

programación es que es independiente de la plataforma tanto en código fuente
como en código de bytes (binario). Esto quiere decir que el código producido
por el compilador Java puede transportarse a cualquier plataforma que tenga
instalada una máquina virtual Java y ejecutarse (ver Figura 2.1). Pensando en
Internet esta característica es crucial ya que esta red conecta ordenadores muy
distintos. En cambio, C++, por ejemplo, es independiente de la plataforma sólo
en código fuente, lo cual significa que cada plataforma diferente debe
proporcionar el compilador adecuado para obtener el código máquina que tiene
que ejecutarse.
Figura 2.1. Procesos de ejecución de un programa en JAVA.
Según lo expuesto, Java incluye dos elementos: un compilador y un intérprete.

El compilador produce un código de bytes que se almacena en un fichero para
ser ejecutado por el intérprete Java denominado máquina virtual de Java.
Los códigos de bytes de Java son un conjunto de instrucciones

correspondientes a un lenguaje máquina que no es específico de ningún
procesador, sino de la máquina virtual de Java. ¿Dónde se consigue esta
máquina virtual? Hoy en día casi todas las compañías de sistemas operativos y
de navegadores han implementado máquinas virtuales según las
especificaciones publicadas por Sun Microsystems, propietario de Java, para
que sean compatibles con el lenguaje Java. Para las aplicaciones de Internet
(denominadas applets) la máquina virtual está incluida en el navegador y para
las aplicaciones Java convencionales, puede venir con el sistema operativo, con
el paquete Java, o bien puede obtenerla a través de Internet.
2.2 VENTAJAS Y DESVENTAJAS DEL JAVA.
Una de las ventajas más significativas de Java es su independencia de la

plataforma. En el caso de que tenga que desarrollar aplicaciones que tengan
que ejecutarse en sistemas operativos diferentes, esta característica es
fundamental. Un browser compatible con Java deberá ejecutar cualquier
programa hecho en Java, esto ahorra a los usuarios tener que estar insertando
"plug-ins" y demás programas que a veces nos quitan tiempo y espacio en
disco.
Otra ventaja importante de Java es que es un lenguaje de programación

orientado a objetos (POO) y tiene todos los beneficios que ofrece esta
metodología de programación.
Además de ser transportable y orientado a objetos. Java es un lenguaje fácil de

aprender. Tiene un tamaño pequeño que favorece el desarrollo y reduce las
posibilidades de cometer errores: a la vez es potente y flexible.
Java está fundamentado en C++. Esto quiere decir que mucha de la sintaxis y
diseño orientado a objetos se tomó de este lenguaje. Por lo tanto, a los
programadores que estén familiarizados con C++ y la POO les será muy fácil
aprender a desarrollar aplicaciones con Java. Pero e advierte a los
programadores de C++ que en Java no existen punteros ni aritmética de
punteros, las cadenas de caracteres son objetos y la administración de memoria
es automática, lo que elimina la problemática que presenta C++ con las lagunas
de memoria al olvidar liberar bloques de memoria que fueron asignados
dinámicamente.
Java es un lenguaje y por lo tanto puede hacer todas las cosas que puede
hacer un lenguaje de programación: cálculos matemáticos, procesa cadenas,
bases de datos, aplicaciones gráficas, animaciones, sonido, etc..
Si lo que nos interesa son las páginas de Web, ya no tienen que ser estáticas,
se le puede poner toda clase de elementos multimedia y permiten un alto nivel
de interactividad.
Pero en Java no todo es maravilloso, pues, también tiene sus desventajas. Una
desventaja es que los programas hechos en java tienden a ser lentos, debido a
que son programas interpretados y nunca alcanzan la velocidad de un

verdadero programa ejecutable. Al ser java un lenguaje de programación no es
tan fácil de aprender y el tiempo de capacitación es muy alto.
2.3 PRIMER PROGRAMA EN JAVA.
Los ficheros se almacenan con la extensión JAVA, al compilar el código fuente,

crea un uno con extensión CLASS. Java requiere que todo el código resida
dentro de una clase con nombre. El nombre del fichero debe ser el mismo que
el nombre de la clase donde esta la función MAIN.
public class Bienvenida{

public static void main(String args[ ]){
System.out.println(“Bienvenido a JAVA”);
}
}
El programa anterior se puede realizar en algún software java como puede ser
el Jcreator, JBuilder, etc.; con los cuales en el momento de compilar se crea los
archivos Bienvenida.java y Bienvenida.class
2.4 IDENTIFICADORES.
Los identificadores se utilizan como nombres de clase, método y variable. Un

identificador puede ser cualquier sentencia descriptiva de letras en mayúscula o
minúscula, números y los caracteres subrayado (_) y signo de dólar ($). No se
deban comenzar por número. Java diferencia entre mayúsculas/minúsculas, lo
que significa que “VALOR” es un identificador diferente de “Valor”.
En este punto es recomendable aclarar que por convención un identificador que

representa una variable debe comenzar con una letra minúscula, mientras que
los nombres o identificadores de las clases y objetos que se crean en Java
deben comenzar con una letra mayúscula.
2.5 VARIABLES Y TIPOS DE DATOS PRIMITIVOS.
Una variable es un nombre que se asocia con una porción de la memoria del
ordenador, en la que se guarda el valor asignado a dicha variable. En Java
todas las variables se deben declarar antes de usarlas, para declarar un variable
se usa una de las siguientes sintaxis.
tipo identificador1,identificador2,identificador3;
tipo identificador1=valor1,identificador2=valor2;
Donde “tipo” es un tipo de dato primitivo en JAVA; estos datos primitivos se

muestran en la Tabla 2.1.

Tabla 2.1. Tipos de datos primitivos en Java que soporta JAVA
TIPO TAMAÑO RANGO
7 7
byte 8 bits Valores numéricos de –128 a 127 (-2 a 2 -1)
15 15
short 16 bits Valores numéricos de –32 768 a 32 767 (-2 a 2 -1)
31 31
int 32 bits Valores numéricos de –2 147 483 648 a 2 147 483 647 (-2 a 2 -1)
63 63
long 64 bits Valores numéricos de (-2 a 2 -1)
Valores numéricos en coma flotante de simple precisión.
38 38
float 32 bits (-3,40282347 x 10 a 3,40282347 x 10 )
Valores numéricos en coma flotante de doble precisión.

double 64 bits 308 308
-1,7976931348623157 x 10 a 1,7976931348623157 x 10
Valores alfanuméricos que está referido a los caracteres del
char 16 bits
UNICODE, similares al código ASCII.
Bolean 8 bits Solo admite true (verdadero) o false (falso)
Según
String Se utiliza para cadenas de caracteres
longitud
A continuación se muestra un ejemplo en Java utilizando variables y tipos primitivos.
class TiposPrimitivos{
public static void main (String args[]){
byte e1,e2; //variable que almacena un número tipo byte
short e3,e4; //variable que almacena un número tipo short
int e5=301028,e6=45; //variable que almacena un número entero
long e7,e8; //variable que almacena un número tipo long
float f1=13.4f; //variables que almacena un número tipo float
double f2; //variables que almacena un número tipo double
char c1; // variable para almacenar un caracter
String cad1; // variable para almacenar una cadena
e1=-43;
e2=127;
e3=-1248;
e4=30654;
e7=3456656;
e8=-352624;
f2=3.4567e15;
c1='U';
cad1="Universidad Continental siempre primero";
System.out.println("e1 = "+e1+" e2= "+e2);
System.out.println("f1 = "+f1+" f2= "+f2);
System.out.println("c1 = "+c1);
System.out.println("cad1 = "+cad1+"\n");
}
}

2.6 OPERADORES ARITMÉTICOS EN JAVA.
Son aquellos operadores que nos permiten realizar operaciones matemáticas y

se aplican sobre variables del tipo numérico, como se muestra en la Tabla 2.2,
en el cual se muestra la columna resultado para valores dex=20 e y=6.
Tabla 2.2. Operadores aritméticos en Java

Operador Operación Ejemplo Resultado
+ Adición z=x+y z=26
- Sustracción z=x-y z=14
* Multiplicación z=x*y z=120
/ División z=x/y z=3.33333
% Residuo de división z=x%y z=2
++ Incremento en 1 x++ x=21
-- Decremento en 1 y-- y=5
A continuación se muestra un ejemplo en Java utilizando operadores aritméticos y

operadores unitarios.
class OperadorAritmetico{
int x=20,y=6; //variable que almacena un número tipo byte
int k,p;
int suma,resta,multiplicacion,residuo;
float division;
suma=x+y;
resta=x-y;
multiplicacion=x*y;
residuo=x%y;
division=(float) x/y;
x++; // x=x+1
--y; // y=y-1
p=x++; // primero hace p=x y luego x=x+1

k=--y; // primero hace k=y-1 y luego y=y-1
System.out.println();
System.out.println("Suma = "+suma);
System.out.println("Resta = "+resta);
System.out.println("Multiplicacion = "+multiplicacion);
System.out.println("Division = "+division);
System.out.println("Residuo = "+residuo);
System.out.println("Operador ++ = "+x);
System.out.println("Operador -- = "+y);
System.out.println("Operador ++ (p)= "+p);
System.out.println("Operador -- (k)= "+k+"\n");
}
}
Los resultados que se obtienen son:
Suma = 26
Resta = 14
Multiplicacion = 120
Division = 3.3333333
Residuo =2
Operador ++ = 22
Operador -- =4
Operador ++ (p)= 21
Operador -- (k) = 4
2.7 EJEMPLOS DE APLICACIÓN DE TIPOS PRIMITIVOS Y OPERADORES

ARITMÉTICOS EN JAVA.
A continuación mostramos algunos ejemplos en los cuales se pueden observar

las utilidades, limitaciones y el uso correcto de cada tipo primitivo utilizando los
operadores aritméticos en JAVA. Se recomienda que el lector haga algunas
modificaciones a los ejemplos de tal manera que pueda comprobar los límites
de los tipos y los posibles errores que puedan causar dichos cambios.
a) Ejemplo de operaciones con tipos primitivos del tipo BYTE.
class OperadorAritmeticoByte{
byte a1,a2; //variable que almacena un número tipo byte
byte suma,resta,multiplicacion,residuo;
float division;
a1=12;
a2=5;
suma=(byte)(a1+a2);
resta=(byte)(a1-a2);
multiplicacion=(byte)(a1*a2);
division=(float)a1/a2;
residuo=(byte)(a1%a2);
System.out.println("a1 = "+a1+" Tipo byte");

System.out.println("a2 = "+a2+" Tipo byte\n");
System.out.println("Residuo = "+residuo+"\n");
}
}
b) Ejemplo de operaciones con tipos primitivos del tipo SHORT.
class OperadorAritmeticoShort{
short a1,a2; //variable que almacena un número tipo short
short suma,resta,multiplicacion,residuo;
float division;
a1=30;
a2=11;
suma=(short)(a1+a2);
resta=(short)(a1-a2);
multiplicacion=(short)(a1*a2);
Mg. Rubén Galeas Arana - 10 -
residuo=(short)(a1%a2);
System.out.println("a1 = "+a1+" Tipo short");

System.out.println("a2 = "+a2+" Tipo short\n");
}
}
c) Ejemplo de operaciones con tipos primitivos del tipo INT.
class OperadorAritmeticoInt{
int a1,a2; //variable que almacena un número tipo int
int suma,resta,multiplicacion,residuo;
float division;
a1=30;
a2=11;
suma=a1+a2;
resta=(int)(a1-a2);
multiplicacion=a1*a2;
residuo=(int)(a1%a2);
System.out.println("a1 = "+a1+" Tipo int");

System.out.println("a2 = "+a2+" Tipo int\n");
}
}
d) Ejemplo de operaciones con tipos primitivos del tipo LONG.
class OperadorAritmeticoLong{
long a1,a2; //variable que almacena un número tipo long
long suma,resta,multiplicacion,residuo;
float division;
a1=2147483650L; // el literal L es necesario
a2=7;
suma=(long)(a1+a2);
resta=a1-a2;
residuo=(long)(a1%a2);
System.out.println("a1 = "+a1+" Tipo long");

System.out.println("a2 = "+a2+" Tipo long\n");
}
}
e) Ejemplo de operaciones con tipos primitivos del tipo FLOAT.
class OperadorAritmeticoFloat{
float a1,a2; //variable que almacena un número tipo float
float suma,resta,multiplicacion;
float division;
a1=12.78F; // El literal F es obligatorio
a2=5;
suma=a1+a2;
resta=(float)(a1-a2);
division=a1/a2;
System.out.println("a1 = "+a1+" Tipo float");

System.out.println("a2 = "+a2+" Tipo float\n");
System.out.println("Division = "+division+"\n");
}
}
f) Ejemplo de operaciones con tipos primitivos del tipo DOUBLE.
class OperadorAritmeticoDouble{
double a1,a2; //variable que almacena un número tipo double
double suma,resta,multiplicacion;
double division;
a1=12.64E300;
a2=5.22e300;
suma=(double)(a1+a2);
resta=a1-a2;
multiplicacion=(double)(a1*a2); // provoca un desbordamiento
division=a1/a2;
System.out.println("a1 = "+a1+" Tipo double");

System.out.println("a2 = "+a2+" Tipo double\n");
System.out.println("Multiplicacion = "+multiplicacion); //Sale infinito
System.out.println("Division = "+division+"\n");
}
}

2.8 ESCRITURA DE FÓRMULAS MATEMÁTICAS EN JAVA.
En todo lenguaje de programación las fórmulas matemáticas se tienen que

escribir en una sola línea, para ello muchas veces se hace uso de los
paréntesis para una evaluación correcta de las operaciones. En la siguiente
tabla se muestra algunos ejemplos de la forma correcta de escribir fórmulas
matemáticas en JAVA.
Tabla 2.2. Tipos de datos primitivos en Java que soporta JAVA

En un lenguaje de Valor calculado para x
Fórmula matemática
programación cuando a=12; b=3; c=10
3a + 2b − 6
x= x=(3*a+2*b-6)/c x=3,6
c
2a a + b
y= + y=2*a/b+(a+b)/(3*c) y=8,5
b 3c
3a
z = −5a +
2−b z= -5*a+3*a/(b+(2-b)/(2*b-c)) z=-48,923077
b+
2b − c
3a b
w= + − 2a
4b a w=3*a/(4*b)+b/(c+a/b)-2*a w=-20,785715
c+
b
En el siguiente ejemplo se muestra es uso de las fórmulas de la tabla 2.2.
class FormulasMatematicas{
int a=12,b=3,c=10;
float x,y,z,w;
x=(3*a+2*b-6)/c;
y=2*a/b+(a+b)/(3*c);
z= -5*a+3*a/(b+(2-b)/(2*b-c));
w=3*a/(4*b)+b/(c+a/b)-2*a;
System.out.println("x = "+x);
System.out.println("y = "+y);
System.out.println("z = "+z);
System.out.println("w = "+w+"\n");
}
}
Los resultados que se obtienen son los siguientes:
x=3.0
y=8.0
z=-48.0
w=-21.0
Pero si observamos la tercera columna de la tabla 2.2 los resultados no

coinciden, lo que ha pasado es que se hecho la combinación de operaciones de
números enteros con números reales y en JAVA eso hay que tener mucho
cuidado; entonces se debe hacer las correcciones correspondientes, por lo
tanto el programa correctamente escrito sería:
class FormulasMatematicas{
int a=12,b=3,c=10;
float x,y,z,w;
x=(float)(3*a+2*b-6)/c;
y=(float)2*a/b+(float)(a+b)/(3*c);
z= -5*a+(float)3*a/(b+(float)(2-b)/(2*b-c));
w=(float)3*a/(4*b)+(float)b/(c+(float)a/b)-2*a;
System.out.println("x = "+x);
System.out.println("y = "+y);
System.out.println("z = "+z);
System.out.println("w = "+w+"\n");
}
}
2.9 CLASES PREDEFINIDAS EN JAVA.
Antes de continuar es conveniente saber que en JAVA hay un montón de clases

predefinidas y utilizables. Éstas vienen en las bibliotecas estándar del JAVA. A
continuación mostraremos algunos de ellos.
• java.lang - clases esenciales, números, strings, objetos, compilador, runtime,

seguridad y threads (es el único paquete que se incluye automáticamente en
todo programa Java).
• java.io - clases que manejan entradas y salidas de datos.
• java.util - clases útiles, como estructuras genéricas, manejo de fecha, hora y
strings, número aleatorios, etc.
• java.net - clases para soportar redes: URL, TCP, UDP, IP, etc.
• java.awt - clases para manejo de interface gráfica, ventanas, etc.
• java.awt.image - clases para manejo de imágenes
• java.awt.peer - clases que conectan la interface gráfica a implementaciones
dependientes de la plataforma (motif, windows)
• java.applet - clases para la creación de applets y recursos para reproducción
de audio.
2.10 OPERACIONES DE ENTRADA Y SALIDA DE DATOS.
Todo lenguaje de programación, para que sea práctico debe tener

procedimientos para entrada y salida de datos. En este caso en JAVA la
entrada de datos se almacenan en memoria de dos formas:
1°) Asignando valores a las variables desde el mismo programa, desde el
momento de la declaración de la variable.
Por ejemplo:
int x=12,y=10;
float a;
a=12.345F;
2°) Leyendo datos desde el teclado, para ello se utiliza la clase java.io
Para la salida de datos se utilizan el método System.out.println(). Por ejemplo

System.out.println(x+” ”+a);
En los siguientes listados de programas en JAVA se puede visualizar el uso de

las operaciones de entrada y salida de datos; estos programas calculan el área
de un rectángulo cuando se ingresa la base y su altura de la Figura 2.2.
Figura 2.2. Área de una rectángulo
class AreaRectangulo01{
float base=12.54F,altura=20.5F;
float area;
area=base*altura;
System.out.println("area = "+area+" m2 \n");
}
}
Ahora modificamos el programa para ingresar los datos desde el teclado:

import java.io.*; // esta clase es obligatorio
class AreaRectangulo02{
public static void main (String args[]) throws IOException{
// Definir un flujo de caracteres de entrada: kkk
InputStreamReader yyy = new InputStreamReader(System.in);
BufferedReader kkk = new BufferedReader(yyy);
String teclado; // variable para almacenar una línea de texto
float base,altura,area; //variables del tipo float
System.out.print("Ingrese base (m): ");
teclado = kkk.readLine(); // leer una línea de texto
base=Float.parseFloat(teclado);//convierte cadena a real
System.out.print("Ingrese altura (m): ");
altura=Float.parseFloat(teclado);//convierte cadena a real
area=base*altura;
System.out.println("area = "+area+" m2 \n");
}
}

2.11 RECOMENDACIONES PARA UNA BUENA PROGRAMACIÓN.
a) Los programas deben ser legibles y comprensibles, utilizando la indentación

correcta para cada bloque de programa; en JAVA un bloque de programa se
separa abriendo y cerrando el símbolo llaves { }.
b) Se deben poner comentarios que describen el propósito de un programa o
segmentos de programa. Los comentarios en JAVA se realiza utilizando dos
barras continuas (// comentario).
c) En la lectura y salida de datos es necesario poner comentarios para que el
usuario del programa pueda saber qué dato ingresar y qué dato o valor está
obteniendo. Recuerde que el programa que Ud. haga lo puede utilizar
cualquier otra persona que no necesariamente tiene conocimientos de
programación ni de computación. Por ejemplo para pedir que ingrese la base
de un rectángulo se debe poner el siguiente comentario “Ingrese base (m): “.
d) Los programas deben ser eficientes, evitando hacer cálculos innecesarios.
Por ejemplo para determinar las raíces de una ecuación cuadrática de la
forma Ax2+Bx+C=0 se sabe que se debe utilizar la siguiente fórmula:
− B ± B 2 − 4AC
x=
2A
Entonces en el programa se podría poner de la siguiente manera:
x1=(-B+sqrt(B*B-4*A*C))/(2*A);
x2=(-B-sqrt(B*B-4*A*C))/(2*A);
Pero sería mejor de la siguiente manera:
D=B*B-4*A*C;
N=2*A;
x1=(-B+sqrt(D))/N;
x2=(-B-sqrt(D))/N;
2.12 ESTRUCTURAS CONDICIONALES.
En la mayor parte de los problemas (por no decir todos) que se presentan en la

vida cotidiana y que se pueden solucionar mediante un programa
computacional, siempre presentan algunas condiciones que harán cambiar una
estructura secuencial. Las estructuras condicionales se utilizan para tomar
decisiones lógicas; por eso muchas veces se les llaman estructuras selectivas,
porque se tiene que seleccionar una determina acción de acuerdo al valor de la
condición planteada.
Las condiciones se especifican usando los operadores de relación (menor,

mayor, igual, etc.) y los operadores lógicos (Y, O, Negación, etc.), además se
debe tener en cuenta que las condiciones pueden ser simples o complejas, pero
siempre tendrán un único ya sea verdadero (true) o falso (false).
a) Operadores de relación.
Estos operadores se utilizan para expresar condiciones y describen una

relación entre dos valores. A través de los operadores de relación se
construyen condiciones que serán evaluados como VERDADERO (true) o
FALSO (false); en un programa se puede hacer comparaciones tanto con
datos numéricos (enteros y reales), con datos del tipo carácter o del tipo
cadena. En la Tabla 2.3 se observa los operadores de relación que se usan
en JAVA.
Tabla 2.3. Operadores de relación en JAVA

Operador de relación Equivalente
Significado
en JAVA matemático
> Mayor que >
< Menor que <
>= Mayor o igual que ≥
<= Menor o igual que ≤
== Igual que =
!= Diferente que (No igual que) ≠
b) Operadores lógicos.
Los operadores lógicos sirven para hacer condiciones complejas, esto se

logra combinando con los operadores de relación; al igual que el caso
anterior el resultado será VERDADERO (true) o FALSO (false). En la
Tabla 2.4 se puede observar los operadores lógicos que existen en JAVA.
Tabla 2.4. Operadores lógicos en JAVA

Operador
Significado
Lógico en JAVA
&& Y (conjunción)
|| O (disyunción)
! No (Negación)
En la Tabla 2.5 se muestra los valores que devuelve después de trabajar con
los operadores lógicos.
Tabla 2.5.
Valores de Variables Resultados de los Operadores Lógicos
A B (A)&&(B) (A)| |(B) !(A)
V V V V F
V F F V F
F V F V V
F F F F V
c) Estructura condicional simple (if).
Esta estructura es la más común de todas, permite ejecutar una instrucción (o

secuencia de instrucciones) si se evalúa una condición como verdadera; en
la Tabla 2.6 se observa el diagrama de flujo y su respectiva codificación en
JAVA para una estructura condicional simple.
Tabla 2.6. Estructura IF simple en JAVA
DIAGRAMA DE FLUJO ESTRUCTURA EN JAVA
1) If unilínea.
if (condición) sentenciaV;
F
Condición 2) If multilínea.
if (condición) {
V Instrucción 1;
Instrucción 2;
AcciónV Instrucción 3; AcciónV
:
.
Instrucción N;
};
En este caso el grupo de instrucciones (acciónV) sólo se ejecutan si la

condición es verdadera mientras que si la condición es falsa no se ejecuta
nada simplemente salta a la siguiente instrucción de la estructura condicional.
d) Estructura condicional doble.
En la Tabla 2.7 se observa el diagrama de flujo y su respectiva codificación

en JAVA para una estructura condicional simple.
Tabla 2.7. Estructura IF doble en JAVA

1) If unilínea.
if (condici’on) sentenciaV; else sentenciaF;
2) If multilínea.
V F if (condición) {
Condición Instrucción 1;
Instrucción 2;
Instrucción 3; AcciónV
AcciónV AciónF :
.
Instrucción N;
}
else {
Instrucción 1;
Instrucción 2;
Instrucción 3; AcciónF
:
.
Instrucción N;
};
En este caso el grupo de instrucciones (acciónV) se ejecutan si la condición

es verdadera, pero si la condición es falsa se ejecuta el grupo de
instrucciones (acciónF).
En el siguiente el listado de un programa en JAVA se puede observar el uso

de la estructura condicional IF.
class EstructuraIF{
// Definir un flujo de caracteres de entrada: flujoE

int dato1,dato2,menor; //variables del tipo entero
int suma,resta,multiplicacion;
float division;
System.out.print("Ingrese dato 1: ");

dato1=Integer.parseInt(teclado);//convierte cadena a entero
System.out.print("Ingrese dato 2: ");

dato2=Integer.parseInt(teclado);//convierte cadena a entero
if (dato1<=dato2) menor=dato1;else menor=dato2;
System.out.println("\nEl menor es = "+menor+"\n");
if (dato1>dato2){
suma=dato1+dato2;
resta=dato1-dato2;
System.out.println("La suma es = "+suma);
System.out.println("La resta es = "+resta+"\n");
} // no se debe poner punto y coma
else {
multiplicacion=dato1*dato2;
division=(float)dato1/dato2;
System.out.println("La multipliacion es = "+multiplicacion);
System.out.println("La division es = "+division+"\n");
}
}
}
e) Estructura Condicional Múltiple.
Este es un caso especial, pero muy utilizado en la práctica, sobre todo

cuando se diseña sistemas de menús, en el cual es necesario seleccionar
más de dos condiciones posibles. La estructura de decisión múltiple evaluará
una expresión que podrá tomar N valores distintos (1; 2; 3; ... ; N). Según se
elija uno de estos valores en la condición, se realizará una de las N acciones.
En la Tabla 2.8 se observa el diagrama de flujo y su respectiva codificación
en JAVA para una estructura condicional múltiple.

Tabla 2.8. Estructura condicional múltiple (switch) en JAVA
switch (Expresión) {
case valor1:
instrucción1;
instrucción2;
instrucción3; Acción 1
M
instrucciónN;
Valor 1 Valor N break;
Expresión case valor2:
instrucción1;
Valor 2 Valor 3 instrucción2;
instrucción3; Acción 2
M
Acción 1 Acción 2 Acción 3 ... Acción N
instrucciónN;
break;
M
default:
instrucción1;
instrucción2;
instrucción3; Acción Otro
M
instrucciónN;
};
En el siguiente listado de un programa en JAVA se muestra una aplicación de

la estructura condicional múltiple.

class DiaSemana{
// Definir un flujo de caracteres de entrada: flujoE

int dia; //variables del tipo entero
System.out.print("Ingrese el numero de un mes: ");

dia=Integer.parseInt(teclado);//convierte cadena a entero
switch (dia){
case 1: System.out.println("lunes");break;
case 2: System.out.println("martes");break;
case 3: System.out.println("miercoles");break;
case 4: System.out.println("jueves");break;
case 5: System.out.println("viernes");break;
case 6: System.out.println("sabado");break;
case 7: System.out.println("domingo");break;
default: System.out.println("Este dia no existe");break;
}
}
}
2.13 ESTRUCTURAS DE CONTROL REPETITIVAS.
En todos los lenguajes de programación modernos, necesariamente tienen que

considerar las estructuras de control repetitivas o de iteraciones también
llamadas “bucles”. Los bucles son segmentos de programa cuyas instrucciones
se repiten varias veces mientras cumpla una condición, a continuación
describiremos algunos conceptos necesarios para comprender las estructuras
de control repetitivas.
a) Contador.
Los procesos repetitivos son la base del uso de computadoras. En estos

procesos se necesitan contar los sucesos o acciones internas del bucle. Un
contador es una variable cuyo valor se incrementa o decrementa de uno en
uno.
En JAVA existen dos operadores que permiten incrementar la variable de uno

en uno o decrementar de uno en uno, a estos operadores se les denomina
operadores unarios. Por ejemplo si el valor de X es 20 cuando se utiliza los
operadores, su valor se muestra en la Tabla 2.9.
Tabla 2.9. Operadores unarios en JAVA
Si X=20
Operador en
Operación Ejemplo inicialmente su
JAVA
resultado es
++ Incremento X++ X=21
-- Decremento X-- X=19
El operador unario ++ es equivalente a X=X+1; mientras que el -- es

equivalente a X=X-1. Estos dos operadores funcionan cuando las variables
aumentan o disminuyen de uno en uno.
Aquí sería bueno aclarar algunos otros usos de los operadores unarios; en el
siguiente bloque de programa, se muestra algunos usos de estos operadores:
x++; // es equivalente a x=x+1

--y; // es equivalente a y=y-1
p=x++; // primero hace p=x y luego x=x+1

k=--y; // primero hace k=y-1 y luego y=y-1
b) Acumulador.
Un acumulador es una variable cuya misión es almacenar cantidades

variables de valores en la misma variable. Este tipo de variable es muy
común utilizar para totalizar por ejemplo en sumas, promedios, etc.. Los
siguientes son ejemplos de acumuladores en JAVA.
suma=10;
suma=suma+20;
suma=suma+50;
En el ejemplo anterior el valor de la variable SUMA acumulada es de 80.
c) Estructura Repetitiva “while”.
La estructura repetitiva “while” es aquella en la que el número de iteraciones

no se conoce por anticipado y es que el cuerpo del bucle se repite mientras la
condición sea verdadera. En la Tabla 2.10 se observa el diagrama de flujo y
su respectiva codificación en JAVA para la estructura repetitiva “while”.
Tabla 2.10. Estructura repetitiva “while” en JAVA

while (condición) {
F instrucción1;
Condición instrucción2;
instrucción3; AciónV
V M
instrucciónN;
AcciónV };
En este caso mientras la condición sea verdadera siempre se irá ejecutando

el grupo de instrucciones (AcciónV). En este caso se deben tener en cuenta
los siguientes aspectos:
- Si a la primera evaluación la condición es falsa el grupo de instrucciones

(AcciónV) no se ejecutarán ni una sola vez, es decir saltará directamente a
la siguiente instrucción del bucle “while”.
- Si la condición en ningún momento se vuelve falso, el bucle se hace infinito,

es decir, cuando se utiliza el bucle “while” se debe tener cuidado en que de
alguna forma la condición se haga falso.
d) Estructura Repetitiva “do-while”.
La estructura repetitiva “do-while” es aquella en la que el número de

iteraciones, al igual que el anterior, no se conoce por anticipado y es que el
cuerpo del bucle se repite hasta que la condición sea falsa; es decir esta
estructura es similar al anterior con la única diferencia que la condición se
evalúa al final del bucle. En la Tabla 2.11 se observa el diagrama de flujo y
su respectiva codificación en JAVA para la estructura repetitiva “do-while”.

Tabla 2.11. Estructura repetitiva “do-while” en JAVA
do {
instrucción1;
AcciónV instrucción2;
instrucción3; AcciónV
M
V instrucciónN;
Condición } while (condición);
En este caso el grupo de instrucciones (AcciónV) se ejecutará hasta la

condición se haga falsa. En este caso se deben tener en cuenta los
siguientes aspectos:
- Como la condición se evalúa al final, el grupo de instrucciones (AcciónV) se

ejecuta por lo menos una vez.
- Si la condición en ningún momento se vuelve falso, el bucle se hace infinito,

es decir, cuando se utiliza el bucle “do-while” se debe tener cuidado en que
de alguna forma la condición se haga falso.
e) Estructura Repetitiva “for”.
Esta estructura se inicia con un “contador” que tiene un valor inicial (V i) y un

valor final (Vf) y que en cada iteración se incrementa generalmente de uno en
uno; aunque en JAVA se puede incrementar de dos en dos o de tres en tres,
etc.; entonces la cantidad de veces que se ejecuta el bucle será mientras que
el valor actual del “contador” sea menor o igual al valor final (V f). En esta
estructura el incremento en cada iteración es automática. En la Tabla 2.12 se
observa el diagrama de flujo y su respectiva codificación en JAVA para la
estructura repetitiva “for”.
Tabla 2.12. Estructura repetitiva “for” en JAVA

for (variable=Vi;variable<=Vf;variable=variable+N); {
instrucción1;
F
Condición instrucción2;
instrucción3; AcciónV
V
M
instrucciónN;
AcciónV };

Como un ejemplo de aplicación, podríamos elaborar un programa para
determinar la suma de “N” números enteros que se ingresan desde el teclado
con las tres formas de estructuras repetitivas que existen en JAVA y poder
compararlos. A continuación se hace el listado del programa
correspondiente:
Haciendo uso del “while” sería:
class UsoWhile{

String teclado;
int numeroDatos;
System.out.print("Ingrese el numero de datos: ");

teclado = kkk.readLine();
numeroDatos=Integer.parseInt(teclado);
int dato;
int i=1; // declaración de contador
int suma=0; // declaración de acumulador
while(i<=numeroDatos){
System.out.print("Ingrese dato: ");
dato=Integer.parseInt(teclado);
suma=suma+dato;
i=i+1;
};
System.out.println("\nLa suma total es: "+suma+"\n");

};
}
Haciendo uso del “do-while” sería:
class UsoDoWhile{

String teclado;
int numeroDatos;

int dato;
int i=0; // declaración de contador
do{
i++;
System.out.print("Ingrese dato: ");
dato=Integer.parseInt(teclado);
suma=suma+dato;
}while(i<numeroDatos);

};
}
Haciendo uso del “for” sería:
class UsoFor{

String teclado;
int numeroDatos;

int dato;
int i; // declaración de contador
for(i=1;i<=numeroDatos;i++){
System.out.print("Ingrese dato("+i+"): ");
dato=Integer.p arseInt(teclado);
suma=suma+dato;
};

};
}
Cuando hacemos correr el programa anterior para 5 datos, los resultados del
programa se muestran en la Figura 2.3. En forma similar debe salir para los
bucles “while” y “do-while”.

Figura 2.3. Resultado de la ejecución del bucle “for”
f) Sentencia “break”.
Esta sentencia cuando se ubica dentro de un bucle “while”, “do-while” o “for”;

fuerza la culminación del bucle, sin respetar las condiciones del bucle y salta
a la siguiente sentencia que continúa al bucle.
g) Sentencia “continue”.
Esta sentencia cuando se ubica dentro de un bucle “while”, “do-while” o “for”;

fuerza al bucle a comenzar la siguiente iteración sin que llegue al final del
bucle.
2.14 LA CLASE MATH.
La clase Math encuentra dentro la clase predefinida java.lang.Math, la clase

Math contiene atributos y métodos que sirven para desarrollar operaciones
matemáticas y numéricas básicas tal como la potenciación, logaritmo, raíz
cuadrada, todo tipo de operaciones trigonométricas, etc..
A continuación se muestran los principales atributos y métodos de la clase Math

de JAVA.
a) Atributos.
- static double E. Devuelve un valor constante que corresponde a

2,71828182845904 que corresponde a la base de los logaritmos naturales.
- static double PI. Devuelve un valor constante que corresponde a
3,1415926535897932 que corresponde al valor de “pi”.
b) Métodos.
- static double abs(double a). Retorna el valor absoluto de un número del

tipo double.
- static float abs(float a). Retorna el valor absoluto de un número del tipo
float.
- static int abs(int a). ). Retorna el valor absoluto de un número del tipo int.
- static long abs(long a). Retorna el valor absoluto de un número del tipo
long.
- static double acos(double a). Retorna el valor del arco seno de un número
y cuyo resultado es un ángulo expresado en radianes.
- static double asin(double a). Retorna el valor del arco coseno de un
número y cuyo resultado es un ángulo expresado en radianes.
- static double atan(double a). Retorna el valor del arco tangente de un
número y cuyo resultado es un ángulo expresado en radianes.
- static double cos(double a). Retorna el valor del coseno de un ángulo
expresado en radianes.
- static double exp(double a). Retorna el valor de e a, e es la base de los
logaritmos naturales.
- static double log(double a). Retorna el valor del logaritmo natural de un
número.
- static double max(double a, double b). Retorna el mayor valor de dos
números del tipo double.
- static float max(float a, float b). Retorna el mayor valor de dos números del
tipo float.
- static int max(int a, int b). Retorna el mayor valor de dos números del tipo
int.
- static long max(long a, long b). Retorna el mayor valor de dos números del
tipo long.
- static double min(double a, double b). Retorna el menor valor de dos
números del tipo double.
- static flota min(float a, float b). Retorna el menor valor de dos números del
tipo float.
- static int min(int a, int b). Retorna el menor valor de dos números del tipo
int.
- static long min(long a, long b). Retorna el menor valor de dos números del
tipo long.
- static double pow(double a, double b). Retorna el valor de a b, donde a es
el primer argumento y b el segundo argumento.
- static double random(). Retorna un valor aleatorio entr 0 y 1.
- static long round(double a). Retorna un valor redondeado del argumento
que es del tipo double.
- static int round(float a). Retorna un valor redondeado del argumento que
es del tipo double.
- static double sin(double a). Retorna el valor del seno de un ángulo
- static double sqrt(double a). Retorna la raíz cuadrada del argumento a .
- static double tan(double a). Retorna el valor de la tangente de un ángulo
- static double toDegrees(double angrad). Retorna un valor que está en
radianes convertido en grados sexagesimales.
- static double toRadians(double angdeg). Retorna un valor que está en
grados sexagesimales convertido en radianes.

Una aplicación de la clase Math se muestra en el siguiente listado de
programa, que calcula el valor de la siguiente función matemática cuando se
ingresa el valor de x desde el teclado.
2 + ln( x + 1) − x.sen ( x )
y=
2,3.x + cos( π / 5) + x 3, 2

import java.lang.Math; // esta clase no es obligatorio
class FuncionesMatematica{
String teclado;
double x,y;
System.out.print("Ingrese el valor de x: ");

x=Double.parseDouble(teclado);
y=(2+Math.log(x+1)-x*Math.sin(x))/(2.3*x+Math.cos(Math.PI/5)+Math.pow(x,3.2));
System.out.println("y = "+y+"\n");
}
}
Después de ejecutar el programa cuando se ingresa el valor de x=5 el valor

de y es igual a 0,04646932973591071 y cuando x=4,21 el valor de y es igual
a 0,06675221443413511.
EJERCICIOS DE APLICACIÓN DE ESTRUCTURAS CONDICIONES Y DE

CONTROL
01. Se desea determinar el promedio de un conjunto de N números reales (positivos o negativos)

que se deben ingresar desde el teclado.
02. Se desea determinar el promedio de un conjunto de números enteros (positivos o negativos)

que se deben ingresar desde el teclado. El ingreso de datos debe terminar cuando se ingresa 0
(cero).
03. Se desea visualizar por pantalla los números enteros del 1 al 10 en una sola fila todos
separados por comas.
04. Se desea visualizar por pantalla los números enteros del 10 al 1 en una columna.
05. De un conjunto de N números enteros (sólo positivos) que se deben ingresar desde el teclado
se desea saber cuántos de ellos son números pares y cuántos son números impares.
06. Se desea calcular el resultado de la siguiente serie:

1 1 1 1
E = 1+ + + +L+
2 3 4 N
El valor de N se debe ingresar desde el teclado y su valor debe estar entre 1 y 20.
1 2 3 N
E= + + +L+
2 3 4 N +1
1 2 3 N
E= − + −L±
2 3 4 N +1
09. Un comerciante registra sus ventas diarias en una semana de lunes a domingo con sus
respectivos montos. El comerciante desea saber el monto total vendido en la semana, el
promedio de ventas diario en dicha semana, el día que vendió más con su monto respectivo y el
día que vendió menos con su respectivo monto.
El formato de salida de información debe ser:
Monto total vendido en la semana S/. xxxxxx.xx

Promedio de ventas diario xxxxxx.xx
Venta mayor xxxxxx.xx (martes).
Venta menor xxxxxx.xx (lunes).

CAPÍTULO III
ARREGLOS EN JAVA
Hasta el momento sólo se han tratado programas con tipos de datos primitivos de
JAVA (enteros y reales), sin embargo JAVA proporciona al programador la
posibilidad de crear unos tipos de datos estructurados. Un tipo de dato
estructurado es aquel que se compone de más de un dato primitivo, como es el
caso de los arreglos.
Un arreglo es un conjunto de variables del mismo tipo que comparten un mismo

nombre, cada valor individual del arreglo se denomina elemento y cada uno de
ellos pueden almacenar valores diferentes, pues, son diferenciados por subíndices.
Los arreglos permiten trabajar con grandes cantidades de información, con los
cuales se puede por ejemplo ordenar los datos (de mayor a menor o viceversa),
realizar una búsqueda, añadir datos, borrar datos, etc.. Básicamente los arreglos
se clasifican en dos tipos que son:
3.1 ARREGLOS UNIDIMENSIONALES.
Un ARREGLO UNIDIMENSIONAL (lista o vector), básicamente se caracteriza

por tener un solo subíndice. Por ejemplo si quisiéramos almacenar las notas de
los alumnos de un determinado salón, donde existen 15 alumnos, se podría
utilizar el vector llamado “notas” y cuyos elementos serían: notas[0], notas[1],
notas[2], notas[3], ... ,notas[14]; todos ellos del tipo entero. Es muy importante
tener en cuenta que el primer elemento de la lista se almacenará y referenciará
a lo largo del programa en la posición 0.
En JAVA, el arreglo “notas” se crea y declara de la siguiente manera:
int notas[ ]=new int[15];
En JAVA no existen arreglos tradicionales como en otros lenguajes de

programación, lo que existe es un objeto, por tanto se tiene que usar el
operador new antes de empezar a procesar el arreglo.
Otros ejemplos de declaraciones de arreglos en JAVA, serían:
int edades[]= new int[12];

float sueldos[]=new float[5];
float venta[3]={40.85f,65.30f,33.33f};
String municipios[]={"Huancayo","El Tambo","Chilca"};
En los dos últimos casos, se observa que también pueden crearse listas ya con
tamaño fijo e inicializadas o cargadas.

A continuación se muestra el ejemplo en el cual se determina la suma de N
datos que se ingresan desde el teclado y que se almacenan en la lista “dato”
class UsoLista{

String teclado;
int numeroDatos;

int dato[]=new int[5]; // creación y declaración de la lista "dato"

// procedimiento para almacenar datos desde el teclado

for(i=1;i<=numeroDatos;i++){
System.out.print("Ingrese dato("+i+"): ");
dato[i]=Integer.parseInt(teclado);
};
// procedimiento para procesar los datos almacenados

for(i=1;i<=numeroDatos;i++)
suma=suma+dato[i]; // Observe que no se utiliza las llaves { }
// procedimiento para imprimir los datos almacenados

System.out.println("\nLos datos almacenados son:\n");
for(i=1;i<=numeroDatos;i++)
System.out.print(dato[i]+"\t");
System.out.println("\n\nLa suma total es: "+suma+"\n");

};
}
Una observación importante con respecto al programa anterior es que se

creado la lista “dato” pero sólo para 5 elementos, el cual significa que el número
de datos máximo debe ser 4 ya que se debe recordar que los subíndices de los
elementos se inician en cero, sin embargo en el programa se inicia con uno.
A continuación se puede observar otro ejemplo donde se usan de diversas

formas los arrays unidimensionales.
class UsoLista01{
int dato[]={10,23,44,55};
float sueldo[]={40.85f,65.30f,33.33f};
String municipio[]={"Huancayo","El Tambo","Chilca"};
System.out.println("\nLos datos enteros almacenados son:");

for(i=0;i<4;i++)
System.out.print(dato[i]+"\t");
System.out.println("\n\nLos datos reales almacenados son:");

for(i=0;i<3;i++)
System.out.print(sueldo[i]+"\t");
System.out.println("\n\nLos datos tipo cadena almacenados son:");

for(i=0;i<3;i++)
System.out.println("- "+municipio[i]);
System.out.println("\n");
};
}
3.2. ARREGLOS BIDIMENSIONALES.
Un ARREGLO BIDIMENSIONAL (tabla o matriz), básicamente se caracteriza

por tener dos subíndices, el primer subíndice representa a las filas y el segundo
representa a las columnas. Por ejemplo la siguiente matriz tiene 3 filas y 5
columnas.
 3 − 3 5 0 − 1
A =  5 2 1 5 0 
− 1 2 3 4 1 
Los elementos de la matriz A son los siguientes:
 A[0;0] = 3 A[0;1] = −3 A[0;2] = 5 A[0;3] = 0 A[0;4] = −1

A =  A[1;0] = 5 A[1;1] = 2 A[1;2] = 1 A[1;3] = 5 A[1;4] = 0 
A[2;0] = −1 A[2;1] = 2 A[2;2] = 3 A[2;3] = 4 A[2;4] = 1 
En JAVA la matriz A se crea y declara de la siguiente manera:
int a[ ][ ]=new int[3][5];
Otros ejemplos de declaraciones de arreglos en JAVA, serían:
float c[ ][ ]=new float[5][5]; // una matriz C de 5 filas y 5 columnas

double ingresos[][]= new double[3][4];
Similar a los arrays unidimensionales, en este caso también la primera fila y la

primera columna de la tabla empiezan en la posición 0.

A continuación se muestra un ejemplo en el cual se determina la suma de dos
matrices A y B de “m” filas y “n” columnas y cuyos datos se deben ingresar
desde el teclado:
class SumaMatrices{

String teclado;
int numeroFilas,numeroColumnas;
int a[][]=new int[50][50]; // creación y declaración de la matriz "a"

int b[][]=new int[50][50]; // creación y declaración de la matriz "b"
int c[][]=new int[50][50]; // creación y declaración de la matriz "c"
int i,j; // declaración de contadores
System.out.print("Ingrese el numero de FILAS : ");

numeroFilas=Integer.parseInt(teclado);
System.out.print("Ingrese el numero de COLUMNAS: ");

numeroColumnas=Integer.parseInt(teclado);
// procedimiento para almacenar datos de la matriz A desde el teclado

System.out.println("\nIngrese elementos de matriz A:");
for(i=1;i<=numeroFilas;i++)
for(j=1;j<=numeroColumnas;j++){
System.out.print("Ingrese elemento("+i+";"+j+"): ");
a[i][j]=Integer.parseInt(teclado);
};
// procedimiento para almacenar datos de la matriz b desde el teclado

System.out.println("\nIngrese elementos de matriz B:");
for(j=1;j<=numeroColumnas;j++){
b[i][j]=Integer.parseInt(teclado);
};
// procedimiento para sumar las matrices

for(j=1;j<=numeroColumnas;j++)
c[i][j]=a[i][j]+b[i][j];
// procedimiento para imprimir matrices

System.out.println("\nLa matriz A es:\n");
for(i=1;i<=numeroFilas;i++){
System.out.print(a[i][j]+"\t");

};
System.out.println("\nLa matriz B es:\n");

System.out.print(b[i][j]+"\t");
};
System.out.println("\nLa matriz SUMA es:\n");

System.out.print(c[i][j]+"\t");
};
};
}
Si ingresamos m=2 y n=3 y luego ingresamos las siguientes matrices:

3 − 2 − 4
A=
1 0 2 
2 1 − 2
B= 
2 − 2 0 
La matriz suma resultante debe salir:
5 − 1 − 6
C= 
3 − 2 2 
A continuación se muestra un ejemplo en el cual se determina la multiplicación

de dos matrices A de “m” filas y “p” columnas y B “p” filas y “n” columnas y
cuyos datos se deben ingresar desde el teclado:
class MultiplicacionMatrices{

String teclado;
int numeroFilasA,numeroColumnasA,numeroFilasB,numeroColumnasB;
int a[][]=new int[50][50]; // creación y declaración de la matriz "a"

int b[][]=new int[50][50]; // creación y declaración de la matriz "b"
int c[][]=new int[50][50]; // creación y declaración de la matriz "c"
int i,j,k; // declaración de contadores

System.out.print("Ingrese el numero de FILAS de la matriz A : ");
numeroFilasA=Integer.parseInt(teclado);
System.out.print("Ingrese el numero de COLUMNAS de la matriz A: ");

numeroColumnasA=Integer.parseInt(teclado);
System.out.print("\nIngrese el numero de FILAS de la matriz B : ");

numeroFilasB=Integer.parseInt(teclado);
System.out.print("Ingrese el numero de COLUMNAS de la matriz B: ");

numeroColumnasB=Integer.parseInt(teclado);
if(numeroColumnasA==numeroFilasB){
// procedimiento para almacenar datos de la matriz A desde el teclado
System.out.println("\nIngrese elementos de matriz A:");
for(i=1;i<=numeroFilasA;i++)
for(j=1;j<=numeroColumnasA;j++){
a[i][j]=Integer.parseInt(teclado);
};
// procedimiento para almacenar datos de la matriz b desde el teclado

System.out.println("\nIngrese elementos de matriz B:");
for(i=1;i<=numeroFilasB;i++)
for(j=1;j<=numeroColumnasB;j++){
b[i][j]=Integer.parseInt(teclado);
};
// procedimiento para multiplicar las matrices

for(i=1;i<=numeroFilasA;i++)
for(j=1;j<=numeroColumnasB;j++){
c[i][j]=0;
for(k=1;k<=numeroFilasB;k++)
c[i][j]=c[i][j]+a[i][k]*b[k][j];
};
// procedimiento para imprimir matrices

System.out.println("\nLa matriz A es:\n");
for(i=1;i<=numeroFilasA;i++){
for(j=1;j<=numeroColumnasA;j++)
System.out.print(a[i][j]+"\t");
};
System.out.println("\nLa matriz B es:\n");

for(i=1;i<=numeroFilasB;i++){
for(j=1;j<=numeroColumnasB;j++)
System.out.print(b[i][j]+"\t");
};

System.out.println("\nLa matriz MULTIPLICACION es:\n");
for(i=1;i<=numeroFilasA;i++){
for(j=1;j<=numeroColumnasB;j++)
System.out.print(c[i][j]+"\t");
};
}
else{
System.out.println("\nDichas matrices no se puede multiplicar");
System.out.println("porque las columnas de A y las filas de B");
System.out.println("son diferentes.\n");
}
};
}
Si ingresamos m=3, p=2 y n=2 y luego ingresamos las siguientes matrices:

3 − 1
A = 2 3 
0 4 
2 2 
B= 
1 − 3
La matriz multiplicación resultante debe salir:
5 9 
C = 7 − 5 
4 − 12

CAPÍTULO IV
CLASES Y OBJETOS EN JAVA
4.1 DEFINICIÓN DE CLASES.
La definición de una clase especifica cómo serán los objetos de dicha clase, es
decir, de qué variables y de qué métodos constarán.
La siguiente es la definición más simple de una clase en JAVA:
class NombreClase{ /* Declaración de la clase */
/* Aquí va la definición de variables y métodos */
Como se puede observar, la definición de una clase consta de dos partes

fundamentales:
a) La declaración de la clase. Aquí se indica el nombre de la clase precedido

por la palabra clave class.
b) El cuerpo de la clase. El cuerpo de la clase sigue a la declaración de la

clase y está contenido entre la pareja de llaves ({ y }). El cuerpo de la clase
contiene las declaraciones de las variables de la clase, y también la
declaración y la implementación de los métodos que operan sobre dichas
variables.
- Declaración de variables de instancia. El estado de un objeto está

representado por sus variables (variables de instancia). Las variables de
instancia se declaran dentro del cuerpo de la clase. Típicamente, las
variables de instancia se declaran antes de la declaración de los métodos,
pero esto no es necesariamente requerido.
- Implementación de métodos. Los métodos de una clase determinan los

mensajes que un objeto puede recibir.
Las partes fundamentales de un método son el valor de retorno, el nombre,

los argumentos (opcionales) y su cuerpo. Además, un método puede llevar
otros modificadores opcionales que van al inicio de la declaración del
método y que se analizarán más adelante. La sintaxis de un método es la
siguiente:
<otrosModificadores> valorRetorno nombreMetodo( <lista de argumentos> ){

/* Cuerpo del método */

sentencias;
}
Nota. Los signos <> indican que no son obligatorios.
Los métodos en Java pueden ser creados únicamente como parte de una
clase. Cuando se llama a un método de un objeto se dice comúnmente que
se envía un mensaje al objeto.
Como ejemplo de aplicación de creación de clases con sus respectivas

declaraciones de variables de instancia e implementación de sus métodos.
class Persona{
String nombre;
int edad;
String direccion;
void setNombre(String n){

nombre = n;
};
int getEdad(){
return edad;
};
void setDireccion(String d){

direccion = d;
};
}
4.2 CREACIÓN DE OBJETOS.
Una vez que se tiene definida la clase a partir de la cual se crearán los objetos
se está en la posibilidad de instanciar los objetos requeridos.
Para la clase “Persona” del ejemplo anterior podemos crear un objeto de la

siguiente manera:
Persona usuario1; //usuario1 es una variable del tipo Persona (declaración del objeto)
usuario1=new Persona(); // iniciación del objeto usuario1
La primera línea corresponde a la declaración del objeto, es decir, se declara

una variable del tipo de objeto deseado y la segunda línea corresponde a la
iniciación del objeto. También el mismo objeto se puede crear de la siguiente
manera
Persona usuario1=new Persona();
a) El operador new. El operador new crea una instancia de una clase

asignando la cantidad de memoria necesaria de acuerdo al tipo de objeto. El
operador new se utiliza en conjunto con un constructor. El operador new
regresa una referencia a un nuevo objeto.

b) Constructores. Un constructor es un tipo específico de método que siempre
tiene el mismo nombre que la clase, y que se utiliza cuando se desean crear
objetos de dicha clase, es decir, se utiliza al crear e iniciar un objeto de una
clase.
c) Constructores múltiples. Cuando se declara una clase en JAVA, se

pueden declarar uno o más constructores (constructores múltiples) opcionales
que realizan la iniciación cuando se instancia un objeto de dicha clase.
Para la clase Persona del ejemplo anterior no se especificó ningún

constructor, sin embargo, JAVA proporciona un constructor por omisión que
inicia las variables del objeto a sus valores predeterminados. En el siguiente
ejemplo se muestra este caso:
class ProgramaPersona{
public static void main(String args[]){
Persona usr1, usr2; /* Se declaran dos objetos de la clase Persona*/
boolean si_no;
usr1 = new Persona(); /* Se utiliza el constructor por omisión */

si_no = usr1 instanceof Persona;
if(si_no == true)
System.out.println("\nEl objeto usr1 SI es instancia de Persona.");
else
System.out.println("\nEl objeto usr1 NO es instancia de Persona.");
usr2 = usr1; /* usr1 y usr2 son el mismo objeto */

si_no = usr2 instanceof Persona;
if(si_no == true)
System.out.println("\nEl objeto usr2 SI es instancia de Persona.");
else
System.out.println("\nEl objeto usr2 NO es instancia de Persona.");
}
}
4.3 ACCESO A VARIABLES Y MÉTODOS
Una vez que se ha creado un objeto, seguramente se querrá hacer algo con él.
Tal vez se requiera obtener información de éste, se quiera cambiar su estado, o
se necesite que realice alguna tarea. Los objetos tienen dos formas de hacer
esto.
a) Manipular sus variables directamente. Para accesar a las variables de un

objeto se utiliza el operador punto (.). La sintaxis es la siguiente:
nombreObjeto.nombreVariable;
b) Llamar a sus métodos. Para llamar a los métodos de un objeto, se utiliza

también el operador punto (.). La sintaxis es la siguiente:
nombreObjeto.nombreMetodo( <lista de argumentos opcionales> );

En el siguiente ejemplo se muestra las diversas forma de usar clases y objetos
en JAVA.
class Usuario2{
String nombre;
int edad;
String direccion;
Usuario2( ) { /* Equivale al contructor por omisión */

nombre = null;
edad = 0;
direccion = null;
}
Usuario2(String nombre, int edad, String direccion){

this.nombre = nombre;
this.edad = edad;
this.direccion = direccion;
}
Usuario2(Usuario2 usr){
nombre = usr.getNombre();
edad = usr.getEdad();
direccion = usr.getDireccion();
}
void setNombre(String n){

nombre = n;
}
String getNombre(){
return nombre;
}
void setEdad(int e){

edad = e;
}
int getEdad(){
return edad;
}
void setDireccion(String d){

direccion = d;
}
String getDireccion(){
return direccion;
}
}
class ProgUsuario2{
void imprimeUsuario(Usuario2 usr){

// usr.nombre equivale en este caso a usr.getNombre()
System.out.println("\nNombre: " + usr.nombre );
System.out.println("Edad: " + usr.getEdad() );
System.out.println("Direccion: " + usr.getDireccion() +"\n");

}
public static void main(String args[]){ // método principal

ProgUsuario2 prog = new ProgUsuario2( );
Usuario2 usr1,usr2; /* Se declaran dos objetos de la clase Usuario2 */
/* Se utiliza el constructor por omisión */

usr1 = new Usuario2( );
prog.imprimeUsuario(usr1);
/* Se utiliza el segundo constructor de Usuario2 */

usr2 = new Usuario2("Eduardo",24,"Mi direccion");
/* Se utiliza el tercer constructor de Usuario2 */

usr1 = new Usuario2(usr2);
/* En este caso usr1.setDireccion("nuevoValor"); equivale

a usr1.direccion = "nuevoValor"; */
usr1.setDireccion("Otra direccion");
}
}
4.4 VARIABLES Y MÉTODOS DE CLASE.
a) Variables de clase. Las variables de clase son variables cuyos valores son
los mismos para la clase y para todas sus instancias. Para indicar que una
variable es una variable de clase se utiliza la palabra clave static en la
declaración de la variable, de la siguiente manera:
static tipoVariable nombreVariable;
b) Métodos de clase. Los métodos de clase al igual que las variables de clase,
se aplican a la clase como un todo y no a sus instancias. Se utiliza de igual
manera la palabra clave static para indicar que un método es un método de
clase, de la siguiente manera:
static valorRetorno nombreMetodo( <lista argumentos opcionales> ){

/* cuerpo del método */
};
Para acceder a las variables o métodos de clase se utiliza el mismo operador

punto (.).
Aunque se puede acceder a las variables y métodos de clase a través de un

objeto, está permitido y se recomienda utilizar mejor el nombre de la clase.
/* Utilizar esto */
nombreClase.nombreVarClase;
nombreClase.nombreMetodoClase();
/* en lugar de esto */
nombreObjeto.nombreVarClase;
nombreObjeto.nombreMetodoClase();
4.5 HEREDANDO CLASES EN JAVA.
El concepto de herencia conduce a una estructura jerárquica de clases o

estructura de árbol, lo cual significa que en la POO todas las relaciones entre
clases deben ajustarse a dicha estructura.
En esta estructura jerárquica, cada clase tiene sólo una clase padre. La clase
padre de cualquier clase es conocida como su superclase. La clase hija de una
superclase es llamada una subclase.
De manera automática, una subclase hereda las variables y métodos de su

superclase (más adelante se explica que pueden existir variables y métodos de
la superclase que la subclase no puede heredar). Además, una subclase puede
agregar nueva funcionalidad (variables y métodos) que la superclase no tenía.
Es necesario tener en cuenta que los constructores no son heredados por las
subclases.
Para crear una subclase, se incluye la palabra clave extends en la declaración

de la clase, de la siguiente manera:
class nombreSubclase extends nombreSuperclase{
En Java, la clase padre de todas las clases es la clase Object y cuando una
clase no tiene una superclase explícita, su superclase es Object.
4.6 SOBRECARGA DE MÉTODOS Y DE CONSTRUCTORES.
La sobrecarga de métodos es la creación de varios métodos con el mismo

nombre pero con diferentes argumentos. Java utiliza el número y tipo de
argumentos para seleccionar que método ejecutar.
Java diferencia los métodos sobrecargados con base en el número y tipo de

argumentos que tiene el método y no por el tipo que devuelve.
También existe la sobrecarga de constructores. Cuando en una clase existen

constructores múltiples, se dice que hay sobrecarga de constructores.
En los siguientes ejemplos se muestran dos métodos sobrecargados.
/* Métodos sobrecargados */
int calculaSuma(int x, int y, int z){
...
}
int calculaSuma(double x, double y, double z){
...
}
/* Error: estos métodos no están sobrecargados */

int calculaSuma(int x, int y, int z){
...
}
double calculaSuma(int x, int y, int z){
...
}
4.7 SOBREESCRITURA DE MÉTODOS.
Como se sabe, una subclase hereda todos los métodos de su superclase que
son accesibles a dicha subclase a menos que la subclase sobreescriba los
métodos.
Una subclase sobreescribe un método de su superclase cuando define un

método con las mismas características (nombre, número y tipo de argumentos)
que el método de la superclase.
Las subclases emplean la sobreescritura de métodos la mayoría de las veces

para agregar o modificar la funcionalidad del método heredado de la clase
padre. Por ejemplo:
class ClaseA{
void miMetodo(int var1, int var2){
...
}
String miOtroMetodo( ){
...
}
}
class ClaseB extends ClaseA{

/* Estos métodos sobreescriben a los métodos de la clase padre */
void miMetodo (int var1 ,int var2){
...
}
String miOtroMetodo( ){
...
}
}
4.8 CLASES Y MÉTODOS ABSTRACTOS.
Una clase que declara la existencia de métodos pero no la implementación de

dichos métodos (o sea, un método sin las llaves { } y las sentencias entre ellas),
se considera una clase abstracta.
Una clase abstracta puede contener métodos no-abstractos pero al menos uno
de los métodos debe ser declarado abstracto.

Para declarar una clase o un método como abstractos, se utiliza la palabra
reservada abstract. Por ejemplo:
abstract class Drawing

{
abstract void miMetodo(int var1, int var2);
String miOtroMetodo( ){ ... }
}
Una clase abstracta no se puede instanciar pero si se puede heredar y las

clases hijas serán las encargadas de agregar la funcionalidad a los métodos
abstractos. Si no lo hacen así, las clases hijas deben ser también abstractas.
4.9 PAQUETES.
Para hacer que una clase sea más fácil de localizar y utilizar así como evitar
conflictos de nombres y controlar el acceso a los miembros de una clase, las
clases se agrupan en paquetes.
Un paquete es un conjunto de clases e interfaces relacionadas. La forma

general de la declaración package es la siguiente:
package nombrePaquete;
En el siguiente ejemplo se muestra una aplicación de paquetes en JAVA.
package miPaquete;
class MiClase{
...
}
Otro ejemplo.
package nombre1.nombre2.miPaquete;
class TuClase{
...
}
Los nombres de los paquetes se corresponden con nombre de directorios en el

sistema de archivos.
De esta manera, cuando se requiera hacer uso de estas clases se tendrán que
importar de la siguiente manera.
import miPaquete.MiClase;
import nombre1.nombre2.miPaquete.TuClase;
class OtraClase{
/* Aqui se hace uso de la clase 'Miclase' y de la
clase 'TuClase' */
...
}

Para importar todas las clases que están en un paquete, se utiliza el asterisco
(*). Por ejemplo:
import miPaquete.*;
4.10 CONTROL DE ACCESO A MIEMBROS DE UNA CLASE.
Los modificadores más importantes desde el punto de vista del diseño de

clases y objetos, son los que permiten controlar la visibilidad y acceso a los
métodos y variables que están dentro de una clase.
Uno de los beneficios de las clases, es que pueden proteger a sus variables y
métodos (tanto de instancia como de clase) del acceso desde otras clases.
Java soporta cuatro niveles de acceso a variables y métodos. En orden, del

más público al menos público son: público (public), protegido (protected), sin
modificador (también conocido como package) y privado (private). En la
Tabla 4.1 se muestra el nivel de acceso permitido por cada modificador.
Tabla 4.1
public protected (sin modificador) private
Clase SI SI SI SI
Subclase en el mismo
SI SI SI NO
paquete
No-Subclase en el
SI SI SI NO
mismo paquete
Subclase en diferente
SI SI/NO (*) NO NO
paquete
No-Subclase en
diferente paquete SI NO NO NO
(Universo)
(*) Los miembros (variables y métodos) de clase (static) si son visibles. Los miembros de instancia no son visibles.
Como se observa de la Tabla 4.1, una clase se ve a ella misma todo tipo de
variables y métodos (desde los public hasta los private); las demás clases del
mismo paquete (ya sean subclases o no) tienen acceso a los miembros desde
los public hasta los sin-modificador. Las subclases de otros paquetes pueden
ver los miembros public y a los miembros protected, éstos últimos siempre que
sean static ya de no ser así no serán visibles en la subclase. El resto del
universo de clases (que no sean ni del mismo paquete ni subclases) pueden ver
sólo los miembros public.
4.11 APLICACIONES VISUALES EN JAVA CON JCREATOR.
Con todo lo aprendido hasta el momento respecto a la programación orientada

a objetos con JAVA, ya podemos estar en condiciones de desarrollar
aplicaciones visuales con JAVA, utilizando el software JCreator versión 3.5. La
aplicación visual con ventanas es el tipo de aplicación que más a menudo se
utilizan cuando trabajamos en una computadora, por lo tanto veremos cómo se
crea una VENTANA usando el paquete AWT (dentro del cual se encuentra la

clase java.awt.Frame) del JAVA, para ello crearemos, como siempre, una
aplicación con el main, como hicimos con los programas anteriores.
La clase Frame tiene varios métodos y constructores que se verán más

adelante. Ahora vamos a crear nuestra primera ventana con el título “Primera
Ventana” y que por ahora no incluirá nada tal como se muestra en la Figura 4.1.
Figura 4.1
Paso 1: Creación de un proyecto.
Antes de crear una aplicación visual con JCreator es necesario crear un

proyecto para trabajar en él. JCreator crea un directorio para organizar los
archivos de la aplicación y mantener la configuración del proyecto. Entonces
para crear un proyecto con JCreator (el cual previamente debe haber sido
instalado en el sistema), se debe cargar el programa en el sistema y luego de
algunos segundos saldrá la pantalla principal del JCreator tal como se muestra
en la Figura 4.2.
Figura 4.2
Entonces, lo primero que se debe hacer es crear un proyecto, y que en este
caso lo denominaremos “Proyecto01”, para ello haremos clic en el menú
File/New/Project o simplemente presionamos Control+Mayúscula+N y saldrá la
ventana que se muestra en la Figura 4.3.
Figura 4.3
Elegimos la opción “Empty Proyect” para generar un proyecto en blanco y

hacemos clic en el botón “Next”, entonces saldrá en pantalla la Figura 4.4.
Figura 4.4
En el campo “Name” pondremos el nombre del proyecto y en el campo
“Location” seleccionaremos la ruta del directorio donde se creará nuestro nuevo
proyecto en este caso con el nombre de “Proyecto01”. Luego, por ahora,
haremos clic directamente en el botón “Finish” y el proyecto se creará en el
directorio especificado; entonces en la esquina superior izquierda de la pantalla
principal del JCreator se puede observar el proyecto que se ha creado con el
nombre de “Proyecto01” tal como se muestra en la Figura 4.5.
Figura 4.5.
Paso 2: Generación de paquetes y clases.
Para generar paquetes y clases en JCreator vaya al menú y elija

File/New/Class… y saldrá la ventana de la Figura 4.6.
Figura 4.6.

En este caso en el campo “Name” pondremos el nombre de la clase
“ClaseVentana” que hereda de la superclase “java.awt.Frame” y en el campo
“Packege” pondremos el nombre del paquete “AplicacionGUI”, luego activamos
la casilla “Públic” y la casilla “Generate main method” y por último haremos clic
en el botón “Finish”; entonces saldrá en la pantalla la ventana que se muestra
en la Figura 4.7.
Figura 4.7.
Paso 3: Codificación del programa.
En la Figura 4.7 se puede observar el archivo de código fuente que se ha

creado con el asistente llamado “ClaseVentana.java”. Luego para visualizar la
ventana de la Figura 4.1, se debe escribir el siguiente código.
package AplicacionGUI;
import java.awt.Frame;
public class ClaseVentana extends Frame {

//Constructor de la clase ClaseVentana
public ClaseVentana(){
// Métodos heredatos de la clase frame
this.setTitle("Primera Ventana"); //Título de la ventana
this.setLocation(100,100); //Localización de inicio de la ventana
this.setSize(300,200); //Ancho y alto de la ventana
this.show(); //visualización de la ventana
}
public static void main(String[] args) {

new ClaseVentana();
}
}

Paso 4: Compilación y ejecución del programa.
Luego tenemos que compilar el programa presionando la tecla de función F7 y

para ejecutar el programa presionamos F5, entonces saldrá la ventana que se
muestra en la Figura 4.8 y que en realidad es similar al de la Figura 4.1.
Figura 4.8
Hasta aquí hemos cumplido con nuestro objetivo. A continuación daremos vida
a la ventana (formulario) creado.
En primer lugar aumentaremos la acción de cerrar la ventana cuando se hace

clic en el botón x (ver Figura 4.8), entonces el programa sería el siguiente:
import java.awt.Frame;
import java.awt.event.*;
public class ClaseVentana extends Frame {

this.setTitle("Primera Ventana"); //Título de la ventana
// Añadimos acción a la ventana.

this.addWindowListener(
new WindowAdapter() {
public void windowClosing(WindowEvent e) {
ClaseVentana.this.cerrarVentana();
}
}
);
}
//Método para cerrar la ventana

protected void cerrarVentana() {
System.exit(0);
}

new ClaseVentana();
}
}
A continuación aumentaremos algunos controles básicos a nuestra ventana

creada tales como etiquetas (Label), cuadros de texto (TextField) y botones
(button), de tal manera que la ventana debe visualizarse como la Figura 4.8 y la
codificación correspondiente sería:
import java.awt.*;
public class ClaseVentana extends Frame{

//creación de etiquetas (objetos)
Label label1=new Label("Ingrese dato 1:");
Label label2=new Label("Ingrese dato 2:");
Label label3=new Label("Resultado :");
//creación de cuadros de texto (objetos)

TextField textField1=new TextField("");
//creación de botones (objetos)

Button button1=new Button("+");
Button button2=new Button("-");
Button button3=new Button("*");
Button button4=new Button("/");
Button button5=new Button("Salir");

this.setTitle("Primera Ventana");
this.setLocation(100,100);
this.setSize(300,200);
//Creación de paneles contenedores

Panel panel1=new Panel();
panel1.add(label1);
panel1.add(textField1);
panel1.add(label2);
panel2.add(label3);
panel3.add(button1);
add(panel1,BorderLayout.NORTH);
add(panel2,BorderLayout.CENTER);
add(panel3,BorderLayout.SOUTH);
this.show();

public void windowClosing(WindowEvent e){
}
}
);
//Método para cerar la ventana

protected void cerrarVentana(){
System.exit(0);
}
public static void main(String[] args){

new ClaseVentana();
}
}
Después de ejecutar el programa debe visualizarse tal como se muestra en la

Figura 4.9.
Figura 4.9
Pero realmente la apariencia del formulario de la Figura 4.9 no es agradable ni

vistoso, ya que las posiciones de los componentes no son los adecuados;
entonces ahora vamos ha mejorar la apariencia, para que el mismo formulario
se visualize como se muestra en la Figura 4.10.

Figura 4.10
Entonces para poder visualizar el formulario tal como se muestra en la Figura

4.10 el código de programación es el siguiente.
import java.awt.*;

//Creación de paneles contenedores (objetos)

Label label1=new Label();

TextField textField1=new TextField();

Button button1=new Button();

//Propiedades de panel1
panel1.setLayout(null);
panel1.setBackground(new Color(158,197,190));
//Propiedades de las etiquetas

label1.setLocation(25,15);

label1.setSize(120,25);
label1.setText("Ingrese dato 1:");
label1.setFont(new Font("SansSerif",0,18)); // 0 es normal
label1.setForeground(new Color(72,66,255)); // Color de la letra
label2.setFont(new Font("SansSerif",1,18)); // 1 es de negrita
label2.setForeground(new Color(72,66,255));
label3.setText("Resultado :");
label3.setFont(new Font("SansSerif",2,18)); // 2 es cursiva y 3 es negrita y cursiva
label3.setForeground(Color.red);
label3.setBackground(new Color(0,120,120)); // combinación Rojo,Verde,Azul
//Propiedades de los cuadros de texto

textField1.setLocation(165,15); //textField1.setBounds(new Rectangle(45, 50, 166, 32));
textField1.setSize(95,25);
textField1.setBackground(new Color(53,190,184));
textField1.setText(""); //Cadena vacía
textField1.setFont(new Font("SansSerif",1,15));
textField1.setForeground(Color.blue);
textField2.setLocation(165,45);
textField2.setText("");
textField3.setEnabled(false); //desactiva el cuadro de texto
//Propiedades de los botones

button1.setLabel("+");
button1.setLocation(25,130);
button1.setSize(25,25);
button1.setBackground(new Color(112,255,164));
button1.setForeground(Color.red);
button1.setFont(new Font("SansSerif",0,11));
button2.setLabel("-");
button3.setLabel("*");
button4.setLabel("/");
button5.setLabel("Salir");
//adición de objetos al panel1

panel1.add(label1,null);
panel1.add(textField1,null);
panel1.add(button1,null);
this.show();

}
}
);

System.exit(0);
}

new ClaseVentana();
}
}

Pero, si hacemos clic en algún botón en este momento no hacen nada, y es que
le falta darle la funcionalidad correspondiente; para ello programaremos las
acciones que deben realizar cada botón; esas acciones programaremos en el
evento clic, es decir cada vez que hagamos clic sobre los botones tenga que
hacer la operación que corresponde; en el siguiente código se puede observar
dicha programación.
import java.awt.*;





this.setResizable(false); // para desactivar botón ampliar
//Propiedades de panel1

label1.setForeground(new Color(72,66,255)); // Color de la letra
label2.setFont(new Font("SansSerif",1,18)); // 1 es de negrita
label2.setForeground(new Color(72,66,255));

label3.setText("Resultado :");
label3.setFont(new Font("SansSerif",2,18)); // 2 es cursiva y 3 es negrita y cursiva
label3.setForeground(Color.red);
label3.setBackground(new Color(0,120,120)); // combinación Rojo,Verde,Azul

textField1.setLocation(165,15); //textField1.setBounds(new Rectangle(45, 50, 166, 32));
textField1.setBackground(new Color(53,190,184)); //textField1.setBackground(Color.red);
textField1.setText(""); //Cadena vacía
textField3.setEnabled(false); //desactiva el cuadro de texto

button1.setLabel("+");
button1.addActionListener(new ClicBoton1(this));
button2.setLabel("-");
button3.setLabel("*");
button4.setLabel("/");
//
button5.addMouseListener(new ClicBoton5(this));

this.show();

}
}
);

System.exit(0);
}
void button1_actionPerformed(ActionEvent e){ // Evento clic del boton Sumar

double num1,num2,resultado;
String cadenaResultado;
num1=Double.parseDouble(textField1.getText());
resultado=num1+num2;
cadenaResultado=String.valueOf(resultado); //Convierte número a cadena
textField3.setText(cadenaResultado);
label3.setText("Suma :");
}
void button2_actionPerformed(ActionEvent e){ // Evento clic del boton Restar

resultado=num1-num2;
textField3.setText(String.valueOf(resultado));
label3.setText("Diferencia :");
}
void button3_actionPerformed(ActionEvent e){ // Evento clic del boton Multiplicar

resultado=num1*num2;
label3.setText("Producto :");
}
void button4_actionPerformed(ActionEvent e){ // Evento clic del boton Dividir

resultado=num1/num2;
label3.setText("Cociente :");
}
void button5_mouseClicked(MouseEvent e) { // Evento clic del boton Salir

cerrarVentana();
}

new ClaseVentana();
}
}
//Clase que controla el evento clic del botón1 (sumar)

class ClicBoton1 implements ActionListener{
ClaseVentana eventoClic;
ClicBoton1(ClaseVentana eventoClic){
this.eventoClic = eventoClic;
}
public void actionPerformed(ActionEvent e){

eventoClic.button1_actionPerformed(e);
}
}
//Clase que controla el evento clic del botón2 (restar)

}

}
}
//Clase que controla el evento clic del botón3 (multiplicar)

}

}
}
//Clase que controla el evento clic del botón2 (dividir)

}

}
}
//Clase que controla el evento clic del botón5

class ClicBoton5 extends MouseAdapter{ // está dentro de java.awt.event.*
}
public void mouseClicked(MouseEvent e){

eventoClic.button5_mouseClicked(e);
}
}
Finalmente después de digitar todo el código anterior y ejecutamos el programa

e ingresamos números en los cuadros de texto y hacemos clic en los botones,
se puede observar los resultados que se obtinen; en la Figura 4.11 se observa
un ejemplo de aplicación.
Figura 4.11
A continuación desarrollaremos otro ejemplo en el cual mostraremos

componentes tales como las casillas de verificación (checkbox) y los botones de
selección (checkbox group); la ventana del ejemplo debe ser similar al que se
muestra en la Figura 4.12.
Figura 4.12
Para ello crearemos un nuevo proyecto con el nombre de “Proyecto02” y luego

añadiremos una clase “CasillaVerificacion” que heredará de “java.awt.Frame” y
el nombre del paquete será “AplicaciónGUI”; si no recuerda la forma de crear el
proyecto y la clase, siga los cuatro pasos que hicimos al inicio del presente
ítem. Luego incluya en el programa la siguiente codificación.
import java.awt.*;
public class CasillaVerificacion extends Frame{

// Constructot clase Botón




//creación de grupos para optionBox (objetos)

CheckboxGroup checkboxGroup1=new CheckboxGroup();
//creación de optionBox (objetos)

Checkbox optionBox1=new Checkbox();
//creación de checkbox (objetos)

Checkbox checkbox1=new Checkbox();
Checkbox checkbox2=new Checkbox();
public CasillaVerificacion(){
this.setTitle("Uso de Colores"); //Título de la ventana
//Propiedades del panel1


label1.setText("Estilo del texto");
label2.setText("Colores del texto");
label2.setFont(new Font("SansSerif",0,18));

textField1.setText("Universidad Continental");
textField1.setForeground(Color.yellow);

button1.addActionListener(new CasillaVerificacion_button1_actionAdapter(this));
//Propiedades de los checkbox

checkbox1.setLabel("Negrita");
checkbox1.setBounds(new Rectangle(27,100,120,25));
checkbox1.setFont(new Font("SansSerif",1,15));
checkbox1.addItemListener(new CasillaVerificacion_checkbox1_itemAdapter(this));
checkbox2.setLabel("Cursiva");
checkbox2.setBounds(new Rectangle(175,100,120,25));
checkbox2.setFont(new Font("SansSerif",2,15));
checkbox2.addItemListener(new CasillaVerificacion_checkbox2_itemAdapter(this));
//Propiedades de los optionBox

optionBox1.setLabel("Amarillo");
optionBox1.setBounds(new Rectangle(25, 165, 135, 24));
optionBox1.setFont(new Font("SansSerif",0,15));
//optionBox1.setState(true); //valor inicial del optionbox
optionBox1.addItemListener(new CasillaVerificacion_optionBox1_itemAdapter(this));
optionBox2.setLabel("Verde");
optionBox3.setLabel("Rojo");
//Adiciona los optionBox al grupo checkboxGroup1

optionBox1.setCheckboxGroup(checkboxGroup1);

panel1.add(optionBox1,null);
panel1.add(checkbox1,null);
panel1.add(checkbox2,null);

CasillaVerificacion.this.cerrarVentana();
}
}
);

System.exit(0);
}
// método main
public static void main (String [] arg){
new CasillaVerificacion();
}
void button1_actionPerformed(ActionEvent e) {
cerrarVentana();
}
void checkbox1_itemStateChanged(ItemEvent e) {
cambiarEstilo();
}
cambiarEstilo();
}
void optionBox1_itemStateChanged(ItemEvent e) {
cambiarColor();
}
cambiarColor();
}
cambiarColor();
}
public void cambiarEstilo(){

if ((checkbox1.getState()==true)&&(checkbox2.getState()==true))
textField1.setFont(new java.awt.Font("SansSerif",3,40));
if ((checkbox1.getState()==true)&&(checkbox2.getState()==false))
if ((checkbox1.getState()==false)&&(checkbox2.getState()==true))
if ((checkbox1.getState()==false)&&(checkbox2.getState()==false))
}
public void cambiarColor(){

if (optionBox1.getState()==true) textField1.setForeground(Color.yellow);
else if (optionBox2.getState()==true) textField1.setForeground(Color.green);
else if (optionBox3.getState()==true) textField1.setForeground(Color.red);
}
} // Fin de la clase CasillaVerificacion
//Implementación de clases para los eventos clic de los botones.

class CasillaVerificacion_button1_actionAdapter implements ActionListener {
CasillaVerificacion adaptee;
CasillaVerificacion_button1_actionAdapter(CasillaVerificacion adaptee) {
this.adaptee = adaptee;
}
public void actionPerformed(ActionEvent e) {
adaptee.button1_actionPerformed(e);
}
}
class CasillaVerificacion_checkbox1_itemAdapter implements ItemListener {

CasillaVerificacion_checkbox1_itemAdapter(CasillaVerificacion adaptee) {
}
public void itemStateChanged(ItemEvent e) {
adaptee.checkbox1_itemStateChanged(e);
}
}
class CasillaVerificacion_checkbox2_itemAdapter implements ItemListener {

CasillaVerificacion_checkbox2_itemAdapter(CasillaVerificacion adaptee) {
}
}
}
class CasillaVerificacion_optionBox1_itemAdapter implements ItemListener {

CasillaVerificacion_optionBox1_itemAdapter(CasillaVerificacion adaptee) {
}
adaptee.optionBox1_itemStateChanged(e);
}
}

}
}
}

}
}
}
A continuación desarrollaremos otro ejemplo en el cual mostraremos

componentes tales como el cuadro de lista combinado (choice) y el cuadro de
lista (list); la ventana del ejemplo debe ser similar al que se muestra en la
Figura 4.13.
Figura 4.13

añadiremos una clase “CuadrosDeListas” que heredará de “java.awt.Frame” y el
nombre del paquete será “AplicaciónGUI”. Luego incluya en el programa la
siguiente codificación.
Este ejemplo sirve para seleccionar un departamento y luego poder visualizar

todos sus lugares turísticos de dicho depatamento, además se puede visualizar
la distancia en kilómetros desde Lima.

import java.awt.*;
public class CuadrosDeListas extends Frame{

// Constructot clase Botón




//Creación de la lista combo

Choice choice1 = new Choice();
List list1 = new List();
public CuadrosDeListas(){
this.setTitle("Circuitos Turísticos"); //Título de la ventana
//Propiedades del panel1

panel1.setBackground(Color.cyan);

label1.setText("ELECCIÓN DE LUGARES TURÍSTICOS");
label1.setBounds(new Rectangle(6, 8, 367, 32));
label2.setFont(new Font("SansSerif", 1, 12));

label2.setText("Seleccione Departamento:");
label2.setBounds(new Rectangle(16,55,154,22));
label3.setText("Seleccione lugar que desea visitar de Arequipa:");
label4.setFont(new Font("SansSerif", 1, 12));

label4.setText("Distancia de Lima:");
label5.setText("km");
//Propiedades de las listas
choice1.setBounds(new Rectangle(16,77,179,30));
choice1.setFont(new Font("SansSerif",1,15));
choice1.setForeground(Color.red);
choice1.add("Arequipa");
choice1.add("Cuzco");
choice1.add("Junín");
choice1.addItemListener(new CuadrosDeListas_choice1_itemAdapter(this));
list1.setBounds(new Rectangle(17,142,344,100));
list1.setFont(new Font("SansSerif",1,12));
list1.add("Valle del Colca"); //Lugares iniciales de Arequipa
list1.add("El Volcán Misti");
list1.add("Camaná");

textField1.setText("845.23"); //distancia de Lima a Arequipa
textField1.setBounds(new Rectangle(134, 267, 102, 29));
textField1.enable(false);

button1.setBounds(new Rectangle(148,335,95,28));
button1.addActionListener(new CuadrosDeListas_button1_actionAdapter(this));

panel1.add(choice1, null);
panel1.add(list1, null);

CuadrosDeListas.this.cerrarVentana();
}
}
);

System.exit(0);
}
// main
public static void main (String [] arg){
new CuadrosDeListas();
}
void button1_actionPerformed(ActionEvent e) {
cerrarVentana();
//System.exit(0);
}
void choice1_itemStateChanged(ItemEvent e){

int indice=choice1.getSelectedIndex();
if (indice==0){
label3.setText("Seleccione lugar que desea visitar de "+choice1.getSelectedItem());
textField1.setText("845.23"); //Distancia de Lima a Arequipa
list1.clear(); //limpia los elementos de la lista

list1.add("Valle del Colca");
list1.add("El Volcán Misti");
list1.add("Camaná");
};
if (indice==1){
textField1.setText("1534.72"); //Distancia de Lima a Cuzco
list1.clear();
list1.add("Saccsaihuamán");
list1.add("Urubamba");
list1.add("Machupicchu");
list1.add("Valle Sagrado de los Incas");
};
if (indice==2){
textField1.setText("257.45"); //Distancia de Lima a Arequipa
list1.clear();
list1.add("Lago Junín");
list1.add("Laguna de Paca");
list1.add("Ingenio");
list1.add("Nevado Huaytapallana");
list1.add("Chanchamayo");
list1.add("Tarma");
list1.add("Satipo");
list1.add("Concepción");
list1.add("Sapallanga");
list1.add("Laguna de Ñahuimpuquio");
list1.add("Jauja");
};
}
} //Fin de la clase CuadrosDeListas
class CuadrosDeListas_choice1_itemAdapter implements java.awt.event.ItemListener {
CuadrosDeListas adaptee;
CuadrosDeListas_choice1_itemAdapter(CuadrosDeListas adaptee) {
}
adaptee.choice1_itemStateChanged(e);
}
}
class CuadrosDeListas_button1_actionAdapter implements ActionListener {

CuadrosDeListas adaptee;
CuadrosDeListas_button1_actionAdapter(CuadrosDeListas adaptee) {
}
adaptee.button1_actionPerformed(e);
}
}
A continuación desarrollaremos otro ejemplo en el cual mostraremos la manera

de dibujar figuras geométricas tales como líneas, polilíneas, rectángulos,
círculos, etc.; la ventana del ejemplo debe ser similar al que se muestra en la
Figura 4.14.
Figura 4.14

añadiremos una clase “ClaseGraficos” que heredará de “java.awt.Frame” y el
import java.awt.*;
// Clase de control del ejemplo

class ClaseGraficos extends Frame {
// Contructor de la clase
public ClaseGraficos() {
this.setTitle( "Uso de Gráficos" );
this.show();
public void windowClosing( WindowEvent evt ) {
// Se concluye el programa
System.exit( 0 );
}
}
);
}
//método principal
public static void main( String[] args ) {
new ClaseGraficos();
}
// Se sobrecarga el método paint()

public void paint( Graphics g ){
// Trasladamos las coordenadas a la esquina superior izquierda
g.translate( this.getInsets().left,this.getInsets().top );
//Limpiamos la pantalla de dibujo

g.clearRect(0,0,475,275);
// Línea simple
g.setColor(Color.red); //dibuja línea de color rojo
g.drawLine(10,0,50,50);
g.drawString("Línea",10,62);
// Se crean dos arrays de coordenadas para dibujar una polilínea

int x1Datos[] = {100,90,110,130,100};
int y1Datos[] = {0,20,50,30,0};
g.setColor(Color.blue);
g.drawPolyline( x1Datos,y1Datos,5);
g.drawString("Polilínea",70,62 );
// Rectángulo
g.setColor(Color.green);
g.drawRect(140,0,50,50 );
g.drawString("Rectángulo",135,62);
// Rectángulo relleno
g.setColor(Color.cyan);
g.fillRect(220,0,50,50);
g.drawString("Rect.rellenado",205,62);
// Rectángulo redondeado
g.setColor(Color.magenta );
g.drawRoundRect(315,0,50,50,10,10);
g.drawString("Rectángulos redondeados",300,62);
// Rectángulo redondeado relleno

g.fillRoundRect(385,0,50,50,20,20 );
// Pinta un rectángulo 3D, sobresaliendo de la pantalla

g.setColor(Color.lightGray);
g.draw3DRect(10,90,55,25,true );
// Rectángulo 3D, pulsado

g.draw3DRect(70,90,50,25,false );
g.drawString("Rectángulos 3D",20,140);
// Rectángulo 3D rellenado
g.setColor(Color.lightGray);
g.fill3DRect(155,90,50,25,true );
// Rectángulo 3D relleno, pulsado

g.fill3DRect(215,90,50,25,false );
g.drawString("Rectángulos rellenados 3D",135,140);
// Dibuja un arco un ángulo de 270 grados inscrito en un rectángulo

g.setColor(Color.red);
g.drawRect(300,77,50,50);
g.drawArc( 300,77,50,50,0,270 );
g.drawString("Arco",310,140 );
// Arco rellenado entre 90 y 180 grados inscrito en un rectángulo

g.drawRect(385,77,50,50);
g.fillArc(385,77,50,50,90,180);
g.drawString("Arco rellenado",370,140);
// Elipse, con el eje grande horizontal

g.setColor(Color.black);
g.drawOval(10,165,50,25);
g.drawOval(70,150,50,50); // Círculo
g.drawString("Elipses",35,218 );
// Elipse rellena, con el eje grande vertical

g.fillOval(170,150,25,50);
g.fillOval(210,150,50,50); // Círculo relleno
g.drawString("Elipses rellenados",165,218);
// Dibujo de polígonos
int x2Datos[] = {300,350,300,350};
int y2Datos[] = {150,200,200,150};
g.drawPolygon(x2Datos,y2Datos,4);
g.drawString("Polígono",300,218);
// Polígono relleno
g.setColor(Color.yellow);
int x3Datos[] = {385,435,385,435};
int y3Datos[] = {150,200,200,150};
g.fillPolygon(x3Datos,y3Datos,4);
g.drawString("Polígono rellenado",360,218 );
}
}

A continuación desarrollaremos otro ejemplo en el cual mostraremos la manera
de dibujar un círculo (cara feliz), pero la característica es que la figura se
redibuja cada que se agranda la ventana; la ventana del ejemplo debe ser
similar al que se muestra en la Figura 4.15.
Figura 4.15

añadiremos una clase “ClaseGraficos01” que heredará de “java.awt.Frame” y el
import java.awt.*;
public class ClaseGraficos01 extends Frame{

public ClaseGraficos01(){
this.setTitle("Cara Feliz");
this.add(new CaraSonriente(new Color(255,120,120)),BorderLayout.CENTER);
this.show();
public void windowClosing( WindowEvent evt ) {
// Se concluye el programa
System.exit(0);
}
}
);
}

new ClaseGraficos01();
}
}
class CaraSonriente extends Canvas{

// Constructor, que solamente fija el color de la carita
public CaraSonriente(Color colorCara){
setForeground(colorCara);
}
public Dimension getPreferredSize(){

return new Dimension(250,250);
}
// Este el el método que pinta, y lo hace cada vez que

// el AWT le indica que lo haga
public void paint(Graphics g) {
// Calcula dinámicamente todos los tamaños, de forma que
// el canvas se puede cambiar externamente
// La circunferencia que forma la carita, siempre utiliza
// como dimensión para el diámetro la dimensión más pequeña
// de la ventana en que se encuentra
Dimension tamano = getSize();
// Calculamos el diámetro total de la carita
int diam = Math.min(tamano.width,tamano.height );
// Fijamos el diámetro de los ojos a un décimo del de la cara
int diamOjo = diam/10;
// Calculamos el centro
int x = (tamano.width-diam)/2;
int y = (tamano.height-diam)/2;
// Pintamos la cara, a la cual ya le ha fijado el color el

// constructor de la clase
g.fillOval(x,y,diam,diam);
g.setColor(Color.black);
g.drawOval(x,y,diam,diam);
// Pintamos los dos ojos de la carita

g.fillOval(x+diam/3-(diamOjo/2),y+diam/3-(diamOjo/2),diamOjo,diamOjo);
g.fillOval(x+(2*(diam/3))-(diamOjo/2),y+diam/3-(diamOjo/2),diamOjo,diamOjo);
// Pintamos la boca de la carita

g.drawArc(x+diam/4,y+2*(diam/5),diam/2,diam/3,0,-180);
}
}
CREACIÓN DE MENÚS
import java.awt.*;
public class CreacionMenuFrame extends Frame {

MenuBar menuBar = new MenuBar();
Menu menuArchivo = new Menu();
MenuItem menuArchivoAbrir= new MenuItem();
MenuItem menuArchivoGuardar= new MenuItem();
MenuItem menuArchivoSalir= new MenuItem();
Menu menuEdicion = new Menu();

MenuItem menuEdicionCopiar= new MenuItem();
MenuItem menuEdicionPegar= new MenuItem();
Menu menuVer = new Menu();

CheckboxMenuItem menuVerFuente = new CheckboxMenuItem();
CheckboxMenuItem menuVerBarra = new CheckboxMenuItem();

MenuItem menuVerExplorador = new MenuItem();
public CreacionMenuFrame() { // Método CreacionMenuFrame

// Características del formulario
this.setTitle("Ejemplo de uso de menús");
this.setMenuBar(menuBar); //inserta al formulario el menuBar creado
//Características de la barra de menús y submenús

menuArchivo.setLabel("Archivo");
menuArchivoAbrir.setLabel("Abrir");
menuArchivoGuardar.setLabel("Guardar");
//menuArchivoGuardar.enable(false); //desactiva el submenú Guardar
menuArchivoSalir.setLabel("Salir");
menuEdicion.setLabel("Edicion");
menuEdicionCopiar.setLabel("Copiar");
menuEdicionPegar.setLabel("Pegar");
menuVer.setLabel("Ver");
menuVerFuente.setLabel("Código fuente");
menuVerBarra.setLabel("Barra de estado");
menuVerExplorador.setLabel("Explorador");
menuBar.add(menuArchivo);
menuArchivo.add(menuArchivoAbrir);
menuArchivo.add(menuArchivoGuardar);
menuArchivo.addSeparator(); //inserta una línea separadora
menuArchivo.add(menuArchivoSalir);
menuBar.add(menuEdicion);
menuEdicion.add(menuEdicionCopiar);
menuEdicion.add(menuEdicionPegar);
menuBar.add(menuVer);
menuVer.add(menuVerFuente);
menuVer.add(menuVerBarra);
menuVer.addSeparator();
menuVer.add(menuVerExplorador);
this.show();
// Adiciona la acción de salir al menu Archivo/Salir

menuArchivoSalir.addActionListener
(
new ActionListener() {
CreacionMenuFrame.this.cerrarFormulario();
}
}
);
// Adicona la acción de cerrar el formulario

this.addWindowListener
(
public void windowClosing(WindowEvent e) {
CreacionMenuFrame.this.cerrarFormulario();
}
}
);
} // Fin de la clase CreacionMenuFrame
//Método principal
// Crea la aplicación formulario01
new CreacionMenuFrame();
}
//Método que sirve para cerrar el formulario

protected void cerrarFormulario() {
System.exit(0); // Para salir de la aplicación.
}
}

CAPÍTULO V
BASES DE DATOS CON EN JAVA
Una Base de Datos es una serie de tablas que contienen información ordenada en
alguna estructura que facilita el acceso a esas tablas, ordenarlas y seleccionar filas
de las tablas según criterios específicos. Las bases de datos generalmente tienen
índices asociados a alguna de sus columnas, de forma que el acceso sea lo más
rápido posible.
Las Bases de Datos son, sin lugar a dudas, las estructuras más utilizadas en
ordenadores; ya que son el corazón de sistemas avanzados o complejos como el
censo de una nación, la nómina de empleados de una empresa, el sistema de
facturación de una multinacional, etc..
La empresa SUN, la fabricante del lenguaje JAVA, diseñó un driver especializado

para usar bases de datos con JAVA, este driver es llamado JDBC (Java DataBase
Conectivity), que según ellos es mas seguro, rapido y más eficiente que ODBC
(Open DataBase Conectivity) que usan otros lenguajes de programación.
JDBC es un API de Java que permite al programador ejecutar instrucciones en

lenguaje estándar de acceso a Bases de Datos, SQL (Structured Query Language,
lenguaje estructurado de consultas), que es un lenguaje de muy alto nivel que
permite crear, examinar, manipular y gestionar Bases de Datos relacionales. Para
que una aplicación pueda hacer operaciones en una Base de Datos, ha de tener
una conexión con ella, que se establece a través de un driver, que convierte el
lenguaje de alto nivel a sentencias de Base de Datos. Es decir, las tres acciones
principales que realizará JDBC son las de establecer la conexión a una base de
datos, ya sea remota o no; enviar sentencias SQL a esa base de datos y, en tercer
lugar, procesar los resultados obtenidos de la base de datos.
JDBC es una especificación de un conjunto de clases y métodos de operación que

permiten a cualquier programa Java acceder a sistemas de bases de datos de
forma homogénea. Lógicamente, al igual que ODBC, la aplicación de Java debe
tener acceso a un driver JDBC adecuado. Este driver es el que implementa la
funcionalidad de todas las clases de acceso a datos y proporciona la comunicación
entre el API JDBC y la base de datos real.
La necesidad de JDBC, a pesar de la existencia de ODBC, viene dada porque

ODBC es un interfaz escrito en lenguaje C, que al no ser un lenguaje portable,
haría que las aplicaciones Java también perdiesen la portabilidad. Y además,
ODBC tiene el inconveniente de que se ha de instalar manualmente en cada
máquina; al contrario que los drivers JDBC, que al estar escritos en Java son
automáticamente instalables, portables y seguros.

Figura 5.1
Toda la conectividad de bases de datos de Java se basa en sentencias SQL, por lo

que se hace imprescindible un conocimiento adecuado de SQL para realizar
cualquier clase de operación de bases de datos.
5.1 ACCESO DE JDBC A BASES DE DATOS.
El API JDBC soporta dos modelos diferentes de acceso a Bases de Datos, los
modelos de dos y tres capas.
a) Modelo de dos capas.
Este modelo se basa en que la conexión entre la aplicación Java o el applet

que se ejecuta en el navegador, se conectan directamente a la base de datos.
Figura 5.2
Esto significa que el driver JDBC específico para conectarse con la base de
datos, debe residir en el sistema local. La base de datos puede estar en
cualquier otra máquina y se accede a ella mediante la red. Esta es la
configuración típica Cliente/Servidor, el programa cliente envía instrucciones
SQL a la base de datos, ésta las procesa y envía los resultados de vuelta a la
aplicación.

b) Modelo de tres capas
En este modelo de acceso a las bases de datos, las instrucciones son

enviadas a una capa intermedia entre Cliente y Servidor, que es la que se
encarga de enviar las sentencias SQL a la base de datos y recoger el
resultado desde la base de datos. En este caso el usuario no tiene contacto
directo, ni a través de la red, con la máquina donde reside la base de datos.
Figura 5.3
Este modelo presenta la ventaja de que el nivel intermedio mantiene en todo

momento el control del tipo de operaciones que se realizan contra la base de
datos, y además, está la ventaja adicional de que los drivers JDBC no tienen
que residir en la máquina cliente, lo cual libera al usuario de la instalación de
cualquier tipo de driver.
5.2 TIPOS DE DRIVERS
Un driver JDBC puede pertenecer a una de cuatro categorías diferentes en

cuanto a la forma de operar.
a) Puente JDBC-ODBC.
La primera categoría de drivers es la utilizada por Sun inicialmente para

popularizar JDBC y consiste en aprovechar todo lo existente, estableciendo un
puente entre JDBC y ODBC. Este driver convierte todas las llamadas JDBC a
llamadas ODBC y realiza la conversión correspondiente de los resultados.

Figura 5.4
b) Java/Binario.
Este driver se salta la capa ODBC y habla directamente con la librería nativa
del fabricante del sistema DBMS (como pudiera ser DB-Library para Microsoft
SQL Server o CT-Lib para Sybase SQL Server). Este driver no es un driver
100% Java porque necesita la existencia de un código binario (la librería
DBMS) en la máquina del cliente, con las limitaciones y problemas que esto
implica.
Figura 5.5
c) Protocolo nativo.
Es un driver realizado completamente en Java que se comunica con el

servidor DBMS utilizando el protocolo de red nativo del servidor. De esta
forma, el driver no necesita intermediarios para hablar con el servidor y
convierte todas las peticiones JDBC en peticiones de red contra el servidor.
La ventaja de este tipo de driver es que es una solución 100% Java y, por lo
tanto, independiente de la máquina en la que se va a ejecutar el programa.
Figura 5.6
d) Protocolo independiente/100% Java.
Esta es la opción más flexible, se trata de un driver 100% Java con Protocolo
independiente.
Figura 5.7
Este es un driver Java puro que habla directamente con la BD y por lo tanto es
el método más eficiente de acceso a DB; por otro lado la mayoría de
fabricantes de BD proveen drivers JDBC de este tipo para sus BD, por lo que
no hay problema en su uso.
5.3 LA API JDBC.
Las clases e interfaces de la API JDBC están en los paquetes java.sql y

javax.sql. En estos paquetes se encuentran definidos métodos que permiten:
conectarse a una BD, recuperar información acerca de la BD, realizar consultas
SQL a la BD y ejecutar Stored Procedures; estos son programas almacenados
en el motor de la BD y que se ejecutan en el servidor de BD.
5.4 CONEXIÓN A BASE DE DATOS SQL DESDE JAVA.
Para desarrollar nuestra primera aplicación, usaremos la primera forma de

conexión a base de datos con el puente JDBC-ODBC. Para ello, en el
desarrollo completo de una aplicación, siempre se debe considerar los pasos
que se muestran en la Figura 5.8; es decir los pasos son los siguiente:
Figura 5.8

a) Creación de la base de datos en SQL.
En primer lugar abra el programa “Administrador corporativo” del SQL

Server, para ello vaya a “Inicio/Todos los programas/Microsoft SQL
Server/Administrador corporativo”. Ingrese hasta “base de datos” y haga clic
derecho y cree una nueva base de datos llamado “ucci” que se creará en la
carpeta “C:\Archivos de programa\Microsoft SQL Server\MSSQL\Data”, con
el nombre de “ucci_Data”, luego crearemos una tabla llamada “Trabajador”
con los campos como se muestra en la Figura 5.9.
Figura 5.9
Luego ingresamos los datos tal como se muestra en la Figura 5.10.
Figura 5.10
b) Construcción del DSN (Data Source Name) mediante ODBC.
ODBC (Open DataBase Conectivity que significa Conectividad Abierta de

Base de Datos) es un administrador de drivers y es un producto de Microsoft
que se instala cuando se instala el sistema operativo Windows y crece
conforme se instalan nuevos gestores de base de datos o software que
registran sus drivers en él. El ODBC permite el acceso a estos drivers con
una interfaz visual de diálogos, que va construyendo una cadena de
conexión que puede ser usada por nuestras aplicaciones para comunicarnos
con una base de datos.
La base de datos se comunica con ODBC y este lo hace con JDBC y este a
su vez se comunica con nuestra aplicación final.

Con ODBC crearemos un DSN (Data Source Name), que es una cadena de
información para la comunicación. Para hacerlo se siguen los siguientes
pasos:
1) Abrir el Panel de control (ver Figura 5.11)
Figura 5.11
2) Luego hacer doble clic en el programa “Herramientas administrativas” y

luego hacer doble clic en el programa “Orígenes de datos (ODBC)” y
debe salir la ventana que se muestra en la Figura 5.12.
Figura 5.12

3) Luego hacer clic en el botón “Agregar” y seleccionar la opción
“SQL Server” y hacer clic en el botón “Finalizar” como se muestra en la
Figura 5.13
Figura 5.13
4) Luego en la ventana que sale, se debe llenar todos los datos que se
muestra en la Figura 5.14 y hacer clic en el botón “Siguiente”
Cualquier nombre
Cualquier nombre
Este es el nombre del

servidor
Figura 5.14
5) En la ventana que se muestra en la Figura 5.15 se deja tal como está y se

hace clic en el botón “Siguiente”.

Figura 5.15
6) En la ventana que sale, se debe activar la opción “Establecer la siguiente

base de datos como predeterminada:” y luego se selecciona la base de
datos “ucci” que hemos creado en el ítem a) tal como se muestra en la
Figura 5.16 y luego se hace clic en el botón “Siguiente”.
Figura 5.16
7) En la ventana que se muestra en la Figura 5.17 se deja tal como está y se

hace clic en el botón “Finalizar”.

Figura 5.17
8) Antes de terminar con la creación del DSN, en la ventana que se muestra

en la Figura 5.18 se debe hacer clic en el botón “Probar origen de datos”
y debe salir una ventana con el siguiente mensaje “PRUEBAS
COMPLETADAS CORRECTAMENTE” y si es así para finalizar se hace
clien en el botón “Aceptar”.
Figura 5.18
9) Luego se debe mostrar la ventana que se muestra en la Figura 5.19, en el

cual se puede observar el DSN creado “dnsUCCI”, luego hacer clic en el
botón “Aceptar”.

Figura 5.19
c) Construcción del código en Java.
Como ejemplo desarrollaremos un programa en JAVA que muestre el

contenido de la tabla “Trabajador”, la ventana debe ser similar al que se
Figura 5.20

El código generado en el softwate Jbuilder es el siguiente:
package ejempbd1;
import java.awt.*;
import javax.swing.*;
import java.sql.*;
public class Marco1 extends JFrame {

JPanel contentPane;
JLabel jLabel1 = new JLabel();
JButton jButton1 = new JButton();
JTextArea jTextArea1 = new JTextArea();
//Construir el marco
public Marco1() {
enableEvents(AWTEvent.WINDOW_EVENT_MASK);
try {
jbInit();
}
catch(Exception e) {
e.printStackTrace();
}
}
//Inicialización de componentes
private void jbInit() throws Exception {
contentPane = (JPanel) this.getContentPane();
jLabel1.setFont(new java.awt.Font("Dialog", 1, 15));
jLabel1.setText("ACCESO A BASE DE DATOS");
jLabel1.setBounds(new Rectangle(99, 3, 209, 24));
contentPane.setLayout(null);
this.setSize(new Dimension(400,350));
this.setTitle("Acceso a bd");
jButton1.setBounds(new Rectangle(76, 46, 236, 29));
jButton1.setText("Mostrar el contenido de la tabla trabajador");
jButton1.addActionListener(new Marco1_jButton1_actionAdapter(this));
jTextArea1.setText("");
jTextArea1.setBounds(new Rectangle(11, 90, 374, 144));
jButton2.setText("Salir");
jButton2.addActionListener(new Marco1_jButton2_actionAdapter(this));
contentPane.add(jLabel1, null);
contentPane.add(jButton1, null);
contentPane.add(jTextArea1, null);
}
//Modificado para poder salir cuando se cierra la ventana
protected void processWindowEvent(WindowEvent e) {
super.processWindowEvent(e);
if (e.getID() == WindowEvent.WINDOW_CLOSING) {
System.exit(0);
}
}
void jButton1_actionPerformed(ActionEvent e) {

try {
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
Connection conexion= DriverManager.getConnection("jdbc:odbc:dnsUCCI", "sa", "");
Statement st= conexion.createStatement();
ResultSet rs= st.executeQuery("Select * From Trabajador");
ResultSetMetaData rmeta= rs.getMetaData();

int numColumnas= rmeta.getColumnCount(); // Cuántas columnas
jTextArea1.setText("");
for(int i=1; i<=numColumnas; ++i) //procedimiento que detecta los campos de la tabla
jTextArea1.append(rmeta.getColumnName(i) + " ");
jTextArea1.append("\n");
while(rs.next()){ // hasta fin de archivo

for(int i=1; i<=numColumnas; ++i) //procedimeinto que muestra el contenido de los campos
jTextArea1.append(rs.getString(i) + "\t");
jTextArea1.append("\n");
}
conexion.close();
}
catch(SQLException ex) {
jTextArea1.setText("Error de SQL:\n\n");
jTextArea1.append(ex.toString());
}
catch(Exception ex) {
jTextArea1.setText("Error genérico:\n\n");
jTextArea1.append(ex.toString());
}
}
System.exit(0);
}
}
class Marco1_jButton1_actionAdapter implements java.awt.event.ActionListener {

Marco1 adaptee;
Marco1_jButton1_actionAdapter(Marco1 adaptee) {
}
adaptee.jButton1_actionPerformed(e);
}
}
class Marco1_jButton2_actionAdapter implements java.awt.event.ActionListener {

Marco1 adaptee;
Marco1_jButton2_actionAdapter(Marco1 adaptee) {
}
}
}

Para poder desarrollar aplicaciones más interesantes con bases de datos en
JAVA, es necesario utilizar el JTable, que es un componente que se divide en
filas y columnas; entonces a continuación desarrollaremos un ejemplo en
JBuilder (ver Figura 5.21), en el cual utilizaremos el JTable acompañado del
JscrollPane.
Figura 5.21
Entonces en el JBuilder se tiene que crear un proyecto con las características

que se muestran en la Figura 5.22, es decir:
- Nombre del proyecto: “UsoDeJtable”.
- Nombre del paquete: “PaqueteUsoDeJtable”
- Clase principal : “Principal”
- Clase marco : “UsoJTable”
Figura 5.22
El código que debe generarse en el softwate JBuilder es el siguiente:

package PaqueteUsoDeJtable;
import java.awt.*;

public class UsoJTable extends JFrame {
public UsoJTable() {
try {
jbInit();
}
}
}
//Creación de campos y registros para el JTable
String[] campos= {"Código","Nombre","Edad","Sueldo","Funcionario"};
Object[][] registros = {
{"RTG01", "Raul Torres Galván",new Integer(25),
new Float(800.25),new Boolean(false)},
{"HRG01", "Henry Ríos García",new Integer(29),
new Float(1200.45),new Boolean(true)},
{"JRB01", "Juana Roque Baltazar",new Integer(26),
};
//Creación de los objetos componentes del Formulario

JPanel contentPane;
JTable jTable1 = new JTable(registros,campos);
JScrollPane jScrollPane1 = new JScrollPane(jTable1);

//Características del Formulario

this.setSize(new Dimension(400, 300));
this.setTitle("Ejemplo de uso del JTable");
//Características de los componentes del Forumulario

jScrollPane1.getViewport().setBackground(Color.white);
jScrollPane1.setBounds(new Rectangle(15, 37, 368, 135));
//Adición de los componentes al formulario

jButton1.addActionListener(new UsoJTable_jButton1_actionAdapter(this));
contentPane.add(jScrollPane1, null);
jScrollPane1.getViewport().add(jTable1, null);
}
System.exit(0);
}
}
System.exit(0);
}
}
class UsoJTable_jButton1_actionAdapter implements java.awt.event.ActionListener {

UsoJTable adaptee;
UsoJTable_jButton1_actionAdapter(UsoJTable adaptee) {
}
}
}
Ahora mejoraremos la aplicación anterior para recuperar en unos TextField los
datos del Jtable, de tal manera que la ventana debe ser similar al que se
Figura 5.23
Para ello crearemos otro proyecto con los datos que se muestra en la
Figura 5.24.
Figura 5.24
Entonces el código que se debe ingresar será el siguiente:

package PaqueteUsoDeJtable01;
import java.awt.*;
import javax.swing.event.*;
public class UsoJTable01 extends JFrame {

int fil,col;
//Creación de campos y registros para el JTable

String campos[]= {"Código","Nombre","Edad","Sueldo","Funcionario"};
Object registros[][] = {
{"RTG01", "Raul Torres Galván",new Integer(25),
{"HRG01", "Henry Ríos García",new Integer(29),
new Float(1200.45),new Boolean(true)},
{"JRB01", "Juana Roque Baltazar",new Integer(26),
};

JPanel contentPane;

JTextField jTextField1 = new JTextField();
public UsoJTable01() {
try {
jbInit();
}
}
}

this.setTitle("Ejemplo de uso del JTable");


jButton1.addActionListener(new UsoJTable01_jButton1_actionAdapter(this));
jLabel1.setText("Código :");
jLabel2.setVerifyInputWhenFocusTarget(true);
jLabel2.setText("Nombre :");
jLabel3.setText("Edad :");
jLabel4.setText("Sueldo :");
jTextField1.setEnabled(false);
jTextField1.setText(registros[0][0].toString());
jTextField1.setBounds(new Rectangle(430, 47, 58, 25));
contentPane.add(jTextField1, null);
//Procedimiento para detectar fila

jTable1.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
ListSelectionModel filaSM = jTable1.getSelectionModel();
filaSM.addListSelectionListener(new ListSelectionListener() {
public void valueChanged(ListSelectionEvent e) {
ListSelectionModel lsm = (ListSelectionModel)e.getSource();
int seleFila = lsm.getMinSelectionIndex();
fil=seleFila;
jTextField1.setText(registros[fil][0].toString());
}
});
}

System.exit(0);
}
}
System.exit(0);
}
}
class UsoJTable01_jButton1_actionAdapter implements java.awt.event.ActionListener {

UsoJTable01 adaptee;
UsoJTable01_jButton1_actionAdapter(UsoJTable01 adaptee) {
}
}
}
Ahora utilizando como modelo el ejemplo anterior recuperaremos los datos

desde la base de datos “ucci” y de la tabla “Trabajador” que hemos creado
anteriormente. La ventana debe ser similar al que se muestra en la Figura 5.25.
Figura 5.25
Para ello crearemos otro proyecto y el código que se debe ingresar será el
siguiente:

package PaqueteUsoDeJtable01;
import java.awt.*;
import java.sql.*;
public class UsoJTable01 extends JFrame {

int fil,col;
String [] campos;
String [][] registros;
public UsoJTable01() {
try {
jbInit();
}
}
}
//Acceso y conexión con la Base de Datos "Trabajador"

try {
Connection conexion= DriverManager.getConnection("jdbc:odbc:dnsUCCI", "sa", "");
ResultSet rs= st.executeQuery("Select * From Trabajador");

int numColumnas= rmeta.getColumnCount(); // Determina el número de columnas
int numreg=0;
//Determina el número de registros
numreg++;
}
campos=new String [numColumnas];

registros= new String [numreg][numColumnas];
for(int i=1; i<=numColumnas; ++i) //procedimiento que detecta los campos de la tabla
campos[i-1]=rmeta.getColumnName(i);
rs= st.executeQuery("Select * From Trabajador"); //ejecuta la consulta
int fil=0; //contador para el número de registros

for(int i=1; i<=numColumnas; ++i) //procedimeinto que detecta el contenido de los campos
registros[fil][i-1]=rs.getString(i);
fil++;
}
conexion.close(); //cierra la conexión con la base de datos.
}
catch(SQLException ex){
System.out.println("Error de SQL:\n\n");
System.out.println(ex.toString());
}
catch(Exception ex){
System.out.println("Error genérico:\n\n");
} //*********************fin acceso a la bd

JPanel contentPane;


final JTextField jTextField1 = new JTextField();

this.setTitle("Ejemplo de uso del JTable con Base de Datos");


jButton1.addActionListener(new UsoJTable01_jButton1_actionAdapter(this));
jLabel1.setText("Código :");
jLabel2.setVerifyInputWhenFocusTarget(true);
jLabel2.setText("Nombre :");
jLabel3.setText("Edad :");
jLabel4.setText("Sueldo :");

fil=seleFila;
}
});
}
//Procedimiento para poder salir cuando se cierra la ventana
System.exit(0);
}
}
System.exit(0);
}
}
class UsoJTable01_jButton1_actionAdapter implements java.awt.event.ActionListener {

UsoJTable01 adaptee;
UsoJTable01_jButton1_actionAdapter(UsoJTable01 adaptee) {
}
}
}

CAPÍTULO VI
CONSTRUCCIÓN DE SOFTWARE ORIENTADO A
OBJETOS
En este capítulo, desarrollaremos algunas aplicaciones práticas, en los cuales
utilizaremos todos los componentes desarrolados en clases tales como JLabel,
JTextField, JButton, JTextArea, JMenu, JMenuItem, JMenuBar, Bases de datos
con SQL, etc.
6.1 PRIMERA APLICACIÒN: PROCESADOR DE TEXTOS.
Figura 6.1
Como primera aplicación desarrollaremos un procesador de textos (ver

Figura 6.1) en JBuilder similar al “Block de Notas” del Windows; para ello
seguiremos los siguientes pasos:
01) Cargar el software “JBuilder” y crear un nuevo proyecto y una nueva

aplicación con los siguientes datos:
Datos del proyecto:

Nombre : EditorTextos
Directorio: Seleccione la unidad donde se guardará el proyecto.
Datos de la aplicación:
Paquete : paqueteEditorTextos
Clase principal : Principal
Clase secundaria : ClaseEditorTextos
Título : Editor de Textos

Activar las casillas de:
- Generar barra de menú.
- Generar barra de herramientas.
- Generar barra de estado.
- Generar cuadro Acerca de
- Centrar Marco en la Pantalla
Grabar el archivo y ejecutamos el programa de tal manera que no debe

enviar ningún mensaje de error. Si no hay ningún error podemos continuar,
en caso contrario regresar al paso inicial.
Nota. Para los pasos siguientes, se recomienda cerrar el proyecto y luego

copiar el directorio del proyecto a otro directorio para que sirva como
backup, de tal manera que si en algún paso falla el programa lo único que
hacemos es recuperar el backup y regresamos sólo al paso anterior.
02) Ahora añadiremos el componente JTextArea al formulario, para ello

- Hacemos clic en la ficha “Diseño” y se observará tal como se muestra en la

Figura 6.2.
JScrollPane
Figura 6.2
- Agregamos el contenedor JScrollPane, para ello seleccionamos la ficha

“Contenedores Swing” y hacemos clic en el componente JscrollPane y

luego hacemos clic aproximadamente al centro del formulario y se
insertará el JScrollPane.
- Luego seleccionamos la ficha “Swing” (ver Figura 6.3) y hacemos clic en el

componente JTextArea y luego hacemos clic aproximadamente al centro
del formulario y se insertará el JTextArea.
Figura 6.3
- Antes de continuar sería bueno verificar en la ventana del “árbol de

componentes” que se hayan añadido los componentes jScrollPane1 y
jTextArea1 tal como se muestra en la Figura 6.4
Figura 6.4
- Por último, es necesario modificar algunas propiedades del jTextArea1 de

manera que se ajuste automáticamente las líneas de texto y lo haga en los
espacios entre palabras, para ello en el Inspector selecciones la ficha
“Propiedades” y modifique las siguientes propiedades:
lineWrap = true
wrapStyleWord = true
text = “”

enviar ningún mensaje de error. Ingrese algún texto dentro del jTextArea1 y
verá que funciona. Si no hay ningún error podemos continuar, en caso
contrario recuperamos el backup del paso uno y regresamos al paso dos.
(Si funciona bien no se olvide de hacer un backup antes de continuar).
03) Ahora añadiremos los menús necesarios tal como se muestra en la

Figura 6.6, para ello seguiremos los siguientes pasos:

- Hacemos clic derecho en “jMenuBar1” en la ventana del “árbol de
componentes” (ver Figura 6.5) y en el menú desplegable que sale
seleccionar “Activar el diseñador”, entonces en ese momento la ventana de
diseño se cambia tal como se muestra en la Figura 6.6.
Figura 6.5
- Para lograr el menú que se muestra en la Figura 6.6 se hace uso del ícono
“Inserta menú” y del ícono “Inserta separador”, luego a cada menú y sub
menú se debe poner sus respectivos nombres.
Inserta separador
Inserta menú
Figura 6.6
- Finalmente en la ventana del “árbol de componentes” se crean los objetos

con le nombre de “jMenuItem1”, “jMenuItem2”, “jMenuItem3”, etc; entonces
para cambiar el nombre de dichos objetos se debe ir a la ventana
propiedades y cambiar la propiedad “name” para cada uno, de tal manera
que al final debe quedar con sus nombres tal como se muestra en la
Figura 6.5.
- Para regresar al diseño del formulario, hacemos clic derecho en “IU” en la

ventana del “árbol de componentes” y en el menú desplegable que sale
seleccionar “Activar el diseñador”, entonces en ese momento la ventana de
diseño se cambia al formulario.

enviar ningún mensaje de error. Ingrese al menú de opciones y verá las
nuesvas opciones. Si no hay ningún error podemos continuar, en caso
contrario recuperamos el backup del paso dos y regresamos al paso tres.
(Si funciona bien no se olvide de hacer un backup antes de continuar).
04) Ahora añadiremos acción al menú Archivo/Nuevo…, para ello seguiremos

los siguientes pasos:
- Vamos a enlazar el elemento de menú Archivo/Nuevo… con un manejador

de sucesos que borra el texto actual del área de texto cuando se hace clic
en la opción “Nuevo…” del menú “Archivo”, para ello seleccionamos el
elemento “jMenuFileNuevo” en el árbol de componentes hacemos clic en la
pestaña “Sucesos” de la ventana “Inspector” y hacemos doble clic en el
suceso actionPerformed() (lado derecho) y automáticamente se pasará al
código fuente y se generará el siguiente código:
void jMenuFileNuevo_actionPerformed(ActionEvent e) {
Dentro del cual se debe añadir el siguiente código:

jTextArea1.setText(""); // Borra el texto del área del texto.
De tal manera que todo el código debe quedar como:

}

enviar ningún mensaje de error. Escriba algo en el área de texto y vea qué
sucede al seleccionar Archivo/Nuevo. Debe borrar el contenido. Pero
observamos que no pregunta si desea guardar el archivo antes de borrar el
contenido como lo hace todos los software, no se preocupe eso lo haremos
más adelante. Si no hay ningún error podemos continuar, en caso contrario
recuperamos el backup del paso tres y regresamos al paso cuatro. (Si
funciona bien no se olvide de hacer un backup antes de continuar).
05) Ahora añadiremos acción al menú Archivo/Abrir…, para ello añadiremos un

cuadro de diálogo selector de archivos “JFileChooser", para ello seguiremos
- Hacemos clic en la ficha “Contenedores Swing” y hacemos clic el

componente JFileChooser (ver Figura 6.7), luego hacemos clic en la
carpeta “IU” del árbol de componentes para colocar el componente en el
diseñador de interfaces (tenga cuidado, si hace clic en la superficie de
diseño, el componente se colocará en una sección equivocada del árbol,
verifique que en el arbol debe aparecer el elemento “jFileChooser1” que
pertenece a “IU”).

Figura 6.7
- Como vamos a leer el contenido de un archivo de texto, es necesario

insertar en la cabecera del programa el siguiente código:
import java.io.*;
- A continuación deserrollaremos un método llamado “openFile”, el cual se

puede ubicar en cualquier parte de la clase, sin embargo lo colocaremos
después del código del método jbInit() y justo antes del suceso
jMenuFileExit_actionPerformed(), el código que añadiremos en el código
fuente es:
// Abrir el archivo con nombre; lee el texto del archivo al jTextArea1 e informar a la barra de estado.
void openFile(String fileName) {
try {
// Abrir un archivo con nombre.
File file = new File(fileName);
// Obtener el tamaño del archivo abierto.

int size = (int)file.length();
// Asignar cero a un contador para realizar un recuento de los caracteres que se han leído del archivo.
int chars_read = 0;
// Crear un vector de entrada basado en el archivo, para leer los datos.

FileReader in = new FileReader(file);
// Crea una matriz de caracteres del tamaño del archivo, para utilizarla como búfer de
// datos, en el que leer los datos del texto.
char[] data = new char[size];
// Leer todos los caracteres disponibles en el búfer.

while(in.ready()) {
// Incrementar el recuento de cada carácter leído, y acumularlos en el búfer de datos.
chars_read += in.read(data, chars_read, size - chars_read);
}
in.close();
// Crear una cadena temporal que contenga los datos, y asignar la cadena a JTextArea.
jTextArea1.setText(new String(data, 0, chars_read));
// Muestra el nombre del directorio y archivos abiertos en la barra de estado.

statusBar.setText("Archivo abierto "+fileName);
}
catch(IOException e) {
statusBar.setText("Error al abrir "+fileName);
}
}
- Luego, seleccionamos el elemento “jMenuFileAbrir” en el árbol de

componentes y le creamos un suceso actionPerformed() similar al caso de
la opción “Nuevo” (visto en el paso anterior) y automáticamente se pasará
al código fuente y se debe añadir el siguiente código:
// Utilizar la versión “Abrir” del cuadro de diálogo, si elije “Cancelar” no pasa nada
if (JFileChooser.APPROVE_OPTION == jFileChooser1.showOpenDialog(this)) {
// Llamar al método openFile para intentar cargar el texto desde el archivo al JTextArea
openFile(jFileChooser1.getSelectedFile().getPath());
//pinta el menú de nuevo una vez que el elemento se ha seleccionado
this.repaint();
}
Guarde la aplicación y ejecútela. En el menú Archivo/Abrir, seleccione un

archivo de texto y pulse Aceptar. Debe aparecer el nombre del archivo y el
directorio completo en la línea de estado en la parte inferior de la ventana y
su contenido en el área de texto. Si no hay ningún error podemos continuar,
en caso contrario recuperamos el backup del paso cuatro y regresamos al
paso cinco. (Si funciona bien no se olvide de hacer un backup antes de
continuar).
06) Ahora añadiremos acción al menú Archivo/Guardar…y Archivo/Guardar

como…; el programa necesita saber si el archivo que se guarda es nuevo o
si se ha modificado un archivo anterior. Cuando un archivo se ha
modificado desde la última grabación, se necesitará controlar con una
variable de instancia String que almacene el nombre del archivo abierto,
además de añadir métodos para comprobar si se trata de un archivo
modificado y escribir de nuevo el texto. Para hacer todo lo dicho seguiremos
- Haga clic en la pestaña “Fuente” y seleccione el elemento “jFileChooser1”

en el panel de estructura (esto le llevará a la última entrada de la lista de
declaraciones de variables de instancia), luego debajo de la creación del
“jFileChooser1”, añadimos las siguientes declaraciones:
String currFileName = null; //Vía completa y nombre de archivo. null significa nuevo / sin título.
boolean modificado = false; // false significa que el archivo no se ha modificado.
- Haga clic en el método openFile(String fileName) del panel de estructura

para buscarlo rápidamente en el código fuente. Sitúe el cursor en el
método, a continuación de la línea siguiente que lee el archivo en
JTextArea:
jTextArea1.setText(new String(data, 0, chars_read));
a continuación de la línea anterior, inserte el siguiente código:

// Almacenar en caché el nombre de archivo abierto actualmente para utilizarlo al guardar
this.currFileName = fileName;
// ...y marcar la sesión de modificación como no modificado
this.modificado = false;
- Crearemos un método llamado saveFile() al que llamaremos desde el

manejador del suceso de Archivo/Guardar. Lo colocaremos justo después
del bloque del método openFile(). Este método tendrá el siguiente código:
// Guardar archivo actual; gestionar los que no tienen nombre de archivo; informar a la barra de estado.
boolean saveFile() {
// Gestionar donde aún no exista nombre de archivo.

if (currFileName == null) {
return saveAsFile();
}
try {
// Abrir el archivo del nombre actual.
File file = new File (currFileName);
// Crear un escritor de salida que escribirá ese archivo.

// FileWriter gestiona las conversiones de códigos de caracteres internacionales.
FileWriter out = new FileWriter(file);
String text = jTextArea1.getText();
out.write(text);
out.close();
this.modificado = false;
// Muestra el nombre del directorio y archivos abiertos en la barra de estado.

statusBar.setText(currFileName);
return true;
}
catch(IOException e) {
statusBar.setText("Error al guardar "+currFileName);
}
return false;
}
Después de crear el código anterior, el panel de estructura del JBuilder,

presenta un mensaje de error, porque el método saveAsFile() aún no ha
sido creado, pero a continuación lo desarrollaremos, teniendo en cuenta
que dicho método también nos servirá para la opción “Archivo/Guardar
como”, el código que añadiremos después del bloque del método
saveFile() es:
// Guardar el archivo actual, preguntando al usuario el nuevo nombre de destino.
// Informar a la barra de estado.
boolean saveAsFile() {
//Utilizar la versión “Guardar” del cuadro de diálogo, comprobar el valor devuelto de Aceptar/Cancelar
if (JFileChooser.APPROVE_OPTION == jFileChooser1.showSaveDialog(this)) {
// Asignar la selección del usuario al nombre de archivo actual,
// a continuación realizar un saveFile normal
currFileName = jFileChooser1.getSelectedFile().getPath();
//pinta el menú de nuevo una vez que el elemento se ha seleccionado
this.repaint();
return saveFile();
}
else {
this.repaint();
return false;
}
}
- Haga clic en la pestaña “Diseño” y seleccione el elemento

“jMenuFileGuardar” en el árbol de componentes y le creamos un suceso
actionPerformed(), luego insertamos el siguiente código:
//Gestionar el elemento de menú Archivo/Guardar.
saveFile();
Guarde la aplicación y ejecútela. En el menú Archivo/Abrir, seleccione un

archivo de texto y pulse Aceptar, luego aumente algún texto adicional y
grabe los cambios seleccionando el menú Archivo/Abrir, luego cierre la
aplicación y vuelva a abrir y recupere el archivo guardado y observará que
se han guardado los cambios. Si no hay ningún error podemos continuar,
en caso contrario recuperamos el backup del paso cinco y regresamos al

paso seis. (Si funciona bien no se olvide de hacer un backup antes de
continuar).
07) Un buen software debe controlar si un archivo se ha modificado desde que

se creó, abrió o guardó; de tal manera que si el archivo ha sido modificado
debe preguntar al usuario si debe guardarse antes cerrar el archivo o salir
del programa. Dicho control se realizará con la variable booleana
denominada “modificado” que creamos en el paso seis y que se hizo
referencia en el código anterior; para ello seguiremos los siguientes pasos:
- Seleccione la ficha “Fuente” y seleccione el método manejador del suceso

de Archivo/Nuevo en el panel de estructura denominado
”jMenuFileNuevo_actionPerformed(ActionEvent e)” y añada a continuación
de la línea jTextArea1.setText("") y antes de la llave de cierre, el siguiente
código:
// Borra el nombre de archivo actual y define el archivo como no modificado.
currFileName = null;
modificado = false;
- Es necesario que el programa presente un cuadro de mensaje de

confirmación para constatar si el usuario desea guardar un archivo
modificado antes de cerrarlo cuando selecciona Archivo/Nuevo,
Archivo/Abrir o Archivo/Salir. Este cuadro de diálogo se abre con una
llamada a un método de clase en JOptionPane, para ello crearemos un
método llamado “comprobacion()”, este método lo situaremos justo a
continuación del bloque del método saveAsFile() creado anteriormente; el
código del método “comprobacion()” es el siguiente:
// Comprobar si el archivo se ha modificado.
// Si es así, pedir al usuario una decisión guardar/no guardar/cancelar.
boolean comprobacion() {
int value = JOptionPane.showConfirmDialog(this, "¿Desea guarda los cambios realizados?",
"Editor de Textos", JOptionPane.YES_NO_CANCEL_OPTION) ;
switch (value) {
case JOptionPane.YES_OPTION:
// sí, guarde los cambios

return saveFile();
case JOptionPane.NO_OPTION:
// No; desechar las modificaciones y devolver true sin guardar

return true;
case JOptionPane.CANCEL_OPTION:
default:
// Cancelar el cuadro de diálogo sin guardar ni cerrar

return false;
}
}
Este método aún no está completo, ya que actualmente, actúa como si el

archivo estuviese modificado, aunque no se hayan producido cambios en
el texto, pero se terminará más adelante. Se llama a este método cuando
el usuario seleccione Archivo/Nuevo, Archivo/Abrir o Archivo/Salir. La
finalidad del método es comprobar si es necesario guardar el texto. Si el
texto fue modificado, este método utiliza un cuadro de diálogo de mensaje
Sí/No/Cancelar para preguntar al usuario si desea guardar el archivo. Este
método realiza también una llamada a saveFile() si el usuario hace clic en
el botón Sí. Cuando el método finaliza, el valor booleano devuelto indica,
si es true, que puede abandonarse el archivo porque no se ha modificado
o porque el usuario ha hecho clic en el botón Sí o No. Si el valor devuelto
es false, querrá decir que el usuario ha hecho clic en Cancelar. En un paso
posterior, se añadirá el código que verifica si el archivo fue modificado.
- Haremos las llamadas al método “comprobacion()” insertando en la parte

superior de los manejadores de los sucesos de las opciones
Archivo/Nuevo, Archivo/Abrir y Archivo/Salir; generado por el asistente. En
cada caso, se debe comprobar el valor que devuelve “comprobacion()” y
realizaremos la operación sólo si el valor devuelto es verdadero (true).
En el caso de la opción Archivo/Nuevo, el método modificado debe tener el

siguiente código:
// Gestiona el elemento de menú Archivo/Nuevo.
if (comprobacion()) {
// Borra el nombre de archivo actual y define el archivo como no modificado.

currFileName = null;
modificado = false;
}
}
En el caso de la opción Archivo/Abrir, el método modificado debe tener el

siguiente código:
void jMenuFileAbrir_actionPerformed(ActionEvent e) {
// Gestiona el elemento de menú Archivo|Abrir.
if (!comprobacion()) {
return;
}
this.repaint();
}
}
En el caso de la opción Archivo/Salir, el método modificado debe tener el

siguiente código:
//Realizar Archivo | Salir
public void jMenuFileExit_actionPerformed(ActionEvent e) {
if (comprobacion()) {
System.exit(0);
}
}
Guarde la aplicación y ejecútela. Si no hay ningún error podemos continuar,

en caso contrario recuperamos el backup del paso seis y regresamos al

paso siete. (Si funciona bien no se olvide de hacer un backup antes de
continuar).
08) Ahora trabajaremos con la barra de herramientas y agregaremos cada

botón de la barra de herramientas sus toolTipText correspondiente, para ello
seguiremos los siguientes paso:
- Hacemos clic en la pestaña “Diseño” y seleccionamos el botón jButton1 de
la barra de herramientas o en el árbol de componentes. Luego hacemos
clic en la pestaña “Propiedades” del Inspector. Luego hacemos clic en la
propiedad toolTipText para resaltar su entrada y escribimos “Abrir archivo”.
- Repitimos le proceso anterior para el botón jButton2 y escribimos “Guardar

archivo” para el botón jButton3 y escribimos “Acerca de…”.
09) Ahora agregaremos los sucesos a cada botón de la barra de herramientas,

para ello seguiremos los siguientes paso:
- Hacemos clic en la pestaña “Diseño” y seleccionamos el botón jButton1.
Luego hacemos clic en la pestaña “Sucesos” y seleccionamos el suceso
“actionPerformed” y hacemos doble clic en el valor (lado derecho) y
automáticamente se creará el siguiente código:
Dentro del cual se debe insertar el siguiente código:

//Gestionar el botón Abrir de la barra de herramientas
fileOpen();
Pero como aún no jemos creado el método fileOpen() el JBuilder nos envía
un mensaje de error, por el momento no se preocupe ya que ese método y
los demás métodos lo desarrollaremos más adelante.
- El mismo pao anterior haremos para los botones jButton2 y jButton3 y se

deben crear los siguientes códigos:
//Gestionar el botón Guardar de la barra de herramientas
saveFile();
}
//Gestionar el botón Acerca de de la barra de herramientas
helpAbout();
}
- Para crear el método “fileOpen()” debemos hacer lo siguiente: Creamos la

máscara del método y lo situaremos encima del método openFile(String
fileName). La máscara debe parecerse al siguiente:

void fileOpen() {
Luego nos dirijimos al manejador del suceso Archivo/Abrir,

jMenuFileAbrir_actionPerformed(ActionEvent e) y seleccionamos el código
comprendido entre el primer comentario y la última llave de cierre. El
código seleccionado debe ser:
return;
}
}
this.repaint();
Luego cortamos el código seleccionado con Shift+Delete y lo pegamos en

la máscara del método fileOpen(), de tal manera que dicho método debe
quedar de la siguiente manera:
void fileOpen() {
return;
}
}
this.repaint();
}
Ahora, llameremos a fileOpen() desde el manejador de susceso de

elemento de menú Archivo/Abrir, entonces el nuevo manejador de sucesos
presentará el siguiente aspecto:
void jMenuFileAbrir_actionPerformed(ActionEvent e) {
// Gestiona el elemento de menú Archivo/Abrir.
fileOpen();
}
- Ahora crearemos el método helpAbout() el cual lo asociaremos con el

botón “Acerca de” y la opción del menú Ayuda/Acerca de. Para ello
colocamos la máscara del método helpAbout() en el código,
inmediatamente antes del método fileOpen() de la siguiente manera:
// Mostrar el cuadro de diálogo Acerca de.
void helpAbout() {
Luego cortamos todo el código que está dentro de

jMenuHelpAbout_actionPerformed() y los pegamos dentro del método
helpAbout(), de tal manera que el código final sería el siguiente:
// Mostrar el cuadro de diálogo Acerca de.
void helpAbout() {
ClaseEditorTextos_AcercaDe dlg = new ClaseEditorTextos_AcercaDe(this);
Dimension dlgSize = dlg.getPreferredSize();
Dimension frmSize = getSize();
Point loc = getLocation();
dlg.setLocation((frmSize.width - dlgSize.width) / 2 + loc.x, (frmSize.height - dlgSize.height) / 2 + loc.y);
dlg.setModal(true);
dlg.pack();
dlg.show();
}
Luego dentro del jMenuHelpAbout_actionPerformed() introducimos el

siguiente código:
helpAbout(); // llamada al método helpAbout()
Ahora, guarde y ejecute la aplicación. Pruebe los botones Abrir, Guardar y

Acerca de. Compárelos con los elementos de menú Archivo|Abrir,
Archivo|Guardar y Ayuda|Acerca de
Guarde la aplicación y ejecútela. Pruebe los botones de las barras de

herramientas y su funcionamiento. Si no hay ningún error podemos
continuar, en caso contrario recuperamos el backup del paso siete y
regresamos al paso ocho y nueve. (Si funciona bien no se olvide de hacer
un backup antes de continuar).
10) Ahora, asociaremos el tratamiento de sucesos con el JTextArea, de manera

que el programa pueda marcar el archivo con el indicador “modificado”
cuando el usuario lo modifique. Para entender lo que se va a hacer, es
necesario saber que las clases que contienen los datos se denominan
modelos. Las listas utilizan ListModel, las tablas utilizan TableModel y los
documentos utilizan Document; entonces ahora, vamos a añadir un
DocumentListener de Swing al modelo DocumentModel de jTextArea, y se
van a buscar sucesos que realicen inserciones, eliminaciones o cambios en
el archivo, para ello seguiremos los siguientes pasos:
- Hacemos clic en la pestaña diseño y seleccionamos el jTextArea1.

- Luego hacemos clic derecho en la propiedad “document” y elegimos la
opción “Exponer como variable de ámbito de clase”, luego si observamos
en la ventana del “árbol de componentes” en la categoría “Otros” se ha
insertado el objeto “document1”.
- Ahora selecionamos en la ventana del “árbol de componentes” el objeto
“document1” y hacemos clic en la pestaña “Sucesos” de la ventana del
inspector; luego seleccionamos el suceso changedUpdate() y creamos el
suceso document1_changedUpdate(DocumentEvent e), dentro del cual
agragamos el sigueinte código:
modificado = true;

- Ahora crearemos dos sucesos más para el objeto “document1”, el suceso
insertUpdate() y removeUpdate(), en cada uno de los cuales añadiremos el
mismo código de changedUpdate para ambos, es decir añadiremos el
siguiente código:
modificado = true;
De esta manera, se asegurará de que la escritura de cualquier carácter en

el área de texto asignará al indicador “modificado” el valor verdadero (true).
- Ahora añadiremos en la parte superior del método “comprobacion()” el

siguiente código:
if (!modificado) {
return true;
}
De tal manera que todo el método “comprobacion()” tenga el siguiente

código:
boolean comprobacion() {
if (!modificado) {
return true;
}
int value = JOptionPane.showConfirmDialog(this, "¿Desea guarda los cambios realizados?",

"Editor de Textos", JOptionPane.YES_NO_CANCEL_OPTION) ;
switch (value) {
case JOptionPane.YES_OPTION:
// sí, guarde los cambios
return saveFile();
case JOptionPane.NO_OPTION:
// No; desechar las modificaciones y devolver true sin guardar
return true;
case JOptionPane.CANCEL_OPTION:
default:
// Cancelar el cuadro de diálogo sin guardar ni cerrar

return false;
}
}
Guarde la aplicación y ejecútela. Haga algunas pruebas el programa ya no

debe solicitar por gusto que se guarden los archivos si no han sido
modificados. Si no hay ningún error podemos continuar, en caso contrario
recuperamos el backup del paso nueve y regresamos al paso diez. (Si
funciona bien no se olvide de hacer un backup antes de continuar).
11) Ahora, completaremos la aplicación para el menú “Edición” y sus

respectivos submenús, entonces comenzaremos enlazando el menú
Edición/Fuente, entonces añadiremos un diálogo Selector de fuentes, para
ello seguiremos los siguientes pasos:
- Hacemos clic en la pestaña “Diseño”, y luego elija la opción Edición/Añadir

componente del JBuilder. Aparece el cuadro de diálogo Seleccionar un
componente. Haga clic en la ficha “Paleta de componentes” y luego
seleccione la opción “Más dbSwing” y luego seleccione el componente

“com.borland.dbswing.FontChooser” ( ) del campo Componentes y
finalmente haga clic en el botón “Aceptar” para añadir el selector de
fuentes al diseño; entonces en la ventana del árbol de componentes se
habrá insertado el objeto “fontChooser1” en la categoría “otros”.
- Para darle funcionalidad al “fontChooser1” que acabamos de crear,

debemos seleccionar el “fontChooser1” en el árbol de componentes, luego
hacemos clic en la pestaña “Propiedades” y seleccionamos la propiedad
“frame” y seleccionamos “this” de la lista desplegable de valores.
- Ahora hacemos clic en el valor de la propiedad “title” y escribimos el texto

“Fuente” y pulsamos Enter. Como resultado de ello, se añaden las líneas
siguiente al código fuente en el método jbInit():
fontChooser1.setFrame(this);
fontChooser1.setTitle("Fuente");
- Ahora, el objeto “fontChooser1” lo asociaremos con el menú

Edición/Fuente.
- Hacemos clic en la pestaña “Diseño” y seleccionamos “jMenuEditFuente”

luego hacemos clic en la pestaña “Sucesos” y seleccionamos el suceso
“actionPerformed” y luego hacemos doble clic en el lado de valor (lado
derecho de la propiedad) y se creará el siguiente código:
void jMenuEditFuente_actionPerformed(ActionEvent e) {
Luego dentro del método ingrese esta línea de código:

fontChooser1.showDialog();
- Ahora para que funcione bien, debemos asociarlo al “área de texto”, para
ello haga clic en la pestaña “Fuente” y seleccione
jMenuEditFuente_actionPerformed(ActionEvent e) e ingrese el siguiente
código:
// Gestiona el elemento de menú "Edición Fuente"
// Obtiene la fuente existente en el área de texto y la coloca
// en el selector de fuentes antes de mostrarlo,
// para que se modifique la fuente actual.
fontChooser1.setSelectedFont(jTextArea1.getFont());
// Comprueba el valor devuelto por showDialog() para verificar si el usuario
// ha pulsado Aceptar. Obtiene la nueva fuente del Selector de fuentes.
if (fontChooser1.showDialog()) {
// Asigna a la fuente de jTextArea1 el valor
// seleccionado por el usuario antes de pulsar Aceptar
jTextArea1.setFont(fontChooser1.getSelectedFont());
}
Guarde la aplicación y ejecútela. Escriba algo en el texto y verifique la

opción Edit/Fuente. (Si funciona bien no se olvide de hacer un backup antes
de continuar).
12) Ahora, enlazaremos el menú Edición/Color de texto, entonces añadiremos
un diálogo Selector de colores, para ello seguiremos los siguientes pasos:
- Hacemos clic en la pestaña “Diseño”, y luego seleccione

“jMenuEditColorTexto”, luego hacemos clic en la pestaña “Sucesos” y
seleccionamos el suceso “actionPerformed” y luego hacemos doble clic en
el lado de valor (lado derecho de la propiedad) y se creará el siguiente
código:
void jMenuEditColorTexto_actionPerformed(ActionEvent e) {
Ahora para que funcione bien, debemos asociarlo al “área de texto”, para
ello ingresaremos el siguiente código:
//Gestiona el elemento de menú "Color de texto"
Color color = JColorChooser.showDialog(this,"Color de texto",jTextArea1.getForeground());
if (color != null) {
jTextArea1.setForeground(color);
}
Guarde la aplicación y ejecútela. Escriba algo en el texto y verifique la

opción Edit/Color de texto. (Si funciona bien no se olvide de hacer un
backup antes de continuar).
13) Por último, enlazaremos el menú Edición/Color de fondo, entonces

añadiremos un diálogo Selector de colores, para ello seguiremos los
siguientes pasos:
- Hacemos clic en la pestaña “Diseño”, y luego seleccione

“jMenuEditColorFondo”, luego hacemos clic en la pestaña “Sucesos” y
seleccionamos el suceso “actionPerformed” y luego hacemos doble clic en
el lado de valor (lado derecho de la propiedad) y se creará el siguiente
código:
void jMenuEditColorFondo_actionPerformed(ActionEvent e) {
Luego agregamos el siguiente código:

// Gestiona el elemento de menú "Color de fondo"
Color color = JColorChooser.showDialog(this,"Color de fondo",jTextArea1.getBackground());
if (color != null) {
jTextArea1.setBackground(color);
}
Con esto habremos cumplido con el diseño de nuestro procesador de textos,

aunque falta mucho por agregar pero como ejemplo es de mucha utilidad.

6.2 SEGUNDA APLICACIÓN.
En esta segunda aplicación, desarrollaremos un proyecto deportivo, el

programa debe visualizarse similar al que se muestra en la Figura 6.8), para ello
Figura 6.8
01) En el software “Administrador corporativo” del SQL se debe crear la base de

datos llamada “deporte”, luego crearemos una tabla llamada “deportistas”
con los campos como se muestra en la Figura 6.9.
Figura 6.9
Luego ingresamos dos datos tal como se muestra en la Figura 6.10.
Figura 6.10
Para observar las fotos de los deportistas en la aplicación, es necesario

colocar los archivos con el mismo nombre del código registrado en la tabla;
por ejemplo en este caso se debe colocar en el directorio “C:\Imagenes” los
archivos “RON01.jpg” (foto de Ronaldo) y “RON02.jpg” (foto de Ronaldiño)
con 100 pixeles de ancho y 120 pixeles de alto (ver Figura 6.11).
Figura 6.11
02) Construir del DSN (Data Source Name) mediante ODBC (los pasos para la
construcción del “dsn” se pueden observar en el ítem 5.4 sección “b” del
capítulo 5); el “dsn” debe tener el nombre “dsnDEPORTE” y como
descripción “ConexionDEPORTE”.
03) Cargar el software “JBuilder” y crear un nuevo proyecto y una nueva

aplicación con los siguientes datos:
Datos del proyecto:

Nombre : AplicacionBD
Directorio: Seleccione la unidad donde se guardará el proyecto.
Datos de la aplicación:
Paquete : paqueteAplicacionBD
Clase principal : Principal
Clase secundaria : ClaseAplicacionBD
Título : Grandes deportistas
Activar las casillas de:
- Generar barra de menú.
- Generar barra de herramientas.
- Generar barra de estado.
- Generar cuadro Acerca de
- Centrar Marco en la Pantalla

enviar ningún mensaje de error. Si no hay ningún error podemos continuar,
pero recuerde que siempre debe hacer copias para no perder todo el
proyecto.
04) De aquí en adelante suponemos que el lector ya conoce el entorno del

JBuilder, si no conoce bien le sugerimos realizar paso a paso la aplicación

anterior (procesador de textos). Entonces continuando con nuestra
aplicación ahora insertaremos el fondo de la aplicación cuyo archivo tiene el
nombre de “fondo.jpg” que se encuentra en el directorio “C:/Imagenes”, para
ello seguiremos los siguientes pasos:
- Modificamos el tamaño del formulario que por defecto es de 400x300, para

ello modificamos el código:
Por:
- Hacemos clic en la ficha “Diseño” y añadimos al formulario un

“JScrollPane" y luego un “JLabel” dentro del “JScrollPane”.
- Hacemos clic en la ficha “Fuente” y creamos una nueva imagen para el

fongo que le llamaremos “image4”, para ello debajo del código:
ImageIcon image3;
Agregamos el siguiente código:

ImageIcon image4 = new ImageIcon("C:/Imagenes/fondo.jpg");
Pero se debe tener en cuenta que en el directorio “C:/Imagenes” debe

estar el archivo “fondo.jpg”
- Hacemos clic en la ficha “Diseño” y seleccionamos en el árbol de

componentes “jLabel1” y en la ficha “Propiedades” seleccione la propiedad
“text” y borre su contenido luego seleccione la propiedad “icon” y
seleccione “image4” y el gráfico se habrá insertado al formulario (similar al
que se muestra en la Figura 6.8).
05) Ahora diseñaremos el sistema de menús (ver Figura 6.12), en el menú

“Archivo” añadiremos los sub menús “Consultar…”, “Añadir registros…”,
“Eliminar registros…” y un separador (si no recuerda cómo hacerlo, vaya al
ejemplo anterior, allí se ha explicado paso a paso).
Figura 6.12

Ahora cambie los nombres de los tres “JMenu” creados como se muestra en
la Figura 6.13.
Figura 6.13
06) Ahora diseñaremos un cuadro de diálogo para hacer consultas en la base

de datos, para ello seguiremos los siguientes pasos:
- Hacemos clic en el menú Archivo/Nuevo y saldrá la ventana que se

muestra en la Figura 6.14 en el cual seleccionaremos la opción “Cuadro de
diálogo” y hacemos clic en el botón “Aceptar”.
Figura 6.14
- En el cuadro que se muestra en la Figura 6.15 en el campo “Clase” ingrese

“ConsultaDB” y haga clic en “Aceptar”.

Figura 6.15
Entonces se crea la clase “ConsultaDB.java” el cual se puede observar en

la Figura 6.16.
Figura 6.16
Luego todo el código generado por el JBuilder reemplácelo por el siguiente

código:
package paqueteAplicacionBD;
import java.awt.*;
import java.sql.*;
public class ConsultaDB extends JDialog {

String [] campos;
String [][] registros;

JPanel panel1 = new JPanel();
BorderLayout borderLayout1 = new BorderLayout();
JPanel jPanel1 = new JPanel();
JScrollPane jScrollPane1 = new JScrollPane();
Choice choice1 = new Choice();
JCheckBox jCheckBox1 = new JCheckBox();
public ConsultaDB(Frame frame, String title, boolean modal) {

super(frame, title, modal);
try {
jbInit();
pack();
}
ex.printStackTrace();
}
}
public ConsultaDB() {
this(null, "", false);
}

this.setTitle("Ventana de consulta de tabla 'Deportistas'");
consultar("SELECT * FROM Deportistas"); //Muestra todos los registros por defecto
jLabel1.setFont(new java.awt.Font("Dialog", 0, 9));

jLabel1.setText("Seleccione campo de consulta");
jLabel2.setFont(new java.awt.Font("SansSerif", 0, 9));
jLabel2.setText("Ingrese condición de consulta");
jLabel3.setText("Registros seleccionados de la consulta");
jLabel4.setText("Fotografía");
jLabel5.setBackground(Color.white);
jLabel5.setOpaque(true);
jLabel5.setText("");
jButton1.setText("Generar Consulta SQL");
jButton1.addActionListener(new ConsultaDB_jButton1_actionAdapter(this));
jTextField1.setFont(new java.awt.Font("SansSerif", 0, 11));
jTextField1.setForeground(Color.red);
jTextField1.setCaretColor(Color.black);
jTextField1.setText("");
choice1.setBounds(new Rectangle(191, 33, 133, 22));
choice1.setFont(new java.awt.Font("SansSerif", 0, 11));
choice1.setForeground(Color.red);
jTextField2.setOpaque(true);
jTextField2.setText("SELECT * FROM Deportistas WHERE Dep_edad<=25");
jButton3.setText("Consultar");
jCheckBox1.setSelected(false);
jCheckBox1.setText("Generar consulta SQL (manual)");
jCheckBox1.setBounds(new Rectangle(12, 82, 183, 22));
jCheckBox1.addActionListener(new ConsultaDB_jCheckBox1_actionAdapter(this));
jLabel6.setForeground(Color.blue);
jLabel6.setText("Ejm. de consulta SQL: SELECT * FROM Deportitas ORDER BY Dep_nombre DESC");
jLabel7.setText("Ejm. de consulta SQL: SELECT * FROM Deportistas WHERE Dep_edad Between 20 And 25");
jLabel8.setText("Ejm. de consulta SQL: SELECT * FROM Deportistas WHERE Dep_nombre LIKE \'RO%\'");
jLabel9.setText("SELECT * FROM Trabajador WHERE");
actualizaTabla(); //Llama al método actualizaTabla

}
public void actualizaTabla(){ //método que actualiza la tabla

JTable jTable1 = new JTable(registros,campos); //Este expresión es necesario
panel1.setLayout(borderLayout1);
jPanel1.setLayout(null);
jPanel1.setBackground(new Color(150, 255, 255));
getContentPane().add(panel1);
panel1.add(jPanel1, BorderLayout.CENTER);
jPanel1.add(jTextField2, null);
jPanel1.add(jScrollPane1, null);
jPanel1.add(jLabel5, null);
jPanel1.add(jButton2, null);
jPanel1.add(jTextField1, null);
jPanel1.add(choice1, null);
jPanel1.add(jCheckBox1, null);

String fotografia;
fotografia="C:/Imagenes/"+registros[seleFila][0].toString()+".jpg";
ImageIcon image5 = new ImageIcon(fotografia);
jLabel5.setIcon(image5);
}
});
}
public void consultar(String consulta){ //conecta a base de datos y consulta

try {
Connection conexion= DriverManager.getConnection("jdbc:odbc:dsnDEPORTE", "sa", "");
ResultSet rs= st.executeQuery(consulta); // Realiza la consulta

int numColumnas= rmeta.getColumnCount(); // Determina el número de columnas
int numreg=0;
//Determina el número de registros
numreg++;
}
campos=new String [numColumnas];

registros= new String [numreg][numColumnas];
for(int i=1; i<=numColumnas; ++i){ //procedimiento que detecta los campos de la tabla
campos[i-1]=rmeta.getColumnName(i);
choice1.add(campos[i-1]);
}
rs= st.executeQuery(consulta); //ejecuta la consulta
int fil=0; //contador para el número de registros

for(int i=1; i<=numColumnas; ++i) //procedimeinto que detecta el contenido de los campos
registros[fil][i-1]=rs.getString(i);
fil++;
}
}
}
}
} //*********************fin del metodo consultar
dispose();
}
String consulta;
consulta=jTextField2.getText();
consultar(consulta); //Muestra la consulta del contenido de jTextField2
actualizaTabla(); //Llama al método actualizaTabla
}
String campo,condicion;
condicion=jTextField1.getText();
int indice=choice1.getSelectedIndex();
campo="";
if (indice==0){
campo="Dep_codigo";
};
if (indice==1){
campo="Dep_nombre";
};
if (indice==2){
campo="Dep_edad";
};
jTextField2.setText("SELECT * FROM Deportistas WHERE "+campo+" "+condicion);
}
void jCheckBox1_actionPerformed(ActionEvent e) {
if (jCheckBox1.isSelected())
jTextField2.setEnabled(true);
else
}
}
class ConsultaDB_jButton2_actionAdapter implements java.awt.event.ActionListener {
ConsultaDB adaptee;
ConsultaDB_jButton2_actionAdapter(ConsultaDB adaptee) {
}
}
}

ConsultaDB adaptee;
}
}
}

ConsultaDB adaptee;
}
}
}
class ConsultaDB_jCheckBox1_actionAdapter implements java.awt.event.ActionListener {

ConsultaDB adaptee;
ConsultaDB_jCheckBox1_actionAdapter(ConsultaDB adaptee) {
}
adaptee.jCheckBox1_actionPerformed(e);
}
}
Figura 6.17
Luego de reemplazar el código anterior haga clic en la ficha “Diseño”,
entonces debe salir el cuadro de diálogo que se muestra en la Figura 6.17;
antes de ejecutar el programa, realice el siguiente paso.
07) Ahora enlazaremos el cuadro de diálogo creado en el paso anterior con el

menú “Archivo/Consultar…”, para ello seguiremos los siguientes pasos:
- Hacemos clic en la ficha “ClaseAplicacionDB” y luego en la ficha “Diseño” y

seleccionamos en el árbol de componentes “jMenuFileConsultar” y luego
en la ficha “Sucesos” seleccionamos “actionPerformed” y hacemos doble
clic y se creará el siguiente código:
void jMenuFileConsultar_actionPerformed(ActionEvent e) {
Luego añadimos el siguiente código:

ConsultaDB dlg = new ConsultaDB();
Dimension frmSize = dlg.getSize();
Point loc = dlg.getLocation();
dlg.setLocation((frmSize.width-dlgSize.width)/2+loc.x+275,(frmSize.height-dlgSize.height)/2+loc.y+200);
dlg.setSize(new Dimension(480, 420)); // este es el tamaño del cuadro de diálogo que se mostrará
dlg.setModal(true);
dlg.show();
Luego ejecutamos el programa y probamos la opción del menú

Archivo/Consulta y realizamos algunas consultas. Si todo está
funcionando bien podemos continuar, pero antes es recomendable cerrar
la ventana “ConsultaDB” haciendo clic en ícono que se muestra en la
Figura 6.18.
Figura 6.18
08) Ahora diseñaremos un cuadro de diálogo para añadir registros a la tabla,

para ello seguiremos los siguientes pasos:
- Hacemos clic en el menú Archivo/Nuevo y luego seleccionaremos la opción

“Cuadro de diálogo” y hacemos clic en el botón “Aceptar” (similar al paso 6,
ver Figura 6.14).
- Luego en el campo “Clase” ingrese “AnnadirDB” y haga clic en “Aceptar”

(ver Figura 6.15).
Entonces se crea la clase “AnnadirDB.java” el cual se puede observar en
la Figura 6.19.
Figura 6.19

código:
import java.awt.*;
import java.sql.*;
public class AnnadirDB extends JDialog {

public AnnadirDB(Frame frame, String title, boolean modal) {

try {
jbInit();
pack();
}
}
}
public AnnadirDB() {
}
this.setTitle("Ventana para añadir registro en tabla 'Deportistas'");
jLabel1.setText("Ingrese datos del Nuevo Deportista:");
panel1.setBackground(new Color(255, 217, 144));
jLabel2.setText("Código:");
jLabel3.setText("Nombre:");

jLabel4.setText("Edad:");
jButton1.setText("Añadir a tabla");
jButton1.addActionListener(new AnnadirDB_jButton1_actionAdapter(this));
jButton2.addActionListener(new AnnadirDB_jButton2_actionAdapter(this));
jLabel5.setText("No olvide de colocar el archivo con el nombre del CODIGO y extensión");
jLabel6.setText(" jpg en la carpeta C:/imagenes");
panel1.add(jLabel1, null);
panel1.add(jTextField1, null);
panel1.add(jButton2, null);
}
dispose();
}
int respuesta = JOptionPane.showConfirmDialog( this,"Desea Añadir los datos a la tabla 'Deportistas'",
"Atención",JOptionPane.OK_CANCEL_OPTION);
String consulta = null,codigo=null,nombre=null,edad=null;
if( respuesta == JOptionPane.OK_OPTION){

try {
Statement st = conexion.createStatement();
codigo=jTextField1.getText();
nombre=jTextField2.getText();
edad=jTextField3.getText();
consulta="INSERT INTO Deportistas (Dep_codigo,Dep_nombre, Dep_edad) VALUES
('"+codigo+"','"+nombre+"',"+edad+")";
st.execute(consulta); // Inserta registro en la tabla
jTextField1.setText(""); //limpia todos los cuadros de texto para ingresar

jTextField2.setText(""); // otros registros
}
}
}
}
}
}
class AnnadirDB_jButton2_actionAdapter implements java.awt.event.ActionListener {
AnnadirDB adaptee;
AnnadirDB_jButton2_actionAdapter(AnnadirDB adaptee) {
}
}
}
class AnnadirDB_jButton1_actionAdapter implements java.awt.event.ActionListener {

AnnadirDB adaptee;
AnnadirDB_jButton1_actionAdapter(AnnadirDB adaptee) {
}
}
}

Figura 6.20

menú “Archivo/Añadir…”, para ello seguiremos los siguientes pasos:

seleccionamos en el árbol de componentes “jMenuFileAnnadir” y luego en
la ficha “Sucesos” seleccionamos “actionPerformed” y hacemos doble clic
y se creará el siguiente código:
void jMenuFileAnnadir_actionPerformed(ActionEvent e) {

AnnadirDB dlg = new AnnadirDB();

dlg.setSize(new Dimension(380, 300));
dlg.setModal(true);
dlg.show();

Archivo/Añadir y también el menú Archivo/Consulta y añadimos algunos
registros y realizamos algunas consultas para comprobar que los datos se
han añadido. Si todo está funcionando bien podemos continuar, pero
antes es recomendable cerrar la ventana “AnnadirDB”.
10) Ahora diseñaremos un cuadro de diálogo para eliminar registros de la tabla,

para ello seguiremos los siguientes pasos:
- Hacemos clic en el menú Archivo/Nuevo y luego seleccionaremos la opción

“Cuadro de diálogo” y hacemos clic en el botón “Aceptar” (similar al paso 6,
ver Figura 6.14).
- Luego en el campo “Clase” ingrese “EliminarBD” y haga clic en “Aceptar”

(ver Figura 6.15).
Entonces se crea la clase “EliminarBD.java” el cual se puede observar en

la Figura 6.21.
Figura 6.21

código:
import java.awt.*;
import java.sql.*;
public class EliminarBD extends JDialog {

public EliminarBD(Frame frame, String title, boolean modal) {

try {
jbInit();

pack();
}
}
}
public EliminarBD() {
}
this.setTitle("Ventana Para Eleminar Registros de tabla 'Deportistas'");
jLabel1.setText("Ingrese código del deportista a eliminar:");
panel1.setBackground(new Color(255, 217, 144));
jButton1.setText("Eliminar registro");
jButton1.addActionListener(new EliminarBD_jButton1_actionAdapter(this));
jButton2.addActionListener(new EliminarBD_jButton2_actionAdapter(this));
}
dispose();
}
int respuesta = JOptionPane.showConfirmDialog( this,"Desea ELIMINAR registro de la tabla
'Deportistas'",
"CUIDADO",JOptionPane.OK_CANCEL_OPTION);
String consulta = null,codigo=null;
if( respuesta == JOptionPane.OK_OPTION){

try {
Statement st = conexion.createStatement();
codigo=jTextField1.getText();
consulta="DELETE FROM Deportistas WHERE Dep_codigo='"+codigo+"'";
st.execute(consulta); // Elimina registro en la tabla
jTextField1.setText(""); //limpia el cuadro de texto

}
}
}
}
}
}
class EliminarBD_jButton2_actionAdapter implements java.awt.event.ActionListener {

EliminarBD adaptee;
EliminarBD_jButton2_actionAdapter(EliminarBD adaptee) {
}
}
}
class EliminarBD_jButton1_actionAdapter implements java.awt.event.ActionListener {

EliminarBD adaptee;
EliminarBD_jButton1_actionAdapter(EliminarBD adaptee) {
}
}
}

Figura 6.22

menú “Archivo/Eliminar…”, para ello seguiremos los siguientes pasos:

seleccionamos en el árbol de componentes “jMenuFileEliminar” y luego en
la ficha “Sucesos” seleccionamos “actionPerformed” y hacemos doble clic
y se creará el siguiente código:
void jMenuFileEliminar_actionPerformed(ActionEvent e) {

EliminarBD dlg = new EliminarBD();
dlg.setModal(true);
dlg.show();

Archivo/Eliminar y también el menú Archivo/Consulta y añadimos luego
borrarmos algunos registros y realizamos algunas consultas para
comprobar que los datos se han borrados. Si todo está funcionando bien
podemos continuar, pero antes es recomendable cerrar la ventana
“EliminarBD”.

12) Ahora enlazaremos los botones de la barra de herramientas a cada uno de
los tres cuadros de diálogo creados anteriormente llamados “ConsultaDB”,
“AnnadirDB” y “EliminarBD”; para ello seguiremos los siguientes pasos:

seleccionamos en el árbol de componentes “jButton1” y luego en la ficha
“Sucesos” seleccionamos “actionPerformed” y hacemos doble clic y
adicionamos el siguiente código:
ConsultaDB dlg = new ConsultaDB();
dlg.setModal(true);
dlg.show();
También en la propiedad “toolTipText” ponemos “Consultar Tabla”.
- Luego hacemos clic en “jButton2” y luego en la ficha “Sucesos”

seleccionamos “actionPerformed” y hacemos doble clic y adicionamos el
siguiente código:
AnnadirBD dlg = new AnnadirBD();
dlg.setModal(true);
dlg.show();
También en la propiedad “toolTipText” ponemos “Añadir Registros”.
- Luego hacemos clic en “jButton3” y luego en la ficha “Sucesos”

seleccionamos “actionPerformed” y hacemos doble clic y adicionamos el
siguiente código:
EliminarBD dlg = new EliminarBD();
dlg.setModal(true);
dlg.show();
También en la propiedad “toolTipText” ponemos “Eliminar Registros”.
Finalmente grabamos y ejecutamos el programa y no debe fallar nada

CAPÍTULO VII
APLICACIONES WEB CON TECNOLOGÍA JAVA
JAVA para desarrollar aplicaciones WEB se fundamenta en el diseño de APPLETS.
Los applets son una manera de incluir programas complejos en el ámbito de una
página web. Estos applets se programan en Java y por tanto se benefician de la
potencia de este lenguaje para la web.
Los applets son pequeños programas hechos en Java, que se transfieren a las
páginas web y que el navegador ejecuta en el espacio de la página, es por ello que
la manera de trabajar de éstos varía un poco con respecto a los lenguajes de script
como Javascript. Los applets son más difíciles de programar que los scripts en
Javascript y requerirán unos conocimientos básicos o medios del lenguaje Java.
La principal ventaja de utilizar applets consiste en que son mucho menos

dependientes del navegador que los scripts en Javascript, incluso independientes
del sistema operativo del ordenador donde se ejecutan. Además, Java es más
potente que Javascript, por lo que el número de aplicaciones de los applets podrá
ser mayor.
Las características de los applets se pueden considerar desde el punto de vista del
programador y desde el del usuario. En este manual lo más importante es el punto
de vista del programador:
- Los applets no tienen un método main() con el que comience la ejecución. El

papel central de su ejecución lo asumen otros métodos que se verán
posteriormente.
- Todos los applets derivan de la clase java.applet.Applet. Los applets deben

redefinir ciertos métodos heredados de Applet que controlan su ejecución, tales
como: init(), start(), stop() y destroy().
- Los applets también suelen redefinir ciertos métodos gráficos, los más
importantes son: paint() y update(), heredados de Component y de Container; y
repaint() heredado de Component.
- Las applets disponen de métodos relacionados con la obtención de información,

como por ejemplo: getAppletInfo(), getAppletContext(), getParameterInfo(),
getParameter(), getCodeBase(), getDocumentBase(), e isActive().
El método showStatus() se utiliza para mostrar información en la barra de estado

del browser. Existen otros métodos relacionados con imágenes y sonido:
getImage(), getAudioClip(), play(), etc.

Para una mejor comprensión sobre applets, a continuación desarrollaremos
algunos ejemplos prácticos de applets desarrollados en JCreator, posteriormente
desarrollaremos con el JBuilder.
7.1 PRIMER APPLET.
A continuación desarrollaremos un applet que muestre los textos que se

muestran en la Figura 7.1 y su posterior visualización en un navegador.
Figura 7.1
Para el diseño y construcción seguiremos los siguientes pasos:
1) Cargamos el JCreator y agregamos un nuevo archivo al cual lo llamaremos

“Bienvenido” en el directorio “C:\Applets\Applet01” (este directorio se debe
crear desde el explorador de windows), entonces se habrá creado el archivo
“Bienvenido.java” y luego añadiremos el siguiente código.
import java.awt.*;
import java.applet.*;
public class Bienvenido extends Applet {

public void init(){
this.setBackground(new Color(255,255,220)); //Color de fondo
}
public void paint( Graphics g ) {

g.setColor(Color.black); //color de la letra
g.setFont(new Font("SansSerif",1,20));
g.drawString( "Bienvenido al mundo de los APPLETS",50,30);
g.setColor(new Color(0,100,120)); //Color de la letra
g.drawString("UCCI",100,120);
}
}
2) Compilamos el archivo y en el directorio “C:\Applets\Applet01” se habrán

añadido los archivos “Bienvenido.java” y “Bienvenido.class”.
3) En el directorio “C:\Applets\Applet01” guardamos el archivo “Index.html” que

lo crearemos con el programa “Block de Notas” de windows y debe tener el
siguiente contenido:
<HTML>
<APPLET CODE="Bienvenido.class" WIDTH=500 HEIGHT=150>
</APPLET>
</HTML>

Luego si hacemos doble clic en el archivo “Index.html” recién creado,
podremos visualizar la página que se muestra en la Figura 7.1, sin embargo,
es mejor utilizar el visualizador de JAVA llamador “appletviewer” que vienen
incorporado con el JAVA, eso lo haremos en el siguiente paso.
4) En el directorio “C:\Applets\Applet01” ahora crearemos, con el programa

“Block de Notas”, un archivo de trabajo por lotes llamado “Visualizar.bat”, el
cual debe tener el siguiente contenido:
set CLASSPATH=
C:\j2sdk1.4.2_04\bin\appletviewer Index.html
5) Finalmente, para observar la página web creada se hace doble clic en el

archivo “Visualizar.bat” y debe salir la página tal como se muestra en la
Figura 7.1.
Si modificamos el diseño de la página web y cambiamos el código del archivo

“Bienvenido.java” por el siguiente código:
import java.awt.*;
public class Bienvenido extends Applet {

public void init(){
}

for(int i=0;i<=255;i++){
g.setColor(new Color(i,255,220)); //Color de la letra
pausa(1000000);
}
repaint();
}
public void pausa(long tiempo){

for(long i=0;i<=tiempo;i++);
}
}
Luego lo compilamos el archivo, y hacemos doble clic en el archivo

“Visualizar.bat” y observaremos que la palabra “UCCI” aparace y desaparece
lentamente en forma permanente.
7.2 SEGUNDO APPLET.
A continuación desarrollaremos un applet que muestre los gráficos que se

muestran en la Figura 7.2 y su posterior visualización en un navegador.
Figura 7.2
Para el diseño y construcción seguiremos los siguientes pasos:
1) Cargamos el JCreator y agregamos un nuevo archivo al cual lo llamaremos

“Graficos” en el directorio “C:\Applets\Applet02” (este directorio se debe
crear desde el explorador de windows), entonces se habrá creado el archivo
“Graficos.java” y luego añadiremos el siguiente código.
import java.awt.*;
public class Graficos extends Applet {

public void init(){
}
public void paint(Graphics g) {

g.setColor( Color.blue);
g.drawLine(0, 0, getWidth(), getHeight() );
g.setColor( Color.red);
g.drawRect(10, 10, getWidth()-20, getHeight()-20 );
g.fillOval(200,50,100,100);
}
}
2) Los demás pasos ya son los mismos del ejemplo del PRIMER APPLET sólo
que en en archivo “Index.html” el tamaño de la ventana pondremos
WIDTH=500 HEIGHT=200; mientras que el archivo “Visualizar.bat” es
exactamente igual.
7.3 CREACIÓN DE APPLETS CON JBUILDER.
A continuación desarrollaremos el primer applet que hicimos en páginas

anteriores (ver Figura 7.1), pero esta vez en JBuilder, para ello seguiremos los
siguientes pasos:
1) Cargamos el JBuilder y luego creamos un nuevo proyecto con el nombre

“PrimerApplet” y luego seleccionamos el directorio dentro del cual se
seleccionará el proyecto (si no recuerda cómo crear un nuevo proyecto con
JBuilder vaya al capítulo V y VI).

2) Luego crearemos el applet respectivo, para ello seleccionamos
“Archivo/Nuevo” y hacemos clic en la ficha “Web” (ver Figura 7.3) y
seleccionamos la opción “Applet”, luego hacemos clic en el botón “Aceptar”.
Figura 7.3
Luego en el ventana que sale, se debe rellenar todos los datos que se
muestran en la Figura 7.4, en realidad en esta ventana existen 4 pasos pero
que por ahora no es necesario cambiar nada de los demás pasos es por eso
que defrente haremos clic en el botón “Finalizar” para crear el applet.
Para comprobar los archivos que se han generado hasta el momento,

debemos observar en el panel del proyecto (ver Figura 7.5), del cual uno de
los archivos más importantes son “Bienvenido.java” ya que de este archivo,
cuando se compila, se creará el archivo “Bienvenido.class” y el otro archivo
importante es “Bienvenido.html” ya que desde allí se ejecutará para
visualizar el applet en la Web.

Figura 7.4
Figura 7.5
3) Ahora estamos listos para diseñar nuestro applet, para ello en el código
generado por el JBuilder heremos lo siguiente:
- Dentro del método jbInit() agregamos código de tal manera que el método
debe quedar de la siguiente manera:
}
- Inmediatamente después del método jbInit() añadimos el paint() cuya

codigficación se muestra a continuación:

}
4) Ya hemos terminano el diseño de nuestro applet, ahora lo compilamos

haciendo clic en el botón y si todo hemos hecho bien debe mostrarse el
applet tal como se muestra en la Figura 7.6. No debemos preocuparnos por
lo que el appet no se muestra completo ya que eso se solucionará cuando el
applet se muestre en un navegador.
Figura 7.6
5) Ahora pasaremos a la etapa de distribuicón del applet, para ello juntaremos

los diversos archivos tales como clases de java, imágenes, sonido, etc.; en
un solo archivo JAR (Java ARchive), es un formato de ficheros basado en el
popular formato de compresión de ficheros ZIP, y se utiliza para poder
contener varios ficheros en uno solo. Aunque JAR se pueda utilizar también
como herramienta de compresión, la razón principal de su desarrollo e
implantación ha sido la de evitar sobrecarga en la red, haciendo que todos
los applets Java y sus componentes (ficheros .class, imágenes y sonidos)
puedan ser descargados por el navegador en una sola transacción http, en
lugar de tener que abrir una conexión por cada una de las piezas. Esto
acelera en gran medida la descarga del applet y su puesta en marcha sobre
una página web. El formato JAR también soporta compresión, lo que reduce

el tamaño del fichero a enviar y contribuye a reducir aún más el tiempo de
descarga del applet. JAR es, por lo tanto:
- El único formato de archivo accesible desde cualquier plataforma
- El único formato que maneja ficheros de sonido, imágenes y .class
- Compatible con cualquier código de applet ya existente
- Un estándar abierto, totalmente ampliable y escrito en Java
- La forma más adecuada de reunir todas las piezas que forman un applet
Para crear un archivo JAR desde JBuilder se procede de la siguiente

manera:
- Compilar nuestro applet principal y verificar que no haya ningún error.

- Creamos un subdirectorio donde se guardará el archivo JAR, este debe ser
distinto del directorio donde se encuentra el proyecto, ya que en la
distribución sólo se necesitan los archivos .class, gráficos y sonidos
empaquetados en un archivo JAR y aparte el archivo HTML del applet,
mientras que los archivos .java son los archivos fuente que Ud. es
propietario, entonces crearemos la carpeta “C:\Applets\AppletJBuilder01”.
- Luego vaya en el menú “Asistentes/Creador de recopilatorios…” y saldrá el
paso 1 de 5 de la ventana “Creador de recopilatorios” tal como se muestra
en la Figura 7.7.
Figura 7.7
- Seleccionamos la opción JAR de applets y luego hacemos clic en el botón

“Siguiente” para ir al paso 2 de 5 y saldrá la ventana que se muestra en la
Figura 7.8.
Figura 7.8
- Hacemos clic en el boto y en la ventana que sale, seleccionamos el

directorio creado anteriormente, es decir el directorio
“C:\Applets\AppletJBuilder01” dentro del cual se creará el archico
“PrimerApplet.jar”; y finalmente hacemos clic en el botón “Finalizar”, ya que
los demás pasos lo dejaremos con las opciones por defecto.
- En el panel del proyecto aparece un nodo de archivo denominado “JAR de

applets” tal como se muestra en la Figura 7.9.
Figura 7.9

- Por último para crear el archivo “PrimerApplet.jar” hacemos clic derecho
sobre el nodo “JAR de applets” y seleccionamos la opción “Ejecutar Make”,
entonces en ese momento se ha creado el archivo “PrimerApplet.jar”, el
cual se puede observar en la Figura 7.10, y también se puede verificar que
dicho archivo está dentro directorio “C:\Applets\AppletJBuilder01”.
Figura 7.10
6) En el directorio “C:\Applets\AppletJBuilder01” creamos y guardamos el

archivo “Index.html” que lo crearemos con el programa “Block de Notas” de
windows y debe tener el siguiente contenido:
<html>
<applet
codebase = "."
code = "paquetePrimerApplet.Bienvenido.class"
archive = "PrimerApplet.jar" Líneas importantes
width = 500
height = 150
>
</applet>
</html>
Si hacemos doble clic sobre el archivo “Index.html”, observameros nuestra

página en el explorador, pero podríamos mejorar la apariencia de nuestro
página combinando algunas sentencias del html con nuestro applet, de la
siguiente manera:
<html>
<head>
<title>
Primer APPLET con JBuilder-UCCI
</title>
</head>
<applet
codebase = "."
code = "paquetePrimerApplet.Bienvenido.class"
archive = "PrimerApplet.jar"
width = 500
height = 150
>
</applet>
</html>
Luego si hacemos doble clic en el archivo “Index.html” recién creado,

podremos visualizar la página que se muestra en la Figura 7.1, sin embargo,
es mejor utilizar el visualizador de JAVA llamador “appletviewer” que vienen
incorporado con el JAVA, eso lo haremos en el siguiente paso.
7) En el directorio “C:\Applets\AppletJBuilder01” ahora crearemos, con el

programa “Block de Notas”, un archivo de trabajo por lotes llamado
“Visualizar.bat”, el cual debe tener el siguiente contenido:
set CLASSPATH=
C:\JBuilder9\jdk1.4\bin\appletviewer Index.html
Debemos tener en cuenta que “C:\JBuilder9\jdk1.4\bin” es el directorio

donde está instalado el JBuilder, quizás en otras máquinas eso puede
cambiar.
8) Finalmente, para observar la página web creada se hace doble clic en el

archivo “Visualizar.bat” y debe salir la página tal como se muestra en la
Figura 7.1.
7.4 CREACIÓN DE APPLETS QUE INCLUYE COMPONENTES CON JBUILDER.
A continuación desarrollaremos un applet que muestre la ventana que se

observa en la Figura 7.11 para ello seguiremos los siguientes pasos:
Figura 7.11
1) Cargamos el JBuilder y luego creamos un nuevo proyecto con el nombre

“Continental” y luego seleccionamos el directorio dentro del cual se
seleccionará el proyecto.
2) Luego crearemos el applet respectivo (ver ejemplo anterior) con los

siguientes datos:
- Paquete: paqueteContinental
- Clase: Colores
3) Todo el archivo que se genera debemos reemplazar por el siguiente código:
package paqueteContinental;
import java.awt.*;
import java.net.*;
public class Colores extends Applet {

private boolean isStandalone = false;
Label label1 = new Label();
TextField textField1 = new TextField();
Checkbox checkbox1 = new Checkbox();
CheckboxGroup checkboxGroup1 = new CheckboxGroup();
Button button1 = new Button();
Button button2 = new Button();
//Obtener el valor de un parámetro
public String getParameter(String key, String def) {
return isStandalone ? System.getProperty(key, def) :
(getParameter(key) != null ? getParameter(key) : def);
}
//Construir el applet
public Colores() {
}
//Inicializar el applet
public void init() {
try {
jbInit();
}
}
}
label1.setFont(new java.awt.Font("SansSerif", 1, 16));
label1.setText("Color de Texto");
this.setBackground(new Color(184, 255, 255));
this.setLayout(null);
textField1.setFont(new java.awt.Font("SansSerif", 1, 40));
textField1.setForeground(Color.yellow);
textField1.setText("Universidad Continental");
textField1.setBounds(new Rectangle(17, 51, 459, 59));
label2.setFont(new java.awt.Font("SansSerif", 1, 16));
label2.setText("Seleccione color");
checkbox1.setCheckboxGroup(checkboxGroup1);
checkbox1.setLabel("Amarillo");
checkbox1.setBounds(new Rectangle(166, 126, 97, 21));
checkbox1.addItemListener(new Colores_checkbox1_itemAdapter(this));
checkbox2.setLabel("Verde");
checkbox2.setLocale(java.util.Locale.getDefault());
checkbox3.setLabel("Rojo");
checkboxGroup1.setSelectedCheckbox(checkbox1);
button1.setLabel("UCCI");
button1.setBounds(new Rectangle(111, 260, 115, 29));
button1.addActionListener(new SaltaUCCI());

button2.setLabel("Google");
button2.setBounds(new Rectangle(267, 260, 115, 29));
button2.addActionListener(new SaltaGoogle());
label3.setFont(new java.awt.Font("Dialog", 1, 13));
label3.setText("Conéctese con:");
this.add(textField1, null);
this.add(label1, null);
this.add(checkbox2, null);
this.add(button1, null);
this.add(button2, null);
}
public class SaltaUCCI implements ActionListener {

public void actionPerformed(ActionEvent ev) {
try {
URL url = new URL("http://www.ucci.edu.pe");
AppletContext context = getAppletContext();
context.showDocument(url);
}
catch (MalformedURLException ex) {
Graphics g = getGraphics();
g.drawString("URL mal formada",8,60);
}
}
}
public class SaltaGoogle implements ActionListener {

public void actionPerformed(ActionEvent ev) {
try {
URL url = new URL("http://www.google.com.pe");
AppletContext context = getAppletContext();
context.showDocument(url);
}
catch (MalformedURLException ex) {
g.drawString("URL mal formada",8,60);
}
}
}
//Obtener información del applet

public String getAppletInfo() {
return "Información del applet";
}
//Obtener información del parámetro
public String[][] getParameterInfo() {
return null;
}
cambiarColor();
}
cambiarColor();
}
cambiarColor();
}
public void cambiarColor(){

if (checkbox1.getState()==true) textField1.setForeground(Color.yellow);
else if (checkbox2.getState()==true) textField1.setForeground(Color.green);
else if (checkbox3.getState()==true) textField1.setForeground(Color.red);
}
}

class Colores_checkbox1_itemAdapter implements java.awt.event.ItemListener {
Colores adaptee;
Colores_checkbox1_itemAdapter(Colores adaptee) {
}
}
}

Colores adaptee;
}
}
}

Colores adaptee;
}
}
}
4) Generamos el archivo “Continental.jar” y luego creamos el archivo

“Index.html” que debe contener lo siguiente:
<html>
<head>
<title>
Aplicación de colores con botones
</title>
</head>
<applet
codebase = "."
code = "paqueteContinental.Colores.class"
archive = "Continental.jar"
width = 500
height = 300
>
</applet>
</html>
5) Finalmente generamos el archivo “Visualizar.bat”, el cual debe tener el

siguiente contenido:
set CLASSPATH=
C:\JBuilder9\jdk1.4\bin\appletviewer Index.html
Para poder ver toda la potencia de los applets con Java y todo lo que se puede
hacer con applets ingrese a la siguiente dirección electrónica
http://www.htmlpoint.com (haga clic en la opción 500 applet Java) en el cual
encontrará muchos diseños de applets que le serán de mucha utilidad.

7.5 CREACIÓN DE APPLETS PRÁCTICOS.
1) Ejemplo de hacer clic con el mouse y se dibuja un círuclo. Para ello

crearemos el proyecto “Raton” y luego creamos un applet (ver Figura 7.12)
con el nombre del paquete “paqueteRaton” y el nombre de la clase
“RatonApplet” y luego ingresar el siguiente código:
Figura 7.12
package paqueteRaton;
import java.awt.*;
public class RatonApplet extends Applet implements MouseListener{

private final int radio = 20;
}
public RatonApplet() {
}
try {
jbInit();
}
}
}
setBackground(new Color(184, 255, 255));
addMouseListener(this);
}
public void mousePressed(MouseEvent ev) {

int rojo=150,verde=0,azul=0;
g.setColor(new Color(rojo,verde,azul));
g.fillOval(ev.getX()-radio, ev.getY()-radio, 2*radio, 2*radio);
g.dispose();
}
public void mouseExited(MouseEvent event) {}
public void mouseReleased(MouseEvent event) {}
public void mouseClicked(MouseEvent event) {}
public void mouseEntered(MouseEvent event) {}

}
return null;
}
}
La creación del archivo JAR y HTLM tiene que hacerlo usted mismo (vea
ítem 7.3).
2) Ejemplo de hacer clic con el mouse y se dibuja un círuclo, pero ahora los
círculos salen de diferentes colores al azar. Para ello crearemos el proyecto
“Raton1” y luego creamos un applet (ver Figura 7.13) con el nombre del
paquete “paqueteRaton1” y el nombre de la clase “Raton1Applet” y luego
ingresar el siguiente código:
Figura 7.13
package paqueteRaton1;
import java.awt.*;
import java.util.Random;
public class Raton1Applet extends Applet implements MouseListener{

private final int radio = 20;
Random azar = new Random();

}
public Raton1Applet() {
}
try {
jbInit();
}
}
}
setBackground(new Color(184, 255, 255));
addMouseListener(this);
}

int rojo,verde,azul;
rojo = (int)(azar.nextDouble() * 255.0); //genera un número aleatorio entre 0 y 255

verde = (int)(azar.nextDouble() * 255.0);
azul = (int)(azar.nextDouble() * 255.0);
g.setColor(new Color(rojo,verde,azul));
g.fillOval(ev.getX()-radio, ev.getY()-radio, 2*radio, 2*radio);
g.dispose();
}

}
return null;
}
}
ítem 7.3).
3) Ejemplo dibujar con el ratón a mano alzada. Para ello crearemos el proyecto
“ManoAlzada” y luego creamos un applet (ver Figura 7.14) con el nombre del
paquete “paqueteManoAlzada” y el nombre de la clase “ManoAlzadaApplet” y
luego ingresar el siguiente código:
Figura 7.14
package paqueteManoAlzada;
import java.awt.*;
public class ManoAlzadaApplet extends Applet implements MouseListener, MouseMotionListener {

int uX=0, uY=0;
}
public ManoAlzadaApplet() {
}

try {
jbInit();
}
}
}
int ancho = Integer.parseInt(this.getParameter("WIDTH"));
int alto = Integer.parseInt(this.getParameter("HEIGHT"));
this.setSize(new Dimension(ancho,alto));
setBackground(Color.white);
this.addMouseListener(this);
this.addMouseMotionListener(this);
}
//interface MouseListener
uX=ev.getX();
uY=ev.getY();
}
//interface MouseMotionListener
public void mouseDragged(MouseEvent ev) {
int x = ev.getX();
int y = ev.getY();
Graphics g=getGraphics();
g.drawLine(uX, uY, x, y);
uX=x; uY=y;
g.dispose();
}

public void mouseMoved(MouseEvent event) {}

}

return null;
}
}
ítem 7.3).
7.5 PASO DE PARAMETROS A APPLETS.
En muchas aplicaciones de applets, es necesario ingresar algunos datos desde

fuera del applet, eso es posible utilizando la marca PARAM en la página HTML
y el método getParameter() de la clase java.applet.Applet para leerlos en el
código interno del applet. Los atributos que acompañan a la marca PARAM son
los siguientes:

NAME Nombre del parámetro que se desea pasar al applet.
VALUE Valor que se desea transmitir en el parámetro que se ha indicado

antes.
Para mostar esta posibilidad vamos a crear un applet para que cuando
pongamos nuestro nombre nos dé la bienvenida. Lo que haremos será pasarle
al applet el nombre de la persona a quien queremos darle la bienvenida. Para
ello crearemos el proyecto “Saludo” y luego creamos un applet (ver Figura 7.15)
con el nombre del paquete “paqueteSaludo” y el nombre de la clase
“SaludoApplet” y luego ingresar el siguiente código: (aunque parece muy
grande pero en realidad sólo se debe añadir el código que está enmarcando, ya
que como se sabe el JBuilder crea su propio código).
package paqueteSaludo;
import java.awt.*;
public class SaludoApplet extends Applet {

String nombre;
}
public SaludoApplet() {
}
try {
jbInit();
}
}
}
nombre = getParameter( "Nombre" );
}
public void paint( Graphics g ){

g.drawString( nombre+" Bienvenido al mundo de los APPLETS",25,25);
}

}
return null;
}
}

Luego debemos compilarlo y se creará el archivo “SaludoApplet.class”; luego
crearemos un archivo JAR con el nombre “Saludo.jar” (si no recuerda cómo
hacerlo vaya al ítem 7.3) y luego generamos el archivo “Index.html” que debe
contener el siguiente código:
<html>
<head>
<title>
Aplicación con parámetros
</title>
</head>
<applet
codebase = "."
code = "paqueteSaludo.SaludoApplet.class"
archive = "Saludo.jar"
width = 500
height = 300
>
<PARAM NAME="Nombre" VALUE="Rubén">
</applet>
</html>
Luego cuando ejecutamos el archivo “Index.html” se observará similar al de la

Figura 7.15.
Figura 7.15
Por supuesto, que puedes sustituir el nombre “Rubén” por el tuyo, sólo tienes
que cambiar en el parámetro VALUE en el archivo “Index.html”. Este cambio no
afectará al código Java, no será necesario recompilarlo para que te salude a ti
el applet.
Los parámetros no se limitan a uno solo. Se puede pasar al applet cualquier

número de parámetros y siempre hay que indicar un nombre y un valor para
cada uno de ellos.
El método getParameter() es fácil de entender. El único argumento que

necesita es el “nombre” del parámetro cuyo valor queremos recuperar. Todos
los parámetros se pasan como Strings, en caso de necesitar pasarle al applet
un valor numérico, se ha de pasar como String, recuperarlo como tal y luego
convertirlo al tipo que deseemos. Tanto el argumento de NAME como el de
VALUE deben ir colocados entre dobles comillas dobles ya que son String.
En el siguiente ejemplo se muestra un applet que se ingresa como parámetros

tres gráficos que representarán la acción del mouse sobre un botón gráfico el
cual irá cambiando de acuerdo a la posición del ratón: cuando el ratón está

fuera del botón se observará la Figura 7.16, cuando el ratón está sobre botón se
observará la Figura 7.17 y cuando se hace clic sobre el botón se observará la
Figura 7.18.
Figura 7.16 (boton0.gif) Figura 7.17 (botonup.gif) Figura 7.18 (botondn.gif)
Entonces para observar este applet debemos crear el proyecto “BotonGrafico” y

luego creamos un applet con el nombre del paquete “paqueteBotonGrafico” y el
nombre de la clase “BotonGraficoApplet” y luego ingresar el siguiente código:
package paqueteBotonGrafico;
import java.awt.*;
public class BotonGraficoApplet extends Applet {

private MediaTracker tracker;

private Image imagen[] = new Image[3];
private boolean BotActivo = false;
private boolean BotPulsado = false;
private boolean tresImg = false;
private int Estado = 0;

}
public BotonGraficoApplet() {
}
try {
jbInit();
}
}
}
String istr;
tracker = new MediaTracker( this );
// Recogemos las tres imagenes de los paramentros de llamada

// al applet
for( int i=0; i < 3; i++ )
{
istr = getParameter( "IMAGEN" + i );
if( istr == null )
tresImg = false;
else
{
// Registramos las imagenes con el Media Tracker
imagen[i] = getImage( getCodeBase(),istr );
tracker.addImage( imagen[i],0 );
try {
tracker.waitForAll();

}
catch( InterruptedException e ) {
System.out.println( "Error cargando imagen " + i );
}
}
}
}
public void start() {

repaint();
}
public void stop(){

}
// Controlamos la pulsacion del raton

public boolean mouseDown( Event evt,int x,int y ) {
BotPulsado = true;
repaint();
return( true );
}
// Controlamos cuando el usuario suelta el boton del raton

public boolean mouseUp( Event evt,int x,int y ) {
if( BotPulsado && BotActivo )
{
BotPulsado = true;
showStatus( "Clic sobre el botón" );
repaint();
}
else
{
BotPulsado = false;
repaint();
}
return( true );
}
// Controlamos cuando el cursor del raton entra en el

// campo de accion del applet
// Presentamos un mensaje en la linea de estado
public boolean mouseEnter( Event evt,int x,int y ) {
BotActivo = true;
showStatus( "Ratón sobre el Botón" );
repaint();
return( true );
}
// Controlamos cuando el cursor del raton abandona el

// lugar ocupado por el applet
public boolean mouseExit( Event evt,int x,int y ) {
BotActivo = false;
showStatus( "Ratón fuera del botón" );
repaint();
return( true );
}
public void update( Graphics g ) {

// Controlamos el estado en que se queda el boton
// tras la accion que se haya hecho con el raton
if( !BotActivo )
Estado = 0;
else
if( BotActivo && !BotPulsado )
Estado = 1;
else
Estado = 2;
paint( g );
}

g.drawImage( imagen[Estado],0,0,this );
}

}

return null;
}
}
Luego debemos compilarlo y se creará el archivo “BotonGraficoApplet.class”;

luego crearemos un archivo JAR con el nombre “BotonGrafico.jar” (si no
recuerda cómo hacerlo vaya al ítem 7.3), luego en el mismo directorio del
archivo JAR, debemos copiar los archivos que contienes los gráficos GIF que
se pueden crear con cualquier graficador (CorelDraw, PhotoShop, Paint, etc.)
los gráficos deben tener la apariencia que se muestra en las figuras del 7.16 al
7.18 y además deben tener los mismos nombres: “boton0.gif”, “botonup.gif” y
botondn.gif; y finalmente generamos el archivo “Index.html” que debe contener
el siguiente código:
<html>
<head>
<title>
Aplicación con parámetros
</title>
</head>
<applet
codebase = "."
code = "paqueteBotonGrafico.BotonGraficoApplet.class"
archive = "BotonGrafico.jar"
width = 180
height = 50
>
<PARAM NAME=IMAGEN0 VALUE=boton0.gif>
<PARAM NAME=IMAGEN1 VALUE=botonup.gif>
<PARAM NAME=IMAGEN2 VALUE=botondn.gif>
</applet>
</html>
Para observar algunos otros applet les recomiendo ejecutar el archivo

C:/j2sdk1.4.2_04/demo/plugin/jfc/Java2D/Java2Demo.html; el cual tiene sus
códigos correspondientes en JAVA.
Referencias INTRODUCCIÓN A LA PROGRAMACIÓN ORIENTADA A

Bibliográficas OBJETOS CON JAVA por José María Pérez Carretero.
Lecturas
Recomendadas
Web a visitar http://www.programacion.com/tutorial/java_basico/
http://www.programacionfacil.com/java/indice.htm
http://www.unav.es/cti/manuales/Java/indice.html

Libro Java

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Libro Java

Încărcat de

Drepturi de autor:

Formate disponibile

UNIVERSIDAD CONTINENTAL

MG. RUBÉN GALEAS ARANA

Un programa tradicional, que sigue el paradigma estructurado, se basa

Algoritmos + Estructuras de Datos = Programas

La POO es el paradigma de programación más utilizado en la actualidad. Su

Una clase es aquella que describe las características (atributos) y el

Cuando hablamos de un objeto, hablamos de pequeños elementos bien

Mg. Rubén Galeas Arana -2-

Entonces mediante el uso e implementación de la metodología de

La abstracción se puede definir como la capacidad de examinar algo sin

La abstracción es la capacidad de un objeto de cumplir sus funciones

Esta característica es la que denota la capacidad del objeto de responder a

La herencia es la propiedad que permite a los objetos construirse a partir de otros

Si una clase recibe propiedades de más de una clase base, la herencia se

En un sentido literal, polimorfismo significa la cualidad de tener más de una

El término de polimorfismo define la capacidad de que más de un objeto puedan

Mg. Rubén Galeas Arana -4-

El lenguaje de programación Java fue desarrollado por Sun Microsystems en

Java es un lenguaje de programación de alto nivel con el que se pueden escribir

Una de las ventajas significativas de Java sobre otros lenguajes de

Figura 2.1. Procesos de ejecución de un programa en JAVA.

Según lo expuesto, Java incluye dos elementos: un compilador y un intérprete.

Los códigos de bytes de Java son un conjunto de instrucciones

2.2 VENTAJAS Y DESVENTAJAS DEL JAVA.

Una de las ventajas más significativas de Java es su independencia de la

Otra ventaja importante de Java es que es un lenguaje de programación

Además de ser transportable y orientado a objetos. Java es un lenguaje fácil de

Mg. Rubén Galeas Arana -6-

2.3 PRIMER PROGRAMA EN JAVA.

Los ficheros se almacenan con la extensión JAVA, al compilar el código fuente,

public class Bienvenida{

Los identificadores se utilizan como nombres de clase, método y variable. Un

En este punto es recomendable aclarar que por convención un identificador que

2.5 VARIABLES Y TIPOS DE DATOS PRIMITIVOS.

Donde “tipo” es un tipo de dato primitivo en JAVA; estos datos primitivos se

Mg. Rubén Galeas Arana -7-

Valores numéricos en coma flotante de doble precisión.

A continuación se muestra un ejemplo en Java utilizando variables y tipos primitivos.

Mg. Rubén Galeas Arana -8-

Son aquellos operadores que nos permiten realizar operaciones matemáticas y

Tabla 2.2. Operadores aritméticos en Java

A continuación se muestra un ejemplo en Java utilizando operadores aritméticos y

p=x++; // primero hace p=x y luego x=x+1

Los resultados que se obtienen son:

2.7 EJEMPLOS DE APLICACIÓN DE TIPOS PRIMITIVOS Y OPERADORES

A continuación mostramos algunos ejemplos en los cuales se pueden observar

a) Ejemplo de operaciones con tipos primitivos del tipo BYTE.

System.out.println("a1 = "+a1+" Tipo byte");

b) Ejemplo de operaciones con tipos primitivos del tipo SHORT.

System.out.println("a1 = "+a1+" Tipo short");

c) Ejemplo de operaciones con tipos primitivos del tipo INT.

System.out.println("a1 = "+a1+" Tipo int");

d) Ejemplo de operaciones con tipos primitivos del tipo LONG.

System.out.println("a1 = "+a1+" Tipo long");

e) Ejemplo de operaciones con tipos primitivos del tipo FLOAT.

System.out.println("a1 = "+a1+" Tipo float");

f) Ejemplo de operaciones con tipos primitivos del tipo DOUBLE.

System.out.println("a1 = "+a1+" Tipo double");

Mg. Rubén Galeas Arana - 12 -

En todo lenguaje de programación las fórmulas matemáticas se tienen que

Tabla 2.2. Tipos de datos primitivos en Java que soporta JAVA

En el siguiente ejemplo se muestra es uso de las fórmulas de la tabla 2.2.

Los resultados que se obtienen son los siguientes:

Pero si observamos la tercera columna de la tabla 2.2 los resultados no