Java fundamentos

Java básico Tipos Básicos Instrucciones básicas Paquetes Objetos herencia Excepciones Genéricos Entrada/Salida Coleccion
Java
Entorno de Programación Emacs/JDEE/Ant
Luis Fernando Llana D´ıaz
Departamento de Sistemas Informáticos y Computación
Universidad Complutense de Madrid
8 de abril de 2013
Luis Fernando Llana D´ıaz Departamento de Sistemas Informáticos y ComputaciónUniversidad Complutense de Madrid
Java

Sintaxis inspirada en C++.
Lenguaje orientado a objetos.
Código compilado independiente de
la máquina j-código.
Lenguaje de moda.
Compilador e intérpretes gratuito.
Libres según la versión.
Java

Entornos de programaci´on
Consola+editor de textos.
Editor de texto emacs + JDEE.
Eclicpse y NetBeans, entornos libres.
JBuilder entorno propietario.
Java

GNU-emacs (JDEE)
Ventajas
Código libre.
Editor potente (coloreado,
sangrado automático,
compilación integrada).
Editor programable.
Java

GNU-emacs (JDEE)
Ventajas
Código libre.
Editor potente (coloreado,
sangrado automático,
compilación integrada).
Editor programable.
Desventajas
Dificultad para entornos
gráficos.
Entorno desconocido.
Java

Programa “Hola Mundo”
1/* El primer programa
2como aparece en todos los
3libros */
4
5/** Esto es un comentario
6* para ser procesado con ’javadoc ’.
7* Clase " ejecutable " Hola mundo.
8*/
9public class HolaMundo {
10// Clase úpblica . óSlo puede haber una en cada fichero .
11// áAdems el fichero se debe llamar ’PrimerPrograma .java ’
12/** El émtodo áesttico "main" es el
13* que comienza a ejecutarse .
14* @author Luis Fernando Llana ´ıDaz
15* @version 1.0
16* @since 5/ oct /98
17* @param args son los parametros introducidos en la ´ılnea de comandos
18*
19*/
20public static void main (String [] args ){
21System.out.println("Hola");
22}
23}
Java

Elmentos básicos
Instrucción de asignación.
Instrucción condicional (if).
Instrucción iterativa (while, for, do-while).
Java

Tipos Básicos
Tipo Que contiene Rango
byte entero de 8 bits -128 a 128
short entero de 16 bits -32.768 a 32.767
int entero de 32 bits -2.147.483.648 a 2.147.483.647
long entero de 64 bits −263
a 263
− 1
float coma flotante de 32 bits 6 d´ıgitos significativos (10−46
, 1038
)
double coma flotante de 64 bits 15 d´ıgitos significativos (10−324
, 10308
)
char Carácter Unicode ’a’, ’b’, . . . ’á’, ’~n’,. . . ’0’, ’1’, . . .
boolean valores booleanos true y false
Java

Literales
Enteros:
Decimal: 37
Hexadecimal: 0x25
Octal: 045
Caracteres
’a’, ’b’, . . . ’´a’, ’~n’, . . . , ’0’, ’1’, . . .
Caracteres “escape”: ’n’, ’’, ’’’, ’"’.
Reales
Float: 1.0345F, 1.04E-12f, .0345f,
1.04e-13f
Double: 1.0345, 1.0345d, 5.6E-120D
Cadenas de caracteres: "holan".
Java

Declaración de variables
Estilo C++.
Permite declaración de variables al vuelo.
Java es sensible a mayúsculas y minúsculas.
Notación:
Nombres de variables y clases largos.
Las variables todas en minúsculas, si una variable se compone
de varias palabras, la segunda y siguientes palabras empiezan
por mayúscula:
numero, numeroPalabras
Las clases empiezan por mayúsculas y las demás en minúsculas:
Lista, ListaEnlazada
Java

Declaración de variables
1public class Variables {
2public static void main (String [] args)
3{
4int num1; // óDeclaracin áestndar
5double media =2.5; // óDeclaracin e óinicializacin
6
7num1 =6;
8System.out.println("num1: "+num1 );
9
10int x, num2; // óDeclaracin al vuelo
11x=2; num2 =10;
12System.out.println("x: "+x+"nnum2: "+num2 );
13
14int num3=x*num2; // óDeclaracin e óinicializacin al vuelo
15System.out.println("num3: "+num3 );
16
17media=num1/num2;
18// media =0
19System.out.println("media: "+media );
20
21media =( double)num1/num2;
22// media =0.6
23System.out.println("media: "+media );
24}
25}
Java

Operadores
Operadores aritméticos
+ suma para enteros y reales.
- resta para enteros y reales.
* producto para enteros y reales.
/ división entera entre enteros y con decimales para reales.
% resto de la división entera entre enteros.
Java

Operadores lógicos
conjunción &&, ¡ojo! no confundir con &.
disyunción || , ¡ojo! no confundir con |.
negación !.
Operadores relacionales
igualdad ==.
desigualdad !=.
comparación <, <=, >, >=.
Java

Expresi´on condicional
1i %2 ? 1:0
2..........
3mes ==2 && bisiesto ? 29:28
Operadores l´ogicos no estrictos
1if (x!=0 && 1/x >3)
2..................
3while (i<=n && v[i]==0)
Java

Constantes
1public static final double CUALQUIERA =3.14159265;
2public static final int MAXIMO_NUMERO_ELEMENTOS =5000;
Java

Cadenas de caracteres
1public class PrString {
2
3public static void main(String args []) {
4String s1 = "Hola";
5String s2 = "Patata";
6String s3 = s1+" "+s2;
7System.out.println(s3.length ());
8for (int i = 0; i < s3.length (); i++) {
9String mensaje = "Letra "+i+":"+s3.charAt(i)+":";
10System.out.println(mensaje );
11}
12
13}
14}
String es una clase especial en Java. Sus objetos son inmutables.
Java

Instrucción condicional
1if (expresión booleana )
2instrucción
3
4if (expresión booleana )
5instrucción
6else
7instrucción
1if (x==0)
2System.out.println("x vale 0");
3else {
4System.out.print("x vale ");
5System.out.println(x);
6}
Java

Instrucci´on condicional
1public class PruebaIf {
2public static void main(String [] args) {
3int x=0;
4
5if (x!=0 && 1/x=0);
6System.out.println (1/x);
7else
8System.out.print("x ´aest ");
9System.out.println("indefinido");
10}
Java

Instrucciones iterativas
1while (expresión booleana )
2instrucción
1do
2instrucción
3while (expresión booleana )
1for (inicialización ; expresión booleana ; incremento )
2instrucción
Java

1i=0;
2while (i<n && v[i]==0) i++;
1for (int i=1; i<n; i++){
2int posMin=i;
3for (int j=i+1; j<n; j++){
4if (v[j]<v[posMin ]) posMin=j;
5}
6intercambiar (v,i,posMin );
7}
Java

Usos “prohibidos” de bucle for
Uso de bucle for como bucle while:
1for (i=0; i<n && v[i]==0; i++);
Java

1public class PruebaBucles {
2static void bucleWhile () {
3int i=1;
4boolean para = false;
5System.out.println("Bucle WHILE");
6while (i <=1000 && !para) {
7System.out.println("i: "+i);
8// Sale del bucle cuando se cumple la ócondicin .
9if (i==10) {
10System.out.println("Me voy ....");
11para = true;
12}
13i++;
14}
15}
16
17static void bucleFor () {
18System.out.println("Bucle FOR");
19for (int i=1; i <=10; i++)
20System.out.println("i: "+i);
21}
22// éDespus del bucle la varaible ’i’ no áest definida ;
23
25bucleWhile ();
26bucleFor ();
27}
28}
Java

