Modulo I

Diplomado en Tecnologías Web
Escuela Tecnológica Superior
Erick Arauco Moreno 1

Diplomado en Tecnologías Web
Módulo I – Java 2 Standard Edition.

1.1. Concepto.
 Java es un lenguaje de programación orientada a objetos.

 Java es gratuito y de uso general, su utilización puede contemplar el desarrollo de
cualquier tipo de aplicación informática (applets, web, de escritorio, móviles, etc).

1.2. Orígenes.
 Proyecto Green. Así se llamó el proyecto iniciado por la Sun que buscaba
desarrollar una interfaz para manejar todo tipo de aparatos electrodomésticos. El
proyecto no derivó en la implementación de productos reales por lo que el grupo
de disolvió, hasta que en 1993 cuando explotó la World Wide Web se observó
que el lenguaje podría adaptarse a múltiples plataformas que conforman la
internet, por lo que el primer producto obtenido fue un navegador completamente
escrito en Java y denominado posteriormente “HotJava”.
 Con este producto, se hizo evidente que los programas Java podían instalarse en
un entorno internet y ser ejecutados en cada máquina cliente sin ninguna
configuración adicional, por lo que se empezaba a presenciar el nacimiento de los
famosos Applets y de la primera versión JDK 1.0 de la plataforma Java.

1.3. Entorno de desarrollo.
 En toda aplicación Java debemos tener en cuenta las siguientes fases:

- Edición. El programa es creado en un editor y almacenado en disco siempre con la extensión “.java”.
Para su edición, cualquier editor puede ser utilizado ( JCreator, Gel, JDeveloper, NotePad, TextPad,
etc. ).
- Compilación. La compilación implica la creación de los llamados bytecodes ( código binario ) y su
almacenamiento en disco con la extensión “.class”. El proceso de compilación del lenguaje implica la
llamada de un script conocido como “javac”.
Ejemplo:
javac MiPrograma.java ( esto genera un archivo llamado MiPrograma.class)
- Carga. El proceso de carga significa leer los archivos que contienen el código binario desde el disco y
llevarlos a memoria primaria.
- Verificación. El verificador se encarga de confirmar que dicho código binario es válido y no viola las
restricciones de seguridad; esto con la finalidad de asegurarse que no se ha introducido algún archivo
dañado.
- Ejecución. Para su ejecución, la Máquina Virtual Java lee el código binario y empieza su
transformación en línea a lenguaje máquina para su correcta ejecución.

1.3. Entorno de desarrollo.
 Algunos de los entornos de desarrollo más utilizados:

1.4. Configuración de variables de entorno.
 La configuración del entorno de desarrollo java implica la definición de dos

variables de suma importancia.
 Por lo tanto, primero debemos situarnos en Inicio / Configuración / Panel de
Control / Sistema /, luego seleccionamos la ficha Opciones avanzadas y vamos
a la opción Variables de entorno y observaremos una pantalla similar a la
siguiente figura:

 Creamos nuestra primera variable de sistema de la siguiente manera:
 La variable JAVA_HOME, es la primera variable a crear la cual debe tener como

valor la ruta exacta donde el lenguaje ha sido instalado.
 Una vez creada la anterior variable pasamos a modificar (o crear en caso no
exista), la variable del sistema llamada "Path" utilizada con la finalidad que el
lenguaje pueda encontrar los archivos necesarios para la correcta compilación y
ejecución de nuestras aplicaciones.

 El valor de la mencionada variable debe apuntar a la carpeta “bin” ubicada

dentro de la instalación del lenguaje Java.
 En caso que las variables mencionadas no se hubiesen configurado
correctamente, al momento de usar cualquiera de los scripts que trae consigo el
lenguaje, podríamos observar un mensaje como:
‘java’ is not recognized as an internal or external command,
operable program or batch file.

1.5. Características.
 Independencia de la plataforma.
- Los programas en Java generalmente son compilados a un lenguaje intermedio
llamado “bytecodes”, que luego son interpretados por una máquina virtual
(JVM).
- Esta última sirve como una plataforma de abstracción entre la máquina y el
lenguaje permitiendo que se pueda "escribir el programa una vez, y ejecutar
la aplicación en cualquier lado".

 Independencia de la plataforma.
1) Se escribe el código fuente

utilizando el editor de nuestra
preferencia.
2) Se compila el código fuente

obteniendo un fichero binario con
extensión “.class” (Bytecode).
Solaris Windows Mac OS
JVM JVM JVM
3) Cada sistema operativo posee una

instalación de la máquina virtual java
para lograr la ejecución del fichero
binario.

 Simple. Java ofrece toda la funcionalidad de un lenguaje potente, pero

sin las características menos usadas y más confusas de éstos; reduce en
un 50% los errores más comunes de programación con lenguajes como
C y C++ al eliminar muchas de las características de éstos, entre las que
destacan:
- Aritmética de punteros
- Necesidad de liberar memoria (free)

 Orientado a Objetos. Java implementa la tecnología básica de C++ con

algunas mejoras y elimina algunas cosas para mantener el objetivo de la
simplicidad del lenguaje.
- Soporta las tres características propias del paradigma de la orientación a
objetos: encapsulación, herencia y polimorfismo.

2.1. Primera aplicación Java
// Programa: MiAplicacion.java
// Nuestro primer programa Java.
public class MiAplicacion {

public static void main ( String args [ ] ) {
System.out.println (“Hola Mundo!“);
System.out.println(“Esta es mi primera aplicación escrita en Java“);
}
}

2.1. Primera aplicación Java
// Programa: MiAplicacion.java
// Nuestro primer programa Java.
Comentarios
/* Programa: MiAplicacion.java
Nuestro primer programa Java. */
public class MiAplicacion Definición de la clase

2.1. Primera aplicación Java – A tener en cuenta.
 Los archivos que contienen código fuente se almacenan con la extensión .java.
 Cada programa Java consiste al menos en la definición de una clase.
 El nombre de la clase debe ser igual al nombre del archivo almacenado en disco
(“MiAplicacion.java”).
 Java es “case sensitive”: diferencia mayúsculas de minúsculas.
 Por convención, el nombre de una clase debe iniciar con la primera letra en
mayúsculas.
 El cuerpo de la clase se encuentra definido entre llaves.
 Si las llaves no se encuentran en pares, el programa no compilará.
 Una clase java puede poseer uno o varios métodos, exactamente, uno de dichos
métodos puede llamarse “main”; y al definirse el intérprete java ejecutará lo
escrito en él.

2.1. Primera aplicación Java.
import java.util.Scanner;
public class Calculadora {
public static void main (String args [ ]) {
Scanner entrada = new Scanner(System.in);
int numero1; //declarando variables de clase.
int numero2;
int suma;
System.out.print("Ingrese el primer entero: ");

numero1 = entrada.nextInt();
System.out.print("Ingrese el segundo entero: ");

suma = numero1 + numero2;
System.out.println("La suma es : " + suma); //imprimiendo el

resultado.
}
}
2.2.1. Estructuras de control – if / else
public class Comparacion {
int numero1;
int numero2;


if ( numero1 == numero2 ) //utilizando operador de igualdad.

System.out.println (“Son iguales”);
if ( numero1 != numero2 ) //utilizando operador de diferencia.

System.out.println(“Son distintos”);
}
}

2.2.1. Estructuras de control – if / else
public class Comparacion {
int numero1;
int numero2;


if ( numero1 == numero2 ) //Sin paréntesis si el cuerpo de la

estructura contiene una //sola línea.
System.out.println (“Son iguales”);
else
System.out.println (“Son diferentes”);
}
}
2.2.2. Estructuras de control – while / do – while / for.
int producto = 2;
while ( producto <= 1000 )
producto = 2 * producto;
contador = 1;
do {
contador = contador + 1;
} while ( contador <= 10 );
for ( int contador = 1; contador <= 10; contador ++) {

System.out.println ( contador );
}

2.3. Operadores.
 m = 5 (asignación).
 n == 6 (comparación).
 a = a + 2  a += 2
 b = b – 3  b -= 3
 c = c * 4  c *= 4
 d = d / 5  d /= 5
 e= e+1
- e++. Post-Incremento.
- ++e. Pre-Incremento.
f=f–1
- f--. Post-Decremento.
- --f. Pre-Decremento.
3.1. Clases y Objetos.
 La definición más básica que le podemos dar a un objeto es: Todo lo que nos rodea;
detallando, podríamos decir, todo aquello que podemos identificar que posee ciertas
características y funcionalidades para su uso.
 Una clase es un molde.
 Una clase está formada por dos conceptos conocidos como: Propiedades y Métodos.
