javauis
TRANSCRIPT
-
8/6/2019 javaUIS
1/108
Introduccin
Rodrigo Lopez
-
8/6/2019 javaUIS
2/108
Table of ContentsJava a Vuelo de Pjaro.......................................................................................................................................1
Caractersticas..........................................................................................................................................1
Algo de Historia.......................................................................................................................................1
Minisintaxis de Java.................................................................................................................................2
Un Programa Java....................................................................................................................................4
Referencias...............................................................................................................................................5
Introduccin a Programacin Orientada por Objetos....................................................................................6
Especificacin de un problema................................................................................................................6
Cambio en la especificacin..............................................................................................................7
Malentendido en la especificacin....................................................................................................7
Diseo de una clase..................................................................................................................................8
Una clase no es un objeto.........................................................................................................................9
Procesamiento de Java.....................................................................................................................................10
Compilacin...........................................................................................................................................10Ejecucin................................................................................................................................................11
Empaque................................................................................................................................................11
Documentacin Javadoc........................................................................................................................12
Variables y Objetos...........................................................................................................................................13
Variables................................................................................................................................................13
Objetos...................................................................................................................................................14
Comportamiento de los Objetos......................................................................................................16
Constructores...................................................................................................................................18
Visibilidad..................... .....................................................................................................................................20Paquetes.................................................................................................................................................20
Control de Acceso.......................... ........................................................................................................21
Encapsulamiento....................................................................................................................................23
Tiempo de vida......................................................................................................................................23
Modificador final...................................................................................................................................24
Herencia y Polimorfismo..................................................................................................................................26
Polimorfismo.........................................................................................................................................27
Clases Abstractas...................................................................................................................................28
Interfaces................................................................................................................................................29
Manejo de Excepciones.....................................................................................................................................34
Definicin de Excepciones....................................................................................................................36
Encadenamiento de Excepciones...........................................................................................................36
Aserciones..............................................................................................................................................36
Conociendo el JDK...........................................................................................................................................38
java.lang.String......................................................................................................................................38
Comparaciones................................................................................................................................39
El mtodo toString()........................................................................................................................39
Manejo de Fechas..................................................................................................................................40
Introduccin
i
-
8/6/2019 javaUIS
3/108
Table of ContentsConociendo el JDK
Date.................................................................................................................................................40
Calendar...........................................................................................................................................40
Mtodos comunes a todos los objetos....................................................................................................41
toString().........................................................................................................................................41
equals()............................................................................................................................................42
hashCode().......................................................................................................................................42
clone()..............................................................................................................................................43
Colecciones.............. ..............................................................................................................................44
Arreglos...........................................................................................................................................44
Interface List....................................................................................................................................44
Interface Set.....................................................................................................................................46
Interface Map..................................................................................................................................47
Ordenamientos.................................................................................................................................48
Formateadores........................................................................................................................................49
DecimalFormat................................................................................................................................49SimpleDateFormat...........................................................................................................................50
System....................................................................................................................................................50
Receta para hashCode()...................................................................................................................................52
Entrada/Salida...................................................................................................................................................53
Flujos.....................................................................................................................................................53
java.io.InputStream................................................................................................................................53
java.io.OutputStream.............................................................................................................................53
Decoracin de flujos..............................................................................................................................56
Manejo de archivos ZIP.........................................................................................................................57Flujos de texto........................................................................................................................................58
Serializacin.......................................................................................................................................................60
Flujos de Objetos..................................................................................................................................60
Flujos de bytes......................................................................................................................................61
Flujos de caracteres...............................................................................................................................62
Archivos de Propiedades..................................................................................................................................64
El sistema de archivos.......................................................................................................................................65
Mtodos.................................................................................................................................................65Carga de Recursos..................................................................................................................................66
Swing..................................................................................................................................................................68
Historia...................................................................................................................................................68
Componentes pesados vs. Componentes livianos.................................................................................68
SWING y AWT....................................................................................................................................69
Manejo de Eventos................................................................................................................................70
Ejemplo simple...............................................................................................................................71
Un ejemplo ms complicado..........................................................................................................71
Interfaz de oyente de varios mtodos.............................................................................................72
Introduccin
ii
-
8/6/2019 javaUIS
4/108
Table of ContentsSwing
Los Eventos...........................................................................................................................................72
Construccin de event listeners............................................................................................................73
Clases internas......................................................................................................................................74
Clases internas annimas......................................................................................................................74
El patrn "Observer"..............................................................................................................................75
Java Beans y POJOs.........................................................................................................................................76
Propiedades............................................................................................................................................76
Propiedades Booleanas....................................................................................................................77
Propiedades indexadas....................................................................................................................78
Manejo de Propiedades..........................................................................................................................78
Commons BeanUtils........................................................................................................................78
Reflexin en Java...................................................................................................................................79
Paralelismo........................................................................................................................................................82MultiTasking.........................................................................................................................................82
MultiThreading......................................................................................................................................82
Threads en Java......................................................................................................................................82
Sincronizacin........................................................................................................................................84
Java 1.5...............................................................................................................................................................85
AutoBoxing............................................................................................................................................85
Enumeraciones.......................................................................................................................................85
Genericidad............................................................................................................................................87
Interfaz Iterable...............................................................................................................................89
Sorpresas.........................................................................................................................................90Import esttico.......................................................................................................................................91
Nmero variable de argumentos............................................................................................................92
Anotaciones............................................................................................................................................93
Definicin de Anotaciones..............................................................................................................94
Ejemplo...........................................................................................................................................94
Log4J..................................................................................................................................................................97
Receta Global para usar Log4J..............................................................................................................98
Arquitectura...........................................................................................................................................98
Jerarqua de Loggers.......................................................................................................................99
Niveles.............................................................................................................................................99Appenders......................................................................................................................................101
Layouts..........................................................................................................................................102
Configuracin......................................................................................................................................103
Configuracin en XML.................................................................................................................103
Introduccin
iii
-
8/6/2019 javaUIS
5/108
Java a Vuelo de Pjaro
Caractersticas
Orientado por objetos.
Cdigo mvil
Computacin basada en la red.
Write once, run everywhere.
El fuente java se compila hacia un bytecode
El bytecode es ejecutado por la Mquina Virtual de Java (JVM)
Algo de Historia
Desarrollado entre 1991 y 1995
Lanzado oficialmente en enero de 1996
Versiones:
JDK 1.02 (1996): primer lanzamiento, applets, 250 clases, lento.
JDK 1.1 (1997): reestructuracin de eventos AWT, clases internas, JavaBeans, JDBC (Java
Data base Connectivity), RMI(Remote Method Invocation), 500 clases, algo ms rpido.
J2SE 1.2 (1998): Nombre clave Playground. Tambin llamado Java 2, incluye los "sabores"
J2EE y J2ME. Palabra reservada strictfp, reflexin, Swing, compilador JIT, Java IDL,
Colecciones.
J2SE 1.3 (2000): Nombre clave Kestrel. Hotspot JVM, JNDI, JPDA (Java Platform Debugger
Architecture).
Java a Vuelo de Pjaro 1
-
8/6/2019 javaUIS
6/108
J2SE 1.4 (2002): Nombre clave Merlin, palabra reservada assert, expresiones regulares,
encadenamiento de excepciones, nuevos mecanismos de entrada/salida, API para logging,
JAXP, seguridad y extensiones criptogrficas, Java Web Start, 2300 clases.
J2SE 5.0 (2004): Nombre clave Tiger. Tipos genricos, anotaciones, autoboxing, palabra
reservada enum, nmero variable de argumentos, formatos para impresin, sintaxis mejorada
para las iteraciones for, 3500 clases.
Java SE 6 (2006): Nombre clave Mustang. Motores de lenguajes de script embebidos (Ruby,
Groof, BeanShell, Rhino), soporta las ltimas especificaciones de servicios Web (JAX-WS
2.0, JAXB 2.0, STAX y JAXP), base de datos embebida (Derby).
En el 2005 se estimaba que haba 4.5 millones de desarrolladores Java y 2.5 millones de dispositivos
habilitados con tecnologa Java.
Sun Microsystems liber una buena parte de su tecnologa Java bajo licencia GNU GPL y de acuerdo
con las especificaciones del Java Community Process.
Minisintaxis de Java
Una clase (pblica) se define en un archivo fuente cuyo nombre es igual al de la clase, con la extensin
.java
ARCHIVO Perro.java
public class Perro{
}
Una clase tiene uno o ms mtodos
ARCHIVO Perro.java
public class Perro{
public void ladrar(){
}
}
Una clase puede tener uno o ms atributos o variables de instancia.
ARCHIVO Perro.java
public class Perro{
public float peso;
public void ladrar(){
}
}
Dentro de un mtodo hay instrucciones y declaraciones de variables.
Introduccin
Algo de Historia 2
-
8/6/2019 javaUIS
7/108
ARCHIVO Perro.java
public class Perro{
public float peso;
public void ladrar(){
float volLadrido;
instr_1 ;
instr_2 ;
}
}
Toda instruccin termina en punto y coma (;)
x = x + 2;
Las variables se declaran con un nombre y un tipo
int x;
Tipos primitivos:boolean, char, byte, short, int, long, float,double.
Los comentarios en una lnea comienzan con doble slash
int x; // declara a x como entero
Iteraciones: while, for, do-while
int x = 1;
while(x (mayor que), == (igualdad), != (diferente)
boolean b = x != y;
if(a == 5) { // ...}
Operadores booleanos: ! (not), && (and), || (or)
if(a && b) { //La evaluacin de b es condicional !!
}
Introduccin
Minisintaxis de Java 3
-
8/6/2019 javaUIS
8/108
if(!a) {
}
Operadores aritmticos: +, -, *, /, %
boolean a;
a = 17 % 5 == 2;
Operadores de incremento y decremento: ++,--
int x = 8;
x++; //Incrementa a x
x--; //Decrementa a x
for(int x=1; x
Creacin de objetos de una clase: operador new
Perro mao = new Perro();
Invocacin de mtodos
Perro mao = new Perro();
mao.ladrar();
Acceso a los atributos de un objeto
Perro mao = new Perro();
float z = 34.5 + mao.peso;
Un Programa Java
Conjunto de clases.
Tpicamente un archivo fuente (.java) por clase.
La ejecucin comienza por el mtodo main de una de las clases.
Hello.java
Compilacin de un programa.
$ javac Hello.java
Introduccin
Un Programa Java 4
http://hello.java.html/ -
8/6/2019 javaUIS
9/108
Ejecucin de un programa
$ java Hello
Referencias
Head First Java (2nd edition)
Editorial O'Reilly (2005)
Kathy Sierra & Bert Bates
Thinking in Java (4th edition)
Prentice Hall (2006)
Bruce Eckel
Introduccin
Referencias 5
-
8/6/2019 javaUIS
10/108
Introduccin a Programacin Orientada por Objetos
Especificacin de un problema
Hay tres figuras en una interfaz grfica: un cuadrado, un crculo y un tringulo. Cuando elusuario da click sobre una figura, la figura debe rotar 360 grados en el sentido de las agujas
del reloj produciendo un ruido especfico para cada figura y que est grabado en un archivo
AIF.
PROGRAMADOR PROCEDIMENTAL
procedure rotar(int codForma) {
// Hacer rotar la figura de cdigo "codForma";
}
procedure hacerRuido(int codForma){
//Usar el codForma para buscar el archivo
//AIF correspondiente y hacerlo sonar.
}
PROGRAMADOR OO
class Cuadrado{
rotar() {
//rotar el cuadrado
}
hacerRuido(){
//hacer sonar el ruido del cuadrado
}
}
class Tringulo{
rotar() {//rotar el tringulo
}
hacerRuido(){
//hacer sonar el ruido del tringulo
}
}
class Crculo{
rotar() {
//rotar el Crculo
}
Introduccin a Programacin Orientada por Objetos 6
-
8/6/2019 javaUIS
11/108
hacerRuido(){
//hacer sonar el ruido del Crculo
}
}
Cambio en la especificacin
Adems hay una amiba en la pantalla. Si el usuario da click sobre ella, tambin debe rotar
pero el ruido est grabado como un archivo .HIF
PROGRAMADOR PROCEDIMENTAL
procedure rotar(int codForma) {
// Hacer rotar la forma de cdigo "codForma";
}
procedure hacerRuido(int codForma){
//if codForma no es el de la amiba
//Usar el codForma para buscar el archivo
//AIF correspondiente y hacerlo sonar.
//else//tocar amiba.hif
}
PROGRAMADOR OO
class Amiba{
rotar() {
//rotar la amiba
}
hacerRuido(){
//hacer sonar el ruido de la amiba
}}
Malentendido en la especificacin
Los programadores hicieron rotar cada figura as:
Se determina el rectngulo que circunscribe a la figura.
Se hace rotar el rectngulo alrededor de su centro.
Introduccin
Especificacin de un problema 7
-
8/6/2019 javaUIS
12/108
pero:
La amiba debe rotar alrededor de su "extremo derecho".
PROGRAMADOR PROCEDIMENTAL
procedure rotar(int codForma) {
// if la forma no es una amiba// calcule el centro del rectangulo
// then rote
// else
// Calcule las coordenadas del extremo derecho
// then rote
}
procedure hacerRuido(int codForma){
//if codForma no es el de la amiba
//Usar el codForma para buscar el archivo
//AIF correspondiente y hacerlo sonar.
//else
//tocar amiba.hif}
PROGRAMADOR OO
Abstrae las cosas comunes a las figuras y las coloca en una nueva clase "Forma"
Forma es la superclase de las otras 4 clases.
Las otras cuatro son subclases de Forma.
Las subclases heredan los mtodos de la superclase.
Diseo de una clase
Hay que pensar en las caractersticas de los objetos de esa clase:
Aquello que el objeto conoce (sabe acerca de s mismo):
Atributos, variables de instancia, variables de estado.
Introduccin
Malentendido en la especificacin 8
-
8/6/2019 javaUIS
13/108
Suelen tener valores diferentes para cada objeto o instancia de la clase.
Pueden influir en el comportamiento del objeto.
Las cosas que hace:
Mtodos (comportamiento).
class Perro {
tamao;
raza;
nombre;
ladrar() {
}
}
Una clase no es un objetoUna clase define una categora (un tipo) de objetos.
Es un patrn para la construccin de los objetos (instancias) de esa clase.
Cada objeto puede tener sus propios valores para los atributos o variables de instancia.
Todos los objetos comparten los mismos mtodos
Juego de adivinanza
Introduccin
Diseo de una clase 9
http://iniciadorjuego.java.html/ -
8/6/2019 javaUIS
14/108
Procesamiento de Java
Dos escenarios tpicos: compilacin y ejecucin
JDK: Java Development Kit.
JRE: Java Runtime Environment.
Compilacin
El compilador requiere tener acceso a todas las clases o interfaces (fuentes o compiladas) mencionadas
explcitamente en los fuentes.
$ javac -classpath ./uis:../lib/api.jar \
-d ./bin ./fuentes/*.java
El classpath de compilacin es uno de los dolores de cabeza de todos los programadores Java
Procesamiento de Java 10
-
8/6/2019 javaUIS
15/108
Las libreras (.jar) pertenecientes al JRE se encuentran implcitamente dentro del classpath
Ejecucin
Todas las clases que deban ser cargadas durante la ejecucin de un programa deben ser accesibles por la
Mquina Virtual.
Las clases pertenecientes a las libreras del JRE son accesibles.
Las dems libreras/clases deben ser especificadas en el classpath de ejecucin
Las clases se van cargando a medida que se requieren.
$ java -classpath ./bin:../lib/api.jar:../lib/jakarta.jar \
com.cincosoft.Facturacion
El classpath de ejecucin es una fuente inagotable de sorpresas
ClassNotFound !!
El mismo programa a veces falla y a veces no.
Empaque
Es cmodo empacar el conjunto de clases y otros recursos de un programa (o de una librera) en un archivo.
$ jar -cf miapplicacion.jar *.class
Usa el formato ZIP.
Incluye un archivo MANIFEST.MF
Se puede descomprimir.
$ jar -xvf miapplicacion.jar
Un programa se puede ejecutar en formato jar.
$ java -classpath miapplicacion.jar Miclase
$ java -jar miapplicacion.jar
Dentro del MANIFEST.MF se especifica la clase que contiene el mtodo main
Archivo MANIFEST.MF
Main-Class : miclase
Introduccin
Compilacin 11
-
8/6/2019 javaUIS
16/108
Documentacin Javadoc
Javadoc genera documentacin en formato Html a partir de comentarios /** ... */.
Vlido para clases, atributos y mtodos.
Crea referencias "vivas" entre los miembros de las clases documentadas.
Permite referenciar documentos html arbitrarios: documentacin de paquetes o de toda una
aplicacin.
$ javadoc [ options ] [ packagenames ] [ sourcefilenames ]
Juego de adivinanza
Javadoc
Las herramientas de procesamiento estndar se usan ms cmodamente desde ANT que desde la lnea decomandos.
Introduccin
Documentacin Javadoc 12
http://iniciadorjuego.java.html/http://index.html/http://iniciadorjuego.java.html/ -
8/6/2019 javaUIS
17/108
Variables y Objetos
Variables
Se declaran con un tipo y un nombre.
int x;
Rueda r;
float _Nombre_1;
La variable siempre conserva su tipo pero puede cambiar de valor mediante la asignacin
int x = 5;
x = 8;
byte b;
b = x; //error!!
x = (int) 17.4;
Las variables pueden verse como contenedores de valores.
Pueden aparecer como:
Atributos de clase.
Variables locales de un mtodo.
Argumentos de un mtodo.
Solamente pueden almacenar dos tipos de valores.
Valores primitivos.
Referencias a objetos.
Joystick j = new Joystick();
Rueda r = new Rueda();
Variables y Objetos 13
-
8/6/2019 javaUIS
18/108
Las variables no almacenan objetos.
Las variables se asignan, por valor (por copia).
int x = 5;
int y;y = x; //tanto x como y contienen el valor 5
Rueda r = new Rueda();
Rueda t;
t = r; // r y t referencian al mismo objeto Rueda.
Joystick j = new Joystick();
j = r //error!!
Las variables locales y los argumentos de los mtodos "viven" en el stack de ejecucin de la mquina
virtual.
Se crean al entrar (en ejecucin) al mtodo que las contiene.
Se destruyen al salir del mtodo que las contiene.
Objetos
Viven en el "heap".
Son de tamaos diferentes
Pueden contener referencias a otros objetos (variables)
Introduccin
Variables 14
-
8/6/2019 javaUIS
19/108
class Casa {
Puerta p = new Puerta();
}
::::
Casa c = new Casa();
Pueden convertirse en basura y ser recogidos por el garbage collector
void abrir(){
Casa c= new Casa();
c.p = null //la puerta se convierte en basura !!
} //Al salir toda la casa es basura !!
Los arreglos son objetos.
int [] nums;
nums = new int[5];
Perro [] p = new Perro[3];
p[2] = new Perro();
Introduccin
Objetos 15
-
8/6/2019 javaUIS
20/108
String [] islas = {"Baru", "Gorgona"};
Los arreglos tienen longitud (el nmero de valores que contienen).
String [] islas = {"Baru", "Gorgona"};
for(int i =0; i 25 ){
Introduccin
Comportamiento de los Objetos 16
-
8/6/2019 javaUIS
21/108
System.out.printl("Woof, Woof");
}
else if (peso > 15) {
System.out.printl("Ruff, Ruff");
}
else {
System.out.printl("Guau, Guau");
}
}
}
Los mtodos pueden tener parmetros
class Perro{
int peso;
String nombre;
void ladrar() {
if(peso > 25 ){
System.out.printl("Woof, Woof");
}
else if (peso > 15) {
System.out.printl("Ruff, Ruff");
}
else {
System.out.printl("Guau, Guau");
}
}
void ladrar(int numLadridos) {
while (numLadridos > 0) {
ladrar();
numLadridos--;
}
}
void setPeso(int p) {
peso = p;
}
}
::::
Perro p = new Perro();
p.setPeso(18);
p.ladrar(5);
Los mtodos pueden retornar un valor:
Hay que declarar el tipo del valor de retorno.
Es obligatorio "retornar" un valor del tipo declarado (o compatible con l)
int darNumero() {
return 42;
}
:::
int valor = obj.darNumero();
long largo = obj.darNumero();
Introduccin
Comportamiento de los Objetos 17
-
8/6/2019 javaUIS
22/108
Constructores
Los constructores son unos mtodos especiales cuya labor es construir los objetos (instancias) de la clase a la
cual pertenecen:
Su nombre es exactamente igual al nombre de la clase.
No especifican el tipo del valor de retorno.
Pueden tener parmetros.
public class Perro{
int peso;
String nombre;
public Perro(int p, String nombre) {peso = p;
this.nombre = nombre
}
}
:::
Perro p = new Perro(16,"Mao");
Si no se define ningn constructor, se supone que hay un constructor sin parmetros
public class Perro{
int peso;
String nombre;
}
:::
Perro p = new Perro();
Si se define algn constructor y se requiere el constructor sin parmetros, es obligatorio definirlo
public class Perro{
int peso;
String nombre;
public Perro(int p, String nombre) {peso = p;
this.nombre = nombre
}
}
::::
Perro p = new Perro(); // error!! (constructor indefinido)
public class Perro{
int peso;
String nombre;
Introduccin
Constructores 18
-
8/6/2019 javaUIS
23/108
public Perro() { }
public Perro(int p, String nombre) {
peso = p;
this.nombre = nombre
}
}
::::
Perro p = new Perro(); // OK
Introduccin
Constructores 19
-
8/6/2019 javaUIS
24/108
Visibilidad
Uno de los beneficios de la programacin Orientada por Objetos es la posibilidad de reutilizacin del
software.
No es conveniente que todo est disponible para ser reutilizado.
Si el comportamiento de un objeto depende de su estado, es crucial poder garantizar que el estado no
se altera "por descuido" o por ignorancia (del programador).
Es conveniente poder limitar el acceso a las variables, a los mtodos y a las clases.
Paquetes
Un paquete es un conjunto de clases. Las clases que tienen un propsito comn suelen agruparse en un
paquete.
Cada clase declara el paquete al cual pertenece.
La declaracin deber ser la primera lnea (distinta de comentario) del archivo fuente.
Si no se declara paquete, la clase pertenece al paquete annimo
El nombre del paquete hace parte del nombre de las clases que pertenecen al paquete.
package animales;
public class Perro{
:::}
public class Prueba{
public static void main(String[] args){
animales.Perro p = new animales.Perro();
Perro can = new Perro(); //error!! la clase Perro no pertenece
//al paquete anonimo
}
}
Los nombres de los paquetes suelen tener identificadores separados por un punto.
package com.cincosoft;
package com.cincosoft.utils;
package org;
Cuando se compila un conjunto de archivos fuente java, los archivos .class generados se almacenan en una
jerarqua de directorios-subdirectorios que refleja la estructura de los nombres de los paquetes declarados en
los fuentes.
Visibilidad 20
-
8/6/2019 javaUIS
25/108
No existe la nocin de subpaquete!!.
Algunos IDE's exigen organizar los fuentes reflejando la estructura de los paquetes.
Control de Acceso
Todos los atributos y mtodos de una clase son accesibles dentro del cuerpo de la clase.
Las clases del mismo paquete son visibles entre s.
package entes;
class Perro { }
package entes;class Joystick {
void metodo() {
Perro p = new Perro();
}
}
Modificadores de acceso (visibilidad):
public: ampla la visibilidad hacia afuera del paquete.
Introduccin
Paquetes 21
-
8/6/2019 javaUIS
26/108
package animales;
public class Perro {
public int peso;
:::
public void ladrar() {
}
}
package devices;
import animales.Perro;
class Joystick {
void metodo() {
Perro p = new Perro();
p.peso = 18;
p.ladrar();
}
}
private: restringe la visibilidad estrictamente al interior de la clase.
package entes;
public class Joystick {
private Baston baston;
private void metodo() {
Perro p = new Perro();
baston = null;
BolitaJS bol = new BolitaJS();
}
private class BolitaJS {
}
}
protected: visible dentro del mismo paquete y en las subclases de la clase en donde se
declara (sin importar el paquete al que pertenezcan).
package figuras;
public class Circulo {
protected double radio;
protected double area() {
}
}
package trigonometricas;
public class CirculoUnitario
extends Circulo{
public float metodo(){
this.radio;
}
Introduccin
Control de Acceso 22
-
8/6/2019 javaUIS
27/108
}
: visible dentro del paquete pero inaccesible por fuera del paquete
(visibilidad "de paquete").
EncapsulamientoEn general, no es buena idea permitir acceso a los atributos de una clase que determinan aspectos cruciales del
estado de los objetos.
Deben declararse privados.
Se permite el acceso en lectura o en escritura mediante mtodos pblicos.
public class Persona {
private Date nacimiento;
private String nombre;
public Persona (Date d, String s){
this.nacimiento = d;
this.nombre = s;
}
public Date getNacimiento(){
return nacimiento;
}
public void setNombre(String s){
nombre = s;
}
public String getNombre(){
return nombre;
}
}
Tiempo de vida
Durante la ejecucin de un programa, las variables y los objetos aparecen (se les reserva memoria) y
desaparecen (se eliminan del stack o se recogen como basura).
Las variables de instancia (atributos) existen mientras exista el objeto al cual pertenecen.
Modificador static: hace el tiempo de vida independiente de las instancias. La vida comienza
cuando se usa por primera vez la clase en la que aparece la variable o mtodo static (parecido a
"variables globales").
public class Vaso {
public static int numVasos = 0;
private Forma forma;
public Vaso() {
Introduccin
Encapsulamiento 23
-
8/6/2019 javaUIS
28/108
numVasos++;
:::
}
}
public class Comedor {
private Comedor (int n) {
}
public static Comedor init() {
:::
Comedor c = new Comedor(3);
:::
return c;
}
}
public class Casa {
public Casa () {
if(Vaso.numVasos > 0) {Comedor c = Comedor.init();
}
}
public class Ensayo {
private int x = 5;
int calcular() {
}
public static void main(String [] args){
x = 3; //error: x es variable de instancia
calcular(); //error: calcular() es metodo de instancia
}
}
public class Vaso {
public static int numVasos;
private Forma forma;
static {
numVasos = (int) (Math.random() * 26);
}
public Vaso() {
numVasos++;
:::
}
}
Modificador final
Impide la modificacin de la variable, mtodo, clase al cual modifica:
Introduccin
Tiempo de vida 24
-
8/6/2019 javaUIS
29/108
public final class Inmutable { //No se puede extender
}
public class Nueva extends Inmutable { //error!!. Inmutable es final
}
final String saludo = "Hola";
saludo = "Hello"; //error!! saludo es final
public static final double MAX_VOL = 35.8; //Constante de clase
public class AparatoElectrico {
public final void prender() {//no se puede redefinir
conectarCorriente();
}
}
public class Licuadora extends AparatoElectrico{
public void prender() {//error!! prender es final
}
}
Introduccin
Modificador final 25
-
8/6/2019 javaUIS
30/108
Herencia y Polimorfismo
La subclase hereda los atributos y mtodos de su superclase (a menos que sean privados)
La subclase no hereda los constructores de la superclase pero tiene acceso a ellos.
La subclase extiende la superclase.
Agrega atributos.
Redefine mtodos
Agrega mtodos.
Todas las clases de un programa Java heredan implcitamente de la superclase
java.lang.Object
public class Doctor {
boolean trabajaEnHospital;
void tratarPaciente () {
// hace revision medicas
}
}
public class MedicoFamiliar extends Doctor {boolean visitarDomicilio;
public MedicoFamiliar(boolean domicilios) {
super();
visitarDomicilio = domicilios;
}
void darConsejos() { //Mtodo agregado
}
}
Herencia y Polimorfismo 26
-
8/6/2019 javaUIS
31/108
public class Cirujano extends Doctor {
void tratarPaciente () { //Mtodo redefinido
// hace cirujias
}
void suturar() {
}
}
Polimorfismo
Una variable del tipo de la superclase puede almacenar referencias a instancias de sus subclases.
Doctor doc = new Doctor();
Cirujano cir = new Cirujano();
MedicoFamiliar mf = new MedicoFamiliar();
doc = cir; //Un doctor puede ser un cirujano
doc.tratarPaciente(); //El doctor hace cirujias
doc = mf; //Un doctor puede ser un mdico familiar
doc.tratarPaciente(); //El doctor hace una revisin mdica
cir = doc; //error !! Un doctor no necesariamente
//es un cirujano
cir = (Cirujano) doc; //Como este doctor es un cirujano, OK
if (doc instanceof Cirujano) {
cir = (Cirujano) doc;}
La herencia, combinada con el polimorfismo permite:
Ahorrar cdigo (evitando las duplicidades).
Ahorrar muchos if's.
Agregar ordenadamente muchos casos nuevos.
public class Neurocirujano extends Cirujano {
public void tratarPaciente() {
//operar con laser
}
}
Cirujano cir;
Doctor doc;
NeuroCirujano nc = new NeuroCirujano();
doc = nc;
cir = nc;
Introduccin
Polimorfismo 27
-
8/6/2019 javaUIS
32/108
doc.tratarPaciente(); // Opera con laser
cir.tratarPaciente(); // Opera con laser
En la prctica, las jerarquas de herencia no son muy profundas. Tres niveles es bastante.
Clases Abstractas
A veces, puede no tener sentido tener instancias de una clase. Los doctores pueden compartir muchas cosas
(nominalmente) pero para cada uno, tratar al paciente es algo muy diferente.
El MedicoFamiliar lo ausculta y receta.
El Cirujano lo opera.
abstract class Doctor {
boolean trabajaEnHospital;
public abstract void tratarPaciente();
public void darConsejos() { //Metodo concreto
}
}
class MedicoFamiliar extends Doctor {// Clase concreta
public void tratarPaciente() {
// Ausculta y receta
}
}
class Urologo extends Doctor {//error!!. Urologo es abstracto
void darConsejos() {
Introduccin
Clases Abstractas 28
-
8/6/2019 javaUIS
33/108
}
}
abstract class Cirujano extends Doctor {
void suturar() {// Metodo concreto
//cose con hilo encerado
}
}
class Plastico extends Cirujano { //Clase concreta
void tratarPaciente() {
// hacer injertos
}
}
class NeuroCirujano extends Cirujano { //Clase concreta
void tratarPaciente () {
// opera con laser
}
void suturar () {
// sutura con laser
}
}
:::
new Doctor().darConsejos(); // error!! Doctor es abstracto
Doctor doc;
Cirujano cir;
cir = new Plastico();
cir.suturar(); // Cose con hilo encerado
doc = new Neurocirujano();
doc.suturar();
cir.tratarPaciente();
Interfaces
Un programa java es un conjunto de clases, e instancias de clases, interactuando mediante la ejecucin de
mtodos.
Cada clase puede considerarse como un servidor y los servicios ms amplios que ofrece son sus mtodos
pblicos. Ellos establecen un protocolo preciso (valor de retorno, parmetros que espera) de cmo deben ser
utilizados por sus clientes.
Ese conjunto de mtodos se denomina (en programacin OO) la interfaz de la clase.
En Java, una interfaz es un conjunto de servicios.
public Iterface Sacristan {
Introduccin
Interfaces 29
-
8/6/2019 javaUIS
34/108
public final int EDAD_MINIMA = 55;
public void sonarCampanas();
public void recogerLimosna();
}
Una interfaz define un tipo.
Una interfaz no se instancia.
Una interfaz puede contener mtodos y atributos
Los atributos son implcitamente final y static.
Los mtodos son implcitamente public.
Una interfaz puede ser implementada por una clase: debe definir todos los mtodos de la interfaz
Una interfaz se puede extender mediante herencia.
class Paisano implements Sacristan {
public void sonarCampanas() {
}
public void recogerLimosna(){
}
}
class NeuroCirujano extends Doctor implements Sacristan {
//Todos los atributos y metodos de Neurocirujano:::
public void sonarCampanas() {
}
public void recogerLimosna(){
}
}
Sacristan sac;
sac = new Sacristan(); // error!!
NeuroCirujano nc = new NeuroCirujano();
sac = nc;
nc.sonarCampanas(); // error!!
sac.sonarCampanas();
Sacristan sac1 = new Paisano();
public void hacerOficio(Sacristan s) {
s.sonarCampanas();
s.recogerLimosma();
Introduccin
Interfaces 30
-
8/6/2019 javaUIS
35/108
}
hacerOficio(new Paisano());
hacerOficio(new NeuroCirujano());
public Sacritan escoger() {
if ( ...) {
return new Paisano();
}
else {
return new NeuroCirujano();
}
}
En java, una interfaz es muy parecida a una clase abstracta.
public abstract class SacristanAbs {
public final int EDAD_MINIMA = 55;
public abstract void sonarCampanas();
public abstract void recogerLimosna();
}
public class Paisano extends SacristanAbs{
public void sonarCampanas() {
}
public void recogerLimosna(){
}
}
SacristanAbs sac = new Paisano();
sac.sonarCampanas();
//Pero no hay modo de que un NeuroCirujano sea
//un SacristanAbs!!
class NeuroCirujano extends Cirujano
extends SacristanAbs {//error!!
}
En general:
Se define una clase abstracta A y una subclase B, si puede decirse que un B es siempre un A (Un
NeuroCirujano es un Cirujano)
Se define una interfaz A si se quiere que distintas clases puedan JUGAR EL ROL de A (Un
NeuroCirujano puede jugar el rol de Sacristn)
public class NeuroCirujano extends Cirujano
implements Sacristan
implements Peluquero {
Introduccin
Interfaces 31
-
8/6/2019 javaUIS
36/108
::::
}
public class Madre implements Peluquero {
}
public class Paisano implements Peluquero {
}
BUENA PRACTICA
Es mejor programar contra interfaces que contra clases concretas
LinkedList lista = new LinkedList();
proceso(lista);
public void proceso(LinkedList lis) {
int i;
:::
lis.get(i);
}
LinkedList lista = new LinkedList();
::
proceso(lista);
::
public void proceso(LinkedList lis) {int i;
:::
while(..){
::
lis.get(i);//Se ejecuta varias veces
}
}
List lista = new ArrayList();
//List lista = new LinkedList();
::
proceso(lista);
::
public void proceso(List lis) {
int i;
:::
while(..){
lis.get(i);//Se ejecuta varias veces
}
}
Programando contra interfaces es menos traumtico cambiar la implementacin de los servicios.
Introduccin
Interfaces 32
-
8/6/2019 javaUIS
37/108
-
8/6/2019 javaUIS
38/108
Manejo de Excepciones
Una excepcin es una indicacin de que una situacin excepcional se ha presentado o de que un error ha
ocurrido.
Se lanza una excepcin para indicar la situacin excepcional.
throw expresion;
Atraparuna excepcin es manejarla: tomar las acciones necesarias para recuperarse de ella.
try {
//Alguna instruccin lanza una excepcin
}catch (Exceptione) {
//Tratamiento de la excepcion
}
Ejemplo
Las excepciones son objetos.
Las "CheckedExceptions" que no sean atrapadas deben ser declaradas.
public String readFirstLine(String filename)
throws IOException {
Manejo de Excepciones 34
http://aritmetica.java.html/http://aritmetica.java.html/http://aritmetica.java.html/ -
8/6/2019 javaUIS
39/108
BufferedReader in =
new BufferedReader(
new FileReader(filename));
return in.readLine();
}
Acciones al lanzar una excepcin:
Se interrumpe la ejecucin del try en donde se lanza.
Se contina la ejecucin en el primer catch que atrape la excepcin lanzada o una superclase
de ella.
try {
String s = readFirstLine("miarchivo.txt");
}
catch(IOException e){
System.out.println(e.getMessage);
}
try {
String s = readFirstLine("miarchivo.txt");
}
catch(Exception e){// Atrapa cualquier excepcion
e.printStackTrace();
}
A veces es necesario ejecutar una accin independientemente de si se lanza o no una excepcin
try {
dbConnection = DAOUtil.getDBConnection(datasource);
ps = dbConnection.prepareStatement(sbf.toString());
ps.setString(1,countryId);
ps.executeQuery();
rs = ps.getResultSet();
while (rs.next()) {
State state = new State();
state.setId(rs.getLong(1));
state.setCountryId(rs.getString(2));
state.setCode(rs.getString(3));
state.setName(rs.getString(4));resp.add(state);
}
}
catch (Exception ae) {
logger.error("Error loading states", ae);
throw new DAOException(ServicingExceptionMessage.PROBLEM_LOADING_STATES
+ ae.getMessage());
}
finally {
DAOUtil.closeResultSet(rs);
DAOUtil.closePreparedStatement(ps);
Introduccin
Manejo de Excepciones 35
-
8/6/2019 javaUIS
40/108
DAOUtil.closeConnection(dbConnection);
}
Definicin de Excepciones
Se pueden definir excepciones extendiendo la clase Exception.
Le da claridad a los programas.
public class PharosException extends Exception{
public PharosException(){}
public PharosException(String s){
super(s);
}
}
public class SearchException extends PharosException {
public SearchException(String msg){super(msg);
}
public SearchException(){}
}
public class NullTaggedValueException extends PharosException{
public NullTaggedValueException(){}
public NullTaggedValueException(String s){
super(s);
}
}
if(tgVal==null || tgVal.getValue()==null){
throw new NullTaggedValueException();
}
Encadenamiento de Excepciones
Es frecuente atrapar una excepcin y, acto seguido, lanzar otra.
Es muy valioso conservar informacin acerca de la excepcin atrapada originalmente
catch (Exception ae) {
logger.error("Error loading states", ae);
throw new DAOException(ae);
}
Aserciones
Mecanismo para verificar dinmicamente el estado de un programa, lanzando excepciones si el estado no es el
que se espera.
Introduccin
Definicin de Excepciones 36
-
8/6/2019 javaUIS
41/108
-
8/6/2019 javaUIS
42/108
-
8/6/2019 javaUIS
43/108
String z = "Este es" + " un letrero"; //
Es una fuente frecuente de basura.
"algo"+"de"+"basura";
procesar("algo".toUpperCase());
Comparaciones
De identidad: decide si dos valores son iguales.
Estructural (mtodo) equals: decide si dos objetos son iguales con un criterio propio de la clase a la
cual pertenece el objeto.
Implementa la interfaz Comparable.
String z = "Este es" + " un letrero";
"Este es un letrero" == z ; //false !!
"Este es un letrero".equals(z); //true
"casa".compareTo("perro") ; // 0
El las comparaciones entre cadenas es bueno apoyarse en los literales para evitar
"NullPointerException".
String x;:::
if(z.equals("casa")) { //peligroso !!
}
if("casa".equals(z)) { //recomendable
}
El mtodo toString()
Muchos mtodos (de muchas clases) cuando reciben un Object como argumento, usan el servicio toString()
para convertir el objeto en una cadena de caracteres.
Es bueno que cada clase redefina el mtodo.
Al hacerlo, es conveniente cuidarse de la produccin de basura.
String s = "Esta " + "es " + "una " + "cadena";
Introduccin
java.lang.String
-
8/6/2019 javaUIS
44/108
Persona p = new Persona();
System.out.println(p);
System.out.println("persona = "+p);
FeeAssessment
BUENA PRACTICACuando hay mltiples concatenaciones es mejor usar StringBuffer o StringBuilder que
String para evitar producir basura.
StringBuffer sbf = new StringBuffer();
sbf.append("assessedAmount = ");
sbf.append(assessedAmount);
sbf.append(sep);
sbf.append("paidAmount = ");
sbf.append(paidAmount);
sbf.append(sep);
:::
return sbf.toString();
Manejo de Fechas
Clases java.util.Date, java.util.Calendar y java.text.SimpleDateFormat.
Date
Representa el tiempo como el nmero de milisegundos a partir del 1 de enero de 1970
Implementa la interfaz Comparable
Date d = new Date(); //Crea fecha en el instante actual.
Date f;
d.before(f);
d.after(f);
d.compareTo(f);
Para interactuar con bases de datos se usa la clase java.sql.Date que permitealmacenar/extraer fechas com mayor precisin que java.util.Date
Calendar
Clase abstracta que permite manejar cmodamente (mediante constantes enteras) las nociones de dia, hora,
mes, ao, etc .. que se encuentran dentro de una fecha.
Las subclases de Calendar interpretan un Date de acuerdo con las reglas de un calendario especfico.
Introduccin
El mtodo toString() 40
http://feeassessment.java.html/ -
8/6/2019 javaUIS
45/108
-
8/6/2019 javaUIS
46/108
equals()
Conviene redefinirlo cuando hay una nocin de igualdad lgica que va ms all de la simple
identidad de campos.
Nodo
hashCode()
Calcula un entero que puede usarse como la "identificacin" del objeto.
Contrato hashCode
A- Siempre que se invoque sobre el mismo objeto, en la misma ejecucin de un programa,
debe producir el mismo valor a menos que se haya cambiado uno de los atributos que
intervienen en el clculo de equals(). El entero calculado no tiene que ser el mismo paradiferentes ejecuciones del mismo programa.
B- Si dos objetos son iguales, en el sentido equals(), el mtodo hashCode() debe
producir el mismo valor para ambos.
C- No se requiere que dos objetos no iguales, en el sentido equals(), tengan hashCode
diferente. Sin embargo, producir hascodes distintos para objetos diferentes puede mejorar el
desempeo de las estructuras basadas en tablas de hash.
Receta
Ejemplo
Es obligatorio redefinirlo si se ha redefinido equals()
No hacerlo es fuente de inconsistencias en el uso de las "colecciones" Java, pues fcilmente
se viola la clusula B del "contrato".
Map map = new HashMap();
map.put(new Fee("Mora",234), "Carlos");
String s = (String)
Introduccin
equals() 42
http://fee.java.html/http://nodo.java.html/ -
8/6/2019 javaUIS
47/108
map.get(new Fee("Mora",234)); // Retorna null si no se
// redefine hashCode() !!
clone()
Mtodoprotected de la clase Object que fabrica una copia (bit por bit) del objeto.
Su ejecucin es lcita nicamente sobre clases que implementen la interfaz Cloneable
La copia bit a bit puede ser peligrosa.
Casi siempre hay que redefinirlo:
Por ser protected puede no ser accesible.
public class Puerta{
}
public class Casa {
Puerta p;
void copiarPuerta(){
Puerta q = (Puerta)p.clone(); //error !!
}
}
public class Puerta implements Cloneable{
public Object clone() {
try {
return super.clone();
}
catch(CloneNotSupportedException e) {
throw new Error("Ooops"); // No puede pasar
}
}
}
Con frecuencia se requieren copias "estructurales" de los objetos.
Introduccin
hashCode() 43
-
8/6/2019 javaUIS
48/108
Nodo
Colecciones
Infraestructura Java para manejar grupos de objetos:
Arreglos
Vectores, Listas, Conjuntos.
Maps
Arreglos
Todos los elementos son del mismo tipo.
Pueden almacenar valores primitivos u objetos.
Interface List
Ofrece servicios para manejar listas de objetos. Los objetos pueden ser de tipos diferentes. Las posiciones se
cuentan a partir de cero.
boolean add(Object o): agrega un objeto al final de la lista.
Object get(int i): retorna el objeto en la posicin i de la lista.
boolean add(int i, Object o): inserta un objeto en la posicin i de la lista, por el objeto
o.
Object set(int i, Object o): Cambia el objeto de la posicin i de la lista.
boolean contains(Object o): retorna true si el objeto o est en la lista.
int indexOf(Object o): retorna el ndice en donde se encuentra el objeto o, o -1 si no se
encuentra.
int size(): retorna el nmero de elementos en la lista.
Introduccin
clone() 44
http://nodo.java.html/ -
8/6/2019 javaUIS
49/108
boolean isEmpty(): retorna true si el nmero de elementos en la lista es 0.
Object remove(Object o): elimina de la lista la primera aparicin del objeto o.
Object remove(int i): elimina de la lista el objeto de la posicin i.
Object [] toArray(): retorna un arreglo de objetos que contiene los mismos elementos de lalista.
Iterator iterator(): retorna un iterador sobre los elementos de la lista.
IMPLEMENTACIONES
ArrayList: Se comporta como un arreglo de tamao variable. El acceso a cada elemento se
hace en tiempo constante.
LinkedList: Se comporta como una lista encadenada. El acceso a cada elemento es
secuencial.
List lista = new ArrayList();
lista.add(new Puerta());
lista.add(new Casa());
Casa c = (Casa)lista.get(1);
Para almacenar valores de los tipos primitivos en una lista (u otras colecciones) se usan las clases
"envolventes" o wrappers:
Boolean
Byte
Character
Integer
Long
Double
Float
List lis = new LinkedList();
lis.add(new Integer(4)); //wrapper de enteros
lis.add(new Boolean(true));
boolean b = ((Boolean)lis.get(1)).booleanValue();
Es muy frecuente que los elementos de una lista sean del mismo tipo
List lista = new LinkedList();
lista.add(new Integer(1));
Introduccin
Interface List 45
-
8/6/2019 javaUIS
50/108
lista.add(new Integer(5));
lista.add(new Integer(3));
for(int i=0; i
-
8/6/2019 javaUIS
51/108
Representa la nocin matemtica de conjunto.
Servicios
boolean add(Object o): agrega el objeto o al conjunto, a menos que ya se encuentre en l.
boolean contains(Object o): retorna true si el objeto se encuentra en el conjunto.
boolean isEmpty(): retorna true si el conjunto est vaco.
boolean remove(Object o): elimina al objeto o del conjunto, si est presente en l.
int size(): retorna el nmero de elementos del conjunto.
Iterator iterator(): retorna un iterador sobre los elementos del conjunto.
Implementaciones
HashSet: basada en tablas de hashing. Admite el elemento nulo. Garantiza tiempo constante para las
operaciones bsicas.
Muy sensible al "contrato de hashCode()"
Set conj = new HashSet();
conj.add(new Fee("Mora",234));
conj.contains(new Fee("Mora",234)); // Retorna null si no se
// redefine hashCode() !!
TreeSet: Admite el elemento nulo. Mantiene los elementos ordenados ascendentemente segn el
orden natural. No garantiza tiempo igual para las operaciones bsicas.
Set conj = new TreSet();
conj.add(new Fee("Mora",234));
conj.add(new Fee("Cheque devuelto", 500));
for (Iterator iter = conj.iterator(); iter.hasNext();) {
Fee fee = (Fee) iter.next();
:::
}
Interface Map
Mantiene un conjunto de parejas en donde tanto la llave como el valor son objetos. En
general, null no puede ser una llave y en algunas implementaciones no puede ser un valor.
Suele usarse como estructura de datos asociativa.
Servicios
Introduccin
Interface Map 47
-
8/6/2019 javaUIS
52/108
Object put(Object llave, Object valor): asocia la llave con el valor en este map.
Retorna el valor asociado.
Object get(Object llave): retorna el valor asociado cn la llave, si est presente.
Object remove(Object llave): elimina del map la asociacin para esta llave.
Set keySet(): retorna el conjunto de las llaves del map.
Set entrySet(): retorna el conjunto de asociaciones del map. Cada asociacin es de tipo
Map.Entry
boolean isEmpty(): retorna true si el map est vaco.
int size(): retorna el nmero de asociaciones en el map.
Implementaciones
HashMap: basada en hash tables. Garantiza tiempo constante en las operaciones de acceso. Sensible
al contrato de hashcode.
TreeMap: mantiene las llaves ordenadas ascendentemente, segn el orden natural de la clase de las
llaves.
BUENA PRACTICA
En el peor de los casos una coleccin es vaca. Jams nula.
List l; //peligroso
List lista = new ArrayList();
Ordenamientos
Las colecciones tienen capacidades implcitas de ordenamiento, siempre y cuando los objetos que almacenan
pertenezcan a clases que implementan la interfaz Comparable.
Implementan el mtodo int compareTo(Object o); el cual define un orden natural para los
objetos de la clase. El resultado de o1.compareTo(o2);se interpreta as:
positivo significa o1 mayor-que o2
cero significa o1 igual-a o2
negativo significa o1 menor-que o2
FeeAssessment
FeeAssessment [] arrFass;
:::
Arrays.sort(arrFass); //ordena ascendentemente
BUENA PRACTICA
Introduccin
Ordenamientos 48
http://feeassessment.java.html/ -
8/6/2019 javaUIS
53/108
Implementar la interface Comparable.
La clase gana mucho, con poco esfuerzo.
La mayora de las clases del JDK la implementan.
SortWordsFeeAssessment [] arrFass;:::
Arrays.sort(arrFass); //ordena ascendentemente
FeeAssessment fass;
:::
int i = Arrays.binarySearch(arrFass, fass);
// i > 0 => fass se encuentra en la posicion i
// i i = -(punto de insercin) - 1
List fassList = new ArrayList(); //Lista de FeeAssessments
:::
FeeAssessment fass = Collections.max(fassList);
Formateadores
Hay formateadores para nmeros y fechas.
Su comportamiento depende del "Locale" escogido.
El Locale por defecto es < en, US >.
DecimalFormat
Subclase de NumberFormat que formatea y lee (hace parsing) de nmeros decimales. Maneja formatos para:
Enteros (123)
Punto fijo (12.3)
Notacin cientfica (1.23 E1)
Porcentajes (12.3%)
Dinero ($12.3)
String MONEY_FORMAT =
"###,###,##0.00";
String PERCENTAGE_FORMAT =
"###,###,##0.000000";
DecimalFormat mnf =
Introduccin
Formateadores 49
http://sortword.java.html/ -
8/6/2019 javaUIS
54/108
(DecimalFormat)NumberFormat.getInstance();
mnf.applyPattern(MONEY_FORMAT);
mnf.format(16); // 16.00
DecimalFormat pctFm =
(DecimalFormat)NumberFormat.getInstance();
pctFm.applyPattern(PERCENTAGE_FORMAT);
pctFm.format(0.32); // 0.320000
SimpleDateFormat
Subclase de DateFormat que formatea y lee (hace parsing) de fechas y tiempo.
String DATE_FORMAT = "MM-dd-yyyy";
SimpleDateFormat sdf =
new SimpleDateFormat(DATE_FORMAT);
try {
Date d = sdf.parse("11-08-2007");
:::
}
catch(ParseException pe) {
}
String TIME_FORMAT = "HH:mm:ss.SSS";
sdf.applyPattern(TIME_FORMAT);
sdf.format(new Date()); //10:28:35.045
System
No puede ser instanciada.
Contiene campos estticos tiles:
static InputStream in: Va estndar de entrada.
static PrintStream out: Va estndar de salida.
static PrintStream err: Flujo de errores.
Mtodos
static void exit(int status): Termina la ejecucin de la Mquina Virtual.
static Properties getProperties(): Obtiene el conjunto vigente de propiedades
del sistema.
static String getProperty(String key): Obtiene el valor de una propiedad
del sistema.
Introduccin
DecimalFormat 50
-
8/6/2019 javaUIS
55/108
Se pueden agregar propiedades al conjunto de propiedades del sistema desde la lnea de comandos.
$ java -Dcasa=puerta basicos.SysProperties uno dos
Introduccin
System 51
http://sysproperties.java.html/ -
8/6/2019 javaUIS
56/108
Receta para hashCode()
1- int result = 17
2- Para cada campo significativo "f" en el objeto
(usado por equals() ) haga:
a- Calcule el hashcode "c" dependiendo del tipo de "f":
- booleano: c = ( f ? 0 : 1)
- byte, char, short, int: c = (int) f
- long: c = (int)(f ^ (f >>> 32))
- float: c = Float.floatToIntBits(f)
- double: long ele = Double.doubleToLongBits(f);
c = (int)(ele ^ (ele >>> 32))
- ref a objeto: c = f.hashCode()
- arreglo: calcule para cada elemento su propio hashcode "c" y combnelo
con los dems como en el paso "b-".
b- Combine el hashcode "c" calculado en el paso "a-" as:
result = 37 * result + c;
3- return result;
4- Ensaye a ver si objetos iguales producen hashCode() igual.
Receta para hashCode() 52
-
8/6/2019 javaUIS
57/108
-
8/6/2019 javaUIS
58/108
java.io.Reader.
java.io.Writer.
Hay alrededor de 60 clases en la jerarqua de I/O de Java.
Introduccin
java.io.OutputStream
-
8/6/2019 javaUIS
59/108
-
8/6/2019 javaUIS
60/108
Decoracin de flujos.
Con FileInputStream y FileOutputStream se obtienen flujos asociados a archivos.
FileInputStream fin =
new FileInputStream("empleados.dat");
File f = new File("empleados.dat");
FileInputStream fin =
new FileInputStream(f);
FileInputStream fin =
new FileInputStream(
new File("empleados.dat"));
byte b = fin.read(); //solo se leen bytes!!
Con DataInputStreamy DataOutputStreamse manejan los tipos bsicos de Java.
DataInputStream din = ::: ;
double s = din.readDouble();
Java separa dos responsabilidades:
Tomar bytes de una fuente fsica.
Ensamblar bytes para armar datos interesantes.
El programador puede combinar estas capacidades para obtener flujos con el comportamiento
deseado.
FileInputStream fin =
new FileInputStream("empleados.dat");
DataInputStream din =
new DataInputStream(fin);
double s = din.readDouble();// lee un double
// de un archivo
DataInputStream din =
new DataInputStream(
new FileInputStream("empleados.dat");
Las subclases de FilterInputStream y FilterOutputStream se pueden filtrar para obtener
flujos con capacidades muy flexibles.
Lectura de tipos de datos primitivos de Java con buffer:
DataInputStream din =
Introduccin
Decoracin de flujos. 56
-
8/6/2019 javaUIS
61/108
new DataInputStream(
new BufferedInputStream(
new FileInputStream("empleados.dat")));
Lectura con LookAhead y PushBack:
PushBackInputStream pbin =
new PushBackInputStream(new BufferedInputStream(
new FileInputStream("empleados.dat")));
int b = pbin.read();
if(b != '+') pbin.unread();
Manejo de archivos ZIP
La clase ZipInputStream permite crear un flujo a partir de un archivo .zip.
ZipEntry getNextEntry(): Retorna la siguiente ZipEntry del flujo, o null si se llega alfinal.
void closeEntry(): Cierra la ZipEntry actual del archivo y permite tomar la siguiente
mediante getNextEntry.
//Ciclo tipico
ZipInputStream zin =
new ZipInputStream(
new FileInputStream("archivo.zip"));
ZipEntry entry;
while((entry = zin.getNextEntry()) != null){
//Analizar entry;
//Leer el contenido de zin;
zin.closeEntry();
}
zin.close();
//Mostrar en una TextArea el texto contenido en
//un archivo que est dentro de un Zip.
private TextArea fileText = new TextArea();
private String zipname;
public void LoadZipFile(String name){
try{
ZipInputStream zin =
new ZipInputStream(
new FileInputStream(zipname));
ZipEntry entry;
fileText.setText("");
while((entry = zin.getNextEntry()) != null){
Introduccin
Manejo de archivos ZIP 57
-
8/6/2019 javaUIS
62/108
if(entry.getName().equals(name)) {
BufferedReader in =
new BufferedReader(
new InputStreamReader(zin));
String s;
while((s = in.readLine()) != null)
fileText.append(s + "\n");
}
zin.closeEntry();
}
zin.close();
}
catch(IOException ex){}
}
Flujos de texto
Usan el Unicode.
Son una jerarqua separada.
Se construyen con las clases derivadas de Reader y Writer.
InputStreamReader: Transforma un flujo de bytes (que codifican cierto tipo de caracteres) en un
flujo de caracteres.
InputStreamReader in =
new InputStreamReader(System.in);
InputStreamReader in =
new InputStreamReader(
new FileInputStream("enruso.txt"),"8859_5");
Es muy frecuente asociar un flujo de texto a un archivo:
FileWriter out =
new FileWriter("salida.txt");
OutputStreamWriter out =
new OutputStreamWriter(
new FileOutputStream("salida.txt"));
Para conversiones (datos primitivos a texto) en salida se usa PrintWriter:
PrintWriter out =
new PrintWriter(
new FileWriter("salida.txt"));
int i;
boolean b;
Introduccin
Flujos de texto 58
-
8/6/2019 javaUIS
63/108
out.println("i = "+i+" , b = "+b);
Leer valores de tipos bsicos, a partir de texto, es ms complicado:
Se usa BufferedReader para tomar lneas de un flujo de caracteres
BufferedReader in =
new BufferedReader(new FileReader("datos.txt"));
String s;
while((s = in.readLine()) != null) {
//Hacer algo con s;
double d =
new Double(s).doubleValue();
}
Para analizar una cadena se usa la clase StringTokenizer
Produce una enumeracin de tokens, dentro de una cadena, separados por caracteres
predefinidos.
StringTokenizer st =
new StringTokenizer("esto es una prueba");
while (st.hasMoreTokens()) {
println(st.nextToken());
}
// imprime
esto
es
unaprueba
Otro constructor:
public StringTokenizer(String str,String delim)
Introduccin
Flujos de texto 59
-
8/6/2019 javaUIS
64/108
-
8/6/2019 javaUIS
65/108
public Object clone(){
try {
ByteArrayOutputStream bout =
new ByteArrayOutputStream();
ObjectOutputStream out =
new ObjectOutputStream(bout);
out.writeObject(this);
out.close();
ByteArrayInputStream bin =
new ByteArrayInputStream(
bout.toByteArray());
ObjectInputStream in =
new ObjectInputStream(bin);
Object ret = in.readObject();
in.close();
return ret;
}
catch(Exception e){
return null;
}
}
}
class Empleado extends SerialCloneable {
:::::
}
public class Test{
Empleado luis = new Empleado( :::: );
Empleado gemelo = (Empleado)luis.clone();
}
A veces puede ser til impedir la serializacin de algunos atributos
Por razones de seguridad.
No definen el estado del objeto sino que son una consecuencia de l.
public class Empleado implements Serializable{
Date nacimiento;
String nombre;
transient int edad;
}
Flujos de bytes
Introduccin
Flujos de Objetos 61
-
8/6/2019 javaUIS
66/108
-
8/6/2019 javaUIS
67/108
-
8/6/2019 javaUIS
68/108
Archivos de Propiedades
Archivos de texto plano que contienen parejas (nombre,valor) y comentarios.
# Directorio de base
base.dir=/usr/java/example
#Fecha efectiva de procesamiento
effective.date=10-24-2007
Son cmodos para pasar informacin de configuracin a las aplicaciones o, simplemente, para pasar datos.
Ejemplo
Archivos de Propiedades 64
http://loadproperties.java.html/http://loadproperties.java.html/ -
8/6/2019 javaUIS
69/108
El sistema de archivos
La clase java.io.File encapsula la funcionalidad requerida para interactuar con el sistema de archivos de
la mquina.
Es una representacin abstracta de un path dentro del sistema de archivos.
Una vez creado es inmutable.
Puede referirse a un archivo o a un directorio.
El caracter separador de los componentes del path es accesible va:
System.getProperty("file.separator")
File.separator
File f = new File("texto.txt"); //no crea un archivo
boolean b = f.createNewFile(); //crea un archivo
//si no existe
String dirPath = "/home/rlopez/uis";
File f = new File(dirPath,"otro.txt");
if(f.exists()) {
:::
}
File dir = new File(".");File f = new File(dir,"otro.txt");
if(f.exists()) {
:::
}
Mtodos
boolean isAbsolute(): Decide si el path es absoluto.
boolean isDirectory(): Decide si el path se refiere a un directorio.
boolean isFile(): Decide si es un archivo.
String [] list(): Calcula un arreglo con los nombres de todos los archivos y directorios
contenidos en este directorio.
boolean delete(): Elimina el archivo o directorio representado por este objeto.
BUENA PRACTICA
El sistema de archivos 65
-
8/6/2019 javaUIS
70/108
Apoyarse en la clase System para evitar inconsistencias en I/O con respecto a las convenciones del
sistema operacional
System.getProperty("line.separator");
System.getProperty("file.separator");
System.getProperty("path.separator");
Carga de Recursos
A travs del cargador de la clase se tiene acceso a recursos que estn en el classpath. Es una manera muy
flexible de leer archivos:
El acceso es independiente de la ubicacin absoluta del archivo dentro del sistema de archivos.
ResourceLoader#!/bin/sh
#-----------------------
# Archivo runLoader.sh
#-----------------------
ROOT=".."
BIN=${ROOT}/classes
DATA=${ROOT}/data
CP=${ROOT}:${BIN}
Introduccin
Mtodos 66
http://resourceloader.java.html/ -
8/6/2019 javaUIS
71/108
JAVA=${JAVA_HOME}/bin/java
${JAVA} -cp ${CP} io.ResourceLoader
Es particularmente til para empacar clases junto con recursos dentro de un archivo jar
Introduccin
Carga de Recursos 67
-
8/6/2019 javaUIS
72/108
Swing
Java tambin es un lenguaje para programacin de Interfaces Grficas de Usuario (GUIs) a travs de un
modelo "orientado por eventos".
Los ambientes de desarrollo visuales ayudan a resolver los problemas bsicos de la parte grfica.
El manejo de los eventos es responsabilidad del programador.
El desarrollo de interfaces grficas se basa en el uso de JFC: Java Foundation Classes:
AWT : Abstract Window Toolkit(versiones 1.1 y posteriores).
API 2D.
Componentes Swing.
API de accesibilidad.
Historia
Swing est construido sobre AWT que no fue diseado para uso interactivo serio: Java fue ms exitoso de lo
que se pens originalmente.
AWT no dispone de muchas facilidades estndar para GUI's: clipboard, impresin, navegacin con el
teclado, mens pop-up, paneles con scroll.
Modelo de eventos basado en herencia: pesado para escalar.
Arquitectura de pares.
Componentes nativos (del sistema bajo el cual corre Java), delegados por los componentes
AWT para proporcionar la interfaz al usuario.
Cada uno requiere de una ventana del sistema para desplegarse: muy exigente en
recursos.
Es muy difcil garantizar comportamiento uniforme entre plataformas diferentes.
Las casas de software comenzaron a ofrecer productos para reemplazar a AWT.
Eclipse ofrece SWT.
Componentes pesados vs. Componentes livianos
Componentes pesados:
Swing 68
-
8/6/2019 javaUIS
73/108
-
8/6/2019 javaUIS
74/108
Un Applet
Manejo de Eventos
Los eventos se manejan con un modelo por delegacin.
Los eventos son generados por fuentes de eventos.
Uno o ms manejadores (oyentes, listeners) se pueden registrar para ser notificados de los eventos de
cierto tipo provenientes de una fuente especfica.
Los manejadores de eventos pueden ser instancias de cualquier clase que implemente una interfaz
apropiada (event listeners).
En un programa que maneja eventos se ven, al menos, tres tipos de cdigo:
Cdigo que declara que la clase implementa un oyente.
public class MiClase
implements ActionListener {
:::
}
Cdigo que registra una instancia de la clase oyente como manejador para los eventos de un
componente.
unComponente.addActionListener(instanciaDeMiClase);
La implementacin de los mtodos de la interfaz oyente escogida.
public class MiClase
implements ActionListener {
:::
public void actionPerformed(ActionEvent e) {
//Tratamiento del evento
}
:::
Introduccin
SWING y AWT 70
http://calculatorapplet.html/ -
8/6/2019 javaUIS
75/108
}
Ejemplo simple
Una fuente y un escucha.
public class Beeper implements ActionListener {
Button boton;
:::
//Se registra el beeper como escucha de ciertos eventos
//del boton.
boton.addActionListener(this);
//Implementa el mtodo que atiende al evento.
public void actionPerformed(ActionEvent e){
::::
}
}
Un ejemplo ms complicado
En java es posible:
Tener un oyente para cada fuente de eventos.
Tener un oyente para todos los eventos de todas las fuentes.
Tener ms de un oyente para un tipo de eventos de una nica fuente.
public class MultiListener implements ActionListener {
void init() {
//inicializacin
:::
button1.addActionListener(this);
button2.addActionListener(this);
button2.addActionListener(new Oyente(bottomTextArea));
}
public void actionPerformed(ActionEvent e) {
topTextArea.append(e.getActionCommand() + newline);}
}
class Oyente implements ActionListener {
:::
public void actionPerformed(ActionEvent e) {
myTextArea.append(e.getActionCommand() + newline);
}
}
Introduccin
Manejo de Eventos 71
-
8/6/2019 javaUIS
76/108
-
8/6/2019 javaUIS
77/108
-
8/6/2019 javaUIS
78/108
-
8/6/2019 javaUIS
79/108
Una Calculadora
Una calculadora sencilla
El patrn "Observer"
El manejo de eventos en Swing es una aplicacin del patrn "Observer".
Introduccin
Clases internas annimas 75
-
8/6/2019 javaUIS
80/108
Java Beans y POJOs
Los Java Beans fueron los primeros "componentes" especificados por Sun.
Originalmente pensados para ser manejados por ambientes grficos.
Definen convenciones para manejo de propiedades.
No deben confundirse con los Enterprise Java Beans (EJB).
Son lo mismo que los POJO (Plain Old Java Objects) aunque deben cumplir con dos restricciones que
stos no tienen:
Deben ser serializables.
Deben tener un constructor sin argumentos.
PropiedadesSon las caractersticas que definen el estado de un bean. Son accedidas mediante mtodos pblicos del bean
llamados getters y setters.
public void set(Tipo prop);
public Tipo get();
/**
* Clase con las propiedades
* nacimiento y nombre.
*/public class Persona {
private Date nacimiento;
private String nombre;
public Date getNacimiento() {
return nacimiento;
}
public void setNacimiento(Date nacimiento) {
this.nacimiento = nacimiento;
}
Java Beans y POJOs 76
-
8/6/2019 javaUIS
81/108
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
}
Una propiedad:
Tiene tipo.
Es "de lectura" si el bean tiene el correspondiente mtodo get.
Es "de escritura" si el bean tiene el correspondiente mtodo set.
No tiene que estar almacenada en un atributo del bean!!
public class Persona {
private Date nacimiento;private String nombre;
public Date getNacimiento() {
return nacimiento;
}
public void setNacimiento(Date nacimiento) {
this.nacimiento = nacimiento;
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
/**
* Propiedad "read only".
*/
public int getEdadEnAnhos() {
Date hoy = new Date();
// Calcula la diferencia con
// "nacimiento"
}
}
Propiedades Booleanas
Las propiedades booleanas admiten dos sintaxis para el mtodo "getter".
public class Persona {
private char sexo; // 'M' o 'F'
public boolean isHombre(){
return sexo == 'M';
Introduccin
Propiedades 77
-
8/6/2019 javaUIS
82/108
}
public setHombre(boolean b){
sexo = b ? 'M' : 'F';
}
}
Propiedades indexadas
Representan colecciones de valores:
public [] get();
public void set([] valor);
public get(int i);
public void set(int i, valor);
BUENA PRACTICA
Respetar las convenciones de las propiedades de los Java Beans.
Muchos "frameworks" modernos usan las propiedades de los beans: JSF, Spring, Java EE 5, Seam,
etc. Es muy valiosos poder interactuar con esos "frameworks".
Manejo de Propiedades
Se pueden manejar directamente usando los getters y setters.
El JDK incluye un API para manejarlas a travs de sus nombres.
Como muchos APIs del JDK ... es incmodo de usar.
Existen varios APIs de terceros.
Commons BeanUtils
Commons es un proyecto de Apache centrado en todos los aspectos de Componentes Reutilizables en Java.
Tambin se conoce como Jakarta Commons.
El programador Java que no usa Commons probablemente ha estado reinventando la rueda ...
BeanUtils es un API para manejo de propiedades de beans
import org.apache.commons.beanutils.PropertyUtils;
Person p = new Person();
p.setNombre("Rodrigo");
Introduccin
Propiedades Booleanas 78
http://commons.apache.org/ -
8/6/2019 javaUIS
83/108
try{
String nom =
(String) PropertyUtils.getSimpleProperty(p,"nombre");
}
catch ( ...) {
//Hay que atrapar varias
// excepciones ..
}
public class Libro {
private String titulo;
public String getTitulo() {
return titulo;
}
}
Libro book = new Libro( ...);
String titulo =
(String) PropertyUtils.
getSimpleProperty(book,"titulo");
String autor =
(String) PropertyUtils.
getNestedProperty(book,"autor.nombre");
Existen lenguajes para manejo de propiedades
JSF EL (Expression Language).
Seam EL.
Extiende la nocin de propiedad.
BUENA PRACTICA
Antes de escribir "utilidades" para una aplicacin, echar una mirada a Apache Commons.
"Reinventar la rueda" es muy ineficiente.
Reflexin en Java
Introduccin
Commons BeanUtils 79
-
8/6/2019 javaUIS
84/108
-
8/6/2019 javaUIS
85/108
try {
Persona p = new Persona();
Class laClase = Persona.class;
//Arma arreglo de parmetros formales
Class parms [] = {String.class};
//Busca un atributo
Field attr = laClase.getField("nacimiento");
//Obtiene el valor
Object valAttr = attr.get(p);
}
catch (NoSuchFieldException e){
:::
}
catch (ClassNotFoundException e){
:::
}
catch (NoSuchMethodException e){:::
}
catch (IllegalArgumentException e){
:::
}
catch (IllegalAccessException e){
:::
}
Introduccin
Reflexin en Java 81
-
8/6/2019 javaUIS
86/108
-
8/6/2019 javaUIS
87/108
::::
MiThread t1 = new MiThread ();
MiThread t2 = new MiThread ();
t1.start(); //ejecuta run()
t2.start(); //ejecuta run()
Clase Thread:
Constructor Thread (Runnable rn): Construye un thread a partir de un objeto Runnable.
void run(): Si este thread fue construdo a partir de un objeto Runnable, se ejecuta el mtodo run()
de ese objeto. Si no, se ejecuta este mtodo --que no hace nada--.
void start(): Comienza la ejecucin de este thread. La JVM invoca el mtodo run() de este thread.
static void sleep(long msecs): Suspende la ejecucin del thread --que se est ejecutando-- por un
nmero