Distinci´on de casos
1switch (n %7){
2case 0:
3System.out.println("Es lunes");
4break;
5case 1:
6System.out.println("Es martes");
7break;
8...
9...
10case 6:
11System.out.println("Es domingo");
12break;
13default:
14System.out.println("Esto es imposible");
15}
Java

1public class PruebaSwitch {
2static char prueba1(char c) {
3char letra;
4
5switch (c) {
6case ’a’:
7letra=’-’;
8break;
9case ’e’:
10letra=’-’;
11break;
12case ’i’:
13letra=’-’;
14break;
15case ’o’:
16letra=’-’;
17break;
18case ’u’:
19letra=’-’;
20break;
21default: letra=c;
22}
23return letra;
24}
Java

1static void prueba2(int i) {
2switch (i){
3case 1:
4System.out.println("Caso 1: "+i);
5case 2:
6System.out.println("Caso 2:"+i);
7case 3:
9case 4:
11case 5:
13default:
14System.out.println("Caso por defecto");
15}
16}
Java

2char letra=prueba1(args [0]. charAt (0));
3System.out.println("letra:"+letra+":");
4
5System.out.println("llamada con 1");
6prueba2 (1);
8prueba2 (2);
10prueba2 (3);
12prueba2 (4);
14prueba2 (5);
16prueba2 (6);
17}
18}
Java

Métodos
Java no tiene procedimientos, sólo hay funciones (métodos).
Existen funciones que devuelven nada (tipo void).
Todos los parámetros son de entrada, pero cuidado con los
punteros o referencias.
Las funciones admiten sobrecarga.
Java

Sobrecarga
1public class Sobrecarga {
2final static double PI =3.1415926535897932;
3
4static double max(double a, double b){
5double m=a;
6if (b>a) m=b;
7return m;
8}
9static double max(double a){
10double m=PI;
11if (a>PI) m=a;
12return m;
13}
14static int max(int a, int b){
15int m=a;
16if (b>a) m=b;
17return m;
18}
Java

Sobrecarga
1public static void main(String [] args ){
2double x=Double.parseDouble(args [0]);
3double y=Double.parseDouble(args [1]);
4int a=Integer.parseInt(args [2]);
5int b=Integer.parseInt(args [3]);
6
7System.out.print("áMximo entre "+x+" y "+y+": ");
8System.out.println(max(x,y));
9
10System.out.print("áMximo entre "+x+" y "+PI+": ");
11System.out.println(max(x));
12
13System.out.print("áMximo entre "+a+" y "+b+": ");
14System.out.println(max(a,b));
15}
16}
Java

Arrays
1int [] v; // definicion de arrays
2double [][] m; //ódefinicin de matrices
3.................................
4int [] v = new int [10]; //ódefinicin y ócreacin de array de 10 componentes
5.................................
6int [] v = {1,2,3,4,5}; //ódefinicin y ócreacin de array
7.................................
8int [] m = new int [10][10];
9.................................
10int [][] m = {{1 ,2 ,3} ,{4 ,5 ,6} ,{7 ,8 ,9}};
Todos los arrays empiezan a numerarse desde 0;
Java

Arrays
1import java.util.Random;
2public class PrArray {
3private static final int N=10;
4private static void escribe(int [] v) {
5System.out.print("[");
6for (int i = 0; i<v.length ; i++) {
7if (i>0)
8System.out.print(",");
9System.out.print(v[i]);
10}
11System.out.println("]");
12}
14int [] v = new int[N];
15genera(v);
16escribe(v);
17ordena(v);
18escribe(v);
19int [] u = v;
20u[0]=10000;
21escribe(u);
22}
Java

Arrays
1private static void genera(int [] v) {
2Random r = new Random ();
3for (int i = 0; i<v.length ; i++)
4v[i] = r.nextInt () % (3*N);
5}
6private static void ordena(int [] v) {
7for (int i = 0; i < v.length ; i++) {
8int pos = i;
9for (int j = i+1; j<v.length ; j++)
10if (v[j]<v[pos])
11pos = j;
12int aux = v[i];
13v[i] = v[pos ];
14v[pos ]=aux;
15}
16}
17}
Java

Paquetes
Hechos
Cualquier programa puede tener varios cientos o miles de
clases.
La propia API de Java tiene m´as de 3000 clases.
No es dif´ıcil escoger el nombre de una clase que ya
est´e cogido.
Java

Paquetes
Hechos
Cualquier programa puede tener varios cientos o miles de
clases.
La propia API de Java tiene más de 3000 clases.
No es dif´ıcil escoger el nombre de una clase que ya
esté cogido.
Paquete
Es una colección de clases con un mismo objetivo.
Java

Clase soporte.Teclado
1package soporte;
2
3import java.io. BufferedReader ;
4import java.io. IOException ;
5import java.io. InputStreamReader ;
6public class Teclado {
7...
8...
9}
Java

Objeto es un ejemplar de una clase.
Estado interno, no manipulable directamente.
Métodos de manipulación.
Programa colección de clases.
Clase definición de objetos.
Similar a RECORD de Pascal + métodos de manipulación.
Java no es un lenguaje orientado a objetos puro, tiene tipos
primitivos.
Java

Implementación de fechas
Implementación de fecha:
Representación de una fecha ordinaria (d´ıa/mes/año)
moderna (desde 01/01/1601).
Dada una fecha, pasar a la siguiente, anterior, añadir/restar
d´ıas.
Comparar fechas.
¿Cuántos d´ıas hay entre 2 fechas?
Java

Uso de fechas
1import fecha.Fecha;
2public class PrFecha {
3public static void main (String [] args) {
4Fecha f1=new Fecha (30, Fecha.DICIEMBRE ,1999);
5Fecha f2=new Fecha (1, Fecha.MARZO ,2004);
6while (f1.compareTo(f2) <=0) {
7System.out.println(f1.diaSemana ()+":"+f1);
8f1.siguiente ();
9}
10}
11}
Java

Implementaci´on de fechas
1package fecha;
2public class Fecha implements Comparable{
3private int dia;
4private int mes;
5private int anyo;
6public Fecha( int _dia , int _mes , int _anyo ) {
7dia = _dia; mes = _mes; anyo = _anyo;
8}
9public String toString( ) {
10return dia + "/" + mes + "/" + anyo;
11}
12public int compare(Object o)
13..........
14}
15public void anyadir(int ´ıdas) {
16..........
17}
18public void siguiente () {
19anyadir (1);
20}
21public void anterior () {
22anyadir (1);
23}
24public int diasHasta(Fecha otra) {
25......
26}
27}
Java

Implementación más real
Establecemos una fecha inicial el d´ıa 0, para simplificar el
01/01/1601 ¿por qué?.
Representamos cada fecha como el número de d´ıas
transcurridos desde el d´ıa 0.
Necesitamos métodos de traducción
Java