Telefono Nombre de la clase
marca
modelo Propiedades, Características, Atributos
color
peso
encender()
apagar() Métodos
llamar()

marca: M1
Telefono modelo: MO1
color: Rojo
peso: 100 gr.
marca
modelo
Instanciación
color
peso
encender() marca: M1
modelo: MO1
apagar() color: Negro
llamar() peso: 100 gr.
Instancias de la
clase “Telefono”

public class Telefono {

String marca;
String modelo;
String color; Telefono
String peso;
marca
public void encender ( ) { modelo
System.out.println (“encendiendo…”); color
} peso
encender()
public void apagar() { apagar()
System.out.println(“apagando…”); llamar()
}
public void llamar() {

System.out.println(“llamando…”);
}
}

public class Principal {

public static void main (String args [ ])
Telefono tlf1 = new Telefono (); // creando el primer teléfono.
Telefono tlf2 = new Telefono(); //creando el segundo teléfono.
tlf1.color= “Rojo”; //definiendo el color del primer teléfono. marca: M1

tlf2.color=”Negro”; //definiendo el color del segundo teléfono. modelo: MO1
color: Rojo
peso: 100 gr.
tlf1.encender(); //encendiendo el primer teléfono.

tlf2.apagar(); //apagando el segundo teléfono.
}
}
marca: M1
modelo: MO1
color: Negro
peso: 100 gr.
Instancias de la

3.2. Métodos y parámetros.
public class Telefono {
String marca;
String modelo;
String color;
String peso;
public void llamar (String numero ) {

System.out.println (“llamando al número: “ + numero);
}
}
Telefono tlf1 = new Telefono (); // creando el primer teléfono.
Telefono tlf2 = new Telefono (); //creando el segundo teléfono.
tlf1.color = “Rojo”; //definiendo el color del primer teléfono.

tlf2.color = “Negro”; //definiendo el color del segundo teléfono.
tlf1.llamar( “961234560” ); //llamando a un número telefónico
tlf2.llamar( “968889633” ); //llamando a un número telefónico

}
Erick}Arauco Moreno 26
3.2. Métodos y parámetros – Clase Math.
Método Descripción
abs ( x ) Valor absoluto.
ceil ( x ) Redondeo superior.
cos ( x ) Coseno.
exp ( x ) Exponencial.
floor ( x ) Redondeo inferior.
log ( x ) Logaritmo.

3.3. Inicializando clases – Constructores.
 Independientemente de los métodos definidos en cada clase, también es posible definir un

tipo de métodos cuyo nombre debe ser igual al nombre de la clase, conocidos como
Constructores, y los cuales, son ejecutados al momento de crear una instancia (Objeto).
 Es posible definir una clase con muchos constructores con la finalidad de proveer múltiples
accesos para inicializar los objetos de dicha clase. Si una clase posee muchos
constructores, los mismos deben ser diferenciados por número, tipo y orden de los
parámetros de entrada.
 A esta técnica que consiste en la declaración de muchos constructores la conocemos como
Sobrecarga de métodos, así cuando uno de estos métodos es llamado, el compilador
selecciona el más apropiado examinando el número, tipo y orden de los argumentos en la
llamada.

public class Cuadrados {

public Cuadrados() { //constructor
String salida = "";
int resultado;
for ( int x = 1; x <= 10; x++ ) {

resultado = calcular(x);
salida += "El cuadrado de " + x + " es " + resultado + "\n";
}
System.out.println(salida);
}
public int calcular ( int y ) { //método.
return y * y;
}
public static void main ( String args[] ) {
Cuadrados obj = new Cuadrados(); //instancia del objeto.
}
}
import java.text.*;
public class Reloj {
private int hora; //propiedades
private int minutos;
private int segundos;
//constructor
public Reloj() { //primer constructor
setTiempo ( 0, 0, 0 );
}
public Reloj(int h) { //segundo constructor.

setTiempo ( h, 0, 0 );
}
public Reloj(int h, int m) { //tercer constructor.

setTiempo ( h, m, 0 );
}

3.4. Finalizadores.
 Un objeto java al momento de ser creado ( claúsula new ), adquiere varios recursos del
sistema como memoria, por lo tanto, los finalizadores son los encargados de “devolver
dichos recursos al sistema”.
 Un finalizador es definido como un método más de una clase, pero que no realiza ninguna
acción, no tiene parámetros de entrada ni define valores de retorno, en conclusión: NO
HACE NADA. El método finalizador es llamado por el recolector de basura.

3.5. Miembros estáticos.
 Normalmente, al momento de instanciar un objeto, el mismo posee una copia de todas las
variables declaradas en el interior de la clase.
marca: M1
Telefono
modelo: MO1
color: Rojo
marca peso: 100 gr.
modelo
color
peso
encender() marca: M1
apagar() modelo: MO1
color: Negro
llamar() peso: 100 gr.
El valor para el atributo “marca” es Instancias de la

distinto en cada instancia. Una
copia del atributo por cada objeto
creado.
3.5. Miembros estáticos.
 En ciertas ocasiones, es necesario que una sola copia de la propiedad o método sea
asignado a los objetos instanciados independientemente de cuántos existan; por lo tanto,
todos los objetos comparten la misma porción de datos. Los miembros estáticos pueden ser
accedidos desde cualquier objeto instanciado o directamente desde la misma clase.
marca: M1
Telefono
modelo: MO1
color: Rojo
peso: 100 gr.
marca contador: 2
modelo
color
Peso
(s)contador marca: M1
encender() modelo: MO1
color: Negro
apagar() peso: 100 gr.
llamar() contador: 2
Una sola copia del atributo Instancias de la

“contador” es compartida entre las
instancias y la clase.
3.6. Variables finales.
 La mayoría de variables que utilizamos en las aplicaciones necesitan ser modificadas en

algún momento, otras no, por lo tanto, es posible utilizar la palabra reservada “final” para
especificar que dicha variable no es modificable (constante) y todo intento de
modificación ocasionaría un error.
Un ejemplo de la declaración de una variable final sería:
private final int CONTADOR = 1;

3.7. Herencia
 Los objetos creados a partir de una misma clase mantienen la misma estructura definida en
el molde; si tomamos en cuenta los métodos definidos en una clase, los objetos
instanciados tendrán el mismo comportamiento porque contienen una copia de todos los
miembros definidos en la clase.
 Si traducimos esto en la vida real e intentamos crear objetos personas, podría ser ilógico
que todas las personas tengan el mismo comportamiento porque no todos somos iguales en
este mundo.
 La herencia es una característica de los lenguajes orientados a objetos que permite
agrupar las clases siguiendo un modelo tipo organigrama, donde existe una relación
entre clases padres e hijas, en la cual, las clases hijas heredan las propiedades y/o
métodos definidos en la clase padre.
 La herencia permite el acceso automático a la información contenida en otras clases, por lo
tanto es con esta técnica que se garantiza la reutilización del código.

3.7. Herencia
Telefono
Fijo Celular
Residencial Comercial Prim_Generacion Seg_Generacion Terc_Generacion

3.7. Herencia
x, y
Punto área: no tiene
Circulo x, y, radio
área: pi * r2
Cilindro x, y, radio, altura

área: 2pi*r2 + 2pi*r*h

3.8. Alcance de miembros.
 Hablar de alcance significa el grado de encapsulamiento que podemos aplicar a la propiedad o método
para lo cual decidimos usar las palabras “public”, “private”, “protected” y “friendly”.
 Un miembro definido con alcance público, implica que al ser heredado por otras clases, las mismas
tendrán acceso a él generación tras generación sin ninguna limitante. En otras palabras todos los
miembros de una clase padre marcados como públicos serán heredados por las subclases.
 Un miembro definido con alcance privado, implica que el mismo sólo podrá ser accedido por la clase que
lo define y ninguna clase hija lo heredará. El acceso a estos miembros marcados como privados será
posible sólo a través de la definición de métodos públicos.
 Un miembro definido con alcance protegido será heredado por todas las subclases independientemente
del paquete al que pertenezcan, sin embargo solamente las clases externas que pertenezcan al mismo
paquete podrán acceder a estos miembros.
 Un miembro definido con alcance amigo ( friendly ), es aquel similar al público, que no se le ha definido
modificador alguno y que puede ser accedido sólo por las clases que se encuentren en el mismo paquete
incluyendo las subclases.

3.9. Encapsulamiento.
 Objetivo: proteger las propiedades de cualquier valor ilegal;

