Igualdad entre Objetos

 Todas las clases en java tiene un herencia

implícita de la clase Object por lo cual cualquier
instancia de clase es una instancia de una
clase Object.

Object

n n n n
 toString() de Object

El método toString() de Object es llamado cada ves que se quiera
obtener la descripción en String de un objeto y debe ser sobre escrito
en consecuencia en aquellas clases que necesitan ser descriptas

Por ejemplo cuando pasamos la referencia de un objeto a
System.out.print() por ejemplo
public
publicclass
classHardToRead
HardToRead{ {
public
publicstatic
staticvoid
voidmain
main(String
(String[][]args)
args){ {
HardToRead
HardToReadhh==new newHardToRead();
HardToRead();
System.out.println(h);
System.out.println(h);
}}
}}

%%java
javaHardToRead
HardToRead
HardToRead@a47e0
HardToRead@a47e0////por
pordefecto
defectoelelmétodo
métodotoString()
toString()devuelve
devuelve un
unString
Stringconteniendo
conteniendo
//el
//el nombre de la clase mas @ mas un códigohash
nombre de la clase mas @ mas un código hash
de la clase
de la clase
////utilizado
utilizadopor
porlas
lascolecciones
colecciones
 toString() sobre escritura
public
publicclass
classBobTest
BobTest{ {
public
publicstatic
staticvoid
voidmain
main(String[]
(String[]args)
args){ {
Bob
Bobf f==new
newBob("GoBobGo",
Bob("GoBobGo",19); 19);
System.out.println(f);
System.out.println(f);
}}
}}

class
classBob
Bob{ {
int
intshoeSize;
shoeSize;
String
StringnickName;
nickName;
Bob(String
Bob(StringnickName,
nickName,int
intshoeSize)
shoeSize){ {
this.shoeSize
this.shoeSize==shoeSize;
shoeSize;
this.nickName = nickName;
this.nickName = nickName;
}}
public
publicString
StringtoString()
toString(){ {
return
return("I("Iam
amaaBob,
Bob,but
butyouyoucan
cancall
callme
me" "++nickName
nickName++
".".MyMyshoe
shoesize
sizeisis" "++shoeSize);
shoeSize);
}}
}}
 El metodo equals()

 El método equals() de la clase Object nos dice

si dos objetos son iguales en sus propiedades
o contenidos mientras que == nos dice si dos
referencias de objetos son las mismas o están
apuntando al mismo objeto.
 equals() este método por defecto internamente
solo usa para comparar el == por lo cual , se
hace necesario la sobre escritura del método
equals()
 Sobre Escritura de equals()
public class EqualsTest {
public class EqualsTest {
public static void main (String [] args) {
public static void main (String [] args) {
Moof one = new Moof(8);
Moof one = new Moof(8);
Moof two = new Moof(8);
Moof two = new Moof(8);
if (one.equals(two)) {
if (one.equals(two)) {
System.out.println("one and two are equal");
System.out.println("one and two are equal");
}
}
}
}
}
}
class Moof {
class Moof {
private int moofValue;
private int moofValue;
Moof(int val) {
Moof(int val) {
moofValue = val;
moofValue = val;
}
}
public int getMoofValue() {
public int getMoofValue() {
return moofValue;
return moofValue;
}
}
public boolean equals(Object o) {
public boolean equals(Object o) {
if ((o instanceof Moof) && (((Moof)o).getMoofValue()
if ((o instanceof Moof) && (((Moof)o).getMoofValue()
== this.moofValue)) {
== this.moofValue)) {
return true;
return true;
} else {
} else {
return false;
return false;
}
}
}
}
}
}
 Contrato equals()
 Reflexiva : x.equals(x) debe retornar true.
 Simetrica : x.equals(y) es true entonces
y.equals(x) tambien debe ser true.
 Transitiva : x.equals(y) es true ademas
y.equals(z) es true entonces x.equals(z) debe
ser true.

Consistente : para x.equals(y) retorna true para
varias llamadas tambien debe retornar
verdadero
 Para una referencia no null de x , x.equals(null)
debe retornar false.
 El metodo hashCode()

 Este método es comúnmente utilizado para la