Clase Fecha
1package fecha;
2
3public class Fecha implements Comparable , Cloneable{
4// Constantes para los meses
5public final static int ENERO =0;
6public final static int FEBRERO =1;
7......................................
8public final static int DICIEMBRE =11;
9
10// Constantes para los ´ıdas
11public final static int LUNES =0;
12public final static int MARTES =1;
13......................................
14public final static int DOMINGO =6;
15......................................
16......................................
17......................................
18
19//´ıDas transcurridos desde del 1 de enero de 1601
20private int diasDesdeInicio ;
21public Fecha(int dia , int mes , int anyo) {
22compruebaFecha (dia , mes , anyo );
23diasDesdeInicio = calculaDiasDesdeInicio (dia , mes , anyo );
24}
25}
Java

Clase Fecha
1public void anyadirDias (int inc) {
2int d= diasDesdeInicio +inc;
3if (d<0) throw new FechaFueraDeRango ("´ıDa anteror al permitido");
4diasDesdeInicio =d;
5}
6
8anyadirDias (1);
9}
10public void anterior () {
11anyadirDias ( -1);
12}
13
14public boolean equals(Object obj) {
15if (! (obj instanceof Fecha )) return false;
16return diasDesdeInicio ==(( Fecha)obj ). diasDesdeInicio ;
17}
18
19public int compareTo(Object o) {
20if (!(o instanceof Fecha ))
21throw new ClassCastException ("Se requiere un objeto de clase Fecha");
22return diasDesdeInicio -(( Fecha)o). diasDesdeInicio ;
23}
Java

Clase Fecha
1private static int calculaDiasDesdeInicio (int elDia , int elMes , int elAnyo ){
2int dias;
3
4dias= calulaDiasHastaPrimeroDe (elAnyo );
5dias=dias+ calculaDiasHastaPrimeroDelMes (elMes ,elAnyo );
6dias=dias+elDia -1; // el 1/1/1601 es el dia 0
7return dias;
8}
Java

Clase Fecha
1protected static int diasMes(int mes , int anyo) {
2int [] diasMes ={31 , 28, 31,
330, 31, 30,
431, 31, 30,
531, 30, 31};
6int dias = diasMes[mes] + ( (mes == FEBRERO )? anyoBisiesto (anyo ):0 );
7return dias;
8}
9private static int calculaDiasHastaPrimeroDelMes (int mes , int anyo ){
10int dias = 0;
11for (int i = 0; i < mes; i++) {
12dias = dias + diasMes(i,anyo );
13}
14return dias;
15}
16
17private static int calulaDiasHastaPrimeroDe (int elAnyo ){
18int dias;
19int diff = elAnyo - ANYO_INICIO ;
20dias = diff *365; // se anyaden 365 dias por cada ~nao
21dias = dias + diff / 4; //~naadimos 1 por cada úmltiplo de 4
22dias = dias - (diff /100); //se quida 1 por cada úmltimo de 100
23dias = dias + (diff /400); //se ~naade 1 por cada úmltimo de 400
24
25return dias;
26}
Java

Clase Fecha
1public String toString (){
2FechaTerna f = new FechaTerna( diasDesdeInicio );
3return f.toString ();
4}
5......................................
6......................................
7class FechaTerna {
8private int dia;
9private int mes;
10private int anyo;
11public FechaTerna(int _dia , int _mes , int _anyo ) {
13}
14public String toString () {
15return dia+"/"+mes+"/"+anyo;
16}
17......................................
18}
Java

Clase Fecha
1private static final int grupo1 = 365;
2private static final int grupo4 = 4*365+1;
3private static final int grupo100 = 25* grupo4 -1;
4private static final int grupo400 = 4* grupo100 +1;
5
6public FechaTerna(int dias) {
7int quedan = dias;
8int grupos400 = quedan / grupo400;
9quedan = quedan % grupo400;
16int anyo = Fecha.ANYO_INICIO +
17grupos1 + 4* grupos4 +
18100* grupos100 + 400* grupos400;
19int mes =0;
20while (quedan >= Fecha.diasMes(mes ,anyo )) {
21quedan = quedan -Fecha.diasMes(mes ,anyo );
22mes ++;
23}
24this.dia = quedan +1;
25this.mes = mes +1;
26this.anyo = anyo;
27}
Java

Terminolog´ıa
clase
Deﬁnici´on de objetos. Todo objeto pertenece a una clase.
1Fecha f1=new Fecha (30, Fecha.DICIEMBRE ,1999);
2Fecha f2=new Fecha (1, Fecha.MARZO ,2004);
1package fecha;
2
4....................................................
5....................................................
6}
7
8class FechaTerna {
9....................................................
10....................................................
11}
Java

Terminolog´ıa
constructor
Procedimiento que construye objetos
4}
1public FechaTerna(int _dia , int _mes , int _anyo ) {
3}
En Java los constructores tienen el mismo nombre que la clase.
Java

Terminolog´ıa
atributo
Variable de un objeto
1private int diasDesdeInicio ;
1private int dia;
2private int mes;
3private int anyo;
Normalmente los atributos son privados al objeto: desde fuera del
objeto no deben ser accesibles, se debe acceder a ellos a trav´es de
m´etodos de acceso.
Java

Terminolog´ıa
m´etodos
1while (f1.compareTo(f2) <=0) {
2System.out.println(f1.diaSemana ()+":"+f1);
3f1.siguiente ();
4}
5.....................................
8throw new ClassCastException ("Se requiere un objeto de clase Fecha");
10}
11..........................................
16}
18anyadirDias (1);
19}
Java

Restricción de permisos
Los objetos pertenecen a clases, las clases se agrupan en paquetes.
Conviene restringir el acceso a los elementos del objeto
public desde cualquier clase (independientemente del
paquete).
protected desde clases que están el mismo paquete.
private sólo desde la misma clase.
Java

Referencias
Tanto las variables de objetos como los arrays son referencias
1int n=4576;
2int [] v={45 ,36 ,56 ,25};
3Fecha f = new Fecha (3, Fecha.DICIEMBRE ,2007);
Java

Referencias, efecto lateral
1int [] u=v;
2u[0]=56; // v [0]=56
Java

Referencias, efecto lateral
1Fecha f1 = f;
2f1.siguiente ();
Java

Referencias, objeros como par´ametros
1void avanza(Fecha fecha) {
2fecha.siguiente ();
3}
4
5avanza(f);
Java

Referencias, cambiar de referencia
1f = new Fecha (31, Fecha.DICIEMBRE ,2007);
Java

Referencias, generaci´on de basura
1f1 = new Fecha (8, Fecha.OCTUBRE ,2007);
Java

Referencias
El contenido de las variables de objetos y arrays son referencias a
los objetos y arrays.
Java

Referencias
Si dos variables hacen referencia al mismo objeto las
modiﬁcaciones tienen efectos laterales
Java

Referencias
Los par´ametros de los procedimientos son por valor: Las
referencias no pueden cambiar, pero el contenido de los
objetos s´ı.
Java

Referencias
Los par´ametros de los procedimientos son por valor: Las
referencias no pueden cambiar, pero el contenido de los
objetos s´ı.
Cuando un objeto no tiene referencias es considerado basura,
que debe se recogida por el recolector de basura (garbage
collector). En Java existe un recolector de basura autom´atico.
Java