 Cómo?: Todas las propiedades de una clase deberán ser siempre privadas
implementando para cada una de ellas un método “set” para transferirle el valor que se
está pasando y un método “get” para recuperar el valor almacenado en la propiedad.
 Ventaja: controlar el tipo de información que se está intentando pasar a la propiedad
evitándola en el caso que esta sea ilegal

3.9. Encapsulamiento.
public class Fecha {
private int mes;
private int anio;
//método que valida el valor que se intenta pasar a la propiedad mes.

public void setMes ( int parametro ) {
if ( parametro > 0 && parametro <= 12 ) {
mes = parametro;
} else {
mes = 1;
}
}
//método que devuelve el valor almacenado en la propiedad mes.

public int getMes ( ) {
return mes;
}
}

3.10. Paquetes
 Una definición de paquetes podría ser “una colección de clases relacionadas o no

relacionadas ordenadas de una manera jerárquica a través de una estructura de
directorios”.
 En java, es posible agrupar un conjunto de clases en un paquete a través de la palabra
reservada “package”.
 Si una clase java tiene la necesidad de utilizar una clase que se encuentra ubicada en un
paquete distinto utilizaremos la palabra reservada “import”.
 Por defecto, cualquier clase java importa el paquete java.lang (donde se encuentran las
definiciones básicas del lenguaje).

3.10. Paquetes

3.10. Paquetes
 java.lang. Incluye las clases Object, Thread, Exception, System, Integer, Float, etc.
 java.awt. Incluye clases para creación de interfaces gráficas de usuario. Entre ellas
encontramos: Button, TextField, CheckBox, ListBox, etc.
 java.io. Incluye las clases necesarias para el manejo de entradas y salidas ( acceso a
ficheros ). InputStream y OutputStream.
 java.util. Incluye clases útiles para diversas necesidades en programación. Entre ellas
tenemos: Date, Random, Stack, Vector, etc.

3.10. Paquetes
Clase Clases Paquete A

C1 A1 A2
A3
C2
C3
Clases Paquete B
B1 B2
B3
• Acceso público. Si cualquiera de las clases representadas en la figura tuviese un miembro definido como público, el mismo, podrá ser
accedido directamente desde cualquier ubicación.
• Acceso privado. Si cualquiera de las clases tuviese un miembro definido como privado, el mismo, podrá ser accedido sólo desde la misma
clase.
• Acceso protegido.
Si la clase A1 define un miembro como protegido y cualquiera de las otras clases (A2, A3, B1, B2, B3, C1, C2, C3) es hija de la clase
A1, entonces heredarán el miembro y tendrán acceso al mismo sin importar sin están ubicadas en un paquete distinto.
Si cualquiera de las clases restantes (A2, A3, B1, B2, B3, C1, C2, C3) necesita instanciar un objeto de tipo A1 que define un miembro
protegido y tener acceso al mismo, entonces, sólo aquellas que pertenezcan al mismo paquete que la clase A1 podrán lograrlo.
• Acceso amigable. Si cualquiera de las clases tuviese un miembro definido como amigo, sólo tendrán acceso a él las clases que se
encuentren en el mismo paquete. Por ejemplo, si la clase A1 define un miembro amigo, solamente las clases A2 y A3 podrán a través de una
Erick Arauco
relación de herenciaMoreno
o instanciando el objeto A1 tener acceso a dicho miembro. 44
3.11. Import estático.
 Ahora que ya hemos visto miembros estáticos y paquetes, podemos invocar las
propiedades y métodos estáticos de cualquier clase utilizando un import estático.
import static java.lang.Math.*;
 Todos los miembros estáticos de la clase “Math” estarán disponibles para su uso.

3.12. Constructores en subclases.
public class Punto {
private int x;
private int y;
public Punto (int xVal, int yVal ) {

x = xVal;
y = yVal;
}
}
public class Circulo extends Punto {
private double radio;
public Circulo (int xVal, int yVal, double rVal ) {

super (xVal, yVal ); //llamamos al constructor de la clase padre.
}
}

3.13. Tipos de datos.
 Tipos primitivos. Una variable de tipo primitivo es aquella que puede almacenar
exactamente un valor en un momento dado.
- int, byte, char, short, long, float, double.
- Al momento de declarar una variable con alguno de estos tipos un valor por defecto es asignado a la
misma,
- por ejemplo, si declaramos una variable de tipo int, su valor inicial será cero ( 0 ), si la declaramos
como tipo boolean, su valor inicial será false.
 Tipos referenciados. La mayoría de aplicaciones Java utilizan los tipos referenciados para
almacenar la ubicación de un objeto en la memoria del computador.
- Los tipos referenciados tienen una referencia a un objeto.
- Por defecto las variables de este tipo son inicializadas con el valor null. Entre algunos de los tipos
referenciados encontramos Integer, String, Float, Double, Boolean, etc.

3.14. Promoción de argumentos – casting.
 Promoción de argumentos : conversión del valor de un argumento en el tipo de dato que el

método espera recibir de acuerdo al parámetro definido.
Por ejemplo,
System.out.println ( Math.sqrt ( 4 ) );
 Analizando: el método “sqrt”, espera un valor de tipo double como parámetro de entrada
pero estamos ingresando un valor entero primitivo, a pesar de esto la impresión arroja
como resultado 2.0
 ¿Qué ha sucedido?, El método “sqrt” está esperando un valor tipo double, por lo que
antes de recibir el valor, Java lo transforma al tipo que el método necesita ( 4.0 ).
Promoción.

Tipo Promoción válida

double Ninguna.
float double
long float, double
int long, float, double
Char int, long, float, double
short int, long, float, double
byte short, int, long, float, double
boolean Ninguna. Los valores booleanos no son considerados
números en Java.

