Programación Orientada a Objetos (3er curso, grupo 32) 13.04.

10
4. Jerarquías de clases

Definición básica de subclases

class Persona {
String nombre;
int edad;
String asString () {
return "Nombre: " + nombre + "\nEdad: " + edad;
}
}
Jerarquías de clases class Empleado extends Persona {
long sueldoBruto;
Directivo jefe;
}
class Directivo extends Empleado {
int categoria;
ArrayList<Empleado> equipo = new ArrayList<Empleado> ();
void promocionar () { categoria++; }
}
2

Jerarquía de tipos (I) Jerarquía de tipos (II)

Persona x1, x2;
class C {
Empleado y, emp = new Empleado (); void f (Empleado p) { ... }
Directivo z, dir = new Directivo (); void g (Directivo p) { ... }
ƒ Conversión automática implícita (generalización) }

x1 = emp; // Empleado → Persona Un Directivo puede

hacer automáticamente Directivo dir = new Directivo ();
x2 = dir; // Directivo → Persona Empleado x = dir
dir, emp = new Empleado ();
ell papell de
d Empleado
E l d
y = dir; // Directivo → Empleado y de Persona C c = new C ();
ƒ Conversión explícita (especialización), responsabilidad del programador ƒ Conversión implícita
z = x2; // Error de compilación c.f (dir); // Directivo → Empleado
Una Persona puede
z = (Directivo) x2; // Persona → Directivo hacer el papel de ƒ Conversión explícita
z = (Directivo) x1; // Error de ejecución: Directivo si realmente c.g (x); // Error de compilación
es un Directivo
// x1 no es un Directivo c.g ((Directivo) x); // Empleado → Directivo
z = (Perro) x1; // Error de compilación (a menos que Perro c.g ((Directivo) emp); // Error de ejecución: emp no es
// un Directivo
// fuese subclase o superclase de Persona)
3 4

Herencia y jerarquía de tipos

Herencia de variables y métodos
Directivo dir = new Directivo ();
Tipo estático vs.
Empleado emp = new Empleado (); Empleado emp = dir;
tipo dinámico
Directivo dir = new Directivo (); Persona p = dir;

emp.nombre = "Pedro"; p.sueldoBruto = 100; // Error: sueldoBruto no

emp.edad = 28; // definido para Persona
emp.sueldoBase = 200; emp promocionar (); //
emp.promocionar Error: promocionar no
emp.jefe = dir; // definido para Empleado
System.out.println (emp.asString ());
Persona

dir.nombre = "Maria"; nombre

Empleado

p
dir.edad = 45; edad
Directivo

emp
dir.sueldoBruto = 700; dir sueldo
dir.jefe = null; jefe
dir.categoria = 3;
categoría
System.out.println (dir.asString ());
5 6

Escuela Politécnica Superior

Pablo Castells Universidad Autónoma de Madrid
Programación Orientada a Objetos (3er curso, grupo 32) 13.04.10
4. Jerarquías de clases

Sobreescritura de variables y métodos

Sobreescritura de variables
ƒ Redefinición de variables y métodos de una clase padre en una subclase
ƒ La definición de la subclase ensombrece a la de la superclase
class Musico extends Persona {
ƒ La definición de la superclase accesible desde la subclase con super
String nombre;
ƒ Sobreescritura de métodos (especialización) void mostrarNombres () {
– El método se redefine con los mismos argumentos y tipo de retorno System.out.println ("Musico: " + nombre);
– Si no coinciden los tipos de los argumentos, se trata de una sobrecarga System.out.println
y p ("Persona: " + super.nombre);
p
– No se puede aumentar la privacidad de los métodos sobreescritos }
}
– Evita la proliferación de identificadores
– Permite la ligadura dinámica
// Bloque main
ƒ Sobreescritura de variables Musico m = new Musico ();
– Se reserva un espacio de memoria para cada definición Persona p = m;
– El tipo no tiene por qué coincidir m.nombre = "Stevie Wonder"; // nombre de Musico
p.nombre = "Stevland Morris"; // nombre de Persona
– Ligadura estática
– En general es preferible evitar la sobreescritura de variables
7 8

Sobreescritura de métodos Ligadura dinámica

