Herencia y Polimorfismo Programacin Avanzada en Java FCC

Herencia y Polimorfismo Programación Avanzada en Java FCC BUAP 2009 Adaptado de UPM 1

Herencia en el mundo real Cosa Medio de telecomunicación Medio de transporte Objeto de oficina Coche Vehiculo aéreo 2

Introducción • La idea básica es poder crear clases basadas en clases ya existentes. • Cuando heredamos de una clase existente, estamos re-usando código (métodos y campos). • Podemos agregar métodos y variables para adaptar la clase a la nueva situación. • Java también permite consultar por la estructura de una clase (cuáles son sus métodos y variables). A esto se le llama reflexión. 3

Introducción (cont. ) • La herencia la identificamos cuando encontramos la relación es-un entre la nueva clase y la ya existente. Un estudiante es una persona. • La clase ya existente se le llama superclase, clase base , o clase padre. • A la nueva clase se le llama subclase, clase derivada, o clase hija. 4

Herencia en Java • Java permite definir una clase como subclase de una clase padre. class clase_hija extends clase_padre { //cuerpo de la clase. . } 5

Ejemplo de Herencia class Polygon { protected int width, height; public void set_values (int a, int b) { width=a; height=b; } } class Rectangle extends Polygon { public int area() { return (width * height); } } class Triangle extends Polygon { public int area() { return (width * height / 2); } public static void main(String[] args) { Rectangle rect; Triangle trgl; rect = new Rectangle(); trgl = new Triangle(); rect. set_values (4, 5); trgl. set_values (4, 5); System. out. print("area" + rect. area() + 'n' + trgl. area() + 'n'); }} 6

Constructores y Herencia • Cuando se declara un objeto de una clase derivada, se ejecutan los constructores siguiendo el orden de derivación, es decir, primero el de la clase base, y después los constructores de las clases derivadas de arriba a abajo. • Para pasar parámetros al constructor de la clase padre: super (para 1, para 2, . . . , para. N) 7

Formato de la referencia super Nombre_subclase (lista de parametros){ Super(lista de parámetros); //Cuerpo del constructor de la subclase } 8

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 nivel. Academico; 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"); } } 9

Redefinir funciones miembros de la clase padre class Persona { private String nombre; private int edad; . . public String to. String() { return nombre + edad; } public void set. Edad(int e) { edad = e; } } class Alumno extends Persona { private int curso; private String nivel. Academico; . . public String to. String() { return super. to. String() + curso + nivel. Academico; } public void set. Curso(int c) { curso = c; } } 10

Referencias a objetos de clases hijas • Si tenemos Clase. Hijo hijo = new Clase. Hijo(. . . ); • entonces es posible padre=hijo donde padre es una variable de tipo Clase. Padre. – pero no es posible!! hijo=padre (sí que es posible con casting hijo= (Clase. Hijo) padre) • Ahora bien: – Con padre sólo podemos acceder a atributos y métodos definidos en la clase padre. 11

Referencias a objetos de clases hijas public static void main(String[] args) { Persona p; Alumno a = new Alumno(“pepe”, 23, 1, ”universitario”); p=a; //referecnia padre señala al objeto hijo // acceso al objeto hijo mediante la referencia padre p. set. Edad(24); /* no es posible acceder a un miembro de la clase hija usando una ref a la clase padre*/ p. set. Curso(88); // ERROR } 12

Ejemplo class Persona {. . . . . } class Alumno extends Persona {. . . . . public String to. String() { return super. to. String() + curso + nivel. Academico; } } class Profesor extends Persona { private String asignatura; public Profesor (String n, int e, String asign) { super(n, e); asignatura = asign; } public String to. String() { return super. to. String() + asignatura; } } 13

public static void main(String[] args){ Dictionary webster = new Dictionary(); webster. message(); webster. def. Message(); } Number of pages: 1500 Number of definitions: 52500 Definitions per page: 35 public class Book { Otro Ejemplo protected int pages = 1500; } public String message() { System. out. println(“Number of pages: ” + pages); } public class Dictionary extends Book { private int definitions = 52500; } public void def. Message() { System. out. println(“Number of definitions” + definitions); System. out. println(“Definitions per page: ” + (definitions/pages)); } 14

El permiso protected • Los modificadores de visibilidad determina qué miembros de la clase son heredados y cuáles NO. • Variables y metodos declarados con el permiso public son heredados, los declardos private NO. • Pero variables public violan el principio del encapsulamiento. • Existe un tercer permiso de acceso a los miembros de una clase: protected T que ayuda a las situaciones de herencia 15

El permiso protected • El protected modificador permite que un miembro de una clase base sea heredado a una clase hija. • El permiso protected provee: – mayor encapsulamiento que el permiso public. – Tel mejor encapsumiento que permite la herencia 16

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 p. to. String(), se ejecuta el to. String de la clase Alumno. – Si p referencia a un profesor, con p. to. String(), se ejecuta el to. String 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). 17

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++) System. out. println(v[i]); // enlace dinámico con to. String() 18 }

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 nombre. Método(. . ); • Luego en cada subclase se define un método con la misma cabecera y distinto cuerpo. 19

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 Nombre. Clase {. . . } 20

Ejemplo de clase abstracta 21

Ejemplo de clase abstracta abstract class Alumno extends Persona { protected int curso; private String nivel. Academico; public Alumno (String n, int e, int c, String nivel) { super(n, e); curso = c; nivel. Academico = nivel; } public String to. String() { return super. to. String() + curso + nivel. Academico; } abstract double pago. Mensual(); abstract String get. Asignaturas(); } 22

Ejemplo de clase abstracta class Libre extends Alumno { private String []lista. De. Asignaturas; private static float precio. Por. Hora=10; private int no. Horas. Diarias; private void pedir. Asignaturas() {}// se inicializa lista. De. Asignaturas public double pago. Mensual() { return precio. Por. Hora*no. Horas. Diarias*30; } public String get. Asignaturas() { String asignaturas=""; for (int i=0; i<lista. De. Asignaturas. length; i++) asignaturas += lista. De. Asignaturas[i] + ' '; return asignaturas; } public Libre(String n, int e, int c, String nivel, int horas) {super(n, e, c, nivel); no. Horas. Diarias = horas; pedir. Asignaturas(); } } 23

Ejemplo de clase abstracta class Presencial extends Alumno { private double matricula. Curso; private double plus. Por. Convocatoria; private int no. Convocatoria; public double pago. Mensual() { return (matricula. Curso+plus. Por. Convocatoria*no. Convocatoria)/12; } public String get. Asignaturas(){ 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); matricula. Curso=mc; plus. Por. Convocatoria=pc; no. Convocatoria=nc; } } 24

Ejemplo de clase abstracta // FUNCIONES GLOBALES void mostrar. Asignaturas(Alumno v[]) { for (int i=0; i<v. length; i++) System. out. println(v[i]. get. Asignaturas()); // enlace dinámico } double total. Pagos(Alumno v[]) { double t=0; for (int i=0; i<v. length; i++) t += v[i]. pago. Mensual(); // enlace dinámico return t; } 25

Interfaces • Podría suceder que los objetos de varias clases compartan la capacidad de ejecutar un cierto conjunto de operaciones. • Y dependiendo de la clase de objeto, cada operación se realice de diferente manera. • Ejemplo: – Clases: Circulo, Elipse, Triangulo, . . – Todas esas clases incluyen los métodos: área, perimetro, cambiar. Escala, etc. • Podríamos definir una interfaz común que agrupe todos los métodos comunes (como métodos abstractos). • Y luego definir varias clases de modo que implementen una misma interfaz. 26

Ejemplo de Interfaz public interface Figura { abstract double area(); abstract double perimetro(); } public class Circulo implements Figura { private double radio; private static double PI=3. 1416; . . . public double area() { return PI*radio; } public double perimetro() { return 2*PI*radio; } } public class Cuadrado implements Figura { private double lado; . . . public double area() { return lado*lado; } public double perimetro() { return 4*lado; } } 27

Ejemplo de Interfaz • Una interfaz puede incluir también definiciones de constantes a parte de métodos abstractos. • Una misma clase puede implementar más de una interfaz Herencia múltiple de interfaces • Se pueden crear jerarquías de interfaces (con extends!!). • Se pueden declarar referencias a objetos que implementen una cierta interfaz. double total. Area(Figura v[]) { double t=0; for (int i=0; i<v. length; i++) t += v[i]. area(); // enlace dinámico return t; } 28

Interfaces Design Abstraction and a way for loosing realizing Multiple Inheritance 29

Interfaces • Interface is a conceptual entity similar to a Abstract class. • Can contain only constants (final variables) and abstract method (no implementation) - Different from Abstract classes. • Use when a number of classes share a common interface. • Each class should implement the interface. 30

Interfaces: An informal way of realising multiple inheritance • An interface is basically a kind of class—it contains methods and variables, but they have to be only abstract classes and final fields/variables. • Therefore, it is the responsibility of the class that implements an interface to supply the code for methods. • A class can implement any number of interfaces, but cannot extend more than one class at a time. • Therefore, interfaces are considered as an informal way of realising multiple inheritance in Java. 31

Interface - Example <<Interface>> Speaker speak() Politician Priest Lecturer speak() 32

Interfaces Definition • Syntax (appears like abstract class): interface Interface. Name { // Constant/Final Variable Declaration // Methods Declaration – only method body } • Example: interface Speaker { public void speak( ); } 33

Implementing Interfaces • Interfaces are used like super-classes who properties are inherited by classes. This is achieved by creating a class that implements the given interface as follows: class Class. Name implements Interface. Name [, Interface. Name 2, …] { // Body of Class } 34

Implementing Interfaces Example class Politician implements Speaker { public void speak(){ System. out. println(“Talk politics”); } } class Priest implements Speaker { public void speak(){ System. out. println(“Religious Talks”); } } class Lecturer implements Speaker { public void speak(){ System. out. println(“Talks Object Oriented Design and Programming!”); } 35 }

Extending Interfaces • Like classes, interfaces can also be extended. The new sub-interface will inherit all the members of the superinterface in the manner similar to classes. This is achieved by using the keyword extends as follows: interface Interface. Name 2 extends Interface. Name 1 { // Body of Interface. Name 2 } 36

Inheritance and Interface Implementation • A general form of interface implementation: class Class. Name extends Super. Class implements Interface. Name [, Interface. Name 2, …] { // Body of Class } • This shows a class can extended another class while implementing one or more interfaces. It appears like a multiple inheritance (if we consider interfaces as special kind of classes with certain restrictions or special features). 37

Student Assessment Example • Consider a university where students who participate in the national games or Olympics are given some grace marks. Therefore, the final marks awarded = Exam_Marks + Sports_Grace_Marks. A class diagram representing this scenario is as follow: Student Sports extends Exam extends Results implements 38

Software Implementation class Student { // student no and access methods } interface Sport { // sports grace marks (say 5 marks) and abstract methods } class Exam extends Student { // example marks (test 1 and test 2 marks) and access methods } class Results extends Exam implements Sport { // implementation of abstract methods of Sport interface // other methods to compute total marks = test 1+test 2+sports_grace_marks; // other display or final results access methods } 39

Interfaces and Software Engineering • Interfaces, like abstract classes and methods, provide templates of behaviour that other classes are expected to implement. • Separates out a design hierarchy from implementation hierarchy. This allows software designers to enforce/pass common/standard syntax for programmers implementing different classes. • Pass method descriptions, not implementation • Java allows for inheritance from only a single superclass. Interfaces allow for class mixing. • Classes implement interfaces. 40

Manejo de una excepción • Supongamos que en una función f de Java se detecta una situación anómala, entonces: • Se ejecuta: throw new Nombre. Excepción([msg]); • Para que pueda ser capturada: try {// bloque try f(. . . ); // u otra func que llame a f. } 41

Manejo de una excepción • El tratamiento de la excepción se especifica mediante una sentencia catch: try { f(. . . ) // fuente de la excepción. . . . } catch (tipo_excepcion 1 parámetro 1) { “tratamiento de la excepción 1” } catch (tipo_excepcion 2 parámetro 2) {. . . . } catch (tipo_excepcion. N parámetro. N) { “tratamiento de la excepción. N” } [ finally { “bloque se ejecuta siempre” }] 42

Creación de clases de Excepciones Se debe definir una nueva clase subclase de la clase Exception. • class Mi. Excepcion extends Exception { public Mi. Exception() { } // si se quiere mostrar un cierto mensaje // se debe definir este segundo constructor public Mi. Exception(String msg) { super(msg); } } 43

Jerarquía de Excepciones 44

Igualdad y Asignación entre objetos • El operador de asignación no sirve para crear una copia de un objeto. • ¿Cómo crear una copia a nivel de bits? – Solución: utilizar el método clone(). – Para poder utilizarlo con los objetos de una clase A, la clase A debe implementar la interfaz Cloneable y se debe incluir el siguiente método clone() en la clase A: public Object clone(){ Object obj=null; try{ obj=super. clone(); }catch(Clone. Not. Supported. Exception ex){ System. out. println(" no se puede duplicar"); } return obj; } 45

Ejemplo con clone() class Date implements Cloneable {. . . . . public Object clone(){ Object obj=null; try{ obj=super. clone(); }catch(Clone. Not. Supported. Exception ex){ System. out. println(" no se puede duplicar"); } return obj; } public static void main(String[] args) { Date ob 1, ob 2; ob 1 = new Date(12, 4, 96); ob 2 = (Date) ob 1. clone(); // ob 2 es una copia de ob 1 // las alias de ob 1 y ob 2 son diferentes System. out. println(ob 1 == ob 2); // el contenido de ob 1 y ob 2 es el mismo System. out. println(ob 1. equals(ob 2)); } } 46

Problemas con el clone() • Si se quiere hacer una copia de un objeto que contiene otros objetos, no sirve el clone() que proporciona Java. – Ejemplo: clase Persona con un atributo fecha de nacimiento. – Solución: redefinir el método clone() para la clase Persona de modo que haga una copia del objeto fecha de nacimiento. 47

Ejemplo con clone() redefinido public class Persona implements Cloneable { private String nombre; private Date fecha. Nacimiento; public Persona(String nombre, Date fecha. Nacimiento){ this. nombre = nombre; this. fecha. Nacimiento = fecha. Nacimiento; } public Object clone(){ return (new Persona(nombre, (Date) (fecha. Nacimiento. clone()))); } public static void main(String[] args) { Persona p 1, p 2; p 1 = new Persona("Pepe", new Date(1, 1, 2006)); p 2 = (Persona) p 1. clone(); } } 48