 Convertir valores hacia un tipo menor traerá como consecuencia que el resultado obtenido
no represente el valor original.
 Por ejemplo, el entero primitivo 2000000 no puede ser representado bajo el tipo short,
porque ocasionaría pérdida de datos.
 Operador cast para forzar la conversión, en caso contrario obtendremos un error en
tiempo de compilación.
square ( ( int ) doubleVal )

3.15. Sobrecarga de métodos.
 Diferenciados por el número, tipo y orden de los parámetros de entrada.
//método suma con parámetros enteros primitivos.

public int Suma ( int a, int b ) {
return a + b;
}
//método suma con parámetros double.

public double Suma ( double a, double b) {
return a + b;
}

3.16. Paso de parámetros.
 En java no es posible decidir sobre el tipo de paso de parámetros. Actualmente existe la

siguiente afirmación: “En java las variables de tipo primitivo se pasan por valor y los objetos
se pasan por referencia”.
import java.awt.Point;
public class Ejemplo {
public static void modificaPunto(Punto pt, int j) {
pt.setLocation(5,5);
j = 15;
System.out.println("En plena modificación " + "pt = " + pt + " ; j = " + j);
}
public static void main(String args[]) {
Punto p = new Punto(0,0);
int i = 10;
System.out.println("Antes de la modificación " + "p = " + p + " ; i = " + i);
modificaPunto(p, i);
System.out.println("Después de la modificación " + "p = " + p + " ; i = " + i);
}
} Antes de la modificacion p = java.awt.Point[x=0,y=0] ; i = 10
En plena modificacion pt = java.awt.Point[x=5,y=5] ; j = 15
Erick Arauco Moreno Despues de la modificacion p = java.awt.Point[x=5,y=5] ; i = 10 52
3.17. Arreglos.
String b[ ] = new String [100]; //creamos un arreglo llamado b.

int c[ ] = new int[10]; //creamos un arreglo llamado c.
int d[ ] = {10, 30, 50, 60, 70, 80 }; //creamos un arreglo llamado d.
for (int contador = 0; contador < arreglo.length; contador++) {

total += arreglo[contador];
}
int arreglo[ ] = { 10, 20, 30, 40 };

int total = 0;
for (int numero : arreglo ) {

total += numero;
}

3.18. Polimorfismo.
 El polimorfismo nos permite simplificar código al momento de programar debido a que es

posible orientar nuestra programación en términos “generales” en lugar de “específicos”.
 Polimorfismo es la capacidad que tienen los objetos de responder al mismo mensaje de
diferentes maneras en función a los parámetros utilizados durante su invocación.

3.19. Clases abstractas.
 Cuando pensamos en clases normalmente es porque necesitamos crear instancias de

dichas clases, pero algunas veces, necesitamos que no sea posible crear objetos a partir de
una clase determinada. Para ello, las declaramos como clases abstractas.
public abstract class Empleado { }
 Una clase abstracta es una clase (normalmente padre) java que puede tener métodos
implementados o abstractos pero que por ningún motivo puede ser instanciada.
Asimismo, al poder definir métodos abstractos, los mismos no deben poseer ninguna
implementación.
public abstract void Metodo( ) { }

Punto Circulo Cilindro
0 1 2
¿Cómo reaccionaría cada uno de ellos ante la orden: “Calcular_Area”?

public abstract class Figura {
Figura Clase abstracta public double calculaArea() { return 0.0; }
public abstract String getNombre();
}
Punto
public class Punto extends Figura {
protected int x,y; //coordenadas
public Punto() { setPunto ( 0, 0 ); }

Circulo
public Punto(int a, int b) { setPunto ( a, b ); }
public void setPunto(int a, int b) {

Cilindro x = a;
y = b;
}
public int getX() { return x; }
public int getY() { return y; }
public String getNombre() { //implementación del método abstracto.

return "Soy un Punto.";
}
Erick Arauco Moreno }
57
public class Circulo extends Punto {
protected double radio;
Figura
public Circulo() {
setRadio(0);
}
Punto
public Circulo(double r, int a, int b) {
super ( a, b ); //llama al constructor de la superclase
setRadio(r);
}
Circulo
public void setRadio(double r) {
radio = ( r >= 0 ? r : 0 );
}
Cilindro
public double getRadio() {
return radio;
}
public double calculaArea() { //redefine el método calculaArea.

return Math.PI * radio * radio;
}
public String getNombre() { //redefine el método getNombre.

return "Soy un circulo";
58
}
public class Cilindro extends Circulo {
protected double altura;
Figura
public Cilindro() {
setAltura(0);
}
Punto public Cilindro( double h, double r, int a, int b ) {

super ( r, a, b );
setAltura(h);
}
Circulo
public void setAltura(double h) {
altura = ( h >= 0 ? h : 0 );
}
Cilindro public double getAltura() {
return altura;
}
//2pi*r2 + 2pi*r*h
public double calculaArea() {
return 2* super.calculaArea() + 2 * Math.PI * radio * altura;
}
public String getNombre() {

return "Soy un cilindro";
Erick Arauco Moreno } 59
}
import java.text.DecimalFormat;
Figura
public static void main (String args[]) {
Punto pt = new Punto(7,11);
Circulo cl = new Circulo(3.5, 22, 8);
Punto Cilindro cil = new Cilindro(10,3.3,10,10);
Figura arregloFiguras[];
arregloFiguras = new Figura[3];
Circulo
arregloFiguras[0] = pt;
arregloFiguras[1] = cl;
arregloFiguras[2] = cil;
Cilindro String salida=””;

DecimalFormat formato= new DecimalFormat("0.00");
for ( int i = 0; i < arregloFiguras.length; i++ ) {

salida += "\n\n" +
arregloFiguras[i].getNombre() + ": " +
"\nArea = " +
formato.format(arregloFiguras[i].calculaArea() ) ;
}
System.out.println( salida );
}
Erick Arauco Moreno
} 60
3.20. Clases y métodos finales.
 Un método declarado como “final” en una superclase significa que el mismo no puede ser
sobreescrito por cualquiera de las clases hijas, por lo tanto las subclases tendrán que usar
la misma implementación hecha en la clase padre.
 Una clase definida como “final” significa que no puede ser una superclase, por lo tanto
todos los métodos de una clase “final” son finales implícitamente.

3.21. Interfaces.
 Las interfaces definen y estandarizan la forma en la cual los objetos

interactúan con otros.
 Es una colección de métodos sin implementaciones y de valores
constantes.
 No es posible definir métodos implementados.
 En ella se define que se debe hacer más no cómo hacer.
 Ventajas:
- Organizar la programación.
- Obligar a algunas clases a utilizar un método con el mismo nombre, tipo de
valor de retorno y parámetros de entrada.

3.21. Interfaces.
public interface Figura {

public double calculaArea();
public String getNombre(); public class Punto implements Figura {
} protected int x,y; //coordenadas
public Punto() { setPunto ( 0, 0 ); }
public Punto(int a, int b) { setPunto ( a, b ); }
public void setPunto(int a, int b) {

x = a;
y = b;
}
public int getX() { return x; }
public int getY() { return y; }
public double calculaArea() {

return 0.0;
}
public String getNombre() {

return "Soy un Punto";
}
}

4.1. Interfaz gráfica / cuadros de entrada y salida.
 Los cuadros de diálogo son ventanas en las cuales las aplicaciones

pueden capturar información o visualizar mensajes que deben ser leídos
por el usuario.
 La clase JOptionPane ofrece un conjunto de métodos para la utilización
de cuadros de entrada (InputDialog) ó cuadros de mensaje
(MessageDialog).
import javax.swing.JOptionPane; //importamos la clase JOptionPane.
public class Mensaje {
public static void main (String args[ ]) {

String nombre = JOptionPane.showInputDialog(“Ingresa tu nombre:”);
JOptionPane.showMessageDialog(null, “Bienvenido “ + nombre,
“Bienvenida”, JOptionPane.PLAIN_MESSAGE);
}
}
 Los cuadros de diálogo son ventanas en las cuales las aplicaciones

pueden capturar información o visualizar mensajes que deben ser leídos
por el usuario.
 La clase JOptionPane ofrece un conjunto de métodos para la utilización
de cuadros de entrada (InputDialog) ó cuadros de mensaje
(MessageDialog).
import javax.swing.JOptionPane; //importamos la clase JOptionPane.
public class Mensaje {

String nombre = JOptionPane.showInputDialog(“Ingresa tu nombre:”);
JOptionPane.showMessageDialog(null, “Bienvenido “ + nombre,
“Bienvenida”, JOptionPane.PLAIN_MESSAGE);
}
}

showMessageDialog(null, “Bienvenido “ + nombre, “Bienvenida”,

JOptionPane.PLAIN_MESSAGE);
 El primer argumento representa la posición en la que aparecerá el cuadro de
mensaje; el valor “null” indica que utilizará como referencia el monitor de la
computadora.
 El segundo argumento representa el mensaje a visualizar.
 El tercer argumento representa el título del cuadro de mensaje.
 El cuarto mensaje hace referencia al tipo de mensaje a visualizar.

4.2. Componentes Swing.
 Antes de la aparición de Swing, los componentes gráficos utilizados

pertenecían a la Abstract Window Toolkit (AWT), por lo que cuando una
aplicación java que utilizaba componentes AWT era ejecutada bajo un
sistema operativo distinto, los componentes gráficos aparecían de
manera diferente.
 Actualmente, los componentes gráficos Swing definen su apariencia
gracias a lo que conocemos como look-and-feel; lo que significa que los
componentes Swing permiten definir una presentación uniforme sobre
cualquier plataforma donde se ejecute la aplicación.

import java.awt.FlowLayout;
4.2.1. JLabel. import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.SwingConstants;
import javax.swing.Icon;
import javax.swing.ImageIcon;
public class MiVentana extends JFrame {

private JLabel etiqueta1;
private JLabel etiqueta2;
public MiVentana( ) {
super(“Etiquetas”);
setLayout(new FlowLayout());
//etiqueta con una línea de texto.

etiqueta1 = new JLabel(“Etiqueta con texto”);
etiqueta1.setToolTipText(“Esta es una etiqueta”);
add(etiqueta1);
//etiqueta con imagen.

Icon logo = new ImageIcon(getClass( ).getResource(“abit.gif”));
etiqueta2 = new JLabel (“Etiqueta con texto e imagen”, logo,
SwingConstants.LEFT);
etiqueta2.setToolTipText(“Esta es una etiqueta2”);
add(etiqueta2);
}
}

4.2.2. JTextField.
import java.awt.FlowLayout;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JTextField;
import javax.swing.JPasswordField;
public class MiVentana extends JFrame {

private JTextField texto1;
private JPasswordField texto2;
private JLabel etiqueta1, etiqueta2;
public MiVentana( ) {
super(“Cajas de Texto”);
etiqueta1 = new JLabel(“Ingresar texto:”);
add(etiqueta1);
texto1 = new JTextField(10);
add(texto1);
etiqueta2 = new JLabel(“Ingresar password:”);

add(etiqueta2);
texto2 = new JPasswordField(“texto oculto”);
add(texto2);
}
}

4.2.2.1. Gestión de eventos.
 Cada uno de los componentes utilizados genera un evento, en especial la

caja de texto; por ejemplo: si al momento de terminar de escribir algún
tipo de información, presionamos la tecla “Enter”, ¿qué ha pasado?
 Ha sucedido lo mismo que debería suceder si hacemos “click” sobre
