JAVA
HERENCIA Y POLIMORFISMO
1
Cosa
Herencia en el mundo real
Medio de tele-
comunicación
Medio de
transporte
Objeto de
oficina
Coche
Vehiculo aéreo
2
HERENCIA EN JAVA
Java permite definir Clase Padre
una clase como
subclase de una clase
padre.
class clase_hija extends
clase_padre
{ Clase Hija
..........
}
3
EJEMPLO DE HERENCIA
class Polygon {
protected int width, height;
public void set_values (int a, int b) { Polygon
#width
width=a; height=b;} } #height
class Rectangle extends Polygon { +set_values()
public int area() { return (width * height); } }
class Triangle extends Polygon {
Triangle
public int area() { return (width * height / 2); } Rectangle
public static void main(String[] args) { +area()
+area()
Rectangle rect; Triangle trgl;
rect = new Rectangle(); trgl = new Triangle();
rect.set_values (4,5); trgl.set_values (4,5);
[Link]("area" + [Link]() + '\n' +
[Link]() + '\n');
4
}}
CONSTRUCTORES Y HERENCIA
Cuando se declara un obj de una clase derivada, se ejecutan
los conts siguiendo el orden de derivación, es decir, primero
el de la clase base, y después los conts de las clases
derivadas de arriba a abajo.
Para pasar parámetros al constructor de la clase padre:
super (para1, para2, ..., paraN)
5
EJEMPLO DE SUPER
class Persona {
private String nombre;
private int edad;
public Persona() {}
public Persona (String n, int e)
{ nombre = n; edad = e; }
}
class Alumno extends Persona {
private int curso;
private String nivelAcademico;
public Alumno (String n, int e, int c, String nivel) {
super(n, e);
curso = c; nivel_academico = nivel;
}
public static void main(String[] args) {
Alumno a = new Alumno("Pepe", 1, 2, "bueno");
}
}
6
REDEFINIR F. MIEMBROS DE LA
CLASE PADRE
class Persona {
private String nombre;
private int edad;
...................
public String toString() { return nombre + edad; }
public void setEdad(int e) { edad = e; }
}
class Alumno extends Persona {
private int curso;
private String nivelAcademico;
...................
public String toString() {
return [Link]() + curso +
nivelAcademico;
}
public void setCurso(int c) { curso = c; }
7
}
REFERENCIAS A OBJETOS DE
CLASES HIJAS
Si tenemos ClaseHijo hijo = new ClaseHijo(...);
entonces es posible padre=hijo donde padre es una variable
de tipo ClasePadre.
• pero no es posible!! hijo=padre (sí que es posible con casting
hijo= (ClaseHijo) padre)
Ahora bien:
• Con padre sólo podemos acceder a atributos y métodos def.
en la clase padre.
8
REFERENCIAS A OBJETOS DE
CLASES HIJAS
public static void main(String[] args) {
Persona p;
Alumno a = new
Alumno(“pepe”,23,1,”universitario”);
p=a; //ref padre señala al objeto hijo
// acceso al objeto hijo mediante la ref padre
[Link](24);
/* no es posible acceder a un miembro de la
clase hija usando una ref a la clase padre*/
[Link](88); // ERROR
}
9
EJEMPLO
class Persona { ................... }
class Alumno extends Persona {
......................
public String toString() {
return [Link]() + curso + nivelAcademico;
}
}
class Profesor extends Persona {
private String asignatura;
public Profesor (String n, int e, String asign) {
super(n, e);
asignatura = asign;
}
public String toString() {
return [Link]() + asignatura;
}
}
10
POLIMORFISMO
Una misma llamada ejecuta distintas sentencias
dependiendo de la clase a la que pertenezca el
objeto al que se aplica el método.
Supongamos que declaramos: Persona p;
Podría suceder que durante la ej. del programa, p
referencie a un profesor o a un alumno en distintos
momentos, y
Entonces:
• Si p referencia a un alumno, con [Link](), se ejecuta el
toString de la clase Alumno.
• Si p referencia a un profesor, con [Link](), se ejecuta el
toString de la clase Profesor.
Enlace dinámico: Se decide en tiempo de
ejecución qué método se ejecuta.
OJO!: Sobrecarga de fs => enlace estático (t. de
compilación).
11
EJEMPLO DE POLIMORFISMO
public static void main(String[] args) {
Persona v[]=new Persona[10];
// Se introducen alumnos, profesores y personas en v
for (int i=0 ; i<10; i++)
/* Se piden datos al usuario de profesor, alumno o
persona */
switch (tipo) {
case /* profesor */: v[i] = new Profesor (….);
break;
case /* alumno */: v[i] = new Alumno(…); break;
case /* persona */: v[i] = new Persona(…); break;
default: /* ERROR */ }
}
for (int i=0 ; i<10; i++)
[Link](v[i]); // enlace dinámico con
toString()
}
12
MÉTODOS ABSTRACTOS
Tenemos un método f() aplicable a todos los
objetos de la clase A.
• Área de un polígono.
La implementación del método es completamente
diferente en cada subclase de A.
• Área de un triángulo.
• Área de un rectángulo.
.....................................
Para declarar un método como abstracto, se pone
delante la palabra reservada abstract y no define
un cuerpo:
abstract tipo nombreMétodo(....);
Luego en cada subclase se define un método con
la misma cabecera y distinto cuerpo.
13
CLASES ABSTRACTAS
Si una clase contiene al menos un método abstracto,
entonces es una clase abstracta.
Una clase abstracta es una clase de la que no se pueden
crear objetos, pero puede ser utilizada como clase padre
para otras clases.
Declaración:
abstract class NombreClase {
..............
}
14
EJEMPLO DE CLASE ABSTRACTA
15
EJEMPLO DE CLASE ABSTRACTA
abstract class Alumno extends Persona {
protected int curso;
private String nivelAcademico;
public Alumno (String n, int e, int c, String nivel) {
super(n, e);
curso = c; nivelAcademico = nivel;
}
public String toString() {
return [Link]() + curso +
nivelAcademico;
}
abstract double pagoMensual();
abstract String getAsignaturas();
}
16
EJEMPLO DE CLASE ABSTRACTA
class Libre extends Alumno {
private String []listaDeAsignaturas;
private static float precioPorHora=10;
private int noHorasDiarias;
private void pedirAsignaturas() {}// se inicializa
listaDeAsignaturas
public double pagoMensual() {
return precioPorHora*noHorasDiarias*30; }
public String getAsignaturas() {
String asignaturas="";
for (int i=0; i<[Link]; i++)
asignaturas += listaDeAsignaturas[i] + ' ';
return asignaturas;
}
public Libre(String n, int e, int c, String nivel, int horas)
{super(n,e,c,nivel); noHorasDiarias = horas;
pedirAsignaturas(); }
}
17
EJEMPLO DE CLASE ABSTRACTA
class Presencial extends Alumno {
private double matriculaCurso;
private double plusPorConvocatoria;
private int noConvocatoria;
public double pagoMensual()
{ return
(matriculaCurso+plusPorConvocatoria*noConvocatoria)/12; }
public String getAsignaturas(){
return “todas las del curso “ + curso;
}
public Presencial(String n, int e, int c, String nivel,
double mc, double pc, int nc) {
super(n,e,c,nivel);
matriculaCurso=mc;
plusPorConvocatoria=pc;
noConvocatoria=nc;
}
}
18
EJEMPLO DE CLASE ABSTRACTA
// FUNCIONES GLOBALES
void mostrarAsignaturas(Alumno v[]) {
for (int i=0; i<[Link]; i++)
[Link](v[i].getAsignaturas());
// enlace dinámico
}
double totalPagos(Alumno v[]) {
double t=0;
for (int i=0; i<[Link]; i++)
t += v[i].pagoMensual(); // enlace dinámico
return t;
}
19