You are on page 1of 136

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.

Erick Arauco Moreno 2


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).

Erick Arauco Moreno 3


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.

Erick Arauco Moreno 4


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.

Erick Arauco Moreno 5


1.3. Entorno de desarrollo.

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

Erick Arauco Moreno 6


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:

Erick Arauco Moreno 7


1.4. Configuración de variables de entorno.

 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.

Erick Arauco Moreno 8


1.4. Configuración de variables de entorno.

 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.

Erick Arauco Moreno 9


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".

Erick Arauco Moreno 10


1.5. Características.

 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.

Erick Arauco Moreno 11


1.5. Características.

 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)

Erick Arauco Moreno 12


1.5. Características.

 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.

Erick Arauco Moreno 13


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

Erick Arauco Moreno 14


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

Erick Arauco Moreno 15


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.

Erick Arauco Moreno 16


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: ");


numero2 = entrada.nextInt();

suma = numero1 + numero2;

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


resultado.
}
}
Erick Arauco Moreno 17
2.2.1. Estructuras de control – if / else
import java.util.Scanner;
public class Comparacion {
public static void main (String args [ ]) {
Scanner entrada = new Scanner(System.in);
int numero1;
int numero2;

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


numero1 = entrada.nextInt();

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


numero2 = entrada.nextInt();

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


System.out.println (“Son iguales”);

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


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

Erick Arauco Moreno 18


2.2.1. Estructuras de control – if / else
import java.util.Scanner;
public class Comparacion {
public static void main (String args [ ]) {
Scanner entrada = new Scanner(System.in);
int numero1;
int numero2;

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


numero1 = entrada.nextInt();

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


numero2 = entrada.nextInt();

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”);
}
}
Erick Arauco Moreno 19
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 );
}

Erick Arauco Moreno 20


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.
Erick Arauco Moreno 21
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()

Erick Arauco Moreno 22


3.1. Clases y Objetos.

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”

Erick Arauco Moreno 23


3.1. Clases y Objetos.

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

Erick Arauco Moreno 24


3.1. Clases y Objetos.

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
clase “Telefono”

Erick Arauco Moreno 25


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


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.

Erick Arauco Moreno 27


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.

Erick Arauco Moreno 28


3.3. Inicializando clases – Constructores.

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.
}
}
Erick Arauco Moreno 29
3.3. Inicializando clases – Constructores.
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 );
}

Erick Arauco Moreno 30


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.

Erick Arauco Moreno 31


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


clase “Telefono”
distinto en cada instancia. Una
copia del atributo por cada objeto
creado.
Erick Arauco Moreno 32
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


clase “Telefono”
“contador” es compartida entre las
instancias y la clase.
Erick Arauco Moreno 33
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;

Erick Arauco Moreno 34


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.

Erick Arauco Moreno 35


3.7. Herencia

Telefono

Fijo Celular

Residencial Comercial Prim_Generacion Seg_Generacion Terc_Generacion

Erick Arauco Moreno 36


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

Erick Arauco Moreno 37


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.

Erick Arauco Moreno 38


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

Erick Arauco Moreno 39


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

Erick Arauco Moreno 40


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).

Erick Arauco Moreno 41


3.10. Paquetes

Erick Arauco Moreno 42


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.

Erick Arauco Moreno 43


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.

Erick Arauco Moreno 45


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

Erick Arauco Moreno 46


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.

Erick Arauco Moreno 47


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.

Erick Arauco Moreno 48


3.14. Promoción de argumentos – casting.

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.

Erick Arauco Moreno 49


3.14. Promoción de argumentos – casting.

 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 )

Erick Arauco Moreno 50


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

Erick Arauco Moreno 51


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

Erick Arauco Moreno 53


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.

Erick Arauco Moreno 54


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

Erick Arauco Moreno 55


3.19. Clases abstractas.

Punto Circulo Cilindro

0 1 2

¿Cómo reaccionaría cada uno de ellos ante la orden: “Calcular_Area”?

Erick Arauco Moreno 56


3.19. Clases abstractas.
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
3.19. Clases abstractas.
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";
Erick Arauco Moreno }
58
}
3.19. Clases abstractas.
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
}
3.19. Clases abstractas.
import java.text.DecimalFormat;
Figura
public class Principal {
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.

Erick Arauco Moreno 61


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.

Erick Arauco Moreno 62


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

Erick Arauco Moreno 63


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);
}
}
Erick Arauco Moreno 64
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);
}
}