cualquier botón. Se ha generado un evento. Todos los componentes
java generan eventos que le dicen al programador que se está
interactuando con este tipo de componente java, el problema es que
dichos eventos no son capturados porque lo no podemos saber en este
momento qué componente está siendo utilizado.

 El modelo que representa la gestión de eventos en java está conformado

por tres partes, a saber:
- El generador del evento: representado por el objeto gráfico java con el que el
usuario interactúa.
- El evento: objeto que contiene información sobre el evento ocurrido.
- El oyente de eventos: encargado de recibir el evento y de responder.
Boton1 Oyente1
Boton2
Oyente2
Caja de Texto
Ventana

 ActionListener: El usuario pulsa un botón, presiona “enter” en una caja de

texto ó elige algún ítem de un menú.
 WindowListener: El usuario elige un JFrame, lo cierra, etc.
 MouseMotionListener: El usuario pasa el puntero del mouse sobre algún
componente.

 Un oyente de eventos es una clase java cualquiera que implementa

cualquiera de las interfaces mencionadas anteriormente (ActionListener,
WindowListener, MouseMotionListener, etc. ).
 Por ejemplo, la interface ActionListener, posee el siguiente método:
- actionPerformed(ActionEvent e): Cada vez que presionamos un botón o “enter”
en una caja de texto, este método es lanzado. El objeto ActionEvent, ofrece
información sobre el objeto que originó el evento.

4.2.2.1. Gestión de eventos – Ejemplo(1)
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class MiAplicacion extends JFrame implements ActionListener {

private JTextField cajaTexto1, cajaTexto2, cajaTexto3;
public MiAplicacion() {
super(“Gestionando eventos”);
cajaTexto1 = new JTextField(10);

cajaTexto1.addActionListener(this);
add(cajaTexto1);
cajaTexto2 = new JTextField(“Ingresar Texto ”);

add(cajaTexto2);
cajaTexto3 = new JTextField(“Texto no editable”, 21);

cajaTexto3.setEditable(false);
add(cajaTexto3);
}
4.2.2.1. Gestión de eventos – Ejemplo(2)
public void actionPerformed(ActionEvent e) {

String cadena = “”;
if (e.getSource().equals(cajaTexto1))
cadena = “Texto 1: “ +
e.getActionCommand();
else if (e.getSource().equals(cajaTexto2))
else if (e.getSource().equals(cajaTexto3))
JOptionPane.showMessageDialog(null,cadena);
}
}

4.2.3. JButton
import java.awt.*;

private JButton boton1, boton2;
super(“Usando botones”);
boton1 = new JButton(“Primer boton”);

boton1.addActionListener(this);
add(boton1);
Icon icono1 = new ImageIcon(getClass().getResource(“icono.gif”));

boton2 = new JButton(“Segundo boton”, icono1);
boton2.addActionListener(this);
add(boton2);
}

JOptionPane.showMessageDialog(this, “Presionaste: “ +
e.getActionCommand());
}
}
4.3. Clases Adaptadoras.
 La implementación del oyente de eventos ActionListener hasta el momento no ha

sido una tarea complicada.
 Eventos relacionados con el manejo del mouse, teclado ó ventanas.
WindowListener, MouseListener o MouseMotionListener.
 WindowsListener:
- windowActivated(WindowEvent e)
- windowClosed(WindowEvent e)
- windowClosing(WindowEvent e)
- windowDeactivated(WindowEvent e)
- windowDeiconified(WindowEvent e)
- windowIconified(WindowEvent e)
- windowOpened(WindowEvent e)

Clase Adaptadora Interface que implementa
ComponentAdapter ComponentListener
ContainerAdapter ContainerListener
FocusAdapter FocusListener
KeyAdapter KeyListener
MouseAdapter MouseListener
MouseMotionAdapter MouseMotionListener
WindowAdapter WindowListener

import java.awt.*;
public class MiAplicacion extends JFrame {
super(“Manejo de eventos”);
addWindowListener(new VentanaEvento());
}
//Clase interna – Clase Adaptadora.

private class VentanaEvento extends WindowAdapter {
public void windowIconified(WindowEvent e) {
JOptionPane.showMessageDialog(null, “Ventana
Minimizada”);
}
}
}

4.4. Contenedores.
 El primer contenedor que hemos utilizado hasta el momento es el propio JFrame,

quien ha tenido la labor de contener botones, cajas de texto, etiquetas, etc. En las
versiones anteriores de java, no era posible insertar directamente un componente
gui en el contenedor JFrame sino a través de su Container (método
getContentPane()), por lo que actualmente al usar el método “add(componente)”,
directamente estamos insertando sobre el “Container “ del JFrame.
 Entre los contenedores más utilizados para la construcción de aplicaciones en
java tenemos: JPanel, JInternalFrame, JFrame, etc.

4.5. Distribuidores de Componentes.
 Posición Absoluta: Esta forma especifica que al no definir un distribuidor de componentes

para un determinado contenedor (setLayout(null)) se debe proceder a definir la posición
exacta del componente. Esta forma de establecer su posición es bastante tediosa a no ser
que se posea un entorno de desarrollo (NetBeans).
 Distribuidores de Componentes: Usando los distribuidores de componentes dejamos en

ellos la responsabilidad para definir la ubicación y tamaño de los componentes, la
desventaja radica en que perdemos el control sobre tamaño y ubicación de los
componentes.
 Programación Visual en algún IDE: Los entornos de desarrollo (IDE), permiten que el
programador simplemente arrastre el componente sobre el contenedor. El IDE genera el
código java correspondiente dependiendo de los componentes utilizados.

4.5. Distribuidores de Componentes.
Distribuidor Descripción
FlowLayout Distribuidor por defecto para los JPanel.
Distribuye los componentes secuencialmente
(izquierda a derecha) en el orden en que son
añadidos.
BorderLayout Distribuidor por defecto para los JFrames.

Distribuye los componentes en cinco áreas:
Norte, Sur, Este, Oeste y Centro.
GridLayout Distribuye los componentes en filas y

columnas.

4.5.1. FlowLayout – BorderLayout – GridLayout.

4.5.2. Paneles.
Mi Primera Aplicación Java
Código:
Apellidos:
Nombres:
Nuevo Modificar Salir

4.5.2. Paneles.
Podemos insertar el titulo (JLabel)
sobre el JFrame y ubicarlo en la
posición NORTH
Mi Primera Aplicación Java
Código:
Código:
Apellidos:
Apellidos:
Nombres:
Nombres:

JPanel insertado en la posición CENTER, a

JFrame (podríamos
su vez tiene un distribuidor GridLayout (3 JPanel insertado en la posición asignarle un distribuidor
filas, 2 columnas). Contiene las tres SOUTH, a su vez tiene un BorderLayout)
etiquetas y las tres cajas de texto. distribuidor FlowLayout para
distribuir los botones de
manera horizontal.

5. Gestión de errores.
 La construcción de cualquier aplicación informática conlleva por naturaleza a tener que

estar preparados para el momento en que aparezcan errores durante la ejecución de la
misma. Java ofrece una manera de gestionar estos errores con la finalidad de evitar la
interrupción total de la aplicación.
 Es necesario tener en cuenta que el uso normal que cualquier usuario da a una aplicación
implica típicamente el ingreso de datos incorrectos, los cuales, sin ningún control por parte
de la aplicación podrían afectar a la misma; es por eso que nuestras aplicaciones se
encuentran en la obligación de implementar un control de errores logrando así de esta
manera dirigir al usuario mientras usa la herramienta.

5.1. Excepciones.
 Una excepción indica que ha ocurrido un problema durante la ejecución de la aplicación.

Representa una anomalía al funcionamiento normal de la aplicación. La gestión de las
excepciones en java permite a los programadores definir un conjunto de reglas que
resuelvan estos problemas al momento de su aparición.
public static int division(int n, int d) {
return n / d;
}
public static void main (String args[]) {

Scanner sc = new Scanner(System.in);
System.out.println(“Ingrese numerador: “);
int num = sc.nextInt();
System.out.println(“Ingrese denominador: “);
int denom = sc.nextInt();
int resultado = division(num, denom);

System.out.println(“resultado : “ + resultado );
}
}
5.1. Excepciones.
Excepción Descripción
ArrayIndexOutOfBoundsException Se accede a una posición del arreglo que no existe.
ArithmeticException Una excepción aritmética ha ocurrido. División por
cero.
ClassNotFoundException La clase instanciada no ha sido encontrada.
NullPointerException Se espera un objeto y se recibe un valor null; ó la
longitud del arreglo esperado es null.
NumberFormatException Se introducen caracteres no numéricos.

