definir herencia, polimorfismo, sobrecarga, sobrescritura e invocación de métodos virtuales. usar...

Definir herencia, polimorfismo, sobrecarga, sobrescritura e invocación de métodos virtuales.

Usar los modificadores de acceso protected y el por defecto (package-friendly)

Describir los conceptos de constructor y de sobrecarga de métodos.

Describir la operación de construcción y de inicialización de objetos en forma completa.

Recordamos las características esenciales:₋ Encapsulamiento₋ Herencia₋ Polimorfismo

Ahora veremos Herencia y Polimorfismo

La clase Employee:

public class Employee {public String name = "";public double salary;public Date birthDate;

public String getDetails() {...}

}

La clase Manager:

public class Manager {public String name = "";public double salary;public Date birthDate;public String department;public String getDetails() {...}

}

public class Employee {public String name = "";public double salary;public Date birthDate;public String getDetails() {...}

}

public class Manager extends Employee {public String department;

}

Cuando una clase hereda de una sola clase, se le llama herencia simple

Las Interfaces proveen la herencia múltiple, sin los problemas de la misma

Sintaxis de clases:

< modifier> class < name> [extends < superclass>] {

< declarations>*

}

¿Que quiere decir acceder a un clase B desde una clase A?

₋ Crear una instancia de B₋ Extender B₋ Acceder ciertos miembros de B dependiendo de

los niveles de acceso de los mismos Acceso se traduce a Visibilidad

Niveles de acceso permitidos para clases:

₋ default (no tienen modificador precediendo a la keyword class): Accesibles por clases dentro del mismo paquete

₋ public: Accesibles por todas las clases

Con nivel de acceso default:package cert;class Beverage {}

package exam.stuff;import cert.Beverage;class Tea extends Beverage {

//Error de compilación porque están en distinto paquete!!

}

Con nivel de acceso public:

package cert;public class Beverage {}package exam.stuff;import cert.Beverage;class Tea extends Beverage {

// OK! Nivel de acceso de Beverage public!!}

Se permiten todos los niveles de acceso:

Los niveles de acceso default y protected difieren solo en que:

₋ Un miembro default puede ser accedido solo si la clase que accede al miembro se encuentra en el mismo paquete.

₋ Un miembro protected puede ser accedido (a través de la herencia) por una sublcase por más que esta no se encuentre en el mismo paquete

Una clase puede modificar el comportamiento heredado de una clase padre

Una subclase puede crear un método con diferente funcionalidad que la clase padre, pero con el mismo:

₋ nombre₋ tipo de retorno₋ lista de argumentos

No se puede sobrescribir constructores

public class Employee {protected String name;protected double salary;protected Date birthDate;

public String getDetails() {return “Name: “ + name + “\n” + “Salary: “ + salary;

}}

public class Manager extends Employee {protected String department;

public String getDetails() { return “Name: “+name +“\n”+ “Salary: “ + salary + "\n" +“Manager of: “ +department;}

}

La palabra clave super es usada en una clase para hacer referencia a su superclase.

También es usada para hacer referencia a los miembros de la superclase, tanto atributos como métodos

El comportamiento invocado no tiene porque estar en la superclase, puede venir también de arriba de la jerarquía de clases

public class Employee {private String name;private double salary;private Date birthDate;public String getDetails() {

return "Name: " + name + "\nSalary: " + salary;}

}

public class Manager extends Employee {private String department;public String getDetails() { // call parent method return super.getDetails() +"\nDepartment: " +department;}

}

La lista de parámetros debe ser idéntica a la del método sobrescrito

El tipo de retorno debe ser idéntico al del método sobrescrito

El nivel de acceso no debe ser más restrictivo que el del método sobrescrito (puede ser menos)

No puede arrojar una nueva excepción o una más general que el método sobrescrito (puede declarar menos o más específicas)

No se puede sobrescribir un método final

public class Parent {public void doSomething() {}

}

public class Child extends Parent {private void doSomething() {}

}

public class UseBoth {public void doOtherThing() {

Parent p1 = new Parent();Parent p2 = new Child();p1.doSomething();p2.doSomething();

}}

Permiten utilizar el mismo nombre que otro método pero con distintos parámetros y opcionalmente distinto tipo de retorno.

Ejemplo:₋ public void println(int i)₋ public void println(float f)₋ public void println(String s)

Deben cambiar la lista de argumentos Pueden cambiar el tipo de retorno Pueden cambiar los modificadores de acceso Pueden declarar excepciones nuevas o más genericas Se puede sobrecargar un método dentro de la misma

clase

Como los métodos, los constructores pueden ser sobrecargados.

Ejemplo:public Employee(String name, double salary, Date DoB)public Employee(String name, double salary)public Employee(String name, Date DoB) La lista de argumentos debe ser diferente Puede usar this en la primera línea del constructor

para llamar otro constructor

public class Employee { private static final double BASE_SALARY = 15000.00; private String name; private double salary; private Date birthDate;

public Employee(String name, double salary, Date DoB) { this.name = name; this.salary = salary; this.birthDate = DoB; } public Employee(String name, double salary) { this(name, salary, null); } public Employee(String name, Date DoB) { this(name, BASE_SALARY, DoB); } public Employee(String name) { this(name, BASE_SALARY); } // more Employee code... }

Una subclase hereda todos los métodos y variables de su superclase

La subclase no hereda constructores de la superclase

Existen dos formas de tener constructores en una clase:₋ Utilizar el constructor por defecto₋ Escribir uno o mas constructores explícitos

Para invocar un constructor padre, debe poner una llamada a super en la primera línea del constructor

Si no es utilizado this o super en el constructor, entonces el compilador agrega una llamada implícita super() (la primer línea siempre debe ser una llamada a super o una llamada a this)

Si en la clase padre se definen constructores y no tiene el constructor sin parámetros, un error de compilación es generado

No se puede crear un objeto sin invocar a su constructor

Más aún, no puede crearse un objeto sin invocar a su constructor y a todos los constructores de sus superclases

La memoria es reservada y la inicialización por defecto es efectuada

La inicialización de las variables de instancia utiliza este paso recursivamente:₋ Busca el constructor con los parámetros invocados₋ Si existe this(), llama recursivamente y saltar hasta

paso 5₋ Invoca recursivamente super (implícitamente o

explícitamente), excepto para Object₋ Ejecuta la inicialización explícita de la variable de

instancia₋ Ejecuta el cuerpo del constructor

public class Object {...public Object() {}...}public class Employee extends Object { private String name; private double salary = 15000.00; private Date birthDate; public Employee(String n, Date DoB) { // implicit super(); name = n; birthDate = DoB; }

public Employee(String n) { this(n, null); }}public class Manager extends Employee { private String department; public Manager(String n, String d) { super(n); department = d; }}

Pueden usar cualquier modificador de acceso incluyendo private (ver Singleton)

El nombre del constructor debe coincidir con el de la clase

No tienen tipo de retorno Si no se declara uno el compilador construye el

constructor por defecto sin argumentos La primer línea del constructor es o una llamada a otro

constructor de la misma clase o a un constructor de la superclase

Tiene el mismo nivel de acceso que la clase No tiene argumentos Incluye una llamada sin argumentos al constructor de

la clase padre (super())

Polimorfismo es la capacidad de tener varias formas diferentes, por ejemplo, la clase Manager tiene acceso a los métodos de la clase Employee.

Un objeto tiene sólo una forma.

Es la variable referencia la que puede referenciar a objetos de diferentes formas

Ejemplo:

Employee employee = new Manager();

employee.department = "Sales";

No se le puede asignar un atributo de Manager, la

variable fue declarada de tipo Employee

Ejemplo:

Employee e = new Manager();

e.getDetails();

El comportamiento lo toma del objeto al que hace referencia en tiempo de ejecución.

Las colecciones de objetos del mismo tipo de clase se llaman colecciones homogéneas.

₋ MyDate[] dates = new MyDate[2];₋ dates[0] = new MyDate(22, 12, 1964);₋ dates[1] = new MyDate(22, 7, 1964);

Las colecciones de objetos de tipos diferentes de clases son llamadas colecciones heterogéneas.

₋ Employee [] staff = new Employee[1024];₋ staff[0] = new Manager();₋ staff[1] = new Employee();₋ staff[2] = new Engineer();

Como un Manager es un Employee:

// In the Employee classpublic TaxRate findTaxRate(Employee e) {}// Meanwhile, elsewhere in the application classManager m = new Manager();:TaxRate t = findTaxRate(m);

public class Employee extends Objectpublic class Manager extends Employeepublic class Engineer extends Employee----------------------------------------public void doSomething(Employee e) {

if (e instanceof Manager) {// Process a Manager

} else if (e instanceof Engineer) {// Process an Engineer

} else {// Process any other type of Employee

}}

Utilice el operador instanceof para conocer el tipo del objeto

Recupere todas las funcionalidades de un objeto mediante el casteo.

Compruebe que el casteo sea correcto, realizando lo siguiente:

₋ El casteo hacia arriba (jerárquicamente) es hecho implícitamente

₋ El casteo hacia abajo (jerárquicamente) debe ser con una subclases y chequeado por el compilador

₋ El tipo del objeto es chequeado en tiempo de ejecución, por lo tanto si hay un error este será en tiempo de ejecución.

Es la clase base de todas las clases en Java

Una declaración de una clase sin extends, implícitamente utiliza “extends Object”

La veremos en profundidad cuando hablemos del paquete java.lang

Definimos:₋ Herencia₋ Polimorfismo₋ Sobrecarga

Sobrescritura e invocación de métodos virtuales Modificadores de acceso: protected Sobrecarga de constructores y de métodos Construcción e inicialización de objetos.

Thinking in Java₋ Bruce Eckel

The Java Tutorial₋ http://download.oracle.com/javase/tutorial/