búsqueda y la recuperación de elementos
dentro de una colección
 Es una especie de id de los objetos pero que
no necesariamente tiene que ser único
 Por defecto el método hashCode() de Object
virtualmente siempre nos da un solo código
hash para objeto instanciado.
 Sobre escribiendo hashCode()
class
classHasHash
HasHash{ {
public
publicint
intx;x;
HasHash(int
HasHash(intxVal)
xVal){ {xx==xVal;
xVal;} }
public
publicboolean
booleanequals(Object
equals(Objecto)o){ {
HasHash
HasHashhh==(HasHash)
(HasHash)o;o;////utilizar
utilizarsiempre
siempreeleloperador
operadorinstanceof
instanceof
ifif(h.x
(h.x==
==this.x)
this.x){ {
return
returntrue;
true;
} }else
else{ {
return
returnfalse;
false;
}}

}}

public
publicint
inthashCode()
hashCode(){ {return
return(x(x* *17);
17);} }
}}
 Reglas para hashCode()

 El hashCode de un objeto debe ser consistente

durante toda la ejecución del programa, es
decir tiene que ser el mismo numero para el
mismo objeto.
 Si dos objetos son iguales de acuerdo a
equals() entonces tienen que tener el mismo
hashCode().
 No necesariamente dos objetos distintos de
acuerdo a equals() tiene que tener distintos
hashCode().
 Colecciones

Las colecciones en java son un marco de trabajo con el cual
podemos almacenar y ordenar y procesar un conjunto de
objetos.

Las colecciones sirven para :

Agregar objetos a una colección existente

Remover objetos a una colección existente

Averiguar si un objeto esta en una colección

Devolver un objetos de un colección

Iterar a través de una colección

Colecciones
 Colecciones
 Las interfaces de las colecciones encapsulan
los diferentes tipos de colecciones.Son las
siguientes.
 Collection: es la interfaz raíz en la jerarquía, representa un conjunto de objetos
llamados elementos de esta.
 Set : es una colección de elementos que no tiene elementos duplicados

List : es una colección ordenada de elementos por un índice , puede contener
elementos duplicados.

Queue : representa una estructura de cola o tipo FIFO.

Map : es un objeto que mapea un clave con un valor , no se pueden tener claves
duplicadas.
 SortedSet : es un Set ordenado en forma ascendente.
 SortedMap : es un Map ordenado por sus claves en forma ascendente.
 Colecciones

 Las interfaces que están dentro de el marco

de trabajo de colecciones
Implementaciones
 Implementacion de List
 ArrayList : es un arreglo capas de crecer dinámicamente, se los
utiliza cuando se necesita iteraciones rápidas , no así cuando
hay muchas inserciones o eliminaciones de elementos.
 Vector : es lo mismo que ArrayList pero sus métodos están
sincronizados , se prefiere el uso de ArrayList si no se utiliza la
sincronización de los métodos debido a que esto disminuye la
performance.
 LinkedList : sus elementos están ordenados por un índice igual
que ArrayList pero cada elementos esta doblemente vinculado
con su predecesor y su antecesor por lo cual LinkedList tiene
mas métodos de eliminación e inserción que ArrayList, se lo
utiliza cuando existen muchas inserciones y eliminaciones y no
así cuando se busca iteraciones rápidas
 Implementaciones de Set
 HashSet : es un conjunto de elementos desordenados únicos ,
insertados por su código hash, utitlize esta colección cuando
quiera que los elementos sean únicos y no le preocupe su
orden.
 LinkedHashSet : es una versión ordenada de HashSet que
vincula cada elemento de la colección doblemente, utilice la
cuando el orden tenga importancia.
 TreeSet : es una colección ordenada que me permite tener un
conjunto de elementos ordenados en forma ascendente.
 Implementaciones de Map

 HashMap : nos ofrece un conjunto de elementos desordenados

vinculados con una clave que tiene que ser única
 HashTable : es lo mismo que HasMap pero tiene sus métodos
sincronizados.
 LinkedHashMap : es lo mismo que HashMap pero sus
elementos estan ordenados por la inserción

TreeMap : nos permite tener un conjunto de elementos
ordenados por su orden natural a través de la interfaz
Comparable o Comparator
 Implementaciones de Queue

 PriorityQueue : esta clase es nueva en Java 5 ,