5.1. Excepciones.
try {
//sentencias
//Pueden generar una excepción
}
catch (TipodeExcepcion ex1) {
//sentencias que se ejecutarán cuando se produzca una
excepción del tipo “TipodeExcepcion”.
}
catch (OtroTipodeExcepcion ex2) {
//sentencias que se ejecutarán cuando se produzca una
excepción del tipo “OtroTipodeExcepcion”.
}
finally {
//sentencias
//Se ejecutan siempre.
}

5.1.1. Claúsula throws.
clase A clase B
public void metodo1( ) { public void metodo2( ) throws ArithmeticException {

B obj = new B(); int a = 5 / 0;
obj.metodo2(); }
}
Creamos una instancia de B y

llamamos a metodo2.

//método division informa que no controlará la excepción, sólo la reenviará.

public static int division(int n, int d) throws ArithmeticException {
return n / d;
}

Scanner sc = new Scanner(System.in);
boolean continuar = true;
do {
try {
System.out.println(“Ingrese numerador: “);
int num = sc.nextInt();
System.out.println(“Ingrese denominador: “);
int denom = sc.nextInt();
int resultado = division(num, denom);

System.out.println(“resultado : “ + resultado );
continuar = false;
}
//en caso aparezca la excepción InputMismatchException
catch (InputMismatchException ex1) {
System.out.println(“Excepcion: “ + ex1);
sc.nextLine();
System.out.println(“Ingresar numeros. Intente de nuevo”);
}
//en caso aparezca la excepción ArithmeticException
catch(ArithmeticExcepcion ex2) {
System.out.println(“Excepcion: “ + ex2);
System.out.println(“Division por cero. Intente de nuevo”);
}
}while(continuar);
}
}

5.1.2. Claúsula throw
 Existen situaciones en las que necesitamos forzar el lanzamiento de una

excepción para indicar que una aplicación no se ajusta a ciertas reglas
particulares; para ello podemos utilizar la claúsula throw.
public class Empleado {
private String nombre;
private int sueldo;
public void setNombre(String nomVal) {

nombre = nomVal;
}
public void setSueldo(int suelVal) throws Exception {

if(suelVal>3000) {
throw new Exception("Limite superado");
} else {
sueldo = suelVal;
}
}
}
5.1.3. Ejemplo
public class Empleado {

private String nombre;
private int sueldo;
public void setNombre(String nomVal) {

nombre = nomVal;
}
public void setSueldo(int suelVal) throws Exception {

if(suelVal>3000) {
throw new Exception("Limite superado");
} else {
sueldo = suelVal;
}
}
}

5.1.3. Ejemplo
import java.awt.*;

private JTextField txtNombre, txtSueldo, txtSueldoNeto;
private double sueldo, sueldoNeto;
super( "Demostrando Excepciones" );
setLayout( new GridLayout( 3, 2 ) );
add(new JLabel( "Nombre: ", SwingConstants.RIGHT ) );

txtNombre = new JTextField();
add( txtNombre );
add( new JLabel( "Sueldo (presionar Enter):", SwingConstants.RIGHT ) );

txtSueldo = new JTextField();
add( txtSueldo );
txtSueldo.addActionListener( this );

5.1.3. Ejemplo
add( new JLabel( "Sueldo Neto: ", SwingConstants.RIGHT ) );
txtSueldoNeto = new JTextField();
add( txtSueldoNeto );
}
public void actionPerformed( ActionEvent e ) {

txtSueldoNeto.setText( "" );
try {
//Esta linea puede generar una excepcion.
sueldo = Double.parseDouble( txtSueldo.getText() );
Empleado emp = new Empleado();

emp.setNombre(txtNombre.getText());
//Esta linea puede generar una excepcion.
emp.setSueldo(sueldo);
sueldoNeto = calcular(sueldo);
txtSueldoNeto.setText( String.valueOf( sueldoNeto ) );
}

5.1.3. Ejemplo
catch ( NumberFormatException nfex ) {

JOptionPane.showMessageDialog( this,
"Se debe ingresar un entero", "Formato invalido",
JOptionPane.ERROR_MESSAGE );
}
catch ( Exception ex ) {
JOptionPane.showMessageDialog( this,
ex.getMessage(), "Excepcion de la clase Empleado",
JOptionPane.ERROR_MESSAGE );
}
}
public double calcular( double numero ) {

double impuesto = numero * 0.19;
return numero - impuesto;
}
}

5.1.3. Ejemplo

5.1.4. JFrames – Java Beans.
Alumno
codigo;
apellidos;
Registro de Alumnos nombres;
Código:
setCodigo();
Apellidos: getCodigo();
Nombres: setApellidos();
getApellidos();
setNombres();
Guardar Modificar Salir
getNombres();
JavaBean

6. JDBC – Java Database Connectivity
 Modelo Relacional.
Number Name Department Salary Location
23603 Jo nes 413 1100 New Jersey
24568 Kerw in 413 2000 New Jersey

Row 34589 La rso n 642 1800 Lo s Ang eles
35761 Myers 611 1400 Orla nd o
47132 Neuma nn 413 9000 New Jersey

78321 Step hens 611 8500 Orla nd o
Prima ry key Co lum n

6.1. SQL – lenguaje de consulta.
Instrucción Descripción
SELECT Selecciona uno o más campos de una o varias tablas.
FROM Selecciona las tablas envueltas en la consulta.

WHERE Condición para la selección.
ORDER BY Ordena los resultados de manera ascendente o
descendente.
INSERT Inserta registros en una tabla.

UPDATE Actualiza registros en una tabla.
DELETE Eliminar registros en una tabla.

6.1. SQL – lenguaje de consulta.
SELECT * FROM Empleados
SELECT Name, Department, Salary

FROM Empleados
WHERE Salary > 3000
SELECT Name, Department, Salary

FROM Empleados
WHERE Name LIKE „L%‟
INSERT INTO Empleados (Number, Name, Department, Salary, Location)

VALUES („67897‟, „Pedro‟, „115‟, 5678, Perú)
UPDATE Empleados DELETE FROM Empleados

SET Name = „Juan‟ WHERE Salary > 3000
WHERE Name = „Pedro‟

6.2. JTable
import java.awt.*;

Object[][] registros = {
{"Carlos", "Martinez", "Natacion", 5, false},
{"Pedro", "Ortega", "Tenis",3, true},
{"Juan", "Garcia", "Ajedrez",2, false},
{"Luis", "Perez", "Futbol", 5, true}
};
String[] columnas = {"Nombre", "Apellidos", "Deporte", "# de Anios", "Vegetariano"};
JTable tabla = new JTable(registros, columnas);

JScrollPane panel = new JScrollPane(tabla);
add(panel, BorderLayout.CENTER);
}
}

6.3. Orígenes de datos.
 A partir de este momento nuestra aplicación java tendrá la necesidad de

almacenar o recuperar datos desde una base de datos relacional; por lo
que se hará necesario definir en la aplicación cierta información que
ayude a nuestra clase java a encontrar la base de datos deseada, la tabla
deseada para poder insertar, actualizar, eliminar o recuperar información.
 Un origen de datos, define cierta información que será utilizada por
nuestra aplicación java para poder establecer conexión con la base de
datos deseada.
 JDBC en este punto, representa un marco de programación utilizado por
los programadores con la finalidad de conectar una aplicación java con
ciertas bases de datos sin importar el software que la gestiona.




MiOrigen

 clase Connection: Es la clase encargada de gestionar la conexión hacia

la base de datos.
 clase Statement: Es aquella clase encargada de definir la consulta SQL
a ejecutar.
 clase ResultSet: Es aquella clase encargada de gestionar el resultado
obtenido producto de la ejecución de una consulta.

import java.awt.*;
import java.sql.*;
import java.util.*;

private Connection cn;
private Statement st;
private ResultSet rs;
private JTable tabla;
super(“Accediendo a una base de datos”);
String url = "jdbc:odbc:DsnAcademico";

//carga del driver JDBC – ODBC y apertura de la conexión
try {
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
cn = DriverManager.getConnection(url);
}
catch (ClassNotFoundException cnfex) {
System.exit(1); //termina el programa
}
catch (SQLException sqlex) {
System.exit(1);
}
Vector cabecera = new Vector();

Vector filas = new Vector();