Erick Arauco Moreno 65


4.1. Interfaz gráfica / cuadros de entrada y salida.

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.

Erick Arauco Moreno 66


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.

Erick Arauco Moreno 67


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

Erick Arauco Moreno 68


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”);
setLayout(new FlowLayout());
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);
}
}

Erick Arauco Moreno 69


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.

Erick Arauco Moreno 70


4.2.2.1. Gestión de eventos.

 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

Erick Arauco Moreno 71


4.2.2.1. Gestión de eventos.

 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.

Erick Arauco Moreno 72


4.2.2.1. Gestión de eventos.

 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.

Erick Arauco Moreno 73


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”);
setLayout(new FlowLayout());

cajaTexto1 = new JTextField(10);


cajaTexto1.addActionListener(this);
add(cajaTexto1);

cajaTexto2 = new JTextField(“Ingresar Texto ”);


cajaTexto2.addActionListener(this);
add(cajaTexto2);

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


cajaTexto3.setEditable(false);
cajaTexto3.addActionListener(this);
add(cajaTexto3);
}
Erick Arauco Moreno 74
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))
cadena = “Texto 2: “ +
e.getActionCommand();

else if (e.getSource().equals(cajaTexto3))
cadena = “Texto 3: “ +
e.getActionCommand();

JOptionPane.showMessageDialog(null,cadena);
}
}

Erick Arauco Moreno 75


4.2.3. JButton
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class MiAplicacion extends JFrame implements ActionListener {


private JButton boton1, boton2;

public MiAplicacion() {
super(“Usando botones”);
setLayout(new FlowLayout());

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

public void actionPerformed(ActionEvent e) {


JOptionPane.showMessageDialog(this, “Presionaste: “ +
e.getActionCommand());
}
}
Erick Arauco Moreno 76
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)

Erick Arauco Moreno 77


4.3. Clases Adaptadoras.

Clase Adaptadora Interface que implementa

ComponentAdapter ComponentListener

ContainerAdapter ContainerListener

FocusAdapter FocusListener

KeyAdapter KeyListener

MouseAdapter MouseListener

MouseMotionAdapter MouseMotionListener

WindowAdapter WindowListener

Erick Arauco Moreno 78


4.3. Clases Adaptadoras.

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class MiAplicacion extends JFrame {

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

Erick Arauco Moreno 79


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.

Erick Arauco Moreno 80


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.

Erick Arauco Moreno 81


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.

Erick Arauco Moreno 82


4.5.1. FlowLayout – BorderLayout – GridLayout.

Erick Arauco Moreno 83


4.5.2. Paneles.

Mi Primera Aplicación Java

Código:

Apellidos:

Nombres:

Nuevo Modificar Salir

Erick Arauco Moreno 84


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:

Nuevo Modificar Salir


Nuevo Modificar Salir

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.

Erick Arauco Moreno 85


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.

Erick Arauco Moreno 86


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.
import java.util.Scanner;
public class Calculadora {
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 );
}
Erick Arauco Moreno 87
}
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.

Erick Arauco Moreno 88


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

Erick Arauco Moreno 89


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.

Erick Arauco Moreno 90


5.1.1. Claúsula throws.

import java.util.Scanner;
public class Calculadora {

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

Erick Arauco Moreno 91


5.1.1. Claúsula throws.
public static void main (String args[ ]) {
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);
}
}

Erick Arauco Moreno 92


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;
}
}
}
Erick Arauco Moreno 93
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;
}
}
}

Erick Arauco Moreno 94


