Relaciones de composición y

Herencia

Composición y Herencia 1

POO en Java
Características:

• Composición “tiene un”

• Herencia “es un”
• Polimorfismo.
•Abstracción.
•Clases y objetos.

Composición y Herencia 2
 Composición
public class
public class Punto
Punto {{
int
int x;x;
int y;
int y;
public Punto(int
public Punto(int x,x, int
int y)
y) {{
this.x == x;
this.x x;
this.y =
this.y = y; y;
}}
public Punto()
public Punto() {{
// llamada
// llamada al
al otro
otro constructor
constructor
this(-1, -1);
this(-1, -1); } }
public void mostrar(){
public void mostrar(){
System.out.println(“x == ““ ++ xx +”
System.out.println(“x +” yy == ““ ++ y);
y); }}
public static
public static void
void main(String
main(String args[])
args[]) {{
Punto pun1
Punto pun1 == new
new Punto();
Punto();
Punto pun2
Punto pun2 == new
new Punto(2,3);
Punto(2,3);
System.out.println( "visualizar
System.out.println( "visualizar datos
datos del
del punto"
punto" );
);
pun1.mostrar();
pun1.mostrar();
pun2.mostrar();}}
pun2.mostrar();}}
Composición y Herencia 3

Composición: clase Círculo

public class
public class Circulo
Circulo {{
Punto origen;
Punto origen;
int radio;
int radio;

public Circulo(int
public Circulo(int x,x, int
int y,
y, int
int radio)
radio) {{
origen = new Punto(x,y);
origen = new Punto(x,y);
this.radio == radio;
this.radio radio;
}}

public void
public void mostrar()
mostrar() {{
origen.mostrar();
origen.mostrar();
System.out.println("radio == "" ++ radio);
System.out.println("radio radio);
}}

public static
public static void
void main(String
main(String args[])
args[]) {{
Circulo cir
Circulo cir == new
new Circulo(5,
Circulo(5, 5,
5, 9);
9);
System.out.println( "visualizar
System.out.println( "visualizar datos datos del
del circulo"
circulo" );
);
cir.mostrar(); }}
cir.mostrar(); }}
Composición y Herencia 4
 Tipos de programación
encapsulación

Basado en
objetos

+ clases Basado en
clases

+ herencia
Orientado a
Objetos

Composición y Herencia 5

Herencia: La palabra
reservada extends
Cuando se crea un modelo de algo y luego se quiere
una versión más actualizada:

public class Empleado public class jefe

{ {
String nombre;
String nombre; ¡datos duplicados!
Date anionac; Date anionac;
String puesto; String puesto;
int categoría; int categoría;
String departamento;
... Empleado [] subordinados;
}
...
}

Composición y Herencia 6
Herencia: La palabra
reservada extends
Se puede definir una clase a partir de otra definida
previamente.
public class Empleado {
String nombre;
Date anionac;
String puesto;
int categoría; }
public class Jefe extends Empleado {
String departamento;
Composición y Herencia 7
Empleado [ ] subordinados; }

Herencia: La palabra
reservada extends
La clase Jefe para tener todas las variables y
métodos de la clase Empleado no tiene que
definirlos, los hereda de la clase padre.
Todo lo que se tiene que definir después son
las características adicionales y especificar los
cambios que se quieren aplicar.
Es una buena manera de generar código fácil
de mantener y de actualizar. Las
modificaciones sobre la clase Empleado
repercuten sobre la clase Jefe únicamente
compilando. Composición y Herencia 8
Ejemplo de Herencia
Animal

Mamífero

Primate Canino

Gorila Chimpance Perro Lobo

Composición y Herencia 9

Herencia simple
Cuando una clase hereda sólo de otra clase,
se llama herencia simple.
Herencia simple hace que el código sea
reutilizable.
Java proporciona las interfaces que
proporcionan las ventajas de la herencia
múltiple y no presentan sus inconvenientes.

Composición y Herencia 10
La palabra reservada super

Una clase utiliza super para apuntar a su
superclase.

Super se utiliza para apuntar a los
miembros de la superclase.

Los métodos de la superclase se invocan
como si el objeto fuera parte de la
subclase.

Composición y Herencia 11

Los constructores no se
heredan
Una subclase hereda de una superclase (la
clase padre), todos los métodos y las
variables.
Una clase no hereda los constructores de la
superclase.
El constructor de una subclase siempre llama
al de la superclase.

Composición y Herencia 12
 Herencia: clase Persona
public class
public class Persona
Persona {{
String nombre == "";
String nombre ""; Persona
int edad;
int edad;

public Persona(String
public Persona(String nom,
nom, int
int ed)
ed) {{
nombre = nom;
nombre = nom; Trabajador
edad == ed;
edad ed;
}}

public void
public void mostrar()
mostrar() {{
System.out.println("Nombre: "+
System.out.println("Nombre: "+ nombre);
nombre);
System.out.println("Edad: "+
System.out.println("Edad: "+ edad);
edad);
}}
public static
public static void
void main(String
main(String args[])
args[]) {{
Persona yo=
Persona yo= new
new Persona(“Luis",
Persona(“Luis", 32);
32);
yo.mostrar();
yo.mostrar();
}}
}}
Composición y Herencia 13

Herencia: clase Trabajador

public class
public class Trabajador
Trabajador extends
extends Persona
Persona {{
float sueldoHora;
float sueldoHora;
int numHoras;
int numHoras;

public Trabajador(String
public Trabajador(String nom,
nom, int
int ed,
ed, float
float suel,
suel, int
int num)
num) {{
super(nom, ed); // llamada al constructor de
super(nom, ed); // llamada al constructor de PersonaPersona
sueldoHora == suel;
sueldoHora suel;
numHoras == num;}
numHoras num;}

public double
public double sueldo()
sueldo() {{
return sueldoHora
return sueldoHora ** numHoras;
numHoras; }}

public static
public static void
void main(String
main(String args[])
args[]) {{
Trabajador yo=
Trabajador yo= new
new Trabajador(“Luis",
Trabajador(“Luis", 32, 32, 200.5f,
200.5f, 45);
45);
yo.mostrar(); //
yo.mostrar(); // se
se invoca
invoca al
al metodo
metodo heredado
heredado mostrar
mostrar
double pelas
double pelas == yo.sueldo();
yo.sueldo();
System.out.println("Cobra: "" ++ euros);
System.out.println("Cobra: euros); }}
Composición y Herencia 14
}}
 Herencia: constructores
Persona
Persona

Trabajador
Trabajador

Bedel
Bedel

Composición y Herencia 15

Reescritura de un método

La signatura de un método viene dada por su
nombre y el tipo y número de los parámetros
 El tipo devuelto no forma parte de la signatura

Cuando se reescribe un método en una clase
derivada
 La signatura debe ser la misma que el método
de la clase base
 El tipo devuelto debe ser el mismo que el del
método de la clase base
 El atributo de acceso del método de la clase
derivada tiene que ser igual o mas general que
el de la clase base (NO puede ser mas
restrictivo)
Composición y Herencia 16
Ejemplo
//En Persona
//En Persona redefinimos
redefinimos el
el método
método mostrar()
mostrar()
public class
public class Trabajador
Trabajador extends
extends Persona
Persona {{
float sueldoHora;
float sueldoHora;
int numHoras;
int numHoras;
public Trabajador(String
public Trabajador(String nom,nom, int
int ed,
ed, float
float suel,
suel, int
int num)
num) {{
super(nom, ed);
super(nom, ed); //
// llamada
llamada al
al constructor
constructor dede Persona
Persona
sueldoHora = suel;
sueldoHora = suel;
numHoras == num;}
numHoras num;}
// sobrecarga
// sobrecarga completa
completa de de mostrar
mostrar
// nombre y edad son atributos heredados de
// nombre y edad son atributos heredados de Persona
Persona
public void mostrar()
public void mostrar() { {
System.out.println("Nombre: "+
System.out.println("Nombre: "+ nombre);
nombre);
System.out.println("Edad: "+
System.out.println("Edad: "+ edad); edad);
System.out.println("Sueldo por
System.out.println("Sueldo por hora:
hora: "+
"+ sueldoHora);
sueldoHora);
System.out.println("Horas trabajadas:
System.out.println("Horas trabajadas: "+"+ numHoras);}}
numHoras);}}

Composición y Herencia 17

Sobrecarga de método
Sobrecarga parcial ampliando el método
heredado
 El método de la subclase puede llamar al
método de la superclase: super.método()

Composición y Herencia 18
Sobrecarga de método
public class
public class Trabajador
Trabajador extends
extends Persona
Persona {{
float sueldoHora;
float sueldoHora;
int numHoras;
int numHoras;

public Trabajador(String
public Trabajador(String nom,
nom, int
int ed,
ed, float
float suel,
suel, int
int
num) {{
num)
super(nom, ed);
super(nom, ed); //
// llamada
llamada alal constructor
constructor dede Persona
Persona
sueldoHora == suel;
sueldoHora suel;
numHoras == num;}
numHoras num;}
// sobrecarga parcial de
// sobrecarga parcial de mostrar
mostrar
// nombre
// nombre yy edad
edad son
son atributos
atributos heredados
heredados dede Persona
Persona
public void
public void mostrar()
mostrar() {{
super.mostrar(); //llamada
super.mostrar(); //llamada alal método
método de
de la
la clase
clase padre
padre
System.out.println("Sueldo por hora: "+ sueldoHora);
System.out.println("Sueldo por hora: "+ sueldoHora);
System.out.println("Horas trabajadas:
System.out.println("Horas trabajadas: "+"+ numHoras);}
numHoras);}
}}

Composición y Herencia 19

Ejercicio 1
Declara e implementa las clases Triángulo, Círculo
y Cuadrado de forma que todas tengan un
atributo

String color

y compartan los siguientes métodos:

String dameColor()

String toString()

Imprimir los datos de la figura

Calcular el área de la figura

Composición y Herencia 20
Ejercicio 1: clase Figura

Composición y Herencia 21

Ejercicio 1: clase Círculo

Composición y Herencia 22
Ejercicio 1: clase Triángulo

Composición y Herencia 23

Ejercicio 1: clase Rectángulo

Composición y Herencia 24
Ejercicio 1: clase Cuadrado

Composición y Herencia 25

La clase genérica Object

Todas las clases en Java heredan
implícitamente de la clase Object. De
esta forma, Object es la raiz de la
jerarquía de herencia (de
implementación) en Java.

Composición y Herencia 26
La clase genérica Object
Object define un conjunto de métodos útiles,
que pueden ser redefinidos en cada clase. En
particular:

public boolean equals(Object o): Permite definir el
criterio de igualdad utilizado para los objetos de
una determinada clase (el operador ==
únicamente chequea la igualdad de referencias).
En Object, equals se define directamente como la
identidad de referencias.

public String toString(): Permite decidir la
representación externa de un objeto como una
cadena. Por defecto es el valor de su referencia,
etiquetada con el nombre de la clase.
Composición y Herencia 27

La clase genérica Object

toString()
equals() Object

no se necesita extends para heredar de Object

Composición y Herencia 28
API de Object
Method Summary

protected
Object clone()
Creates and returns a copy of this object.
boolean
equals(Object obj)
Indicates whether some other object is "equal to" this one.
protected finalize()
void
Called by the garbage collector on an object when garbage collection
determines that there are no more references to the object.
Class getClass()
Returns the runtime class of an object.
int
hashCode()
Returns a hash code value for the object.
String
toString()
Returns a string representation of the object.
Composición y Herencia 29

Operadores de comparación
Los métodos equals () y == determinan si las
referencias apuntan a un mismo objeto.
El método equals() está sobrescrito en ciertas
clases (String, Date, File, Double, Integer y
otras), para devolver el valor verdadero
cuando el contenido y el tipo de los objetos
es el mismo.

Composición y Herencia 30
Operadores de comparación
Por ejemplo:
String s1 = new String (“jdk");
String s2 = new String (“jdk");
s1

"jdk"
s2

"jdk"

Composición y Herencia 31

Operadores de comparación
s1 == s2
//retorna FALSE ya que los punteros
//son distintos
s1.equals (s2)
//retorna TRUE, pues aún siendo
//diferentes objetos, son del
//mismo tipo y tienen el mismo contenido

Composición y Herencia 32
 Ejemplo equals
public static void main(String args[]) {
Alumno alum = new Alumno("Julian", "Fdez");
Alumno alum2 = alum;
alum2.apellidos = "Rodriguez";
System.out.println(
"son el mismo objeto?:"+ (alum==alum2));

alum2 = new Alumno("Antonio", "Rodriguez");

System.out.println(
"son iguales los objetos?:"+
alum.equals(alum2)); }}

Nota: El equals de Object es como el

operador ==, que indica si son el mismo
objeto, no si tienen datos iguales.
Composición y Herencia 33

Ejercicio 2: Añadir equals

public class Figura {
public boolean equals(Figura f){
return this.color.equals(f.color);
}
..
}

public class Circulo extends Figura {

public boolean equals(Circulo c){
return super.equals(c) &&
this.radio==c.radio;
}
..
}

Composición y Herencia 34
Ejercicio 2: probar equals

Composición y Herencia 35

Referencia estática
La referencia estática se fija en tiempo de
compilación
Rectangle r = new Rectangle();
Circle c = new Circle();
...
c = r; //Error

Composición y Herencia 36
Referencia dinámica
Programador es un Empleado
Empleado

mite
extends er
S ep

Programador Empleado e = new Programador();

Empleado es referencia estática
Revisada por el compilador
Programador es referencia dinámica
Sus métodos se eligen en tiempo
de ejecución
Composición y Herencia 37

Enlace dinámico

El método a ejecutarse se determina en
ejecución en función de la referencia
dinámica (no de la estática)

Composición y Herencia 38
 Enlace dinámico
Cuenta [ ]accArray = new Cuenta[10];
accArray[0] = new CAhorro();
accArray[1] = new CCorriente();
Cuenta retirar() ...

CCorriente CAhorro
accArray[i].retirar()
retirar() retirar()

enlace dinámico

Composición y Herencia 39

Enlace dinámico
class Shape{
class Shape{ ...
... double
double getArea(){...};}
getArea(){...};}
class Rectangle
class Rectangle extends
extends Shape{
Shape{ ...
... double
double
getArea(){...};}
getArea(){...};}
class Triangle
class Triangle extends
extends Shape{
Shape{ ...
... double
double
getArea(){...};}
getArea(){...};}

Shape s;
Shape s; Rectangle
Rectangle r; r; Triangle
Triangle t;
t;
// ...
// ...
if (/*...*/)
if (/*...*/) ss == r;
r; else
else ss == t;
t;
double answer
double answer == s.getArea();
s.getArea(); // // ¿Cual ejecuta?
¿Cual ejecuta?

rr == s;
s; //
// ¿legal?
¿legal?

Composición y Herencia 40
 Persona

Enlace dinámico
public static
public static void
void main(String
main(String args[])
args[]) {{ Trabajador
Persona per;
Persona per;
Trabajador yo=
Trabajador yo= new
new Trabajador("Balta",
Trabajador("Balta", 99,
99, 200.5f,
200.5f, 45);
45);

per == yo;
per yo; // Asignacion
// Asignacion legal
legal
// se
// se ejecuta
ejecuta el
el método
método mostrar
mostrar dede Trabajador
Trabajador
per.mostrar(); //
per.mostrar(); // per
per se
se trata
trata como
como cualquier
cualquier Trabajador
Trabajador
pelas == per.sueldo();
pelas per.sueldo();
// Ilegal
// Ilegal (sueldo
(sueldo se
se define
define en
en Trabajador)
Trabajador)

boolean b1,
boolean b1, b2;
b2;
b1 == (per
b1 (per instanceof
instanceof Persona);
Persona); // // True
True
b2 == (per
b2 (per instanceof
instanceof Trabajador);
Trabajador); //// True
True
System.out.println("b1: "+
System.out.println("b1: "+ b1
b1 ++ "" b2:
b2: "+
"+ b2);
b2);
}}
Composición y Herencia 41

Enlace dinámico
Nota:
Nota:
En
En C++
C++ sólo
sólo hay
hay enláce
enláce dinámico
dinámico
en
en los
los métodos
métodos virtual
virtual
En
En Java,
Java, todos
todos los
los métodos
métodos son
son
virtuales
virtuales

Composición y Herencia 42
Ejercicio 3: Imprimir el
toString() de un círculo

Composición y Herencia 43

Ejercicio 3: Imprimir el
toString() de diferentes Figuras

Composición y Herencia 44
Ejercicio 3: Otra manera de
recorrer arrays y vectores con for

Composición y Herencia 45

Ejercicio 3: ¿qué toString() se

imprime?

¿Se imprime el toString() de Figura
(referencia estática)?. No

¿Se imprime el toString() de la referencia
dinámica?. Si

Nota:
System.out.println(f);
es equivalente a
System.out.println(f.toString());

Composición y Herencia 46