try {
st = cn.createStatement();
rs = st.executeQuery("SELECT * FROM Alumno");
rs.next();
//obteniendo la cabecera de la tabla.

ResultSetMetaData rsmd = rs.getMetaData();
for (int i = 1; i <= rsmd.getColumnCount(); ++i) {
cabecera.addElement(rsmd.getColumnName(i));
}
//obteniendo registros de la tabla.

while (rs.next()) {
Vector fila = new Vector();
for (int j = 1; j <= rsmd.getColumnCount(); ++j) {
fila.addElement(rs.getString(j));
}
filas.addElement(fila);
}

tabla = new JTable(filas, cabecera);
add(panel, BorderLayout.CENTER);
}
catch (SQLException sqlex) {
sqlex.printStackTrace();
}
}

6.3. Orígenes de datos – analizando.
 JTable (Object[ ][ ] datos, Object[ ] columnas)

 JTable (Vector datos, Vector columnas)
 Ventaja: facilidad de uso.
 Desventajas:
- Cada celda automáticamente se encuentra en estado editable.
- Todos los datos visualizados son tratados con el mismo tipo (String).
- La obligación de utilizar arreglos o vectores para almacenar datos. Esto puede
ser una desventaja, por ejemplo si obtenemos un conjunto de objetos
provenientes de una base de datos, no podremos trabajar con ellos
directamente sino es a través de un vector ó un arreglo bidimensional.

6.4. Modelo de datos – ModelTable.
 Cada JTable utilizado en nuestros ejemplos está basado en un modelo

de datos que tiene como finalidad gestionar los datos visualizados en la
tabla. Hasta el momento, en los ejemplos anteriores al no crear un
modelo de datos propio, la clase JTable al momento de ser instanciada
automáticamente crea un modelo de datos por defecto
(DefaultTableModel).
 La utilización de un modelo de datos permitirá a los programadores
agregar, modificar, eliminar todo dato visualizado en la tabla; por lo tanto,
cualquier operación que realicemos con el modelo de datos implicará
automáticamente un cambio en el objeto JTable.

Modelo de Datos Base de

Datos

public class Persona {
private String codigo = null;
private String nombre = null;
private String apellido = null;
private int edad = 0;
public Persona(String codigo, String nombre, String apellido, int edad) {

this.codigo = codigo;
this.nombre = nombre;
this.apellido = apellido;
this.edad = edad;
}
public String getCodigo() { return codigo; }

JavaBean
public String getNombre() { return nombre; }
public String getApellido() { return apellido; }
public int getEdad() { return edad; }
public void setCodigo (String codigo) { this.codigo = codigo; }
public void setNombre (String nombre) { this.nombre = nombre; }
public void setApellido (String apellido ) { this.apellido = apellido; }
public void setEdad (int edad) {this.edad = edad;}

117
 Para la implementación del modelo propio, tenemos inicialmente dos

opciones: implementar la interface TableModel e implementar todos sus
métodos ó extender la clase abstracta AbstractTableModel.
- int getColumnCount(): método que debe devolver el número de columnas que
posee la tabla.
- int getRowCount(): método que debe devolver el número de registros
existentes en la tabla.
- Object getValueAt(int rowIndex, int columnIndex): método que debe retornar
el valor de una celda habiendo especificado previamente su fila y columna.

import javax.swing.table.*;
import javax.swing.event.*;
import java.util.*;
public class MiModelo extends AbstractTableModel {
private LinkedList datos = new LinkedList();

private LinkedList listeners = new LinkedList();
public int getColumnCount() {

return 4;
}
public int getRowCount() {

return datos.size();
}
Modelo de Datos
public String getColumnName(int columnIndex) {
switch (columnIndex) {
case 0:
return "Codigo";
case 1:
return "Nombres";
case 2:
return "Apellidos";
case 3:
return "Edad";
default:
return null;
}
}

public Object getValueAt(int rowIndex, int columnIndex) {

Persona aux;
aux = (Persona)(datos.get(rowIndex));
case 0:
return aux.getCodigo();
Modelo de Datos case 1:
return aux.getNombre();
case 2:
return aux.getApellido();
case 3:
return new Integer(aux.getEdad());
default:
return null;
}
}

public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
Persona aux = (Persona)(datos.get(rowIndex));
case 0:
aux.setCodigo ((String)aValue);
break;
case 1:
aux.setNombre ((String)aValue);
break;
case 2:
aux.setApellido ((String)aValue);
break;
case 3:
aux.setEdad (Integer.parseInt((String)aValue));
break;
default:
Modelo de Datos break;
}
TableModelEvent evento = new TableModelEvent (this, rowIndex, rowIndex,
columnIndex);
avisaSuscriptores (evento);
}
public void eliminaPersona (int fila) {

datos.remove(fila);
TableModelEvent evento = new TableModelEvent (this, fila, fila,
TableModelEvent.ALL_COLUMNS, TableModelEvent.DELETE);
}

public void insertaPersona (Persona nuevaPersona) {
datos.add (nuevaPersona);
TableModelEvent evento;
evento = new TableModelEvent (this, this.getRowCount()-1,
this.getRowCount()-1, TableModelEvent.ALL_COLUMNS,
TableModelEvent.INSERT);
}
public void addTableModelListener(TableModelListener l) {

listeners.add (l);
}
public void removeTableModelListener(TableModelListener l) {

listeners.remove(l);
}
Modelo de Datos
private void avisaSuscriptores (TableModelEvent evento) {
int i;
for (i=0; i<listeners.size(); i++)
((TableModelListener)listeners.get(i)).tableChanged(evento);
}
public boolean isCellEditable(int rowIndex, int columnIndex) {

return true;
}
}

public class GestionTabla {
private MiModelo modelo = null;
private static int numero = 0;
public GestionTabla(MiModelo modelo) {

this.modelo = modelo;
modelo.insertaPersona(new Persona ("001", "Juan", "Perez", 38));
modelo.insertaPersona(new Persona ("002", "María", "García", 24));
modelo.insertaPersona(new Persona ("003", "Luis", "Rivera", 15));
modelo.insertaPersona(new Persona ("004", "Pedro", "Chavez", 48));
}
public void insertaFila () {

Persona dato = new Persona (
GestionTabla "Codigo " + Integer.toString(numero),
"Nombre " + Integer.toString (numero),
"Apellido " + Integer.toString (numero),
numero);
modelo.insertaPersona (dato);
numero++;
}
//Elimina la primera persona de la tabla.

public void borraFila () {
if (modelo.getRowCount() > 0)
modelo.eliminaPersona(0);
}
123
import java.awt.*;

GestionTabla control;
JButton botonInserta, botonElimina;
super(“Utilizando modelo de datos”);
setLayout(null);
MiModelo modelo = new MiModelo();
control = new GestionTabla (modelo);
Interfaz Gráfica JTable tabla = new JTable (modelo);
botonInserta = new JButton ("Insertar");
botonInserta.addActionListener(this);
botonElimina = new JButton ("Eliminar");
botonElimina.addActionListener(this);
panel.setBounds(50, 70, 500, 300);

botonInserta.setBounds(50, 400, 100, 25);
botonElimina.setBounds(160, 400, 100, 25);
add(panel);
add(botonInserta);
add(botonElimina);
124

if (e.getSource().equals(botonInserta)) {
control.insertaFila();
} else {
control.borraFila();
}
}
}
Interfaz Gráfica

setValueAt
getColumnCount
getColumnName
getRowCount ….
Modifica una celda. Modelo de Datos

Recupera el valor de una
celda.
Recupera nombre de Inserta una fila
columna. Elimina una fila
JFrame + JTable Gestion Tabla

Inserta una fila
Elimina una fila

7.1. Modelo Vista Controlador
 La arquitectura Modelo Vista Controlador (MVC) separa la aplicación en tres

partes que toman exactamente las mismas palabras (Modelo, Vista, Controlador).
El objetivo principal de la mencionada arquitectura: Separar la interfaz de usuario
de los datos.
- Modelo: El modelo es la capa que permite gestionar los datos de la aplicación. El modelo
es el responsable del almacenamiento y recuperación del objeto.
- Vista: Representa la interfaz de usuario. En otras palabras, la vista puede ser concebida
como la interfaz gráfica del modelo. Es posible asociar más de una vista a un modelo.
- Controlador: Es el encargo de implementar la lógica para el procesamiento de las
entradas de usuario. Encargado de integrar la aplicación. Una vez que la vista notifica al
controlador que se ha originado una entrada de usuario, el controlador notifica al modelo
que los datos han cambiado, y por último el modelo notifica a todas las vistas registradas
que procedan a su actualización.

7.1. Modelo Vista Controlador
Modelo
Notifica
Actualiza
Evento
Vista(s) Controlador

