How to use Redis with MuleSoft. A quick start presentation.
Tema 0 Repaso Programación en Java
1. Análisis y Diseño
de Software
Tema 0. Repaso
Programación
Carlos A. Iglesias <cif@gsi.dit.upm.es>
Departamento de Ingeniería de Sistemas Telemáticos
http://moodle.dit.upm.es
2. Leyenda
Teoría
Ejercicio práctico en el ordenador
Ampliación de conocimientos
Lectura / Vídeo / Podcast
Práctica libre / Experimentación
Repaso Programación 2
3. Bibliografía
● Libros:
– Objects First with
Java, A Practical
Introduction using
BlueJ, D. Barnes &
M. Kölling, 2012
Repaso Programación 3
4. Bibliografía
●Head First Java, K.
Sierra and B. Bates,
O'Reilly, 2005
●
http://proquest.safari
booksonline.com/bo
ok/programming/jav
a/0596009208
Repaso Programación 4
6. Objetivos
● Repasar los conceptos de programación
● Practicar dichos conceptos
Repaso Programación 6
7. Estructuras de datos (I)
De tamaño fijo: arrays
– Pueden ser de objetos (inicializados a null) o
tipos primitivos (inicializados a 0, 0.0,'',false)
– Tamaño fijo al
int [] array = new int[2]; crearlos int i = 0;
Punto [] array2 = {new Punto(1,2), while (i < array.length) {
new Punto(2,3)}; System.out.println(a[i]);
int [] array3 = {1, 2, 3}; i++;
for (int elem : array){ }
System.out.println(elem); int i = 0;
} do {
for (int i = 0; i < array.length; i++){ System.out.println(a[i]);
System.out.println(a[i]); I++;
} }while(i < array.length);
Repaso Programación 7
9. Estructura de datos (II)
De tamaño dinámico: Collections
– Sólo objetos
– Diferentes interfaces extienden Collection: Set,
List, Map
– Implementaciones de las interfaces: HashSet,
ArrayList, HashMap
import java.util.List; import java.util.ArrayList; import java.util.Iterator;
List<Punto> lista = new ArrayList<Punto>();
lista.add(new Punto(1,2));
for (Punto p : lista){ System.out.println(p);}
for (int i = 0; i < lista.size(); i++) {System.out.println(lista.get(i));}
Iterator<Punto> it = lista.iterator();
while ( it.hasNext()) {System.out.println(it.next());}
int i = 0;
while (i < lista.size()) {System.out.println(lista.get(i)); i++;}
int i = 0; Repaso Programación 9
do { System.out.println(lista.get(i)); i++; }while (i < lista.size());
12. Interfaz List<E>
extends Collection<E>
●Tiene orden y puede tener elementos
repetidos. Añade métodos para el índice
– E get(int index) (empieza en 0)
– int indexOf(Object o) (primera ocurrencia, -1 si
no está)
– int lastIndexOf(Object o) (última / -1 si no está)
– E remove (int index)
– List<E> sublist(int fromIndex, int toIndex)
Repaso Programación 12
13. Interfaz Set<E>
extends Colllection<E>
●Sin elementos repetidos y sin orden
●Métodos de Collection
●Nota. Collection extiende Iterable<E> que
tiene el método iterator()
Repaso Programación 13
14. Copia de arrays
(compartir referencia)
int [] a = {1, 2, 3, 4};
a
int [] b = a; b
a
a[0] = 2;
b
Repaso Programación 14
15. Copia de arrays
(copiar valores)
int [] a = {1, 2, 3, 4, 5};
int [] b = new int[a.length];
for (int i = 0; i < a.length; i++){
b[i] = a[i];
}
int [] a = {1, 2, 3, 4, 5};
System.arraycopy(a, 0, b, 0, a.length);
b no puede ser null, tiene que estar inicializado
Repaso Programación 15
16. Copia de arrays
unidimenisionales
String [] a = {“a1”, “a2”};
String [] b = new String[a.length];
System.arraycopy(a, 0, b, 0, a.length); // equiv a un for
a
b
a[0] = “a1 modificado”;
a
b
Repaso Programación 16
17. Copia de arrays
multidimensionales
String [][] a = {{“a1”, “a2”}, {“a3”, “a4”}};
String [][] b = new String[a.length][a[0].length];
System.arraycopy(a, 0, b, 0, a.length);
a
b
a[0][0] = “a1 modificado”;
a
b
Repaso Programación 17
18. Arrays bidimensionales -
Ejercicios
●Método que reciba un array bidimensional
de Strings y lo imprima
●Método suma que reciba dos arrays
bidimensionales de ints devuelva la suma
●Método mezcla que recibe dos arrays
bidimensionales con mismas filas y los
mezcla (primero las columnas de a1 y
luego las columnas de a2). Lanza
excepción si no se cumplen dimensiones
Repaso Programación 18
19. Comparar arrays
●Comprobar si es el mismo array
– a1 == a2
●Comparar si tienen el mismo contenido
boolean compara(int [] a1, int [] a2){
if ((a1 == null) || (a2 == null)
|| (a1.length != a2.length)) { return
false;}
for (int i = 0; i < a1.length; i++) {
if (a1[i] != a2[i]) {return false;}
}
return true;
}
Repaso Programación 19
20. Ejercicio
●Crear un array de 100 enteros y cargarlo
con el cuadrado de cada uno [0, 1, 4, 9, 16,
…]
●Crear un array de booleans para los 100
primeros enteros positivos que diga true si
es impar [false, true, false, true, …]
●Crearun array de 100 enteros y rellenarlo
con enteros aleatorios entre 0 y 1000.
Repaso Programación 20
21. Ejercicio
●Crear un array de 100 enteros y cargarlo
con el cuadrado de cada uno [0, 1, 4, 9, 16,
…]
●Crear un array de booleans para los 100
primeros enteros positivos que diga true si
es impar [false, true, false, true, …]
●Crearun array de 100 enteros y rellenarlo
con enteros aleatorios entre 0 y 1000.
Repaso Programación 21
22. Tipos enumerados – Day.java
public enum Day {
SUNDAY, MONDAY, TUESDAY, WEDNESDAY,
THURSDAY, FRIDAY, SATURDAY
}
Repaso Programación 22
23. Uso en una clase.
EnumTest(I)
public class EnumTest {
private Day day;
public EnumTest(Day day) {
this.day = day;
}
public void tellItLikeItIs() {
switch (day) {
case MONDAY: System.out.println("Mondays are bad.");
break;
case FRIDAY: System.out.println("Fridays are better.");
break;
case SATURDAY:
case SUNDAY: System.out.println("Weekends are best.");
break;
default: System.out.println("Midweek days are so-so.");
break;
}
}
Repaso Programación 23
24. main de EnumTest
public static void main(String[] args) {
EnumTest firstDay = new EnumTest(Day.MONDAY);
firstDay.tellItLikeItIs();
EnumTest thirdDay = new EnumTest(Day.WEDNESDAY);
thirdDay.tellItLikeItIs();
EnumTest fifthDay = new EnumTest(Day.FRIDAY);
fifthDay.tellItLikeItIs();
EnumTest sixthDay = new EnumTest(Day.SATURDAY);
sixthDay.tellItLikeItIs();
EnumTest seventhDay = new EnumTest(Day.SUNDAY);
seventhDay.tellItLikeItIs();
}
Mondays are bad.
Midweek days are so-so.
Fridays are better.
Weekends are best.
Weekends are best.
Repaso Programación 24
25. Más cosas de enums
●En Java, los tipos enum definen una clase
de tipo enum (extiende de forma implícita
java.lang.Enum). El cuerpo de la clase
puede tener métodos y otros campos.
●Los tipos enum, tienen un método de clase
(static) llamado values() que nos devuelve
un array de los valores del enum en el
orden que se declararon
for (Day d : Day.values()) {
System.out.printf("Day “ + d);
}
Repaso Programación 25
26. Otro ejemplo
Estacion.java
public enum Estacion {INVIERNO, PRIMAVERA, VERANO, OTONO}
Uso:
- if (estacion == Estacion.INVIERNO) // o equals()
● - Estacion[] estaciones = Estacion.values();
● - Estacion i = Estacion.valueOf(“INVIERNO”); //String->Enum
Repaso Programación 26
28. Métodos de clase
●Un método de clase se define añadiendo
static a la definición del método
●Ej.
en clase Calendar
public static int getNumberDays(){}
●Se pueden invocar con la notación punto,
especificando el nombre de la clase
seguida del método
●int days = Calendar.getNumberOfDays();
Repaso Programación 28
29. Clase ejecutable
●Una clase es ejecutable si tiene un método
de clase especial, con la cabecera:
●public static void main(String [] args){...}
●Paraejecutarlo, se puede hacer con la
máquina virtual java Ej.
●>java Calendario
Repaso Programación 29
30. Limitaciones métodos de
clase
●Un método de clase NO puede acceder a
ningún campo de instancia
– ¿a qué objeto accedería?
– Sólo a campos static (de clase)
●Un método de clase NO puede invocar
ningún método de instancia
– ¿en qué objeto se ejecutaría?
– Sólo a métodos static
Repaso Programación 30
31. Equals() y hashCode()
●Sidos objetos son iguales (equals()), deben
devolver el mismo valor 'hash' con hashCode()
●Elvalor hash permite ver rápidamente que dos
objetos son diferentes
●Cuando reescribimos equals(), debemos
reescribir hashCode() en Java
●Object define hashCode() que devuelve un
valor hash diferente y único para cada objeto
Repaso Programación 31
34. Constructor por defecto
●En Java, si no defines ningún constructor
en una clase, se crea automáticamente un
constructor por defecto
– Sin parámetros
– Llama automáticamente a super()
– Inicializa todos los campos a su valor por
defecto (0, false, ''”, null, etc.)
●Sólose crea si no existe ningún otro
constructor en esa clase
Repaso Programación 34
35. Constructores y métodos
●Un constructor no devuelve nada en la
cabecera
●El nombre del constructor es el nombre de la
clase
●Un constructor no tiene sentencia return
●La primera línea de un constructor debe ser
this(...) o super(...) para llamar a
constructores de la misma clase o de la
clase madre, respectivamente
Repaso Programación 35
36. Sobreescritura, sobrecarga y
polimorfismo
●Sobreescritura: si una clase implementa un
método con la misma signatura que otro que
hereda, 'se sobreescribe' (se puede acceder con
super.método()
●Sobrecarga: un mismo nombre de método que
tiene diferentes signaturas. Según la signatura,
se invoca un método u otro
●Polimorfismo: un objeto puede ser de más de
un tipo dinámico. Al invocar un método de un
objeto se selecciona el tipo dinámico
Repaso Programación 36
37. Operador ternario if-else
●Heredado de C. Abrevia if-else
int j = 0;
if (a > b){
j = a; int j = (a > b) ? a : b;
}else {
j = b;
}
Repaso Programación 37
38. Número variable de
argumentos
●Se trata como si recibiéramos un array
public class Operaciones {
public static int suma(int … sum) {
int suma = 0;
for (int i = 0; i < sum.length, i++) {
suma += sum[i];
}
return suma;
}
}
> int s = Operaciones.suma(2, 3); // s = 5
> int s2 = Operaciones.suma(2, 3, 4); // s= 9
Repaso Programación 38
39. Lanzar una excepción
Los objetos de excepción se construyen
así:
– new TipoExcepcion("...");
El objeto excepción se lanza así:
– throw ...
Documentación Javadoc:
– @throws TipoExcepcion razón
Repaso Programación 39
41. Categorías de excepciones
Excepciones comprobadas (checked)
Subclase de Exception
Se usan para fallos que se pueden anticipar.
Es posible recuperarse.
Excepciones no comprobadas (unchecked)
Subclase de RuntimeException
Se usa para fallos no anticipables.
Es improbable recuperarse del fallo.
Repaso Programación 41
42. El efecto de una excepción
El método que la lanza termina
prematuramente.
No se devuelve ningún valor.
El control no vuelve al punto de llamada
del cliente.
Así el cliente no puede obviar su efecto.
El cliente puede ‘capturar’ (catch) la
excepción.
Repaso Programación 42
43. Excepciones no
comprobadas
El uso de ellas no es comprobado por el compilador.
– No las tiene que declarar el método que las puede
lanzar
Causa la terminación del programa si no se capturan.
Esta es la práctica habitual.
Algunos ejemplos: IllegalArgumentException,
ClassCastException, NullPointerException,
IndexOutOfBoundsException.
Repaso Programación 43
45. Resumen excepciones no
comprobadas
●Derivan de RuntimeException
●Los métodos que las lanzan no necesitan
declararlas
●Losmétodos que llaman a métodos que las
pueden lanzar, no hacen nada especial, con lo
que normalmente se para el programa
– Pueden capturarlas si capturan todas las Exceptions
(tanto comprobadas como no comprobadas)
Repaso Programación 45
46. Gestión de excepciones
Las excepciones comprobadas deben
capturarse (o relanzarlas).
El compilador se asegura de que su uso
es controlado fuertemente.
Tanto en el servidor como en el cliente.
Deben usarse de forma adecuada,
cuando los fallos pueden ser
recuperables.
Repaso Programación 46
47. La cláusula throws
Los métodos que lanzan una excepción
comprobada deben incluir una cláusula
throws :
public void grabarEnFichero(String fichDestino)
throws IOException
Throws significa
“puede lanzar” si
sucede situación de
error
Repaso Programación 47
48. Capturar o relanzar...
●Un método que llama a un método que
lanza una excepción comprobada puede:
– Capturarla: usa try-catch de esa excepción (o
una superclase de esa excepción)
– Relanzarla: declara que también puede
lanzarla. Si salta la excepción cuando llama a
ese método, simplemente se relanzará
No hace falta (ni es buena idea)
hacer las dos cosas: capturar y
relanzar no tiene sentido
Repaso Programación 48
49. La sentencia try
Los clientes que capturan una excepción
deben proteger la invocación con una
sentencia try:
try {
Proteger una o más sentencias aquí.
}
catch(Exception e) {
Informar y recuperarse de la excepción aquí.
}
Repaso Programación 49
50. La sentencia try
1. La exception se lanza aquí
try {
libreta.grabarEnArchivo (nombreDeArchivo);
reintentar = false;
} 2. El control se transfiere aquí
catch(IOException e) {
●
System.out.println(“Imposible grabar en " + nomFichero);
reintentar = true;
}
Repaso Programación 50
51. try { ... } catch (arg) { ... }
● Sino se lanza nada, el catch como si no existiera
dentro del try se lanza (throw) una excepción
se olvida el resto del código envuelto por el try
se ejecuta lo que se diga en catch
try {
... ... ...
throw new Exception ();
... ... ...
} catch (Exception e) {
... ... ...
} Repaso Programación 51
52. Capturando múltiples
excepciones
●
public void procesar() throws EOFException, FileNotFoundException{...}
try {
... Si lanzamos más de una
ref.procesar(); excepción comprobada,
... debemos declarar todas
}
catch(EOFException e) {
// Tomar las medidas apropiadas para una excepción
// fin-de-fichero
...
}
catch(FileNotFoundException e) {
// Tomar las medidas apropiadas para una excepción
// fichero-no-encontrado
...
}
Repaso Programación 52
53. catch
try { ●Los diferentes catch se
... ... ... intentan en el orden en que
aparecen hasta que uno de
} catch (ClaseA ida) { ellos casa; después de
... ... ... casar con uno, los demás
} catch (ClaseB idb) { se olvidan
... ... ... ●Catch significa que la
} catch (ClassC idc) { excepción que capuramos
es de la clase indicada o de
... ... ... una clase extensión de ella
(aplicándose un upcasting)
Repaso Programación 53
54. La cláusula finally
try {
Protege una o más sentencias aquí.
}
catch(Exception e) {
Informa y se recupera de la excepción aquí.
}
finally {
Realiza cualquier acción aquí que es común tanto si
se lanza la excepción como si no.
}
Repaso Programación 54
55. La cláusula finally
Una cláusula finally se ejecuta incluso si
la sentencia return es ejecutada en el try
o en el catch.
Las excepciones no capturadas o
propagadas aún saltarían vía la cláusula
finally.
Repaso Programación 55
57. Definir nuevas excepciones
Extiende RuntimeException para una
excepción no comprobada o de
Exception para una excepción
comprobada.
Define nuevos tipos para dar mejor
información de diagnóstico.
Incluye información de recuperación y/o
notificación de fallo.
Repaso Programación 57
58. Nuevas excepciones
public class NoMatchingDetailsException extends Exception
{
public NoMatchingDetailsException(String msg)
{
super(msg);
}
public NoMatchingDetailsException()
{
super();
}
}
Repaso Programación 58
59. Recuperación de errores
Los clientes deberían tomar nota de las
notificaciones.
Comprobar los valores devueltos.
No ‘ignorar’ las excepciones.
Incluye código para intentar recuperarte.
Normalmente requerirá un bucle.
Repaso Programación 59
60. Intentar recuperarse
// Try to save the address book.
boolean successful = false;
int attempts = 0;
do {
try {
addressbook.saveToFile(filename);
successful = true;
}
catch(IOException e) {
System.out.println("Unable to save to " + filename);
attempts++;
if(attempts < MAX_ATTEMPTS) {
filename = an alternative file name;
}
}
} while(!successful && attempts < MAX_ATTEMPTS);
if(!successful) {
Report the problem and give up;
}
Repaso Programación 60
61. Evitar errores
Los clientes pueden a menudo usar métodos de
consulta del servidor para prevenir errores.
Clientes más robustos significa que los servidores
son más fiables.
Pueden usarse excepciones no comprobadas.
Simplifica la lógica del cliente.
Puede incrementar el acoplamiento cliente-servidor.
Repaso Programación 61
69. Subclases y subtipado
Las clases definen tipos.
Las subclases definen subtipos.
Los objetos de las subclases pueden ser
usados allí donde se puedan usar objetos
de los supertipos.
(Esto se denomina sustitución .)
Repaso Programación 69
70. Subtipado y asignación
Los objetos de
una subclase
pueden ser
asignados a
variables de la
superclase
Vehicle v1 = new Vehicle();
Vehicle v2 = new Car();
Vehicle v3 = new Bicycle();
Repaso Programación 70
71. Subtipado y paso de
parámetros
public class Database
{
public void addItem(Item theItem)
{
... Los objetos de
}
} la subclase se
pueden pasar
DVD dvd = new DVD(...); como
CD cd = new CD(...);
parámetros de
database.addItem(dvd); la superclase
database.addItem(cd);
Repaso Programación 71
74. Variables polimórficas
Las variables objeto en Java son
polimórficas.
(Pueden albergar objetos de más de un tipo.)
Pueden albergar objetos del tipo
declarado, o de los subtipos del tipo
declarado.
Repaso Programación 74
75. Enmascaramiento (Casting)
Podemos asignar un subtipo a un supertipo.
¡No podemos asignar un supertipo a un subtipo!
Vehiculo v;
Coche c = new Coche();
v = c; // correcto;
c = v; ¡error en tiempo de compilación!
Enmascaramiento arregla esto:
c = (Coche) v;
(¡sólo es correcto si el vehículo es realmente un Coche!)
Repaso Programación 75
76. Enmascaramiento (Casting)
Un tipo de objeto entre paréntesis.
Empleado para resolver la ‘pérdida de tipo'.
El objeto no se cambia de ninguna manera.
Se hace una comprobación en tiempo de
ejecución de que el objeto es realmente de ese
tipo:
– ClassCastException si no lo es!
Empléalo sólo si es necesario.
Repaso Programación 76
77. Casting, Upcasting,
Downcasting
class Animal {
int health = 100;
}
class Mammal extends Animal { }
class Cat extends Mammal { }
class Dog extends Mammal { }
public class Test {
public static void main(String[] args) {
Cat c = new Cat();
System.out.println(c.health);
Dog d = new Dog();
System.out.println(d.health);
}
}
Repaso Programación 77
78. Upcasting
Cat c = new Cat();
System.out.println(c);
Mammal m = c; // upcasting
System.out.println(m);
/*
Imprime:
Cat@a90653
Cat@a90653
*/
Mammal m = (Mammal)new Cat();
Mammal m = new Cat();
// Equivale al anterior, preferible
Puedo indicar el casting, pero
no es necesario en upcasting
Upcasting siempre es seguro
Repaso Programación 78
79. Downcasting
Cat c1 = new Cat();
Animal a = c1; //upcasting automático a Animal
Cat c2 = (Cat) a; //downcasting debe ser manual para volver a Cat
Downcasting puede fallar, convertir un Animal (Dog) a Cat!!
Para verificar antes de convertir, puedo usar instanceof
Cat c1 = new Cat();
Animal a = c1; //upcasting aAnimal
if(a instanceof Cat){ // pruebo si Animal es un Cat
System.out.println("Es un Gato! Ahora puedo hacer downcasting a Cat
sin que pueda fallar.");
Cat c2 = (Cat)a;
}
Mammal m = new Mammal(); No siempre
Cat c = (Cat)m; ¡FALLO! puedo hacer
downcasting
Repaso Programación 79
80. La clase Object
Todas las
clases se
derivan de
Object.
Repaso Programación 80
81. Colecciones polimórficas
Todas las colecciones son polimórficas.
Los elementos son del tipo Object.
public void add(Object elemento)
public Object get(int indice)
Repaso Programación 81
82. Colecciones y tipos
primitivos
Todos los objetos se pueden meter en las
colecciones ...
... porque las colecciones aceptan
elementos de tipo Object ...
... y todas las clases son subtipos de
Object.
¡Estupendo! Pero, ¿qué pasa con los
tipos primitivos?
Repaso Programación 82
83. Clases envoltorio
Los tipos primitivos (int, char, etc) no son
objetos. Deben “envolverse” en un objeto
Hay clases “envoltorio” para todos los tipos
simples:
Tipo simple Clase envoltorio
int Integer
float Float
char Character
... ...
Repaso Programación 83
84. Conversiones X → String
●int → String
int i = 42; String str = Integer.toString(i); // o bien
String str = "" + i
●double/long/float → String
double d; float f; long l;
String str = Double.toString(d); // o bien con “” + i
String str = Long.toString(l);
String str = Float.toString(f);
Repaso Programación 84
85. Conversiones int ↔ Integer
double d; float f; long l;
Float fObj, Long lObj, Double dObj
●double/float/long->Double/Float/Long
dObj = new Double(d); // o
dObj = Double.valueOf(d);
fObj = new Float(f); // o bien
fObj = Float.valueOf(f);
lObj = new Long(l); // o bien
lObj = Long.valueOf(l);
●Double/Float/Long Integer.valueOf(int) ↔ iObj.intValue()
d = dObj.doubleValue();
f = fObj.floatValue();
l = lObj.longValue();
Repaso Programación 85
86. Conversiones (II)
String str = “25”; double d; float f; long l; int i
●String → int
int i = Integer.valueOf(str).intValue(); // o bien
int i = Integer.parseInt(str);
●Float/Double/long → String
double d = Double.valueOf(str).doubleValue(); // o bien
double d = Double.parseDouble(str);
float f = Float.valueOf(str).floatValue();
float f = Float.parseFloat(str)
long l = Long.valueOf(str).longValue(); //o bien
long l = Long.parseLong(str);
intObj.toString() ↔Integer.parseInt(str)
Repaso Programación 86
87. Clases envoltorio
int i = 18;
Integer intEnvuelve = new Integer(i); envuelve el valor
…
int valor = intEnvuelve.intValue();
lo desenvuelve
En la práctica, gracias a el
‘envoltorio automático’
(autoboxing y unboxing) no
hacemos esto a menudo.
Repaso Programación 87
88. Autoboxing y unboxing
private ArrayList<Integer> listaMarca;
…
public void almacenaMarca(int marca)
{
listaMarca.add(marca);autoboxing
}
int primerMarca = listaMarca.remove(0);unboxing
Repaso Programación 88
89. Principales conceptos
cubiertos
Métodos polimorficos
Tipado estático y dinámico
Sobrescritura
Enlace dinámico de métodos
Acceso protegido
Repaso Programación 89
91. Salida conflictiva
CD: A Swingin' Affair (64 mins)*
Frank Sinatra
tracks: 16
my favourite Sinatra album
Lo que queremos
DVD: O Brother, Where Art Thou? (106 mins)
Joel & Ethan Coen
The Coen brothers’ best movie!
titulo: A Swingin' Affair (64 mins)*
my favourite Sinatra album
Lo que tenemos
titulo: O Brother, Where Art Thou? (106 mins)
The Coen brothers’ best movie!
Repaso Programación 91
92. El problema
El método print de Item sólo imprime
los campos comunes.
La herencia es una calle de un único
sentido:
Una subclase hereda los campos de la
superclase.
La superclase no sabe nada de los campos
de sus subclases.
Repaso Programación 92
93. Intentando resolver el
problema
Pon print donde tenga acceso a la información que
necesita.
Cada subclase tiene su propia versión.
Pero los campos de Item son privados.
Database no puede encontrar un método print en
Item.
Repaso Programación 93
94. Tipo estático y tipo dinámico
Una jerarquía más compleja de tipos
necesita algunos conceptos nuevos para
describirla.
Nueva terminología:
Tipo estático
Tipo dinámico
Búsqueda dinámica de métodos
Repaso Programación 94
95. Tipo estático y dinámico
¿Cuál es el tipo de c1? Coche c1 = new Coche();
¿Cuál es el tipo de v1? Vehiculo v1 = new Coche();
Repaso Programación 95
96. Tipo estático y dinámico
El tipo declarado de una variable es su tipo
estático.
El tipo del objeto al que se refiere una variable
es su tipo dinámico.
El trabajo del compilador es comprobar las
violaciones de tipos estáticos.
for (Item item : items) {
item.print(); //Error tiempo-compilación.
}
Repaso Programación 96
97. Nuevo diseño: sobrescritura
Método print
tanto en la
superclase
como en las
subclases.
Satisface tanto la
comprobación de
tipos estáticos
como dinámicos.
Repaso Programación 97
98. Sobrescritura
La superclase y las subclases definen métodos
con la misma signatura.
Cada método tiene acceso a los campos de su
clase.
La superclase satisface la comprobación de
tipos estáticos.
El método de la subclase se llama en tiempo de
ejecución – el método sobrescribe la versión de
la superclase.
¿Cómo accedemos a la versión de la
superclase?
Repaso Programación 98
99. Búsqueda de métodos
Sin herencia o polimorfismo.
Se selecciona el método obvio.
Repaso Programación 99
100. Búsqueda de métodos
Herencia pero sin
sobrescritura. Se asciende
en la jerarquía de
herencia para encontrar
un emparejamiento.100
Repaso Programación
101. Búsqueda de métodos
v1.print();
Polimorfismo y
sobrescritura. Se
“usa” la primera
versión encontrada.
Repaso Programación 101
102. Resumen de búsqueda de
métodos
Se accede a la variable.
Se encuentra el objeto almacenado en la variable.
Se encuentra la clase del objeto.
Se busca la clase para encontrar el método con esa
signatura.
Si no se encuentra un emparejamiento, se busca en la
superclase.
Esto se repite hasta que se encuentra un
emparejamiento, o termina la jerarquía de clases.
Los métodos sobrescritos tienen precedencia.
Repaso Programación 102
103. Llamada a super en métodos
Los métodos sobrescritos están ocultos ...
... pero a menudo queremos poder llamarlos.
Un método sobrescrito puede ser llamado desde
el método que lo sobrescribe.
– super.metodo(...)
Compara esto con el uso de super en los
constructores.
Repaso Programación 103
104. Llamada desde un método
sobrescrito
public class CD
{
...
public void print()
{
super.print();
System.out.println(" " + artista);
System.out.println(" pistas: " +
numeroDePistas);
}
...
}
Repaso Programación 104
105. Métodos polimórficos
Hemos visto cómo se buscan los métodos
polimórficos.
Una variable polimórfica puede almacenar
objetos de varios tipos.
Las invocaciones de métodos son
polimórficas.
El método llamado depende del tipo dinámico
del objeto.
Repaso Programación 105
106. Métodos de la clase Object
Los métodos de Object se heredan por
todas las clases.
Cualquiera de ellos puede ser sobrescrito.
A menudo se sobrescribe el método
toString:
– public String toString()
Devuelve una cadena con la representación
del objeto.
Repaso Programación 106
107. Sobrescribiendo toString
public class Item
{
...
public String toString()
{
String linea = titulo
+ " (" + tiempoReproduccion
+ " mins)");
if(loTengo) {
return linea + "*n" + " "
+ comentario + "n");
} else {
return linea + "n" + " "
+ comentario + "n");
}
}
...
} Repaso Programación 107
108. Sobrescribiendo toString
Los métodos print explícitos pueden a
menudo ser omitidos desde una clase:
– System.out.println(elemento.toString());
Las llamadas a println son
simplemente el resultado de llamar
automáticamente a toString:
– System.out.println(elemento);
Repaso Programación 108
109. Acceso protegido
El acceso privado en la superclase puede ser
demasiado restrictivo para una subclase.
La relación de herencia más cercana que se
soporta es la de acceso protegido (protected).
El acceso protegido es más restrictivo qaue el
acceso público.
Seguimos recomendando que mantengas los
campos privados.
Puedes definir mutadores y accesores protegidos.
Repaso Programación 109
111. Clases y métodos abstractos
Las clases abstract tienen abstract en la
definición, y al menos un método abstracto.
Los métodos abstractos tiene abstract en la
signatura.
Los métodos abstractos no tienen cuerpo.
Los métodos abstractos hacen que la clase sea
abstracta.
Las clases abstractas no pueden ser instanciadas.
Las subclases concretas completan la
implementación.
Repaso Programación 111
112. La clase Animal
public abstract class Animal
{
campos omitidos
/**
* Hace que este animal actúe – esto es, hace que
* haga lo que quiere/necesita hacer
*/
public abstract void act(List<Animal> nuevosAnimales);
otros métodos omitidos
}
Repaso Programación 112
115. Herencia múltiple
Consiste en que una clase hereda de múltiples
clases.
Cada lenguaje tiene sus propias reglas.
¿Cómo resolver las definiciones que compiten?
Java lo prohíbe para las clases.
Java lo permite para las interfaces.
No hay implementación que compita.
Repaso Programación 115
116. Interfaces
●Una interfaz define un conjunto de métodos
y/o constantes públicas
●No incluye implementación!
●Es como un contrato
●Laclase que cumple ese contrato debe
implementar la interfaz (implementar los
métodos definidos)
Repaso Programación 116
117. Una interfaz Actor
public interface Actor
{
/**
* Ejecuta la conducta diaria del actor.
* Transfiere el actor al campoActualizado si va a
* participar en más pasos de la simulación.
* @param currentField Estado actual del campo.
* @param updatedField Estado actualizado del campo.
* @param newActors Nuevos actores creados como
* resultados de las acciones del actor.
*/
void act(Field currentField, Field updatedField,
List<Actor> newActors);
}
Repaso Programación 117
118. Las clases implementan una
interfaz
public class Fox extends Animal implements Drawable
{
...
}
public class Hunter implements Actor, Drawable
{
...
}
Repaso Programación 118
119. Interfaces como tipos
Implementar una interfaz no hereda
código, pero ...
... implementa clases como subtipos del
tipo interfaz.
Así, el polimorfismo está disponible tanto
para interfaces como para clases.
Repaso Programación 119
120. Características de las
interfaces
Todos los métodos son abstractos.
No hay constructores.
Todos los métodos son públicos.
Todos los campos son constantes
públicas (public, static y final).
Repaso Programación 120
121. Interfaces como
especificaciones
Fuerte separación entre la funcionalidad y la
implementación.
Aunque los tipos de los parámetros de entrada y de
vuelta son requeridos.
Los clientes interactúan independientemente de
la implementación.
Así los clientes pueden elegir entre
implementaciones alternativas.
Repaso Programación 121
123. Herencia en Interfaces
●Una interfaz puede extender más de una
interfaz
●Nos indica que es interfaz (contrato)
requiere implementar varios contratos y
puede añadir más métodos / constantes
public interface Alumno{ void matricula(int dni); }
public interface PersonalEtsit {
void registraParking(int matricula);}
public interface AlumnoEtsit extends Alumno, PersonalEtsit {
void monederoElectronico();
};
Repaso Programación 123
124. Interfaz vs Clase abstracta (I)
INTERFAZ CLASE ABSTRACTA
Múltiple herencia Una clase puede Una clase puede extender sólo una
implementar múltiples clase (abstracta o no)
interfaces.
Una interfaz puede
extender más de una
interfaz.
Implementación por Una interfaz no Una clase abstracta puede
defecto proporciona ningún código proporcionar métodos
implementado. Define implementados y al menos un
métodos public. método abstracto (no
implementado)
atributos No define Sí puede definir
constantes Sí puede definir. Por Sí puede definir
defecto, ya son public.
Repaso Programación 124
125. Interfaz vs Clase abstracta
(II)
INTERFAZ CLASE ABSTRACTA
homogeneida Si todas las implementaciones Si se comparten atributos y
d comparten los mismos métodos, métodos, una clase abstracta
escoger interfaz puede ser adecuada. Si cambian al
implementarlos, escoger interfaz.
En general, es mejor escoger
interfaces.
Es-un vs Una interfaz describe Una clase abstracta define la
capaz de funcionalidad no central de una identidad de una clase y sus
hacer clase descendientes
Repaso Programación 125