tema 0 repaso programación en java

Análisis y Diseño de Software

Departamento de Ingeniería de Sistemas Telemáticoshttp://moodle.dit.upm.es

Tema 0. Repaso ProgramaciónCarlos A. Iglesias <[email protected]>

Repaso Programación 2

Teoría

Ejercicio práctico en el ordenador

Ampliación de conocimientos

Lectura / Vídeo / Podcast

Práctica libre / Experimentación

Leyenda


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.safaribooksonline.com/book/programming/java/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 crearlosint [] array = new int[2];Punto [] array2 = {new Punto(1,2), new Punto(2,3)};int [] array3 = {1, 2, 3};for (int elem : array){ System.out.println(elem);}for (int i = 0; i < array.length; i++){ System.out.println(a[i]);}

int i = 0;while (i < array.length) { System.out.println(a[i]); i++;}int i = 0;do { 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, HashMapimport 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;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

b

a[0] = 2;


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 contenidoboolean 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, …]

●Crear un 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 EnumTestpublic 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 declararonfor (Day d : Day.values()) { System.out.printf("Day “ + d);}


Otro ejemplo

public enum Estacion {INVIERNO, PRIMAVERA, VERANO, OTONO}

Estacion.java

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

●Para ejecutarlo, 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()

●Si dos objetos son iguales (equals()), deben devolver el mismo valor 'hash' con hashCode()

●El valor 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ólo se 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;}else { j = b;}

int j = (a > b) ? a : 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

●Los mé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

try { libreta.grabarEnArchivo (nombreDeArchivo); reintentar = false;}catch(IOException e) {

● System.out.println(“Imposible grabar en " + nomFichero); reintentar = true;}

1. La exception se lanza aquí

2. El control se transfiere aquí


try { ... } catch (arg) { ... }

● Si no se lanza nada, el catch como si no existieradentro 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) {

... ... ...

}


Capturando múltiples excepciones

try { ... ref.procesar(); ...}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 ...}

● public void procesar() throws EOFException, FileNotFoundException{...}

Si lanzamos más de una excepción comprobada, debemos declarar todas


catch

try { ... ... ...} catch (ClaseA ida) { ... ... ...} catch (ClaseB idb) { ... ... ...} catch (ClassC idc) { ... ... ...

●Los diferentes catch se intentan en el orden en que aparecen hasta que uno de ellos casa; después de casar con uno, los demás se olvidan●Catch significa que la 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 {



... ... ...

} finally {

try {



... ... ...

}

... ... ...

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


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

Nuevas excepciones


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

DVD dvd = new DVD(...);CD cd = new CD(...);

database.addItem(dvd);database.addItem(cd);

Los objetos de la subclase se pueden pasar como parámetros de la superclase


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


UpcastingCat c = new Cat();System.out.println(c);Mammal m = c; // upcastingSystem.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 upcastingUpcasting siempre es seguro


DowncastingCat c1 = new Cat(); Animal a = c1; //upcasting automático a AnimalCat c2 = (Cat) a; //downcasting debe ser manual para volver a Cat

Cat c1 = new Cat(); Animal a = c1; //upcasting aAnimalif(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;}

Downcasting puede fallar, convertir un Animal (Dog) a Cat!!Para verificar antes de convertir, puedo usar instanceof

Mammal m = new Mammal();Cat c = (Cat)m; ¡FALLO!

No siempre 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 envoltorioint Integerfloat Floatchar Character... ...


Conversiones X → String

●int → Stringint i = 42; String str = Integer.toString(i); // o bienString str = "" + i

●double/long/float → Stringdouble d; float f; long l;String str = Double.toString(d); // o bien con “” + iString 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/LongdObj = new Double(d); // odObj = Double.valueOf(d);fObj = new Float(f); // o bienfObj = Float.valueOf(f);lObj = new Long(l); // o bienlObj = Long.valueOf(l);

●Double/Float/Longd = dObj.doubleValue();f = fObj.floatValue();l = lObj.longValue();

Integer.valueOf(int) ↔ iObj.intValue()


Conversiones (II)

String str = “25”; double d; float f; long l; int i

●String → intint i = Integer.valueOf(str).intValue(); // o bienint i = Integer.parseInt(str);

●Float/Double/long → Stringdouble d = Double.valueOf(str).doubleValue(); // o biendouble d = Double.parseDouble(str);float f = Float.valueOf(str).floatValue();float f = Float.parseFloat(str)long l = Long.valueOf(str).longValue(); //o bienlong l = Long.parseLong(str);

intObj.toString() ↔Integer.parseInt(str)


Clases envoltorio

int i = 18; Integer intEnvuelve = new Integer(i); …int valor = intEnvuelve.intValue();

envuelve el valor

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

}

int primerMarca = listaMarca.remove(0);

autoboxing

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

titulo: O Brother, Where Art Thou? (106 mins) The Coen brothers’ best movie!

Lo que queremos

Lo que tenemos


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

Coche c1 = new Coche();¿Cuál es el tipo de c1?

Vehiculo v1 = new Coche();¿Cuál es el tipo de v1?


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.



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

v1.print();


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 toStringpublic class Item{ ... public String toString() { String linea = titulo + " (" + tiempoReproduccion + " mins)"); if(loTengo) { return linea + "*\n" + " " + comentario + "\n"); } else { return linea + "\n" + " " + comentario + "\n"); } } ...}


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

●La clase 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 implementar múltiples interfaces. Una interfaz puede extender más de una interfaz.

Una clase puede extender sólo una clase (abstracta o no)

Implementación por defecto

Una interfaz no proporciona ningún código implementado. Define métodos public.

Una clase abstracta puede proporcionar métodos implementados y al menos un método abstracto (no implementado)

atributos No define Sí puede definir

constantes Sí puede definir. Por defecto, ya son public.

Sí puede definir


Interfaz vs Clase abstracta (II)

INTERFAZ CLASE ABSTRACTA

homogeneidad

Si todas las implementaciones comparten los mismos métodos, escoger interfaz

Si se comparten atributos y métodos, una clase abstracta puede ser adecuada. Si cambian al implementarlos, escoger interfaz. En general, es mejor escoger interfaces.

Es-un vs capaz de hacer

Una interfaz describe funcionalidad no central de una clase

Una clase abstracta define la identidad de una clase y sus descendientes


¿Preguntas?

tema 0 repaso programación en java

Technology

length i

size i

int a2

repaso programacin9do

arraysrepaso programacin

lengthfor int

int elem

printlnelem int