Calificativo static
Algo estático pertenece a la clase. Es común a todos los objetos de
la clase.
Variables comunes a todos los objetos.
Métodos que no hacen referencia a atributos dinámicos (no
estáticos).
Permiten mejor aprovechamiento de los recursos.
Java

Calificativo final
Se añade las partes que no se pueden cambiar
Variables constantes.
Métodos que no se pueden reescribir en la herencia.
Java

Referencia null
1Fecha f1; // Referencia no definida
2Fecha f2=null; // Referencia a objeto nulo.
Java

Igualdad de referencias
Dos referencias son iguales si y s´olo si apuntan al mismo objeto
1boolean b;
2int [] u = v;
3b = u==v; // b es true
4int [] w = new int [4];
5w[0]=56; w[1]=36; w[2]=56; w[3]=25;
6b = u==w; // b es false
Java

1public class Fecha {
2...........
3public Fecha clone () {
4Fecha fecha = new Fecha ();
5fecha. diasDesdeInicio = this. diasDesdeInicio ;
6return fecha;
7}
8..........
9}
10............
11Fecha f = new Fecha (1,ENERO ,1956);
12Fecha f1 = f; // referencias iguales ;
13Fecha f2 = f.clone (); // referencias distintas a objeros iguales .
Java

1boolean b;
2b = f==f1; // b es true;
3b = f==f2; // b es false;
4b = f1==f2; // b es false;
1boolean b;
2b = f.equals(f1); // b es true;
4b = f1.equals(f2); // b es true;
5b = f1.equals(f); // b es true;
6b = f2.equals(f1); // b es true;
Java

1f.siguiente ();
2b = f==f1; // b es true;
3b = f==f2; // b es false;
4b = f1==f2; // b es false;
1boolean b;
3b = f.equals(f2); // b es false;
4b = f1.equals(f2); // b es false;
6b = f2.equals(f1); // b es false;
7b = f2.equals(f); // b es false;
Java

Herencia: relaci´on es un I
Seres materiales
Seres inertes
Coches
Renault
El coche de Flora
Seres vivos
Plantas
Flores
El geranio de juan
Animales
Insectos Peces Mam´ıferos
Perros
El caniche de juan
Humanos
Vendedores
Floristas
Flora
Profesores
Enrollados
Juan
Capullos
Luis
Java

Herencia: relación es un II
Recorrido de la jerarqu´ıa
Según se recorre la jerarqu´ıa los elementos que están por debajo
heredan caracter´ısticas de los elementos superiores:
Todos los objetos tienen masa y volúmen.
Todos los seres vivos nacen, crecen, etc. . . .
Todos los mam´ıferos maman cuando son pequeños, etc. . . .
Todos los perros ladran.
Java

Herencia: relación es un III
Por tanto el perro de juan
tienen masa y volúmen.
nace, crece, etc. . . .
mamó cuando fue pequeño, etc. . . .
ladra.
Caracter´ısticas heredadas
Existen caracter´ısticas que no cambian (peso y volúmen).
Caracter´ıticas que se añaden.
Caracter´ısticas que se modifican, se refinan o cambian.
Java

Herencia m´ultiple
Padre Director de banco
Director de banco con hijos
Pepe
Java

Herencia en Java
Interfaces.
Clases abstractas.
Extensi´on de clases.
Implementaci´on de interfaces.
Java

Clase Object
1public class Patata {
2.......
3.......
4.......
5}
1public class Patata extends Object {
2.......
3.......
4.......
5}
Clase Object
La clase Object es la superclase de todas las clases en Java.
Dispone, entre otros, de los m´etodos:
boolean equals(Object obj)
String toString()
Estos m´etodos se deben sobreescribir en las subclases.
Java

Clase Fecha
2if (! (obj instanceof Fecha )) return false;
3return diasDesdeInicio ==(( Fecha)obj ). diasDesdeInicio ;
4}
1public String toString (){
2FechaTerna f = new FechaTerna( diasDesdeInicio );
3return f.toString ();
4}
Java

Extensión de clases
Extensión de clase
1package fecha;
2public class FechaFueraDeRango extends RuntimeException {
3public FechaFueraDeRango (String s) {
4super(s);
5}
6}
Extensión de interfaz
2.........
3.........
4.........
5}
Java

Clases, clases abstracas e interfaces
Clase normal: todalmente definida, puede haber objetos de esa
clase.
Clase abstracta: parcialmente definida, puede tener algún atributo,
métodos totalmente definidos y métodos no
definidos.
Interfaz: sólo define algún método, pero sin implementar.
Java

Clase Abstracta
1public abstract class Patata{
2private int atributo;
3public abstract modifica(int x);
4}
Java

Interfaz
El interfaz Comparable del API de Java debe ser de la forma
1package java.lang;
2public interface Comparable {
3public int compareTo(Object o);
4}
Java

Herencia m´ultiple
1public class Patata {
2public int x;
3public void incrementa (){
4x=x+1;
5}
6}
1public class Tomate {
2public int x;
3public void incrementa (){
4x=x+10;
5}
6}
1public class Lechuga extends Patata , Tomate {
2public int y;
3}
4......
5......
6Lechuga lechuga = new Lechuga ();
7lechuga.incrementa (); // incrementa x = x+1 ´o x = x+10 ?
Java

Herencia múltiple en Java
En Java existe versión restringida de herencia
Se puede extender sólo 1 clase.
Se puende implementar más de 1 interfaz.
1public class Trazador extends Frame
2implements WindowListener , ObjetoComparable {
Java

Objeto super
Invocaci´on a la superclase
1public class Estudiante{
2private String nombre;
3public Estudiante(String nombre) {
4this.nombre = nombre;
5}
6public void estudia(double tiempo ){....}
7}
1public class EstudiantePerezoso extends Estudiante{
2public EstudiantePerezoso (String nombre) {
3super(nombre );
4}
5public void trabaja(double tiempo ){
6super.estudia(tiempo /3);
7descansa(tiempo /3);
8super.estudia(tiempo /3);
9}
10}
Java

Objeto this
2....................
6}
7
8public Fecha () {
9this (1 ,1 ,1998);
10}
11....................
12}
1class FechaTerna {
2private int dia;
3private int mes;
4private int anyo;
5......................
6public FechaTerna(int dias) {
7this.dia = quedan +1;
8this.mes = mes +1;
9this.anyo = anyo;
10}
11........
12}
Java

Figuras planas
1package geometria. figurasPlanas ;
2public interface FiguraPlana {
3public boolean intersecaCon ( FiguraPlana otra );
4public double distancia(Punto p);
5}
1package geometria. figurasPlanas ;
2public abstract class Superficie implements FiguraPlana{
3public abstract boolean estaDentro(Punto P);
4public abstract double superficie ();
5}
Java

Puntos
1public class Punto implements FiguraPlana {
2public Punto(double x, double y){
3posX=x; posY=y;
4}
5public double distancia(Punto otro ){
6Vector v=new Vector(this ,otro );
7return v.modulo ();
8}
9public boolean equals(Object o){
10if (o instanceof Punto) {
11Punto otro = (Punto)o;
12return (this.posX == otro.posX) && (this.posY == otro.posY );
13}
14else return false;
15}
16public boolean intersecaCon ( FiguraPlana otra ){
17if (otra instanceof Punto) {
18return this.equals(otra );
19}
20else {
21return otra. intersecaCon (this );
22}
23}
24}
Java