5.1.3. Ejemplo
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class MiAplicacion extends JFrame implements ActionListener {


private JTextField txtNombre, txtSueldo, txtSueldoNeto;
private double sueldo, sueldoNeto;

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

Erick Arauco Moreno 95


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

Erick Arauco Moreno 96


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

Erick Arauco Moreno 97


5.1.3. Ejemplo

Erick Arauco Moreno 98


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

Erick Arauco Moreno 99


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

Erick Arauco Moreno 100


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.

Erick Arauco Moreno 101


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‟

Erick Arauco Moreno 102


6.2. JTable
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class MiAplicacion extends JFrame {


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

Erick Arauco Moreno 103


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.

Erick Arauco Moreno 104


6.3. Orígenes de datos.

Erick Arauco Moreno 105


6.3. Orígenes de datos.

Erick Arauco Moreno 106


6.3. Orígenes de datos.

Erick Arauco Moreno 107


6.3. Orígenes de datos.

MiOrigen

Erick Arauco Moreno 108


6.3. Orígenes de datos.

 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.

Erick Arauco Moreno 109


6.3. Orígenes de datos.
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.sql.*;
import java.util.*;

public class MiAplicacion extends JFrame {


private Connection cn;
private Statement st;
private ResultSet rs;
private JTable tabla;

public MiAplicacion() {
super(“Accediendo a una base de datos”);
String url = "jdbc:odbc:DsnAcademico";

Erick Arauco Moreno 110


6.3. Orígenes de datos.
//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();

Erick Arauco Moreno 111


6.3. Orígenes de datos.
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);
}

Erick Arauco Moreno 112


6.3. Orígenes de datos.
tabla = new JTable(filas, cabecera);
JScrollPane panel = new JScrollPane(tabla);
add(panel, BorderLayout.CENTER);
}
catch (SQLException sqlex) {
sqlex.printStackTrace();
}
}

Erick Arauco Moreno 113


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.

Erick Arauco Moreno 114


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.

Erick Arauco Moreno 115


6.4. Modelo de datos – ModelTable.

Modelo de Datos Base de


Datos

Erick Arauco Moreno 116


6.4. Modelo de datos – ModelTable.
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;}


Erick Arauco Moreno }
117
6.4. Modelo de datos – ModelTable.

 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.

Erick Arauco Moreno 118


6.4. Modelo de datos – ModelTable.
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;
}
}

Erick Arauco Moreno 119


6.4. Modelo de datos – ModelTable.

public Object getValueAt(int rowIndex, int columnIndex) {


Persona aux;

aux = (Persona)(datos.get(rowIndex));

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

Erick Arauco Moreno 120


6.4. Modelo de datos – ModelTable.
public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
Persona aux = (Persona)(datos.get(rowIndex));
switch (columnIndex) {
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);
avisaSuscriptores (evento);
}

Erick Arauco Moreno 121


6.4. Modelo de datos – ModelTable.
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);
avisaSuscriptores (evento);
}

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

Erick Arauco Moreno 122


6.4. Modelo de datos – ModelTable.
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);
}
Erick Arauco Moreno }
123
6.4. Modelo de datos – ModelTable.
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class MiAplicacion extends JFrame implements ActionListener {


GestionTabla control;
JButton botonInserta, botonElimina;

public MiAplicacion() {
super(“Utilizando modelo de datos”);
setLayout(null);
MiModelo modelo = new MiModelo();
control = new GestionTabla (modelo);
Interfaz Gráfica JTable tabla = new JTable (modelo);
JScrollPane panel = new JScrollPane(tabla);
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);
Erick Arauco Moreno }
124
6.4. Modelo de datos – ModelTable.

public void actionPerformed(ActionEvent e) {


if (e.getSource().equals(botonInserta)) {
control.insertaFila();
} else {
control.borraFila();
}
}
}

Interfaz Gráfica

Erick Arauco Moreno 125


6.4. Modelo de datos – ModelTable.
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

Erick Arauco Moreno 126


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.

Erick Arauco Moreno 127


7.1. Modelo Vista Controlador

Modelo

Notifica
Actualiza

Evento
Vista(s) Controlador

Erick Arauco Moreno 128


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

Erick Arauco Moreno 129


7.2. Patrón Observador - Observable
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
7.2. Patrón Observador - Observable
import java.awt.*;
import java.util.*;
import javax.swing.*;
import java.awt.event.*;
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 );
Erick Arauco Moreno } 131
7.2. Patrón Observador - Observable
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() ) );
}
}

Erick Arauco Moreno 132


7.2. Patrón Observador - Observable
import java.awt.*;
import java.util.*;
import javax.swing.*;
import java.awt.event.*;

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() );
Erick Arauco Moreno } 133
}
7.2. Patrón Observador - Observable
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class Principal {


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

Erick Arauco Moreno 134


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

Erick Arauco Moreno 135


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.
Erick Arauco Moreno 136