es una mejora que se hizo a LinkedList , y es
utilizada para construir estructuras FIFO
ordenadas mediante la interfaz Comparator.

out

In
Usando el FrameWork Collections

 El paquete que encapsula todos los elementos

del framework es el de java.util
 Allí se encuentra también las interfaces
Comparable y Comparator

java.util.*
 ArrayList
List
ListmyList
myList==new
newArrayList();
ArrayList();
////En
Enjava
java55se
sepuede
puedeescribir
escribirde
delalasiguiente
siguienteforma
forma
List<String>
List<String>myList
myList==new
newArrayList<String>();
ArrayList<String>();

import
importjava.util.*;
java.util.*;
public
public classTestArrayList
class TestArrayList{ {
public
publicstatic
staticvoid
voidmain(String[]
main(String[]args)
args){ {
List<String>
List<String>test
test==new
newArrayList<String>();
ArrayList<String>();
String s = "hi";
String s = "hi";
test.add("string");
test.add("string");
test.add(s);
test.add(s);
test.add(s+s);
test.add(s+s);
System.out.println(test.size());
System.out.println(test.size());
System.out.println(test.contains(42));
System.out.println(test.contains(42));
System.out.println(test.contains("hihi"));
System.out.println(test.contains("hihi"));
test.remove("hi");
test.remove("hi");
System.out.println(test.size());
System.out.println(test.size());
}}
}}
 Autoboxing en Colecciones
 Antes de java 5 uno tenia que encapsular si o si
un tipo de dato primitivo para utilizarlo en una
colección , a partir de java 5 ya no es necesario
debido al autoboxing.

List
ListmyInts
myInts==new
newArrayList();
ArrayList();////pre
preJava
Java55declaración
declaración
myInts.add(new
myInts.add(newInteger(42));
Integer(42)); ////tenemos
tenemosque
queencapsular
encapsularint
int
////en
enjava
java55nosotros
nosotrosdecimos
decimosesto
esto
myInts.add(42);
myInts.add(42); ////autoboxing
autoboxingmanipula
manipulaesto
esto
 Ordenando Colecciones

 ArrayList no tiene un metodo para ordenar los

objetos que contiene pero la clase Collections
dentro de java.util si.
import
importjava.util.*;
java.util.*;
class
class TestSort1{ {
TestSort1
public
publicstatic
staticvoid
voidmain(String[]
main(String[]args)
args){ {
ArrayList<String>
ArrayList<String>stuff
stuff==new
newArrayList<String>();
ArrayList<String>();////ArrayList
ArrayListde
deString
String
stuff.add("Denver");
stuff.add("Denver");
stuff.add("Boulder");
stuff.add("Boulder");
stuff.add("Vail");
stuff.add("Vail");
stuff.add("Aspen");
stuff.add("Aspen");
stuff.add("Telluride");
stuff.add("Telluride");
System.out.println("unsorted
System.out.println("unsorted" "++stuff);
stuff);
Collections.sort(stuff);
Collections.sort(stuff); ////Ordenamos
Ordenamoslalacoleccion
coleccionde
deString
String
System.out.println("sorted " + stuff);
System.out.println("sorted " + stuff);
}}
}}
 La interface Comparable
 La interface Comparable es utilizada por
Collection.sort() para ordenar los objetos dentro
de la coleccion de elementos.
 Los elementos de una colección deben
implementarla para que Collection.sort() pueda
ordenarlos
 Comparable solo tiene un metodo para
implementar y es compareTo()
 La interface Comparable
 La invocación de compareTo() se ve de la
siguiente forma .
int
intxx==thisObject.compareTo(anotherObject);
thisObject.compareTo(anotherObject);