Método equals
Definido en Object, todos los objetos son subclase suya: todos
tienen definido el método equals.
1public boolean equals(Object o){
2if (o instanceof Punto) {
3Punto otro = (Punto)o;
4return (this.posX == otro.posX) && (this.posY == otro.posY );
5}
6else return false;
7}
Java

Interfaces Comparable y Cloneable
1public class Fecha implements Comparable , Cloneable{
2................................
5throw new ClassCastException ("Se requiere un objeto de clase fecha.Fecha."+
6"He recibido algo de clase "+o.getClass (). getNa
8}
9public Fecha clone () {
10Fecha fecha = new Fecha ();
11fecha. diasDesdeInicio = this. diasDesdeInicio ;
12return fecha;
13}
14.......................
15}
Java

Interfaz Comparable
1package java.lang;
2public interface Comparable <T> {
3public int compareTo(T o);
4}
Se usa para:
ordenaci´on.
colecciones ordenadas.
1public class Fecha implements Comparable <Fecha >, Cloneable{
2.............
3.............
4public int compareTo(Fecha o) {
5return diasDesdeInicio -o. diasDesdeInicio ;
6}
7}
Java

Interfaz Comparable
Autoriza el uso del m´etodo clone de la clase object.
Copia los atributos, no hace un clone de los atributos.
Si se quiere hacer p´ublico hace falta reescribirlo.
Java

Estático y dinámico
Estático
Conocido en tiempo de compilación.
Dinámico
Lo que se conoce en tiempo de ejecución.
Java

Tipo est´atico
2....................
4..............
5..............
6}
7....................
8}
¿Qu´e sabemos de obj?
El objeto al que hace referencia obj pertenece a un subclase de
Object.
Java

Tipo din´amico
2....................
4..............
5..............
6}
7....................
8Fecha f1 = new Fecha (31,JULIO ,2006);
9Fecha f2 = new Fecha (31,JULIO ,2005);
10boolean b = f1.equals(f2);
11........
12}
¿Qu´e sabemos de obj?
f2 es de clase Fecha. Cuando se hace la llamada obj va a ser una
referencia a un objeto de clase Fecha.
Java

Los m´etodos y atributos marcados como static
son inherentes a la clase,
todos los objetos los comparten ,
se pueden invocar directamente desde la clase.
2....................
3....................
4public final static int ENERO =0;
5.................
6}
7........
8Fecha f = new Fecha (1, Fecha.ENERO ,2005);
Si un atributo es est´atico
Se comparte por todos los objetos de la clase
Java

2....................
3....................
4private static int calculaDiasDesdeInicio (int elDia , int elMes , int elAnyo ){
5int dias;
6
7dias= calulaDiasHastaPrimeroDe (elAnyo );
8dias=dias+ calculaDiasHastaPrimeroDelMes (elMes ,elAnyo );
9dias=dias+elDia -1; // el 1/1/1601 es el dia 0
10return dias;
11}
12
13....................
14
15}
Si un método es estático
Se gana en eficiencia (tiempo/memoria)
No puede hacer referencia a atributos no estáticos.
Java

Permisos de acceso
Los métodos y atributos de una clase pueden ser
public: accesibles desde cualquier clase.
protected: accesibles desde clases que estén en el mismo
paquete o desde subclases.
private sólo es accesible desde la propia clase.
Java

¿Qué es una excepción? I
Excepción
Es un evento que ocurre durante la ejecución de un programa e
interrumpe su ejecución normal
Java

¿Qué es una excepción? II
Cuando se produce una excepción se puede
Capturarla y arreglar la situación
Transmitir el error al procedimiento llamante
Java

Capturar/Transmitir una excepción
1public static int leeInt () throws IOException {
2try {
3return Integer.parseInt(teclado.readLine ());
4}
5catch ( NumberFormatException e) {
6System.out.println("úNmero incorrecto , ádmelo otra vez.");
7return leeInt ();
8}
9}
El método readLine puede lanzar java.io.IOException
El método parseInt puede lanzar
java.lang.NumberFormatException
Java

Instrucción try/catch/finally
1try {
2codigo
3} catch (Excepcion1e1 ) {
4codigo1
5} catch (Excepcion2e2 ) {
6codigo2
7}
8..........
9} finally {
10
11}
Intenta ejecutar el código.
Si se produce una excepción de clase Excepcionk se ejecuta el
código codigok
El código en finally se ejecuta al final en cualquier caso.
Java

Instrucci´on try/catch/finally
1public void writeList () {
2PrintWriter out = null;
3try {
4System.out.println("Entering try statement");
5out = new PrintWriter (
6new FileWriter("OutFile.txt"));
7for (int i = 0; i < SIZE; i++)
8out.println("Value at: " + i + " = "
9+ vector.elementAt(i));
10} catch ( ArrayIndexOutOfBoundsException e) {
11System.err.println("Caught "
12+ " ArrayIndexOutOfBoundsException : "
13+ e.getMessage ());
14} catch ( IOException e) {
15System.err.println("Caught IOException: "
16+ e.getMessage ());
17} finally {
18if (out != null) {
19System.out.println("Closing PrintWriter ");
20out.close ();
21
22}
23else {
24System.out.println(" PrintWriter not open");
25}
26}
27}
Java

Declarar/lanzar excepciones
Requisito captura o declarar
Si una instrucción en un método puede lanzar una excepción se
debe
Capturar con instrucción catch
El método debe declarar (throws) que la puede lanzar.
Excepciones normales deben cumplir el requisito
Errores errores externos (fallos de hardaware). No necesitan
cumplir el requisito.
Excepciones Runtime errores internos que se debe a fallos, usos
incorrectos de una API. No necesitan cumplir el
requisito.
Java

Lanzar excepciones
5}
Java

Escribiendo excepciones
1package fecha;
2public class FechaFueraDeRango extends RuntimeException {
3public FechaFueraDeRango (String s) {
4super(s);
5}
6}
Java

¿Para qu´e?
1private static List leePuntos(String fichero)
2throws FileNotFoundException , IOException{
3
4BufferedReader lector = new BufferedReader (new FileReader(fichero ));
5List listaPuntos =new LinkedList ();
6String datos=lector.readLine ();
7while (datos != null ){
8Punto p=new Punto(datos );
9listaPuntos.add(p);
10datos=lector.readLine ();
11}
12return listaPuntos;
13}
Java

Evitar conversiones de tipo
1private static void analizaListaPuntos (List c){
2Iterator itr=c.iterator ();
3int i=1;
4while(itr.hasNext ()){
5Punto p = (Punto)itr.next ();
6...........................
7}
8}
Java

Evitar conversiones de ejecuci´on
1Lista lista = leePuntos(fichero );
2lista.add(new Recta(new Punto (0,0), new Punto (1 ,0)));
3analizaPuntos (lista );
Java

Deﬁniendo clases gen´ericas
1public interface List <E>{
2void add(E x);
3Iterator <E> iterator ();
4}
5
6public interface Iterator <E>{
7E next ();
8boolean hasNext ();
9}
Java

Subclases
1List <Punto > ls = new ArrayList <Punto >();
2List <FiguraPlana > lo = ls; // Es admisible?
1lo.add(new Recta(A,B)); // ´ısera legal.
Java