7.2. Patrón Observador - Observable
 Un “Observer” es cualquier objeto que necesita recibir notificaciones sobre el

estado de otros objetos, mientras que un “Observable” posee ciertos métodos que
permitan cambiar los datos y notificar a todos los “Observer” registrados al
mismo.
Cambia
Vista 1
Valor
Observable Notifica
Cambia Vista 2

import java.util.Observable;
public class ValorObservable extends Observable {
private int nValor = 0;
private int nInferior = 0;
private int nSuperior = 0;
public ValorObservable( int nValor,int nInferior,int nSuperior ) {

this.nValor = nValor;
this.nInferior = nInferior;
this.nSuperior = nSuperior;
}
public void setValor(int nValor) {

this.nValor = nValor;
setChanged();
notifyObservers();
}
public int getValor() {

return( nValor );
}
public int getLimiteInferior() {

return( nInferior );
}
public int getLimiteSuperior() {

return( nSuperior );
}
Erick Arauco Moreno
} 130
import java.awt.*;
import java.util.*;
public class TextoObservador extends JFrame implements ActionListener, Observer {
private ValorObservable vo;
private TextField tf1;
private JLabel lbl1;
private int nInferior = 0;
private int nSuperior = 0;
public TextoObservador( ValorObservable vo ) {

super("Observador de Texto");
this.vo = vo;
setLayout( new GridLayout( 0,1 ) );
nInferior = vo.getLimiteInferior();
nSuperior = vo.getLimiteSuperior();
tf1 = new TextField( String.valueOf( vo.getValor() ) );

tf1.addActionListener(this);
add( tf1 );
lbl1 = new JLabel();

add( lbl1 );
public void actionPerformed (ActionEvent e) {
if (e.getSource().equals(tf1)) {
int n = 0;
boolean bValido = false;
try {
n = Integer.parseInt( tf1.getText() );
bValido = true;
}
catch( NumberFormatException nfe ) {
bValido = false;
}
// Comprobamos que no se sobrepasen los límites que hemos fijado
if( n < nInferior || n > nSuperior )
bValido = false;
if( bValido ) {
vo.setValor( n );
lbl1.setText( "" );
} else
lbl1.setText( "Valor no valido - intentelo de nuevo" );
}
}
public void update( Observable obs,Object obj ) {

if( obs == vo )
tf1.setText( String.valueOf( vo.getValor() ) );
}
}

import java.awt.*;
import java.util.*;
public class BarraObservador extends JFrame implements Observer, AdjustmentListener {

private ValorObservable vo = null;
private JScrollBar sb = null;
public BarraObservador( ValorObservable vo ) {

super( "Observador de Barra" );
this.vo = vo;
setLayout( new GridLayout( 0,1 ) );
sb = new JScrollBar(Scrollbar.HORIZONTAL, vo.getValor(), 10, vo.getLimiteInferior(),
vo.getLimiteSuperior());
sb.addAdjustmentListener(this);
add(sb);
}
public void adjustmentValueChanged( AdjustmentEvent e ) {

if (e.getSource().equals(sb)){
vo.setValor( sb.getValue() );
}
}
public void update( Observable obs,Object obj ) {

if( obs == vo )
sb.setValue( vo.getValor() );
}
import java.awt.*;

public static void main( String args[] ) {
ValorObservable vo = new ValorObservable( 100,0,500 );
TextoObservador to = new TextoObservador( vo );
to.pack();
to.setVisible(true);
BarraObservador bo = new BarraObservador( vo );

bo.pack();
bo.setVisible(true);
vo.addObserver( to );
vo.addObserver( bo );
}
}

7.3. Caso a desarrollar
(Observer)
AbstracTableModel BD
setPersonas() , getPersonas()
(Observable)
Codigo Nombre Apellido Edad
ComponenteObservable
int filaActual
Vector<Persona> personas
(Observer)
JTable setFilaActual() , setFilaActual (Notifica)
getFilaActual() getFilaActual
Codigo: setPersonas (Notifica)

Nombre: getPersonas
Apellido:
Edad:
setFilaActual() ,
getFilaActual(), Persona
Buscar
JFrame
Anterior Siguiente setPersonas(), Codigo
getPersonas() Nombre
(Observer) Apellido
Edad

7.3. Caso a desarrollar
 Existen tres (3) observadores que implementarán el método “update” cada vez que exista
una modificación en el objeto observable.
 El observador “AbstractTableModel” representa los datos contenidos en el objeto JTable,
asimismo es el encargado de insertarlos, modificarlos o eliminarlos. Cualquier cambio en
este objeto será visualizado en el JTable. Este objeto necesita obtener los datos del objeto
observable y para ello utiliza el método “getPersonas()” para obtener el vector
correspondiente.
 El observador “JTable” visualiza los datos contenidos en su respectivo modelo, asimismo,
permitirá seleccionar alguna de sus filas, y al momento en que se realice esta operación se
procederá utilizar el método “setFilaActual()” y a notificar al observador “JFrame” para que
visualice el mismo registro; lo mismo sucedería si el observador “JFrame” cambia de
registro, esto implicaría modificar el atributo “filaActual” e informar a los observadores, por lo
tanto el observador “JTable” recuperará este valor y seleccionará la misma fila.
 El observador “JFrame” no sólo recibirá notificaciones cuando exista un cambio en el
atributo “filaActual” sino también cuando el vector personas haya sido modificado, por lo
tanto ante esto, solicitará a través del método “getPersonas()”, el nuevo vector a utilizar.

Modulo I

Diunggah oleh

Informasi Dokumen

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Modulo I

Diunggah oleh

Hak Cipta:

Format Tersedia

Diplomado en Tecnologías Web

Escuela Tecnológica Superior

Erick Arauco Moreno 1

Erick Arauco Moreno 2

 Java es un lenguaje de programación orientada a objetos.

Erick Arauco Moreno 3

Erick Arauco Moreno 4

 En toda aplicación Java debemos tener en cuenta las siguientes fases:

Erick Arauco Moreno 5

 Algunos de los entornos de desarrollo más utilizados:

Erick Arauco Moreno 6

 La configuración del entorno de desarrollo java implica la definición de dos

Erick Arauco Moreno 7

 Creamos nuestra primera variable de sistema de la siguiente manera:

 La variable JAVA_HOME, es la primera variable a crear la cual debe tener como

Erick Arauco Moreno 8

 El valor de la mencionada variable debe apuntar a la carpeta “bin” ubicada

Erick Arauco Moreno 9

Erick Arauco Moreno 10

1) Se escribe el código fuente

2) Se compila el código fuente

Solaris Windows Mac OS

JVM JVM JVM

3) Cada sistema operativo posee una

Erick Arauco Moreno 11

 Simple. Java ofrece toda la funcionalidad de un lenguaje potente, pero

Erick Arauco Moreno 12

 Orientado a Objetos. Java implementa la tecnología básica de C++ con

Erick Arauco Moreno 13

public class MiAplicacion {

Erick Arauco Moreno 14

public class MiAplicacion Definición de la clase

Erick Arauco Moreno 15

Erick Arauco Moreno 16

System.out.print("Ingrese el primer entero: ");

System.out.print("Ingrese el segundo entero: ");

suma = numero1 + numero2;

System.out.println("La suma es : " + suma); //imprimiendo el

System.out.print("Ingrese el primer entero: ");

System.out.print("Ingrese el segundo entero: ");

if ( numero1 == numero2 ) //utilizando operador de igualdad.

if ( numero1 != numero2 ) //utilizando operador de diferencia.

Erick Arauco Moreno 18

System.out.print("Ingrese el primer entero: ");

System.out.print("Ingrese el segundo entero: ");

if ( numero1 == numero2 ) //Sin paréntesis si el cuerpo de la

for ( int contador = 1; contador <= 10; contador ++) {

Erick Arauco Moreno 20

Telefono Nombre de la clase

Erick Arauco Moreno 22

Erick Arauco Moreno 23

public class Telefono {

public void llamar() {

Erick Arauco Moreno 24

public class Principal {

tlf1.color= “Rojo”; //definiendo el color del primer teléfono. marca: M1

tlf1.encender(); //encendiendo el primer teléfono.

Erick Arauco Moreno 25

public void llamar (String numero ) {

tlf1.color = “Rojo”; //definiendo el color del primer teléfono.

tlf1.llamar( “961234560” ); //llamando a un número telefónico

tlf2.llamar( “968889633” ); //llamando a un número telefónico

Erick Arauco Moreno 27

 Independientemente de los métodos definidos en cada clase, también es posible definir un