ƒ La sobreescritura de métodos se resuelve por ligadura dinámica en
class Empleado extends Persona { tiempo de ejecución
long sueldoBruto; ƒ Se ejecuta la definición del método de la clase más específica del objeto,
Directivo jefe; independientemente de cómo se ha declarado la referencia al objeto
String asString () {
return "Nombre: " + nombre + "\nEdad: " + edad + A void f ()
"\nSueldo: " + sueldoBruto + "\nJefe: " + objj ppertenece a las
((jefe == null)? nombre : jefe.nombre); clases A, B, C, D, E
B void f ()
} E obj = new E();
} x declarado como A,
C A x = obj;
apunta a un E
// Bloque main x.f();
Empleado emp = new Empleado (); D void f () se ejecuta la versión
Persona p = emp; de f definida en D
emp.asString (); // asString de Empleado E
p.asString (); // asString de Empleado
ƒ Los métodos estáticos tienen ligadura estática
9 10

Ligadura dinámica: ejemplo

class Persona { class Directivo extends Empleado {
String nombre; int categoria;
int edad; ArrayList<Empleado> equipo = new ArrayList<Empleado> ();
String asString () { String asString () {
return "Nombre: " + nombre + "\nEdad: " + edad; return "Nombre: " + nombre + "\nEdad: " + edad +
} "\nSueldo: " + sueldoBruto + "\nJefe: " +
} ((jefe == null)? nombre : jefe.nombre) +
class Empleado extends Persona { "\nCategoria: " + categoria;
long sueldoBruto; }
Directivo jefe; void promocionar () { categoria++; }
String asString () { }
return "Nombre: " + nombre + "\nEdad: " + edad +
"\nSueldo: " + sueldoBruto + "\nJefe: " +
((jefe == null)? nombre : jefe.nombre);
}
} 11 12

Escuela Politécnica Superior

Pablo Castells Universidad Autónoma de Madrid
Programación Orientada a Objetos (3er curso, grupo 32) 13.04.10
4. Jerarquías de clases