Comodines
1void muestra(Collection <Object > c) {
2for (Object e : c) {
3System.out.println(e);
4}
¿Puedo pasarle algo de tipo Lista<FiguraPlana>?
1void muestra(Collection <?> c) {
2for (Object e : c) {
3System.out.println(e);
4}
Es una colecci´on de tipo desconocido, pero al menos deben ser
objetos.
Java

Comodines Acotados
1private static void muestra(List <? extends FiguraPlana > c){
3int i=1;
5System.out.format("Elemento %d "+itr.next(),i);
6System.out.println ();
7i++;
8}
9}
1List <FiguraPlana > listaFiguras =leeFiguras( nombreFiguras );
2List <Punto > listaPuntos =leePuntos( nombrePuntos );
3System.out.println("Puntos:");
4muestra(listaPuntos );
5System.out.println("Figuras:");
6muestra( listaFiguras );
Java

M´etodos gen´ericos
1void insterta(Collection <?> c, FiguraPlana [] figuras) {
2for (FiguraPlana f : figuras) {
3c.add(f); // Ilegal , no se el tipo base de figura .
4}
5}
1void insterta(Collection <? extends FiguraPlana > c, FiguraPlana [] figuras) {
2for (FiguraPlana f : figuras) {
3c.add(f); // Ilegal , no se el tipo base de figura .
4}
5}
Java

1private static <Fig extends FiguraPlana > void insterta(Collection <Fig > c,
2Fig [] figuras) {
3for (Fig f : figuras) {
4c.add(f);
5}
6}
Java

1interface Sink <T> {
2flush(T t);
3}
4public static <T> T writeAll(Collection <T> coll , Sink <T> snk) {
5T last;
6for (T t : coll) {
7last = t;
8snk.flush(last );
9}
10return last;
11}
12
13.....................
14
15Sink <Object > s;
16Collection <String > cs;
17String str = writeAll(cs , s); // Ilegal .
Java

1public static <T> T writeAll(Collection <? extends T>, Sink <T>) {
2...
3}
4...
5String str = writeAll(cs , s); // Devuelve algo de clase Object
Java

1public static <T> T writeAll(Collection <T>, Sink <? super T>) {
2...
3}
4...
5String str = writeAll(cs , s); // Devuelve algo de clase Object
Java

Flujos de entrada/salida
Stream de entrada
Stream de entrada
Java

Byte Streams
1import java.io. FileInputStream ;
2import java.io. FileOutputStream ;
4
5public class CopiaBytes {
6public static void main(String [] args) throws IOException {
7FileInputStream in = null;
8FileOutputStream out = null;
9try {
10in = new FileInputStream (args [0]);
11out = new FileOutputStream (args [1]);
12int c;
13
14while ((c = in.read ()) != -1) {
15out.write(c);
16}
17
18} finally {
19if (in != null) {
20in.close ();
21}
22if (out != null) {
23out.close ();
24}
25}
26}
27}
Java

Llamada desde la l´ınea de comandos
1luis@casa :~/ docencia/Java06 -07$ java CopiaBytes quijote.txt quijote2.txt
2.............
3}
4
5args.length () 2
6args [0] "quijote.txt"
7args [1] "quijote2.txt"
Java

Streams caracteres
1import java.io.FileReader;
2import java.io.FileWriter;
4
5public class CopiaCaracteres {
7FileReader inputStream = null;
8FileWriter outputStream = null;
9
10try {
11inputStream = new FileReader(args [0]);
12outputStream = new FileWriter(args [1]);
13
14int c = inputStream.read ();
15while (c!= -1) {
16outputStream .write(c);
17c = inputStream .read ();
18}
19} finally {
20if ( inputStream != null) {
21inputStream.close ();
22}
23if ( outputStream != null) {
24outputStream .close ();
25}
26}
27}
28}
Java

Streams L´ıneas
1import java.io.FileReader;
2import java.io.FileWriter;
3import java.io. BufferedReader ;
4import java.io. PrintWriter ;
6
7public class CopiaLineas {
9BufferedReader inputStream = null;
10PrintWriter outputStream = null;
11try {
12inputStream = new BufferedReader (new FileReader(args [0]));
13outputStream = new PrintWriter(new FileWriter(args [1]));
14
15String l = inputStream .readLine ();
16while ( l!= null ) {
17outputStream .println(l);
18l = inputStream .readLine ();
19}
20} finally {
21if ( inputStream != null)
22inputStream.close ();
23if ( outputStream != null)
24outputStream .close ();
25}
26}
27}
Java

Buﬀering
1inputStream =
2new BufferedReader (new FileReader(args [0]));
3outputStream =
4new BufferedWriter (new FileWriter(args [1]));
5.........................
6.........................
7outputStream .flush (); // vaciamos el buffer de escritura
Java

Leyendo cosas que no son caracteres
M´etodos Integer.parseInt(java.lang.String),
Double.parseDouble(java.lang.String)
Clase java.util.Scanner
Java

clase Scanner
1import java.io .*;
2import java.util.Scanner;
3
4public class Escaner {
6Scanner s = null;
7try {
8s = new Scanner(new BufferedReader (new FileReader(args [0])));
9
10while (s.hasNext ()) {
11System.out.println(s.next ());
12}
13} finally {
14if (s != null) {
15s.close ();
16}
17}
18}
19}
Java

clase Scanner
1import java.io .*;
2import java.util.Scanner;
3
4public class SumaScan {
6Scanner s = null;
7try {
8s = new Scanner(new BufferedReader (new FileReader(args [0])));
9double suma =0;
10while (s.hasNext ()) {
11if (s. hasNextDouble ()) {
12suma += s.nextDouble ();
13} else {
14String d = s.next ();
15suma += Double.parseDouble(d);
16System.out.println("Error:"+d);
17}
18}
19System.out.format("Suma: %sn",suma );
20} finally {
21if (s != null) {
22s.close ();
23}
24}
25}
26}
Java

clase Scanner
Fichero numeros.txt
11.994.986 ,34
22.000.000 ,00
33.000.000 ,00
43000000
510.11
1~/ Java$ export CLASSPATH =./ classes/
2~/ Java$ /opt/java/jdk1 .5/ bin/java SumaScan numeros.txt
3Error :10.11
4Suma: 9994996.45
Java

Construyendo puntos
2private double posX ,posY;
3public Punto(String s){
4Scanner scan = new Scanner(s);
5scan.useLocale(Locale.US);
6posX=scan.nextDouble ();
7posY=scan.nextDouble ();
8}
9................
10................
11}
Java

Construyendo puntos
2private double posX ,posY;
3public Punto (String s){
4Scanner scan = new Scanner(s);
5posX=Double. parseDouble(scan.next ());
6posY=Double. parseDouble(scan.next ());
7}
8................
9................
10}
Java

Fichero de ﬁguras
Fichero figuras.txt
1circulo
25 5 2
3segmento
43 4 8 4
5recta
63 5 3 6
7recta
80 1 1 1
9circulo
100 2 0.5
11recta
120 2 4 5
13paralelogramo
140 4 2 2 -2 2
15paralelogramo
160 0 2 2 -2 2
17paralelogramo
182 2 0 4 0 0
19paralelogramo
200 0 2 2 4 0
21punto
222 3
Java

