Download Relaciones de composición y Herencia POO en Java Composición

POO en Java
Relaciones de composición y
Herencia
Características:
• Composición “tiene un”
• Herencia “es un”
• Polimorfismo.
•Abstracción.
•Clases y objetos.
Java
Arrays y Cadenas
1
Java
Composición
2
Composición: clase Círculo
public class
class Punto
Punto {{
public
int xx;;
int
int yy;;
int
public Punto(
Punto(int
int x,
x, int
int y)
y) {{
public
this.x
.x == x;
x;
this
this
.y
=
y;
this .y = y;
}}
public Punto()
Punto() {{
public
// llamada
llamada al
al otro
otro constructor
constructor
//
this(-1,
(-1, --1);
1); }}
this
public
void
mostrar(){
public void mostrar(){
System.out.println(“x == ““ ++ xx +”
+” yy == ““ ++ y);
y); }}
System.out.println(“x
public static
static void
void main
main(String
(String args[])
args[]) {{
public
Punto pun1
pun1 == new
new Punto();
Punto();
Punto
Punto pun2
pun2 == new
new Punto(2,3);
Punto(2,3);
Punto
System.out.println( "visualizar
"visualizar datos
datos del
del punto"
punto" );
);
System.out.println(
pun1.mostrar();
pun1.mostrar();
pun2.mostrar();}}
pun2.mostrar();}}
Java
Arrays y Cadenas
Arrays y Cadenas
public class
class Circulo
Circulo {{
public
Punto origen;
origen;
Punto
int radio;
radio;
int
public Circulo(int
Circulo(int x,
x, int
int y,
y, int
int radio)
radio) {{
public
origen == new
new Punto(x,y);
Punto(x,y);
origen
this.radio
.radio == radio;
radio;
this
}}
public void
void mostrar()
mostrar() {{
public
origen.mostrar();
origen.mostrar();
System.out.println("radio == "" ++ radio);
radio);
System.out.println("radio
}}
public static
static void
void main(
main(String
String args[])
args[]) {{
public
Circulo cir
cir == new
new Circulo(5,
Circulo(5, 5,
5, 9);
9);
Circulo
System.out.println( "visualizar
"visualizar datos
datos del
del circulo"
circulo" );
);
System.out.println(
cir.mostrar();
}}
cir.mostrar();
}}
3
Java
Arrays y Cadenas
4
Herencia: La palabra
reservada extends
Tipos de programación
Cuando se crea un modelo de algo y luego se quiere
una versión más actualizada:
encapsulación
public class Empleado
{
String nombre;
Date anionac;
String puesto;
int categoría;
Basado en
objetos
+ clases
Basado en
clases
+ herencia
...
Orientado a
Objetos
public class jefe
{
String nombre;
¡datos duplicados!
Date anionac;
String puesto;
int categoría;
String departamento;
Empleado [] subordinados;
}
...
}
Java
Arrays y Cadenas
5
Java
Arrays y Cadenas
6
1
Herencia: La palabra
reservada extends
Herencia: La palabra
reservada extends
Se puede definir una clase a partir de otra definida
previamente.
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.
public class Empleado {
Todo lo que se tiene que definir después son
las características adicionales y especificar los
cambios que se quieren aplicar.
String nombre;
Date anionac;
String puesto;
int categoría; }
public class Jefe extends Empleado {
String departamento;
Arrays y Cadenas}
Empleado [ ] Java
subordinados;
7
Ejemplo de Herencia
Cuando una clase hereda sólo de otra clase,
se llama herencia simple.
Herencia simple hace que el código sea
reutilizable.
Mamífero
Primate
Java proporciona las interfaces que
proporcionan las ventajas de la herencia
múltiple y no presentan sus inconvenientes.
Canino
Chimpance
Java
Perro
Lobo
Arrays y Cadenas
9
Los constructores no se
heredan
Java
public class
class Persona
Persona {{
public
String nombre
nombre == "";
"";
String
int edad;
edad;
int
10
Persona
public Persona(String
Persona(String nom
nom,, int
int ed)
ed) {{
public
nombre == nom;
nom;
nombre
edad
=
ed;
edad = ed;
}}
Una clase no hereda los constructores de la
superclase.
Trabajador
public void
void mostrar()
mostrar() {{
public
System.out.println("Nombre: "+
"+ nombre);
nombre);
System.out.println("Nombre:
System.out.println("Edad:
"+ edad);
edad);
System.out.println("Edad: "+
}}
public static
static void
void main(String
main(String args[])
args[]) {{
public
Persona yo=
yo= new
new Persona(“Luis",
Persona(“Luis", 32);
32);
Persona
yo.mostrar();
yo.mostrar();
}
}
Sólo hay dos formas de que una clase tenga
constructor:
Utilizar el constructor por defecto.
Escribir uno o más constructores explícitos.
Arrays y Cadenas
Arrays y Cadenas
Herencia: clase Persona
Una subclase hereda de una superclase (la
clase padre), todos los métodos y las
variables.
Java
8
Herencia simple
Animal
Gorila
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.
Java
Arrays y Cadenas
11
}}
Java
Arrays y Cadenas
12
2
Herencia: clase Trabajador
Herencia: constructores
public class
class Trabajador
Trabajador extends
extends Persona
Persona {{
public
float sueldoHora;
sueldoHora;
float
int numHoras
numHoras;;
int
Persona
Persona
public Trabajador(
Trabajador(String
String nom,
nom, int
int ed
ed,, float
float suel,
suel, int
int num)
num) {{
public
super(nom,
(nom, ed);
ed); //
// llamada
llamada al
al constructor
constructor de
de Persona
Persona
super
sueldoHora == suel
suel;;
sueldoHora
numHoras == num
num;}
;}
numHoras
Trabajador
Trabajador
public double
double sueldo()
sueldo() {{
public
return sueldoHora
sueldoHora ** numHoras;
numHoras; }}
return
public static
static void
void main(
main(String
String args[])
args[]) {{
public
Trabajador yo=
yo= new
new Trabajador(“Luis",
Trabajador(“Luis", 32,
32, 200.5f,
200.5f, 45);
45);
Trabajador
yo.mostrar(); //
// se
se invoca
invoca al
al metodo
metodo heredado
heredado mostrar
mostrar
yo.mostrar();
double pelas
pelas == yo.sueldo();
yo.sueldo();
double
System.out.println("Cobra:
println("Cobra: "" ++ euros);
euros);
System.out.
}}
Java
Arrays y Cadenas
}}
Bedel
Bedel
13
Reescritura de un método
n
n
Arrays y Cadenas
Arrays y Cadenas
14
Ejemplo
La signatura de un método viene dada por su
nombre y el tipo y número de los parámetros
w El tipo devuelto no forma parte de la signatura
Cuando se reescribe un método en una clase
derivada
w La signatura debe ser la misma que el método
de la clase base
w El tipo devuelto debe ser el mismo que el del
método de la clase base
w 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)
Java
Java
//En Persona
Persona redefinimos
redefinimos el
el método
método mostrar()
mostrar()
//En
public class
class Trabajador
Trabajador extends
extends Persona
Persona {{
public
float sueldoHora;
sueldoHora;
float
int numHoras;
numHoras;
int
public Trabajador(String
Trabajador(String nom,
nom, int
int ed,
ed, float
float suel,
suel, int
int num)
num) {{
public
super(nom, ed);
ed); //
// llamada
llamada al
al constructor
constructor de
de Persona
Persona
super(nom,
sueldoHora == suel;
suel;
sueldoHora
numHoras == num;}
num;}
numHoras
// sobrecarga
sobrecarga completa
completa de
de mostrar
mostrar
//
//
nombre
y
edad
son
atributos heredados
heredados de
de Persona
Persona
// nombre y edad son atributos
public void
void mostrar()
mostrar() {{
public
System.out.println("Nombre: "+
"+ nombre);
nombre);
System.out.println("Nombre:
System.out.println("Edad: "+
"+ edad);
edad);
System.out.println("Edad:
System.out.println("Sueldo por
por hora:
hora: "+
"+ sueldoHora);
sueldoHora);
System.out.println("Sueldo
System.out.println("Horas trabajadas:
trabajadas: "+
"+ numHoras);}}
numHoras);}}
System.out.println("Horas
15
Sobrecarga de método
Java
Arrays y Cadenas
16
Sobrecarga de método
Sobrecarga parcial ampliando el método
heredado
public class
class Trabajador
Trabajador extends
extends Persona
Persona {{
public
float sueldoHora
sueldoHora;;
float
int numHoras;
numHoras;
int
public Trabajador(String
Trabajador(String nom
nom,, int
int ed,
ed, float
float suel,
suel, int
int
public
num) {{
num)
w El método de la subclase puede llamar al
super(nom, ed
ed);
); //
// llamada
llamada al
al constructor
constructor de
de Persona
Persona
super(nom,
sueldoHora == suel;
suel;
sueldoHora
numHoras == num;}
num;}
numHoras
// sobrecarga
sobrecarga parcial
parcial de
de mostrar
mostrar
//
// nombre
nombre yy edad
edad son
son atributos
atributos heredados
heredados de
de Persona
Persona
//
public
void
mostrar()
{
public void mostrar() {
super.mostrar(); //llamada
//llamada al
al método
método de
de la
la clase
clase padre
padre
super.mostrar();
System.out.println("Sueldo por
por hora:
hora: "+
"+ sueldoHora
sueldoHora);
);
System.out.println("Sueldo
System.out.println("Horas
trabajadas:
"+
numHoras);}
System.out.println("Horas trabajadas: "+ numHoras);}
método de la superclase
}}
Java
Arrays y Cadenas
17
Java
Arrays y Cadenas
18
3
La clase genérica Object
La clase genérica Object
Object define un conjunto de métodos útiles,
que pueden ser redefinidos en cada clase. En
particular:
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.
n
n
Java
Arrays y Cadenas
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.
19
La clase genérica Object
Java
Arrays y Cadenas
20
API de Object
Method Summary
toString()
equals()
protected
Object
Object
boolean
protected
void
Class
int
no se necesita extends para heredar de Object
String
Java
Arrays y Cadenas
21
Ejemplo
clone()
Creates and returns a copy of this object.
equals (Object obj)
Indicates whether some other object is "equal to" this one.
finalize()
Called by the garbage collector on an object when garbage collection
determines that there are no more references to the object.
getClass()
Returns the runtime class of an object.
hashCode()
Returns a hash code value for the object.
toString()
Returns a string representation of the object.
Java
Arrays y Cadenas
22
Ejemplo
public class Alumno{
String nombre;
String apellidos;
public Alumno(String nombre, String apellidos){
this.nombre= nombre;
this.apellidos= apellidos;
}
public boolean equals(Alumno al){
if (apellidos.equals(al.apellidos))
return true;
else return false;
}
Java
Arrays y Cadenas
23
public static void main(String args[]) {
Alumno alum = new Alumno("Julian", "Fdez");
Class tipoObjeto = alum.getClass();
System.out.println("nombre de la clase: " +
tipoObjeto .getName());
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));
}}
Java
Arrays y Cadenas
24
4
Copias de Objetos
clone( )
La asignación en Java simplemente copia
A'
A
la referencia
Copia superficial:
15
B
C
23
"abc"
Copia en profundidad:
A
B
23
"abc"
15
C
42
Java
15
A'
B'
23
"abc"
42
15
C'
Crea un objeto que es copia “superficial” del
objeto actual independientemente de su tipo.
El tipo objeto a copiar debe haber declarado
que es susceptible de copia implementando el
interfaz vacío Clonable
Es un método protegido de Object, por tanto
para que pueda ser invocado desde otro
paquete hay que redeclararlo como público y
simplemente invocar a la clase base.
42
Arrays y Cadenas
25
clone( )
Java
Arrays y Cadenas
26
clone( )
public class
class ClaseClonable
ClaseClonable
public
implements Cloneable
Cloneable {{
implements
// Otro
Otro código
código de
de la
la clase
clase
//
public Object
Object clone
clone ()
()
public
throws CloneNotSupportedException
CloneNotSupportedException
throws
{{
return super.clone();
super.clone();
return
}}
}}
Java
Arrays y Cadenas
27
clone( )
public abstract class Transaction implements
Cloneable{
private long amount;
private Date date;
public Object clone(){
Object o = null;
try{
o = super.clone(); //copia superficial
}
catch(CloneNotSupportedException e){
throw new InternalError(); }
return o;
Java
Arrays y Cadenas
28
}
clone( )
Si los miembros de una clase son otros
objetos que necesiten “copia profunda”
habrá que añadir el código necesario
w Llamada a los métodos clone() de cada uno de
los objetos implicados para crear una copia
Java
Arrays y Cadenas
29
public abstract class Transaction
implements Cloneable{
private long amount;
private Date date;
public Object clone(){
Transaction t = null;
try{
t = (Transaction)super.clone();//superf
t.date = (Date)t.date.clone();//profund
}
catch(CloneNotSupportedException e){
throw new InternalError(); }
return t;
Java
Arrays y Cadenas
30
}
5
clone( )
Ejemplo
Reglas generales
n
n
Implementar el interfaz Cloneable si se desea que
la clase se pueda copiar
No utilizar constructores en la implementación de
clone() si no llamadas a los métodos clone() de
los otros objetos a copiar
w Puede existir problemas en el tipo de objeto creado
n
Todas las subclases de una clase Clonable
también son susceptibles de ser clonadas.
w Deben reescribir el método clone()
Java
Arrays y Cadenas
31
Ejemplo (cont.)
public class
class Alumno
Alumno implements
implements Cloneable
Cloneable {{
public
String nombre;
nombre;
String
String
apellidos;
String apellidos;
public Alumno(String
Alumno(String nombre,
nombre, String
String apellidos){
apellidos){
public
this.nombre= nombre;
nombre;
this.nombre=
this.apellidos= apellidos;
apellidos;
this.apellidos=
}}
public
boolean
equals
(Alumno
al){
public boolean equals (Alumno al){
if (apellidos.equals(al.apellidos))return
(apellidos.equals(al.apellidos))return true
true;;
if
else return
return false;
false;
else
}}
public Object
Object clone
clone ()
() throws
throws
public
CloneNotSupportedException{
CloneNotSupportedException{
return super.clone();
super.clone();
return
}}
public String
String toString
toString(){
(){
public
return nombre
nombre
Java
apellidos ++ "" ";
"; 32}}
return
++ ""Arrays
"" ++y Cadenas
apellidos
Referencia estática
public static
static void
void main(String
main(String args[])
args[]) {{
public
Alumno alum
alum == new
new Alumno("Julian",
Alumno("Julian", ""Fdez");
Fdez");
Alumno
Class tipoObjeto
tipoObjeto == alum.
alum.getClass();
getClass();
Class
System.out.println
.out.println("nombre
("nombre de
de la
la clase:"
clase:" ++tipoObjeto
tipoObjeto.getName());
.getName());
System
Alumno alum2
alum2 == alum;
alum;
Alumno
alum2.apellidos == "Rodriguez";
"Rodriguez";
alum2.apellidos
System.out.println
.out.println("son
("son el
el mismo
mismo objeto?:"+
objeto?:"+ ((alum
alum==alum2));
==alum2));
System
alum2 == new
new Alumno("Antonio",
Alumno("Antonio", "Rodriguez");
"Rodriguez");
alum2
System.out.println
.out.println("son
("son iguales
iguales os
os objetos?:"+
objetos?:"+
System
alum.equals(alum2));
.equals(alum2));
alum
try {{ alum2
alum2 == (Alumno)alum.clone();
(Alumno)alum.clone();
try
}catch (CloneNotSupportedException
(CloneNotSupportedException e){
e){
}catch
System.out.println("no tiene
tiene implementada
implementada la
la clonacion");
clonacion");
System.out.println("no
}}
alum.nombre="Fran";
alum.nombre="Fran";
alum2.nombre="Moises";;
alum2.nombre="Moises"
System.out.println
.out.println("objetos:
("objetos: "+
"+ alum
alum ++ alum2);
alum2);
System
}}
Java
Arrays y Cadenas
33
}}
Referencia dinámica
La referencia estática se fija en tiempo de
compilación
Rectangle r = new Rectangle();
Circle c = new Circle();
...
c = r; //Error
Java
Arrays y Cadenas
34
Enlace dinámico
Programador es un Empleado
Empleado
n
e
mit
per
Se
extends
Programador
El método a ejecutarse se determina en
ejecución en función de la referencia
dinámica (no de la estática)
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
Java
Arrays y Cadenas
35
Java
Arrays y Cadenas
36
6
Enlace dinámico
Cuenta
CCorriente
Cuenta [ ]accArray = new Cuenta[10];
accArray[0] = new CAhorro();
accArray[1] = new CCorriente();
...
retirar()
CAhorro
retirar()
Enlace dinámico
class Shape{
Shape{ ...
... double
double getArea(){...};}
getArea(){...};}
class
class Rectangle
Rectangle extends
extends Shape{
Shape{ ...
... double
double
class
getArea(){...};}
getArea(){...};}
class Triangle
Triangle extends
extends Shape
Shape{{ ...
... double
double
class
getArea(){...};}
getArea(){...};}
Shape s;
s; Rectangle
Rectangle r;
r; Triangle
Triangle t;
t;
Shape
// ...
...
//
if
(/*...*/)
s
=
r;
else
s
=
t;
if (/*...*/) s = r; else s = t;
double answer
answer == s.getArea();
s.getArea(); //
// ¿Cual
¿Cual ejecuta?
ejecuta?
double
accArray[i].retirar()
retirar()
enlace dinámico
s; //
// ¿legal?
¿legal?
rr == s;
Java
Arrays y Cadenas
Enlace dinámico
37
Persona
public static
static void
void main(String
main(String args[])
args[]) {{
Trabajador
public
Persona per;
per;
Persona
Trabajador yo=
yo= new
new Trabajador("Balta",
Trabajador("Balta", 99,
99, 200.5f,
200.5f, 45);
45);
Trabajador
per == yo;
yo;
// Asignacion
Asignacion legal
legal
per
//
// se
se ejecuta
ejecuta el
el método
método mostrar
mostrar de
de Trabajador
Trabajador
//
per.mostrar(); //
// per
per se
se trata
trata como
como cualquier
cualquier Trabajador
Trabajador
per.mostrar();
pelas == per.sueldo();
per.sueldo();
pelas
//
Ilegal
(sueldo
se
define
en
Trabajador)
// Ilegal (sueldo se define en Trabajador)
boolean b1,
b1, b2;
b2;
boolean
b1 == (per
(per instanceof
instanceof Persona);
Persona); //
// True
True
b1
b2 == (per
(per instanceof
instanceof Trabajador);
Trabajador); //
// True
True
b2
System.out.println("b1:
"+
b1
+
"
b2:
"+ b2);
b2);
System.out.println("b1: "+ b1 + " b2: "+
}
}
Java
Arrays y Cadenas
39
La palabra reservada super
n
n
n
Arrays y Cadenas
Arrays y Cadenas
38
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
Java
Arrays y Cadenas
40
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.
Java
Java
41
public class Empleado{
private String nombre;
private int salario;
public String getDetails(){
return "Nombre: "+ nombre + "\nsalario: "
+ salario; }}
public class Jefe extends Empleado {
private String departamento;
public String getDetails(){
return super.getDetails()+
"\nDepartamento: " + departamento;
//llama al método del padre
}}
Java
Arrays y Cadenas
42
7