 El método retorna un int con las siguientes

caracteristicas.
 Negativo si ”thisObject” < ”anotherObject”
 Cero si ”thisObject” == ”anotherObject”
 Positivo si ”thisObject” > ”anotherObject”
 La interface Comparable
 La interface Comparable se puede implementar
asi.
class
classDVDInfo
DVDInfoimplements
implementsComparable
Comparable{{
private
privateString
Stringtitle;
title;
public
publicint
intcompareTo(Object
compareTo(Objecto)
o){{ ////toma
tomaun
unObject
Objectcomo
como
//parametro
//parametro
DVDInfo
DVDInfodd==(DVDInfo)o;
(DVDInfo)o;
return
returntitle.compareTo(d.getTitle());//
title.compareTo(d.getTitle());//utiliza
utilizaelelmetodo
metodo
//compareTo
//compareTode
de
lalaclase
claseString
String
}}
 La interface Comparator

 El metodo Collections.sort() tambien puede

utilizar la interface Comparator para ordenar los
objetos de una lista.
 La interface Comparator me permite comparar
dos objetos ,incluso aquellos objetos que no
puedo modificar sus clases.
 Esta interface tiene un solo metodos llamado
”compare(Object o1 , Object o2)”
 Interface Comparator
import
importjava.util.*;
java.util.*;
class
class GenreSortimplements
GenreSort implementsComparator<DVDInfo>
Comparator<DVDInfo>{ {
public
publicint
intcompare(DVDInfo
compare(DVDInfoone,one,DVDInfo
DVDInfotwo)
two){ {
return
returnone.getGenre().compareTo(two.getGenre());
one.getGenre().compareTo(two.getGenre());////getGenre() getGenre()retorna
retornaun
unString
String
////
se
seutiliza
utilizaelelcompareTo
compareTode deString
String
}}
}}
import
importjava.util.*;
java.util.*;
import java.io.*;
import java.io.*;
public
publicclass
classTestDVD
TestDVD{ {
ArrayList<DVDInfo>
ArrayList<DVDInfo>dvdlist
dvdlist==new
newArrayList<DVDInfo>();
ArrayList<DVDInfo>();
public
public static void main(String[] args){ {
static void main(String[] args)
new
newTestDVD().go();
TestDVD().go();
}}
public
publicvoid
voidgo()
go(){ {
populateList();
populateList();
System.out.println(dvdlist);
System.out.println(dvdlist); //lee //leelalalista
listade
dedvd dvddesde
desdeununarchivo
archivo
Collections.sort(dvdlist);
Collections.sort(dvdlist);
System.out.println(dvdlist);
System.out.println(dvdlist); ////muestramuestralalalista listade
dedvd
dvdordenada
ordenadapor
portitulo
titulo
GenreSort gs = new GenreSort(); // Contrulle objeto que implementa
GenreSort gs = new GenreSort(); // Contrulle objeto que implementa Comparable Comparable
Collections.sort(dvdlist,
Collections.sort(dvdlist,gs);
gs);////ordena
ordenalalalista
listaporporgenero
genero
System.out.println(dvdlist);
System.out.println(dvdlist); // muestra la lista porgenero
// muestra la lista por genero
}}
 Convirtiendo Array a List
 ”List” y ”Set” tienen el metodos ”toArray()” para
convertir listas y conjuntos a arreglos mientras
que la Clase Array tiene el metodo asList().
String[]
String[]sasa=={"one",
{"one","two",
"two","three",
"three","four"};
"four"};
List sList = Arrays.asList(sa);
List sList = Arrays.asList(sa); ////transforama
transforamaun unarreglo
arregloaauna
unalista
lista
//mantienen
//mantienen referencias al mismo conjunto deelementos
referencias al mismo conjunto de elementos
System.out.println("size " + sList.size());
System.out.println("size " + sList.size());
System.out.println("idx2
System.out.println("idx2" "++sList.get(2));
sList.get(2));
sList.set(3,"six");
sList.set(3,"six"); ////cambia
cambialalalistalista
sa[1] = "five";
sa[1] = "five"; // cambia el arreglo
// cambia el arreglo
for(String s : sa)
for(String s : sa)
System.out.print(s
System.out.print(s++" "");");
System.out.println("\nsl[1]
System.out.println("\nsl[1]" "++sList.get(1));//
sList.get(1));//

//Resultados
//Resultados
size
size44
idx2
idx2three
three
one
one fivethree
five threesix
six
sl[1] five
sl[1] five
 Usando List

 Las listas List tienen iteradores que son objetos

que implementan la interface Iterator , para
recorrer los elementos de la lista.
 Los metodos mas importante de Iterator son :
 boolean hasNext() que retorna true si tiene mas
elementos la lista para recorrer.
 Object next() que retorna el proximo objeto en la
coleccion.
 Usando List
import
importjava.util.*;
java.util.*;
class Dog {
class Dog {
public String name;
public String name;
Dog(String n) { name = n; }
Dog(String n) { name = n; }
}
}
class ItTest {
class ItTest {
public static void main(String[] args) {
public static void main(String[] args) {
List<Dog> d = new ArrayList<Dog>();
List<Dog> d = new ArrayList<Dog>();
Dog dog = new Dog("aiko");
Dog dog = new Dog("aiko");
d.add(dog);
d.add(dog);
d.add(new Dog("clover"));
d.add(new Dog("clover"));
d.add(new Dog("magnolia"));
d.add(new Dog("magnolia"));
Iterator<Dog> i3 = d.iterator(); // make an iterator
Iterator<Dog> i3 = d.iterator(); // make an iterator
while (i3.hasNext()) {
while (i3.hasNext()) {
Dog d2 = i3.next(); // cast not required
Dog d2 = i3.next(); // cast not required
System.out.println(d2.name);
System.out.println(d2.name);
}
}
System.out.println("size " + d.size());
System.out.println("size " + d.size());
System.out.println("get1 " + d.get(1).name);
System.out.println("get1 " + d.get(1).name);
System.out.println("aiko " + d.indexOf(dog));
System.out.println("aiko " + d.indexOf(dog));
d.remove(2);
d.remove(2);
Object[] oa = d.toArray();
Object[] oa = d.toArray();
for(Object o : oa) {
for(Object o : oa) {
Dog d2 = (Dog)o;
Dog d2 = (Dog)o;
System.out.println("oa " + d2.name);
System.out.println("oa " + d2.name);
}
}
}
}
}
}
 Usando Set

 Set tiene solo elementos distintos y se descarta

la insercion de elementos que ya existen.
 Set es bastante rapido debido a que utiliza el
hashCode de los objetos, para la insercion.
 Se puede utilizar con esta interface HashSet,
LinkedHashSet , TreeSet que es un conjunto
ordenado.
 Usando Set
import
importjava.util.*;
java.util.*;
class
class SetTest{ {
SetTest
public
publicstatic
staticvoid
voidmain(String[]
main(String[]args)
args){ {
boolean[]
boolean[]ba ba==newnewboolean[5];
boolean[5];
Set s = new HashSet();
Set s = new HashSet();
ba[0]
ba[0]==s.add("a");
s.add("a");
ba[1]
ba[1] = s.add(newInteger(42));
= s.add(new Integer(42));
ba[2] = s.add("b");
ba[2] = s.add("b");
ba[3]
ba[3]==s.add("a");
s.add("a");
ba[4]
ba[4] = s.add(newObject());
= s.add(new Object());
for(int
for(int x=0; x<ba.length;x++)
x=0; x<ba.length; x++)
System.out.print(ba[x]
System.out.print(ba[x] +" "");");
+
System.out.println("\n");
System.out.println("\n");
for(Object
for(Objectoo: :s)s)
System.out.print(o
System.out.print(o++" "");");
}}
}}
//resultado
//resultado
true
truetrue
truetrue
truefalse
falsetrue
true
aajava.lang.Object@e09713
java.lang.Object@e0971342 42bb
 Usando Set
import
importjava.util.*;
java.util.*;
class
class SetTest{ {
SetTest
public
publicstatic
staticvoid
voidmain(String[]
main(String[]args)
args){ {
boolean[]
boolean[]ba ba==new
newboolean[5];
boolean[5];
Set s = new TreeSet();
Set s = new TreeSet();
ba[0]
ba[0]==s.add("a");
s.add("a");
ba[1]
ba[1] = s.add(newInteger(42));//
= s.add(new Integer(42));//error
errorlos
loselementos
elementostienen
tienenque
queser
sercomparables
comparablesentre
entresisi
ba[2]
ba[2]==s.add("b");
s.add("b");
ba[3] = s.add("a");
ba[3] = s.add("a");
ba[4]
ba[4]==s.add(new
s.add(newObject());
Object());
for(int
for(int x=0; x<ba.length;x++)
x=0; x<ba.length; x++)
System.out.print(ba[x]
System.out.print(ba[x] +" "");");
+
System.out.println("\n");
System.out.println("\n");
for(Object
for(Objectoo: :s)s)
System.out.print(o
System.out.print(o++" "");");
}}
}}
 Usando Map
 Para usar una clase en Map como clave es
necesario sobre escribir los metodos equals() y
hashCode() para encontrar los elementos
dentro del Map.
import
importjava.util.*;
java.util.*;
class
class Dog{ {
Dog
public
publicDog(String
Dog(Stringn)n){ {name
name==n;n;} }
public
publicString
Stringname;
name;
public
public booleanequals(Object
boolean equals(Objecto)o){ {
if((o
if((oinstanceof
instanceofDog)
Dog)&&&&
(((Dog)o).name
(((Dog)o).name == name)){ {
== name))
return
returntrue;
true;
} }else {
else {
return
returnfalse;
false;
}}
}}
public
publicint inthashCode()
hashCode(){return
{returnname.length();
name.length();} }
}}
class
classCat Cat{ {} }
enum
enumPets Pets{DOG,
{DOG,CAT,
CAT,HORSE
HORSE} }
 Usando Map
class
classMapTest
MapTest{ {
public
publicstatic
staticvoid
voidmain(String[]
main(String[]args)
args){ {
Map<Object,
Map<Object,Object>
Object>mm==newnewHashMap<Object,
HashMap<Object,Object>();Object>();
m.put("k1",
m.put("k1", new Dog("aiko")); // add some key/valuepairs
new Dog("aiko")); // add some key/value pairs
m.put("k2", Pets.DOG);
m.put("k2", Pets.DOG);
m.put(Pets.CAT,
m.put(Pets.CAT,"CAT "CATkey");
key");
Dog
Dog d1 = new Dog("clover"); ////let's
d1 = new Dog("clover"); let'skeep
keepthis
thisreference
reference
m.put(d1, "Dog key");
m.put(d1, "Dog key");
m.put(new
m.put(newCat(),
Cat(),"Cat
"Catkey");
key");
System.out.println(m.get("k1"));
System.out.println(m.get("k1")); ////#1 #1
String k2 = "k2";
String k2 = "k2";
System.out.println(m.get(k2));
System.out.println(m.get(k2)); ////#2#2
Pets p = Pets.CAT;
Pets p = Pets.CAT;
System.out.println(m.get(p));
System.out.println(m.get(p)); ////#3#3
System.out.println(m.get(d1));
System.out.println(m.get(d1)); // #4
// #4
System.out.println(m.get(new
System.out.println(m.get(new Cat()));////#5
Cat())); #5
System.out.println(m.size());
System.out.println(m.size()); // #6
// #6
}}
}}
//resultados
//resultados
Dog@1c
Dog@1c
DOG
DOG
CAT
CATkeykey
Dog key
Dog key
null
null
 Generics

 Generics en java nos da la posibilidad de

establecer claramente los tipos de datos que va
a tener una colección y con ello decirnos en
tiempo de compilación alguna asignación
errónea
 Los generics fueron introducidos a partir de
java 5
 Generics
List
ListmyList
myList==new
newArrayList();
ArrayList();////viejo
viejoestilo
estiloantes
antesde
dejava
java55

List<Integer>
List<Integer>myList
myList==new
newArrayList<Integer>();
ArrayList<Integer>();////nuevo
nuevoestilo
estilo
//esto
//estoes
escomo
comose
sepuede
puededeclarar
declararuna
unacolección
colecciónen
enjavajava55

Lista de Tipos Object Lista de Tipos Integer

 Polimorfismo Generics

 En Generics el polimorfismo no tiene las misma

reglas que para los arreglos
class
classParent
Parent{ {} }
class
classChild
Childextends
extendsParent
Parent{ {} }
List<Parent>
List<Parent>myList
myList==new
newArrayList<Child>();
ArrayList<Child>();////error
errorno
nopuede
puedeser
seruna
unasubclase
subclase
////tiene
tieneque
que
ser la misma clase
ser la misma clase
List<Object>
List<Object>myList
myList==new
newArrayList<JButton>();
ArrayList<JButton>();////NO!
NO!
List<Number>
List<Number> numbers = new ArrayList<Integer>();////NO!
numbers = new ArrayList<Integer>(); NO!
List<JButton>
List<JButton>myList
myList==new
newArrayList<JButton>();
ArrayList<JButton>();////SiSies
escorrecto
correcto
List<Object> myList = new ArrayList<Object>(); // Si es correcto
List<Object> myList = new ArrayList<Object>(); // Si es correcto
List<Integer>
List<Integer>myList
myList==new
newArrayList<Integer>();
ArrayList<Integer>();////SiSies
escorrecto
correcto
 Polimorfismo Generics

import
importjava.util.*;
java.util.*;
class
class Parent{ {} }
Parent
class
classChild
Childextends
extendsParent
Parent{ {} }
public
publicclass
classTestPoly
TestPoly{ {
public
publicstatic
staticvoid
voidmain(String[]
main(String[]args)
args){ {
Parent[]
Parent[]myArray
myArray==new
newChild[3];
Child[3];//Es
//Escorrecto
correctocon
conarreglos
arreglospero
perono
nocon
conGenerics
Generics
}}
}}

En los arreglos existe una excepción llamada ArrayStoreException en el caso de poner
un objeto no adecuado al arreglo.

En los generics no existe tal cosa por lo que el compilador no permite que se les asigne
una lista de subtipos
 Polimorfismo Generics
public
publicvoid
voidfoo()
foo(){ {
Cat[]
Cat[]cats
cats=={new
{newCat(),
Cat(),new
newCat()};
Cat()};
addAnimal(cats);
addAnimal(cats); // no hay problemascon
// no hay problemas conlos
losarreglos
arreglos
}}

public
publicvoid
voidaddAnimal(Animal[]
addAnimal(Animal[]animals)
animals){ {
animals[0]
animals[0]==new
newDog();
Dog();////Error
Errorestoy
estoyponiendo
poniendoun
unDog
Dogen
enun
unarreglo
arreglode
deCat
Cat
}}
public
publicvoid
voidaddAnimal(List<Animal>
addAnimal(List<Animal>animals)
animals){ {
animals.add(new
animals.add(newDog());
Dog());////esto
estoes
eslegal
legal
}}

public
publicstatic
staticvoid
voidmain(String[]
main(String[]args)
args){ {
List<Animal>
List<Animal>animals
animals==new
newArrayList<Animal>();
ArrayList<Animal>();
animals.add(new Dog());
animals.add(new Dog());
animals.add(new
animals.add(newDog());
Dog());
AnimalDoctorGeneric
AnimalDoctorGenericdoc doc==new
newAnimalDoctorGeneric();
AnimalDoctorGeneric();
doc.addAnimal(animals);
doc.addAnimal(animals); //Ok estoesta
//Ok esto estabien
bien
}}
 Polimorfismo Generics

 Se puede hacer que un metodo que tiene como

parametro una lista generics pueda recibir una
lista de subtipos de la clase de elementos usan
do <?> de la siguiente forma.
public
publicvoid
voidaddAnimal(List<Animal>
addAnimal(List<Animal>animals);
animals);
////este
estemétodo
métodose
setransforma
transformaen
enesto
estode
delalasiguiente
siguienteforma
forma
public
publicvoid
voidaddAnimal(List<?
addAnimal(List<?extends
extendsAnimal>
Animal>animals);
animals);
//Con
//Conesto
estoestamos
estamosdiciendo
diciendoque
queelelmétodo
métodovavaaceptar
aceptarListas
Listasde
desubtipos
subtiposde
deAnimal
Animal
////yytambién
también estoy diciendo que el dentro del método addAnimal no voy a agregarnada
estoy diciendo que el dentro del método addAnimal no voy a agregar nadapor
por
//lo que lo siguiente estaría mal
//lo que lo siguiente estaría mal
public
publicvoid
voidaddAnimal(List<?
addAnimal(List<?extends
extendsAnimal>
Animal>animals)
animals){ {
animals.add(new
animals.add(newDog());
Dog());////NO!
NO!No
Nose
sepuede
puedeagregar
agregarsisise
seusa
usa
////<? extends Animal>
<? extends Animal>
}}
 Generics

 Con <?> siempre se usa extends no importa si

es una clase superior o una interface.
void
voidfoo(List<?
foo(List<?extends
extendsSerializable>
Serializable>list)
list)//esto
//estose seusa
usacuando
cuandoquiero
quieropasar
pasarunauna
////clase
claseque
que
implementa Serializable
implementa Serializable
////totouse
use"extend
"extend
public
publicvoid
voidaddAnimal(List<?
addAnimal(List<?super
superDog>
Dog>animals)
animals){ {
animals.add(new
animals.add(newDog());
Dog());//add
//addesta
estabien
biencon
consuper
supercomo
comorestriccion
restriccion
}}
public
publicstatic
staticvoid
voidmain(String[]
main(String[]args)
args){ {
List<Animal>
List<Animal>animals
animals==new
newArrayList<Animal>();
ArrayList<Animal>();
animals.add(new Dog());
animals.add(new Dog());
animals.add(new
animals.add(newDog());
Dog());
AnimalDoctorGeneric
AnimalDoctorGenericdoc doc==newnewAnimalDoctorGeneric();
AnimalDoctorGeneric();
doc.addAnimal(animals);
doc.addAnimal(animals); // passingan
// passing anAnimal
AnimalList
List
}}
 Generics
public
publicvoid
voidfoo(List<?>
foo(List<?>list)
list){ {} }
//Hay
//Hayunaunadiferencia
diferenciabastante
bastanteimportante
importanteentre
entreestos
estosdos
dosmétodos
métodos
//el
//el primero acepta una lista de cualquier tipo mientras queelelsegundo
primero acepta una lista de cualquier tipo mientras que segundo
////solo acepta lista de Object y nada mas
solo acepta lista de Object y nada mas // //

public
publicvoid
voidfoo(List<Object>
foo(List<Object>list)
list){ {} }

import
importjava.util.*;
java.util.*;
public
public classTestWildcards
class TestWildcards{ {
public
publicstatic
staticvoid
voidmain(String[]
main(String[]args) args){ {
List<Integer>
List<Integer>myList
myList==new newArrayList<Integer>();
ArrayList<Integer>();
Bar bar = new Bar();
Bar bar = new Bar();
bar.doInsert(myList);
bar.doInsert(myList);
}}
}}
class
classBar Bar{ {
void
voiddoInsert(List<?>
doInsert(List<?>list)list){ {
list.add(new
list.add(newDog());
Dog());////error
errorelel<?>
<?>nonomemedeja
dejautilizar
utilizarelelmetodo
metodoadd
addde
delalalista
lista
}}
}}
 Declaracion de Generics
//declaransion
//declaransiongenerics
genericsde
delalainterface
interfaceList
List
public
publicinterface
interfaceList<E>
List<E>

 <E> es una convención por Elements pero

también puede ir <T> o cualquier identificador
de java valido
 Declaracion de Generics
import
importjava.util.*;
java.util.*;
public
public classRentalGeneric<T>
class RentalGeneric<T>{ { ////"T" "T"isisfor
forthe
thetype
type
////parameter
parameter
private
private List<T> rentalPool; ////Use
List<T> rentalPool; Usethetheclass
classtype
typefor
forthe
the
////List type
List type
private int maxNum;
private int maxNum;
public
publicRentalGeneric(
RentalGeneric(
int
int maxNum,List<T>
maxNum, List<T>rentalPool)
rentalPool){ {////constructor
constructortakes
takesaa
////List
Listofofthe
theclass
classtype
type
this.maxNum = maxNum;
this.maxNum = maxNum;
this.rentalPool
this.rentalPool==rentalPool;
rentalPool;
}}

public
publicTTgetRental()
getRental(){ { ////we
werent
rentout
outaaTT
////blocks
blocksuntil
untilthere's
there'ssomething
somethingavailable
available
return rentalPool.get(0);
return rentalPool.get(0);
}}
public
publicvoid
voidreturnRental(T
returnRental(TreturnedThing)
returnedThing){ {////and
andthe
therenter
renter
////returns a
returns a TT
rentalPool.add(returnedThing);
rentalPool.add(returnedThing);
}}

}}