Leyendo puntos
Fichero puntos.txt
14 5
27 3
31 1
40.5 1
51 0.5
67 4
70 2
Java

Leyendo
1public class PruebaGeometriaI {
2private static void leeFiguras(String fichero) {..}
3
4private static void leePuntos(String fichero) {..}
5
6public static void main(String args []) throws IOException , FileNotFoundException {
7String nombrePuntos =args [0];
8String nombreFiguras =args [1];
9System.out.println("Puntos:");
10leePuntos( nombrePuntos );
11System.out.println("Figuras:");
12leeFiguras( nombreFiguras );
13}
14}
Java

Leyendo puntos
1private static void leePuntos(String fichero)
3
8System.out.println(p);
10}
11}
Java

Leyendo ﬁguras
1private static FiguraPlana construyeFigura (String tipoFigura , String datos ){..}
2
3private static void leeFiguras(String fichero)
5
7String tipoFigura=lector.readLine ();
8int i=1;
9while (tipoFigura != null ){
11FiguraPlana figura= construyeFigura (tipoFigura ,datos );
12System.out.println(figura );
13tipoFigura=lector.readLine ();
14}
15}
Java

Construyendo ﬁguras
1private static FiguraPlana construyeFigura (String tipoFigura , String datos ){
2FiguraPlana figura;
3if (tipoFigura.equals("punto")) figura=new Punto(datos );
4else if (tipoFigura.equals("recta")) figura=new Recta(datos );
5else if (tipoFigura.equals("segmento")) figura=new Segmento(datos );
6else if (tipoFigura.equals(" paralelogramo ")) figura=new Paralelogramo (datos );
7else if (tipoFigura.equals("circulo")) figura=new Circulo(datos );
8else throw new RuntimeException ("Figura no implementada :"+tipoFigura+":");
9return figura;
10}
Java

Invocación desde la l´ınea de comandos
Variable de entorno CLASSPATH
Debe apuntar al directorio ra´ız donde estén los ficheros .class
1~/ Java$ ls
2build.xml figuras.txt prj.el quijote3.txt src
3classes lib puntos.txt quijote4.txt
4CVS numeros.txt quijote2.txt quijote.txt
5~/ Java$ echo $CLASSPATH
6
7~/ Java$ export CLASSPATH =./ classes
8~Java$ echo $CLASSPATH
9./ classes/
Java

Invocación desde la l´ınea de comandos
Variable de entorno JAVA HOME
Debe apuntar al directorio donde está la instalación de Java.
1~/ Java$ ls ls -ald /opt/java/jdk1 .5
2lrwxrwxrwx 1 root root 11 2006 -07 -18 07:53 /opt/java/jdk1 .5 -> jdk1 .5.0 _07
3~/ Java$ echo $JAVA_HOME
4/opt/java/jdk
5~/ Java$ export JAVA_HOME =/ opt/jdk/jdk1 .5
6~/ Java$ echo $JAVA_HOME
7/opt/jdk/jdk1 .5
8~/ Java$ $JAVA_HOME/bin/java PruebaGeometriaI puntos.txt figuras.txt
9Puntos:
10Punto: (4.0 ,5.0)
11..............
12Punto: (0.0 ,2.0)
13Figuras:´ı
14Crculo:Punto: (5.0 ,5.0):2.0*
15Segmento: Punto: (3.0 ,4.0) - Punto: (8.0 ,4.0)
16Recta: 1.0*X + 0.0*Y = 3.0
17.................................´ı
18Paraleppedo*Punto: (2.0 ,2.0): Punto: (0.0 ,4.0): Punto: ( -2.0 ,2.0): Punto: (0.0 ,0.0)*´ı
19Paraleppedo*Punto: (0.0 ,0.0): Punto: (2.0 ,2.0): Punto: (6.0 ,2.0): Punto: (4.0 ,0.0)*
20Punto: (2.0 ,3.0)
Java

Jerarqu´ıa de clases de colecciones
Java

Colecciones
Collection Grupo de objetos.
Set Concepto matemático. El orden no importa, no hay
repeticiones. SortedSet.
List El orden es importante, admite repeticiones.
Map Concepto de función matemática. SortedMap
Java

Jerarqu´ıa de clases: Map
Java

Interfaz Collection
1public interface Collection <E> extends Iterable <E> {
2................................
3boolean add(E element );
5..........................
6Object [] toArray ();
7<T> T[] toArray(T[] a);
8}
Java

Interface Iterador
1public Interface Iterator {
2public boolean hasNext ();
3public Object next ();
4void remove ();
5}
Java

Uso de listas
1private static List leePuntos(String fichero)
3
5List listaPuntos =new LinkedList ();
11}
13}
1private static void analizaListaPuntos (List c){
3int i=1;
6...........................
7}
8}
Java

Errores en tiempo de ejecución
¿Qué pasar´ıa si añadiera un objeto que no sea de clase Punto?
1Lista lista = leePuntos(fichero );
3analizaPuntos (lista );
La l´ınea
lanzar´ıa un java.lang.ClassCastException.
Java

Clases gen´ericas
1public Interface List <E> {
2......
3public Iterator <E> iterator ()
4.....
5}
1public Interface Iterator <E> {
2public boolean hasNext ();
3public E next ();
4void remove ();
5}
Java

Uso de listas con gen´ericos
1private static List <Punto > leePuntos(String fichero)
3
5List <Punto > listaPuntos =new LinkedList <Punto >();
11}
13}
1private static void analizaListaPuntos (List <Punto > c){
2Iterator <Punto > itr=c.iterator ();
3int i=1;
5Punto p = itr.next ();
6...........................
7}
8}
Java

Errores en tiempo de compilación
¿Qué pasar´ıa si añadiera un objeto que no sea de clase Punto?
1Lista <Punto > lista = leePuntos(fichero );
No compila, la lista es de puntos y puedo añadir rectas.
Java

Interfaz Collection
1public interface Collection <E> extends Iterable <E> {
2int size ();
3boolean isEmpty ();
4boolean contains(Object element );
5boolean add(E element );
6boolean remove(Object element );
8
9boolean containsAll (Collection <?> c);
10boolean addAll(Collection <? extends E> c);
11boolean removeAll(Collection <?> c);
12boolean retainAll(Collection <?> c);
13void clear ();
14
15Object [] toArray ();
16<T> T[] toArray(T[] a);
17}
Los métodos contains y remove comparan los objetos según el
método equals.
Java

Interfaz Set
No añade métodos.
No puede haber elementos repetidos.
Subclases
HashSet La mejor en eficiencia, los iteradores no garantizan el
orden. Método hashCode en la clase Object.
TreeSet Implementación con árboles roji-negros. Los
iteradores recorren el conjunto según el orden
establecido por sus elementos
LinkedHashSet Otra implementación de las tablas hash.
Java

Método equals
Definido en la clase Object. Hay que sobreescribirlo si se va a usar
una clase como elemento de una colección.
Debe ser una relación de orden: o1!=null, o2!=null y
o3!=null
Reflexivo o1.equals(o1)
Simétrico o1.equals(e2)==o2.equals(e1)
Si o1.equals(o2) y o2.equals(o3) entonces
o1.equals(o3)
Si o!=null entonces o.equals(null)==false.
Debe ser consistente: distintas invocaciones a lo largo de un
programa debe dar el mismo resultado si no cambian el valor
de los objetos.
Java