La ligadura respecto a
// Bloque main los argumentos es estática
Directivo dir = new Directivo (); class A {
Empleado emp = new Empleado (); void f (Persona p) {
Empleado z = dir; System.out.println ("Clase Persona");
Persona p = new Persona (); }
Persona x = emp; void f (Empleado emp) {
Persona y = z; System.out.println ("Clase Empleado");
}
p.asString (); // asString de Persona } // Bloque main
emp.asString (); // asString de Empleado A a = new A ();
dir.asString (); // asString de Directivo Se ejecuta la definición Directivo dir = new Directivo (...);
x.asString (); // asString de Empleado compatible más específica Persona p = dir;
y.asString (); // asString de Directivo a.f (dir); Suponiendo que Persona
z.asString (); // asString de Directivo a.f (p); es subclase de Animal
y.promocionar (); // ERROR Animal x = p;
a.f (x); // ERROR
13 14

Herencia y constructores Herencia y constructores: ejemplo

class Persona {
Los constructores no se heredan ni se sobreescriben String nombre;
int edad;
ƒ Al crear un Empleado, se invoca al constructor de Persona Persona (String str, int i) {
nombre = str;
ƒ Invocación automática implícita edad = i;
– Se invoca al constructor de la clase padre sin argumentos }
String asString () {
– Si no está definido → error ...
ƒ Invocación explícita }
}
– Invocación a super (...) en la primera línea del constructor de Empleado
// Error al crear un Empleado: el constructor por
ƒ Invocación a otros constructores de la misma clase: this (...) // defecto Empleado () invoca al constructor por
// defecto Persona (), que ya no está definido

15 16

class Empleado extends Persona {

long sueldoBruto;
Directivo jefe;
Empleado (String str, int i, long sueldo, Directivo dir) { class Empleado extends Persona {
nombre = str; long sueldoBruto;
super (str, i); Directivo jefe;
edad = i;
sueldoBruto = sueldo; Empleado (String str, int i, long sueldo, Directivo dir) {
jefe = dir; super (str, i);
} sueldoBruto = sueldo;
St i
String asString
St i () {
jefe = dir;
...
} }
} String asString () {
// Error al crear un Empleado: se sigue invocando ...
// automáticamente a Persona () por defecto }
}
// Error al crear un Directivo: el constructor por
// defecto Directivo () invoca al constructor por
// defecto Empleado (), que ya no está definido
17 18

Escuela Politécnica Superior

Pablo Castells Universidad Autónoma de Madrid
Programación Orientada a Objetos (3er curso, grupo 32) 13.04.10
4. Jerarquías de clases

class Directivo extends Empleado { Control de acceso: private

int categoria;
ArrayList<Empleado> equipo class Persona {
= new ArrayList<Empleado> (); private String nombre;
Directivo (String str, int i, long n, int j) { private int edad;
this (str, i, n, null, j); String asString () {
Siempre en la } return "Nombre: " + nombre + "\nEdad: " + edad;
primera línea Directivo (String str, int i, long n, }
, int j) {
Directivo dir, }
super (str, i, n, dir); Error: nombre y
categoria = j; class Empleado extends Persona {
long sueldoBruto; edad son privados
}
String asString () { Directivo jefe;
... String asString () {
} return "Nombre: " + nombre + "\nEdad: " + edad +
void promocionar () { categoria++; } "\nSueldo: " + sueldoBruto + "\nJefe: " +
} ((jefe == null)? nombre : jefe.nombre);
}
}
19 20

Control de acceso: protected (I) Control de acceso: protected (II)

class Persona {
package personal;
protected String nombre;
protected int edad; public class Persona {
protected String asString () { protected String nombre;
return "Nombre: " + nombre + "\nEdad: " + edad; protected int edad;
} protected String asString () {
Error: sólo puede ser
} return "Nombre: " + nombre + "\nEdad: " + edad;
protected o public
}
class Empleado extends Persona { Correcto incluso si }
long sueldoBruto; Empleado y Persona
Directivo jefe; en distinto package
String asString () { package personal; package X;
return super.asString () + ... ...
"\nSueldo: " + sueldoBruto + "\nJefe: " + // En cualquier clase // En cualquier clase
((jefe == null)? nombre : jefe.nombre); Persona p = new Persona (); personal.Persona p =
} p.asString (); new personal.Persona ();
} En distinto package habría error si ... p.asString (); // Error
jefe fuera Persona pero no Empleado ...
21 22

package p2;

Control de acceso: class C { Clases final y miembros final

void h () {
protected (III) p1.A a = new p1.A ();
final class A {
a.w = 2; // Error
a.x = 6; // Error }
a.y = 8; // Error
a.z = 3; class B extends A { // Error: A no se puede derivar
package p1;
} final int x; // Error: obligatorio inicializar x
public class A { } final double f (int x) {
i t w; // package
int k class D extends p1
p1.A
A { return (x-1)/(x+1);
private int x; void h () { }
p1.A a = new p1.A (); }
protected int y;
w = 2; a.w = 2; // Error
public int z; x = 2; a.x = 6; // Error
class C extends B {
} z = 3; a.z = 3;
a.y = 8; // Error
int x;
y = 8; double f (int x) { // Error: f no se puede sobreescribir
D d = new D (); return (x-2)/(x+2);
d.y = 8; }
} }
}
23 24

Escuela Politécnica Superior

Pablo Castells Universidad Autónoma de Madrid
Programación Orientada a Objetos (3er curso, grupo 32) 13.04.10
4. Jerarquías de clases

Clases abstractas, métodos abstractos

ƒ Clases abstractas
– No se pueden crear objetos
new A () → ERROR si A abstracta
– Se pueden definir subclases
Abstracción de clases ƒ Métodos abstractos
e interfaces – Métodos sin código, se declaran pero no se definen
– Deben definirse en alguna subclase
ƒ Una clase abstracta puede tener métodos no abstractos
ƒ Un método abstracto debe pertenecer a una clase abstracta
ƒ Si una subclase no implementa un método abstracto heredado,
debe ser abstracta también
26

Clases abstractas: ejemplo Utilidad de los métodos abstractos

abstract class Figura {
abstract double area (); class Grupo {
} private ArrayList<Figura> figuras
class Circulo extends Figura { = new ArrayList<Figura> ();
Pubto2D centro; double radio; void agregarFigura (Figura fig) {
double area () { figuras.add (fig);
return Math.PI * radio * radio; }
} double area () {
} double a = 0;
Iterator iter<Figura> = figuras.iterator ();
class Triangulo extends Figura {
Punto2D a, b, c; while (iter.hasNext ())
double area () { a += iter.next () .area ();
return Math.abs ((b.x-a.x)*(c.y-a.y) - return a;
(b.y-a.y)*(c.x-a.x))/2; }
} }
} 27 28

Métodos heredados abstractos java.lang.Number es una clase abstracta

abstract class Figura { Error: Poligono tiene doubleValue()

abstract double area (); que ser abstract intValue() métodos
} byteValue() floatValue() abstractos
métodos
class Poligono extends Figura { no abstractos shortValue() abstract longValue()
// No se implementa area () Number
}
Byte Double
class Triangulo extends Poligono {
Punto2D a, b, c;
double area () {
return Math.abs ((b.x-a.x)*(c.y-a.y) - Short Float
(b.y-a.y)*(c.x-a.x))/2;
} Integer Long
}
29 30

Escuela Politécnica Superior

Pablo Castells Universidad Autónoma de Madrid
Programación Orientada a Objetos (3er curso, grupo 32) 13.04.10
4. Jerarquías de clases

Motivación

// Algoritmo de ordenacion

public class Algoritmos {

Interfaces public static void ordenar (double valores[]) {

int i, j;
for (i = 0; i < valores.length; i++)
for (j = valores.length-1; j > i; j--)
if (valores[j] < valores[j-1])
intercambiar (valores, j, j-1);
}
}

32

// Generalizacion
interface Ordenable {
boolean menor (Ordenable valor);
public class Algoritmos { }
public static void ordenar (Ordenable valores[]) {
int i, j; class Directivo extends Empleado implements Ordenable {
...
for (i = 0; i < valores.length; i++)
public boolean menor (Ordenable dir) {
for (j = valores.length-1; j > i; j--) return categoria < ((Directivo) dir).categoria;
if (valores[j]
(valores[j].menor
menor (valores[j
(valores[j-1]))
1])) }
intercambiar (valores, j, j-1); }
}
class Figura implements Ordenable {
}
...
Se necesita: public boolean menor (Ordenable fig) {
return area () < ((Figura) fig).area ();
ƒ Una forma genérica de referirse a datos ordenables }
ƒ Una definición de la relación de orden para cada tipo de datos ordenables }

33 34

public static void main (String args[]) {

Directivo jefes[] = { ¿Qué es una interfaz?
new Directivo (...),
new Directivo (...),
ƒ Colección de métodos sin definir y valores constantes
new Directivo (...)
}; ƒ Similar a una clase abstracta con todos los métodos abstractos
Figura objcompuesto[] = {
y públicos y todas las variables public static final
new Triangulo (...),
new Circulo (...), ƒ Derivar de una clase → implementar una interfaz
new Rectangulo (...)
}; ƒ Una clase puede implementar varias interfaces
Algoritmos.ordenar (jefes);
Algoritmos.ordenar (objcompuesto);
}

35 36

Escuela Politécnica Superior

Pablo Castells Universidad Autónoma de Madrid
Programación Orientada a Objetos (3er curso, grupo 32) 13.04.10
4. Jerarquías de clases

public class Pila implements Coleccion {

private ArrayList elementos = new ArrayList ();
Definición de una interfaz: ejemplo public void introducir (Object obj) {
if (elementos.size () < MAXIMO_NUMERO)
elementos.add (obj);
}
import java.util.*;
public Object extraer () {
if (vacia ()) return null;
public interface Coleccion { else {
public int MAXIMO_NUMERO = 500; Object ultimo = elementos.get (elementos.size ());
public void introducir (Object obj); elementos.remove (ultimo);
return ultimo;
public Object extraer ();
}
} }
public boolean vacia () {
return elementos.size () == 0;
}
}
37 38

Utilización de una interfaz

class A {
¿Para qué sirve una interfaz?
Coleccion elementos;
ƒ Una interfaz impone un protocolo de métodos a implementar
A (Coleccion col) { elementos = col; }
void cogerUno (Coleccion col) { ƒ Una interfaz introduce un nuevo tipo
elementos.introducir (col.extraer ());
} Las clases que implementan la interfaz son compatibles con este tipo
}
ƒ Las interfaces posibilitan la herencia múltiple en cuanto a jerarquía de tipos:
class MainClase {
public static void main (String []) { Una interfaz define un tipo ⇒ una clase puede tener múltiples supertipos
Pila p1 = new Pila ();
ƒ Sin embargo una interfaz no tiene contenido que heredar:
Pila p2 = new Pila ();
p1.introducir ("Buenos dias"); – los métodos no tienen código
p2.introducir ("Buenas noches"); – las variables se heredan pero son inamovibles (son estáticas y constantes)
p2.introducir ("a todo el mundo");
ƒ Una interfaz no proporciona funcionalidad a un objeto, sino la posibilidad
A a = new A (p1);
a.cogerUno (p2); de ser objeto de la funcionalidad de otros objetos
}
} 39 40

¿Por qué una interfaz y no una clase? Interfaces: otros detalles

Si Ordenable es una clase abstracta: Ordenable ƒ Una interfaz puede derivar de varias otras interfaces con extends

ƒ Obliga a derivar desde la cima de la jerarquía ƒ Las interfaces también pertenecen a un package
Declara f ( ) Implementa f ( )
ƒ Obliga a definir el método menor a nivel de Figura Persona ƒ Las interfaces pueden ser public o del package
interface I class A
Persona y de Empleado (si no, clases abstractas) ƒ Los métodos implementados deben ser public
ƒ Problema si Persona y Directivo son clases Polígono Empleado en las clases que implementan las interfaces
definidas por distintos programadores class B
ƒ Al implementar una interfaz, la clase pierde las
Triángulo Rectángulo Hexágono Directivo definiciones de los métodos que coincidan con Se pierde la definición
de f ( ) dada en A
métodos definidos en sus superclases
En general, siempre que sea posible y
tenga sentido, mejor interfaz que clase
41 42

Escuela Politécnica Superior

Pablo Castells Universidad Autónoma de Madrid
Programación Orientada a Objetos (3er curso, grupo 32) 13.04.10
4. Jerarquías de clases

Jerarquía de interfaces y clases (I)

Ejemplo de abstracción de clases:
Framework de colecciones Java Collection

ƒ Arquitectura para representar y manipular colecciones de datos Set AbstractCollection List Queue

ƒ Interfaces: jerarquía de funcionalidades

SortedSet AbstractSet AbstractList
ƒ Implementaciones: distinto comportamiento

ƒ Clases abstractas: implementaciones parciales TreeSet HashSet AbstractSequentialList ArrayList Vector

ƒ Algoritmos: polimórficos, operaciones sobre las interfaces Stack

LinkedList PriorityQueue ...

43 44

Jerarquía de interfaces y clases (II) Interfaz java.util.Collection

Map
ƒ Colección genérica

ƒ Insertar,
Insertar eliminar
eliminar, pertenencia,
pertenencia iterar
SortedMap AbstractMap Dictionary

TreeMap HashMap HashTable

45 46

public interface Collection<E> extends Iterable<E> {

// Basic Operations
int size();
boolean isEmpty(); Interfaz java.util.Set
boolean contains(Object element);
boolean add(E element);
boolean remove(Object element); ƒ Mismos métodos que Collection
Iterator<E> iterator(); ƒ Los elementos no pueden repetirse

// Bulk Operations Esto influye en add, containsAll, addAll, retainAll, removeAll

boolean containsAll(Collection<?> c); ƒ set1.equals (Object set2) puede devolver true aunque set2 no
boolean addAll(Collection<? extends E> c);
boolean removeAll(Collection<?> c); sea del mismo tipo de implementación que set1
boolean retainAll(Collection<?> c); ƒ Implementaciones
void clear();
– HashSet: tabla hash, máxima eficiencia
public interface Iterator<E> {
// Array Operations – TreeSet: árbol red-black, asegura orden de iteración
boolean hasNext();
Object[] toArray(); E next();
<T> T[] toArray(T a[]); void remove();
} } 47 48

Escuela Politécnica Superior

Pablo Castells Universidad Autónoma de Madrid
Programación Orientada a Objetos (3er curso, grupo 32) 13.04.10
4. Jerarquías de clases

Interfaz java.util.SortedSet public interface SortedSet<E> extends Set<E> {

// Range-view
SortedSet<E> subSet(E fromElement, E toElement);
ƒ Conjunto ordenado
SortedSet<E> headSet(E toElement);
ƒ Con iterator() se itera por orden SortedSet<E> tailSet(E fromElement);

ƒ toArray() devuelve los elementos en orden

// Endpoints
ƒ toString() muestra los elementos en orden E first();
E last(); Subsets que comparten memoria
ƒ Se puede especificar una relación de orden (función de comparación) en
con el set original
el constructor (ver implementaciones) // Comparator access
Comparator<? super E> comparator();
ƒ Implementaciones: TreeSet
}

49 50

public interface List<E> extends Collection<E> {

// Positional Access
Interfaz java.util.List E get(int index);
E set(int index, E element);
ƒ Colección con posiciones asociadas a los elementos
void add(int index, E element);
ƒ Operaciones posicionales E remove(int index);
ƒ add al final, remove el primero abstract boolean addAll(int index, Collection<? extends E> c);

ƒ list1.equals (Object list2) puede devolver true aunque list2 no sea // Search
del mismo tipo de implementación que list1 int indexOf(Object o);
ƒ Implementaciones int lastIndexOf(Object o);
– ArrayList: encapsula un array dinámico (acceso cte., inserción/eliminación lineal)
// Backward iteration
– LinkedList: encapsula una lista enlazada (acceso lineal, inserción/eliminación cte.) ListIterator<E> listIterator();
addFirst (Object obj) addLast (Object obj) ListIterator<E> listIterator(int index);
getFirst () getLast () Sublista que comparte
// Range-view memoria con la lista original
removeFirst () removeLast ()
List<E> subList(int from, int to); Si la original cambia,
51
} resultado impredecible 52

Interfaz java.util.Map
public interface ListIterator<E> extends Iterator<E> {
boolean hasNext();
E next(); ƒ Pares clave / elemento
void remove();
ƒ Las claves no se repiten
boolean hasPrevious();
E previous(); ƒ map1.equals (Object map2) puede devolver true aunque map2 no
sea del mismo tipo de implementación que map1
int nextIndex();
int previousIndex(); ƒ Implementaciones
void set (E e); – HashMap: tabla hash, máxima eficiencia
void add (E e);
} – TreeMap: árbol red-black, asegura orden de iteración

53 54

Escuela Politécnica Superior

Pablo Castells Universidad Autónoma de Madrid
Programación Orientada a Objetos (3er curso, grupo 32) 13.04.10
4. Jerarquías de clases

public interface Map<K,V> {

// Basic Operations
V put(K key, V value);
V get(K key);
V remove(K key);
boolean containsKey(Object key); ...
boolean containsValue(Object value);
// Interface for entrySet elements
int size();
public interface Entry<K,V> {
boolean isEmpty();
K getKey();
// Bulk Operations V getValue();
void putAll(Map<? extends K, ? extends V> t); V setValue(V value);
void clear(); }
}
Siempre se devuelve el
// Collection Views mismo objeto Collection.
public Set<K> keySet(); remove afecta, add no
public Collection<V> values();
public Set<Map.Entry<K,V>> entrySet();
... 55 56

Interfaz java.util.SortedMap
public interface SortedMap<V,K> extends Map<V,K> {
Comparator<? super K> comparator();
ƒ Map ordenado por clave

K firstKey(); Submaps que comparten memoria

ƒ first, last, rangos (submaps)
K lastKey(); con el map original
ƒ Con iterator() se itera por orden de clave
// Range view
ƒ toArray() devuelve los elementos en orden de clave SortedMap<V,K> subMap(K fromKey, K toKey);
SortedMap<V,K> headMap(K toKey);
ƒ toString() muestra los elementos en orden SortedMap<V,K> tailMap(K fromKey);
}
ƒ Permite cambiar la relación de orden (función de comparación)

ƒ Implementaciones: TreeMap

57 58

Algunas conversiones (I) Algunas conversiones (II)

Iterator
Object[]
No comparten iterator() ArrayList (Collection c) ArrayList
Comparten
memoria toArray() memoria
LinkedList (Collection c) LinkedList
Collection Arrays.asList(Object[]) Collection
values()
HashSet (Collection c) H hS t
HashSet
Comparten memoria Comparten memoria
remove afecta, add no No permite añadir, eliminar, TreeSet (Collection c) TreeSet
No comparten
ni cambiar el tamaño
memoria
keySet()
Map Set List
entrySet() HashMap (Map m) HashMap
No se puede
Map
singleton(Object)
modificar TreeMap (Map m) TreeMap
Object
59 60

Escuela Politécnica Superior

Pablo Castells Universidad Autónoma de Madrid
Programación Orientada a Objetos (3er curso, grupo 32) 13.04.10
4. Jerarquías de clases

Algoritmos sobre colecciones

Interfaz java.util.Collections Interfaz java.lang.Comparable
Los elementos de las
public interface Comparable<E> {
class Collections colecciones tienen que
implementar Comparable public int compareTo (E o);
public static void sort (List list)
}
public static void sort (List list, Comparator c)
public static int binarySearch (List list, Object key) ƒ Hacer que una clase pueda ser objeto de comparación (establecer orden
public static int binarySearch (List list, Object key, natural,
t l definir
d fi i relación
l ió d de orden
d ttotal
t l en una clase)
l ) p.e.:
Comparator c) – Para introducirlas en colecciones ordenadas SortedSet ó SortedMap
public static Object min (Collection col) – Para algoritmos de búsqueda y ordenación
public static Object min (Collection col, Comparator c) ƒ ClassCastException si se comparan Comparable’s de distinta clase
public static Object max (Collection col) ƒ Conviene que sea consistente con equals para SortedSet y SortedMap
public static Object max (Collection col, Comparator c)
ƒ Algunas clases Java implementan Comparable
public static List reverse (List list)
...
61 62

Clases Java que implementan Interfaz java.util.Comparator

java.lang.Comparable
public interface Comparator<T> {
public int compare (T o1, T o2);
Comparable public int compareTo (E o) }

ƒ Saltarse
S lt la
l relación
l ió d de orden
d natural
t ld de un Comparable
– En colecciones ordenadas SortedSet ó SortedMap
Byte Character Short Integer Long Float Double
– Para algoritmos de búsqueda y ordenación

ƒ Conviene que sea consistente con equals para SortedSet y SortedMap

BigInteger BigDecimal String Date

63 64

Diseño de clases basadas

en colecciones
ƒ Métodos que manipulan colecciones
– Arguentos de entrada: interfaces, lo más genéricas posibles
– Valores de retorno: la implementación más específica posible
ƒ Nuevas implementaciones de colecciones Reflexión: conocimiento
– Escoger la clase abstracta apropiada
AbstractCollection
dinámico de las clases
AbstractSet
AbstractList
AbstractSequentialList
AbstractMap
– Implementar todos los métodos abstractos como mínimo

65

Escuela Politécnica Superior

Pablo Castells Universidad Autónoma de Madrid
Programación Orientada a Objetos (3er curso, grupo 32) 13.04.10
4. Jerarquías de clases

La clase java.lang.Object Metainformación sobre las clases

en tiempo de ejecución
ƒ Clase padre por defecto si no se especifica otra

class A {...} es equivalente a class A extends Object {...} El operador instanceof

ƒ Tratamiento genérico de objetos: vectores, etc. Triangulo t = new Triangulo;

Figura fig = t;
ƒ Proporciona definición por defecto para métodos como equals,
t instanceof Triangulo → true
toString, getClass t instanceof Poligono → true
ƒ Los arrays son tambien subclases de Object t instanceof Figura → true
t instanceof Circulo → false
fig instanceof Triangulo → true

67 68

Metainformación de clase: ejemplo Metainformación sobre las clases

class A {
en tiempo de ejecución
void f (Persona p) {
if (p instanceof Empleado)
La clase java.lang.Class
System.out.println ("Clase Empleado"); método de la
ƒ Obtener un objeto Class
else if (p instanceof Persona) clase Object
Class c1 = t.getClass ();
System.out.println ("Clase Persona"); c1 == c2
} Class c2 = fig.getClass
g g ();
c11 == c3
3
} Class c3 = Class.forName ("Triangulo");
// Bloque main
A a = new A (); ƒ Métodos de java.lang.Class método estático de
la clase Class
Directivo dir = new Directivo (...); – getName () → String
Persona p = dir; – isArray (), isPrimitive (), isInterface ()
a.f (dir); – getConstructors (), getFields (),
a.f (p); getMethods (), getSuperclass ()
Animal x = p;
– newInstance ()
a.f (x); // ERROR
ƒ Class es subclase de Object
69 70

Escuela Politécnica Superior

Pablo Castells Universidad Autónoma de Madrid