Tema 0 Repaso Programación en Java

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

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

Bibliografía
● Libros:
– Objects First with
Java, A Practical
Introduction using
BlueJ, D. Barnes &
M. Kölling, 2012


Bibliografía
●Head First Java, K.
Sierra and B. Bates,
O'Reilly, 2005
●
http://proquest.safari
booksonline.com/bo
ok/programming/jav
a/0596009208


Temario
● Repaso clases
● Repaso arrays
● Repaso estructuras
● Repaso excepciones
● Repaso interfaces, tipos estáticos y
dinámicos
● Repaso herencia


Objetivos
● Repasar los conceptos de programación
● Practicar dichos conceptos


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);

arrays


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());

Collection<E>
●Métodos importantes
– boolean add(E e)
– boolean clear()
– boolean contains(Object o)
– boolean isEmpty()
– Iterator iterator()
– boolean remove(Object o)
– int size()
– Object [] toArray()

Interfaz Collection<E>


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)


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()


Copia de arrays
(compartir referencia)
int [] a = {1, 2, 3, 4};
a

int [] b = a; b

a
a[0] = 2;

b


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

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

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

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

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;
}

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.


Tipos enumerados – Day.java

public enum Day {
SUNDAY, MONDAY, TUESDAY, WEDNESDAY,
THURSDAY, FRIDAY, SATURDAY
}


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;
}
}

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.

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);
}


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


Ej. prueba enums


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();


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


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


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


Equals y hashCode()


Ejemplo de hashCode()
private String nom;
private String apellido;
public int hashcode() {
int hash = 4;
hash = 24 * hash + (this.nom != null ?
this.nom.hashCode() : 0);
hash = 24 * hash + (this.apellido != null ?
this.apellido.hashCode() : 0);
return hash;
}

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

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

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

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;
}


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

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


La jerarquía de la clase
Exception


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.


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.


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.


Excepciones no comprobadas


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)


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.


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

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

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í.
}


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;
}


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

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
...
}

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)


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.
}


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.


Finally
try { try {
... ... ... ... ... ...
throw new Exception (); throw new Exception ();
... ... ... ... ... ...
} catch (Exception e) { } catch (Exception e) {
... ... ... ... ... ...
} finally { } finally {
... ... ... ... ... ...
} }


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.


Nuevas excepciones

public class NoMatchingDetailsException extends Exception
{
public NoMatchingDetailsException(String msg)
{
super(msg);
}
public NoMatchingDetailsException()
{
super();
}
}


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.


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;
}

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.


Ejemplo


ExcepcionNoComprobada


ExcepcionComprobada


Ej. NoComprobadas


Ej. Comprobadas


Ej. relanzar / capturar


Ej. excepciones múltiples


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 .)


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();


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);


Diagrama de Objetos


Diagrama de Clases


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.


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!)


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.


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);
}
}


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

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


La clase Object

Todas las
clases se
derivan de
Object.


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)


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?


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
... ...


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);


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();


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)

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.


Autoboxing y unboxing

private ArrayList<Integer> listaMarca;
…
public void almacenaMarca(int marca)
{
listaMarca.add(marca);autoboxing
}

int primerMarca = listaMarca.remove(0);unboxing


Principales conceptos
cubiertos

Métodos polimorficos

Tipado estático y dinámico

Sobrescritura

Enlace dinámico de métodos

Acceso protegido


La jerarquía de herencia


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!


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.


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.


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


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();


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.
}


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.


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?


Búsqueda de métodos

Sin herencia o polimorfismo.
Se selecciona el método obvio.


Herencia pero sin
sobrescritura. Se asciende
en la jerarquía de
herencia para encontrar
un emparejamiento.100
Repaso Programación


v1.print();

Polimorfismo y
sobrescritura. Se
“usa” la primera
versión encontrada.

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.


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.


Llamada desde un método
sobrescrito
public class CD
{
...
public void print()
{
super.print();
System.out.println(" " + artista);
System.out.println(" pistas: " +
numeroDePistas);
}
...
}


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.


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.


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

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);


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.


Niveles de acceso


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.


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
}


Mayor abstracción


Dibujo selectivo
(herencia múltiple)


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.


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)


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);
}


Las clases implementan una
interfaz

public class Fox extends Animal implements Drawable
{
...
}

public class Hunter implements Actor, Drawable
{
...
}


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.


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).


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.


Implementaciones
alternativas


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();
};

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.


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


¿Preguntas?


Tema 0 Repaso Programación en Java

Más contenido relacionado

Similar a Tema 0 Repaso Programación en Java

Más de Carlos A. Iglesias

Tema 0 Repaso Programación en Java