Método hashCode
Definido en la clase Object. Hay que sobreescribirlo si se va a usar
una clase como elemento de una colección tipo hash.
Debe ser consistente.
Si o1.equals(o2), entonces o1.hashCode()=o2.hashCode.
No debe ser necesariamente inyectiva, dos objetos distintos
pueden tener el mismo valor.
Deber´ıa distribuir uniformemente los objetos.
Java

M´etodo CompareTo
1public class Fecha implements Comparable <Fecha >, Cloneable {
2................
3public int compareTo(Fecha f) {
4....
5}
6..........
7}
Implementa relaci´on de orden
x.compareTo



< 0 si x < y
= 0 si x = y
> 0 si x > y
Debe ser implementada para tener colecciones ordenadas.
Java

Método CompareTo
sgn(x.compareTo(y)) == -sgn(y.compareTo(x)).
Debe ser reflexiva antisimétrica y transitiva, para objetos no
nulos
si x.compareTo(x)==0.
si x.compareTo(y)<=0 y y.compareTo(x)<=0 entonces
x.compareTo(z)==0 y z.compareTo(x)==0.
si x.compareTo(y)<=0 y y.compareTo(z)<=0 entonces
x.compareTo(z)<=0.
Debe ser consistente con el resto de los objetos. Si
x.compareTo(y)==0 entonces para todo z entonces
sgn(x.compareTo(z)) == sgn(y.compareTo(z)).
es conveniente que sea consistente con equals: x.equals(y)
sii x.compareTo(y)==0
Java

PrColeccion
1public class PrColeccion {
2public static void lee(String nombre , Collection <String > conjunto)
3throws IOException {
4BufferedReader reader = null;
5try {
6reader = new BufferedReader (new FileReader(nombre ));
7String linea = reader.readLine ();
8while (linea != null) {
9conjunto.add(linea );
10linea = reader.readLine ();
11}
12} finally {
13if (reader != null) {
14reader.close ();
15}
16}
17}
18public static void muestra(Collection <String > conjunto) {
19for (String s : conjunto) {
20System.out.println(s);
21}
22
23}
24}
Java

PrConjunto
1public class PrConjunto {
2public static void main(String [] args) throws Exception{
3String tipo = args [1];
4Set <String > conjunto = null;
5if (tipo.equals("hash")) {
6conjunto = new HashSet <String >();
7} else if (tipo.equals("tree")) {
8// Collator c = Collator . getInstance (new Locale ("es","ES "));
9// conjunto = new TreeSet <String >(c);
10conjunto = new TreeSet <String >();
11} else {
12throw new RuntimeException ("Clase no implementada : "+tipo );
13}
14
15PrColeccion.lee(args [0], conjunto );
16PrColeccion.muestra(conjunto );
17}
18}
Java

Lista de nombres
Fichero nombres.txt
1Luis
2Almudena
3JavierÁ
4lvaro
5Isabel
6Marisa
7Natalia
8Albertoé
9Andrs
10Andres
11Andros
12Luis
13Almudena
14JavierÁ
15lvaro
16Isabel
17Marisa
18Natalia
19Albertoé
20Andrs
21Andres
22Andros
23Luis
24Almudena
25JavierÁ
26lvaro
27IsabelLuis Fernando Llana D´ıaz Departamento de Sistemas Informáticos y ComputaciónUniversidad Complutense de Madrid
Java

Ejecución de conjuntos
1~/ Java$ $JAVA_HOME/bin/java PrConjunto nombres.txt tree
2Alberto
3Almudena
4Andres
5Androsé
6Andrs
7Isabel
8Javier
9Luis
10Marisa
11NataliaÁ
12lvaro
Java

Iteradores
Un iterador es un objeto que sirve para recorrer una estructura
1public interface Iterator <E> {
3E next ();
4}
1for (Iterator <String > it = coleccion.iterator (); it.hasNext (); )
2String s = s.next ();
3System.out.println ();
4}
1for (String s : coleccion) {
2System.out.println(s);
3}
Java

Listas
El orden de los objetos es importante, puede haber repeticiones de
objetos.
1public interface List <E> extends Collection <E> {
2// Acceso posicional
3E get(int index );
4E set(int index , E element ); // optional
5boolean add(E element ); // optional
6void add(int index , E element ); // optional
7E remove(int index ); // optional
8boolean addAll(int index ,
9Collection <? extends E> c); // optional
10
11// ´uBsquedas
12int indexOf(Object o);
13int lastIndexOf (Object o);
14
15// Iteradores de listas
16ListIterator <E> listIterator ();
17ListIterator <E> listIterator (int index );
18
19// Sublistas
20List <E> subList(int from , int to);
21}
Java

Iteradores de listas
1public interface ListIterator <E> extends Iterator <E> {
3E next ();
4boolean hasPrevious ();
5E previous ();
6int nextIndex ();
7int previousIndex ();
8void remove (); // optional
9void set(E e); // optional
10void add(E e); // optional
11}
Java

Implementaciones de listas
ArrayList Generalmente más eficiente.
LinkedList Eficiente cuando no se hacen accesos posicionales.
Java

Maps
1public interface Map <K,V> {
2
3// Operaciones ´absicas
4V put(K key , V value );
5V get(Object key );
6V remove(Object key);
7boolean containsKey(Object key );
8boolean containsValue (Object value );
9int size ();
10boolean isEmpty ();
11
12void putAll(Map <? extends K, ? extends V> m);
13void clear ();
14
15// Vistas
16public Set <K> keySet ();
17public Collection <V> values ();
18public Set <Map.Entry <K,V>> entrySet ();
19
20// Interface for entrySet elements
21public interface Entry {
22K getKey ();
23V getValue ();
24V setValue(V value );
25}
26}
Java

PrMap
1public class PrMap {
2private static void lee(String nombre ,
3Map <String ,Integer > map) throws IOException {
4BufferedReader reader = null;
5try {
6reader = new BufferedReader (new FileReader(nombre ));
7String linea = reader.readLine ();
8while (linea != null) {
9Integer i = map.get(linea );
10if (i== null) {
11i = new Integer (1);
12} else {
13i = new Integer(i.intValue ()+1);
14}
15map.put(linea ,i);
16linea = reader.readLine ();
17}
18} finally {
19if (reader != null) {
20reader.close ();
21}
22}
23}
Java

PrMap
1
2private static void muestra(Map <String ,Integer > map) {
3for (String s: map.keySet ()) {
4System.out.println(s+":"+map.get(s));
5}
6}
7public static void main(String [] args) throws Exception{
8String tipo = args [1];
9Map <String ,Integer > map = null;
10if (tipo.equals("hash")) {
11map = new HashMap <String ,Integer >();
12} else if (tipo.equals("tree")) {
13map = new TreeMap <String ,Integer >( Collator. getInstance ());
14} else {
15throw new RuntimeException ("Clase no implementada : "+tipo );
16}
17
18lee(args [0], map);
19muestra(map);
20}
21}
Java

Implementaciones
HashMap Basadas en tablas hash.
TreeMap Basadas en ´arboles, cuando las claves se pueden
ordenar.
Java

Java fundamentos

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (19)

Destacado

Destacado (20)

Similar a Java fundamentos

Similar a Java fundamentos (20)

Java fundamentos