La diferencia entre eager y lazy la puedes ver cuando tienes 2 entidades

relacionadas. Por ejemplo, si tienes una entidad llamada Ciudad, y otra habitantes...
La entidad ciudad tiene unas propiedades básicas como Id, nombre, superficie, al
igual que la entidad habitante tiene las suyas.

Cuando java carga la entidad Ciudad, carga esas propiedades básicas, pero para
habitantes tienes 2 opciones. Cargar todos los habitantes de esa ciudad(eagerly) o
ir cargando los habitantes a demanda(lazy) cuando por ejemplo se llame a una
función como por ejemplo GetHabitantes().

Como ves es cuestión de eficiencia, ya que si no necesitas ver información de los

habitantes sería un derroche cargar inicialmente todos los datos de esos habitantes.

public class University {

private String id;
private String name;
private String address;
private List<Student> students;

// setters and getters

}
ESCRIBA LAS ENTIDADES Y LAS RELACIONES DEL SGT DIBUJO

En orientación a objetos la herencia es el mecanismo fundamental para implementar la

reutilización y extensibilidad del software. A través de ella los diseñadores pueden
construir nuevas clases partiendo de una jerarquía de clases ya existente (comprobadas y
verificadas) evitando con ello el rediseño, la remodificación y verificación de la parte ya
implementada. La herencia facilita la creación de objetos a partir de otros ya existentes,
obteniendo características (métodos y atributos) similares a los ya existentes.

La herencia es uno de los mecanismos de la programación orientada a objetos, por medio

del cual una clase se deriva de otras, a la clase ya existente se le llama superclase, clase
base o clase padre y a la nueva clase se le llama subclase, clase derivada o clase hija.

Jerarquía

Los descendientes de una clase heredan todas las variables y métodos que sus
ascendientes hayan especificado como heredables, además de crear los suyos propios.

Ejemplo de árbol de herencia.

La característica de herencia, nos permite definir nuevas clases derivadas de otra ya
existente, que la especializan de alguna manera. Así logramos definir una jerarquía de
clases, que se puede mostrar mediante un árbol de herencia.
En todo lenguaje orientado a objetos existe una jerarquía, mediante la que las clases se
relacionan en términos de herencia. En Java, el punto más alto de la jerarquía es la clase
Object de la cual derivan todas las demás clases (paquete java.lang).

Tipos de herencia

En java existen dos tipos de herencia, herencia simple y herencia múltiple.

Herencia simple

Un objeto puede extender las características de otro objeto y de ningún otro, es decir, que
solo puede heredar o tomar atributos de un solo padre o de una sola clase.

Herencia múltiple

Un objeto puede extender las características de uno o más objetos, es decir, puede tener
varios padres.

Declaración

Para indicar que una clase deriva de otra, heredando sus propiedades (métodos y
atributos), se usa el término extends, como en el siguiente ejemplo:

public class SubClase extends SuperClase

{
// Contenido de la clase
}

Por ejemplo, creamos una clase MiPunto3D, hija de la clase ya mostrada MiPunto:

class MiPunto3D extends MiPunto {

int z;
MiPunto3D( ) {
x = 0; // Heredado de MiPunto
y = 0; // Heredado de MiPunto
z = 0; // Nuevo atributo
}
}

La palabra clave extends se utiliza para decir que deseamos crear una subclase de la
clase que es nombrada a continuación, en nuestro caso MiPunto3D es hija de MiPunto.

Limitaciones de la herencia

Todos los campos y métodos de una clase son siempre accesibles para el código de la
misma clase.

Para controlar el acceso desde otras clases, y para controlar la herencia por las subclases,
los miembros (atributos y métodos) de las clases tienen tres modificadores posibles de
control de acceso:

Public: Los miembros declarados public son accesibles en cualquier lugar en que sea
accesible la clase, y son heredados por las subclases.

Private: Los miembros declarados private son accesibles sólo en la propia clase.

Protected: Los miembros declarados protected son accesibles sólo para sus subclases.

Por ejemplo

class Padre {
// Atributos
private int numeroFavorito;
private int nacidoHace;
private int dineroDisponible;

// Métodos
public int getApuesta()
{
return numeroFavorito;
}

protected int getEdad()

{
return nacidoHace;
}

private int getSaldo()

{
return dineroDisponible;
}

class Hija extends Padre {

// Definición

class Visita {

// Definición

En este ejemplo, un objeto de la clase Hija, hereda los tres atributos (numeroFavorito,
nacidoHace y dineroDisponible) y los tres métodos ( getApuesta(), getEdad() y getSaldo() )
de la clase Padre, y podrá invocarlos. Cuando se llame al método getEdad() de un objeto
de la clase Hija, se devolverá el valor de la variable de instancia nacidoHace de ese objeto,
y no de uno de la clase Padre.

Sin embargo, un objeto de la clase Hija, no podrá invocar al método getSaldo() de un

objeto de la clase Padre, con lo que se evita que el Hijo conozca el estado de la cuenta
corriente de un Padre.

La clase Visita, solo podrá acceder al método getApuesta(), para averiguar el número
favorito de un Padre, pero de ninguna manera podrá conocer ni su saldo, ni su edad.
La clase object

La clase Object es la superclase de todas las clases da Java. Todas las clases derivan,
directa o indirectamente de ella. Si al definir una nueva clase, no aparece la cláusula
extends, Java considera que dicha clase desciende directamente de Object.

Los métodos públicos y protegidos de esta clase son:

Public boolean equals(Object obj) compara si dos objetos son iguales, por defecto un
objeto es igual solamente a si mismo.

Public int hashCode() devuelve (con alta probabilidad) un valor distinto para cada objeto.

Protected Object clone() throws CloneNotSuportedException devuelve una copia binaria

del objeto (incluyendo sus referencias).

Public final Class getClass() devuelve el objeto del tipo Class que representa dicha clase
durante la ejecución.

Protected void finalize() throws Throwable se usa para finalizar el objeto, es decir, se
avisa al administrador de la memoria que ya no se usa dicho objeto, y se puede ejecutar
código especial antes de que se libere la memoria.

Public String toString() devuelvo una cadena describiendo el objeto.

El polimorfismo

El polimorfismo es un concepto de la programación orientada a objetos que nos permite

programar en forma general, en lugar de hacerlo en forma específica. En general nos sirve
para programar objetos con características comunes y que todos estos compartan la
misma superclase en una jerarquía de clases, como si todas fueran objetos de la
superclase. Esto nos simplifica la programación.

Existen varias formas de polimorfismo:

* Cuando invocamos el mismo nombre de método sobre instancias de distinta clase.

* Cuando creamos múltiples constructores.

* Cuando vía subtipo asignamos una instancia de una subclase a una referencia a la clase
base.

Para poner en práctica se hará un ejemplo bastante sencillo:

public class Coche {

private String propietario;
private String matricula;
private double cuentaKilometros ;

public void vender (String elPropietario) {

propietario = elPropietario;
}
public void matricular(String laMatricula) {
matricula = laMatricula;
}
public void recorrer(double kms ) {
cuentaKilometros = cuentaKilometros + kms;
}
public void printInfo() {
String tmp =
"Propietario: "+propietario+";"+
"Matricula: "+matricula+";"+
"Kms recorridos: "+cuentaKilometros+";" ;
System.out.println(tmp) ;
}
}

public class CocheConGPS extends Coche {

private double latitud = 0;
private double longitud = 0;
public void cambiarCoordenadas (double deltaLatitud, double deltaLongitud) {
latitud = latitud+deltaLatitud;
longitud = longitud+deltaLongitud;
}
public double latitud() {
return latitud;
}
public double longitud() {
return longitud;
}
public void printInfoPosicion() {
String tmp = "Latitud: " + latitud + "; Longitud: " + longitud;
System.out.println(tmp);
}
}

/
public class Taxi extends Coche {
/* heredado de Coche */
public void recorrer(double kms) {
System.out.println("Taxi@: inicia carrera" );
printInfo();
/* metodo "recorrer"heredado de Coche
* /
super.recorrer(kms);
System.out.println("Taxi@: fin de carrera" );
}
}

/* Ejemplo de asignacion a
la misma variable de objetos de diferentes clases. */

public class EjemploVariablePolimorfica {

public static void main (String[ ] args ) {
Coche coche = null;
/ * A coche se le pueden asignar coches de diferentes tipos!!! */
coche = new Coche ();
coche = new CocheConGPS();
coche = new Taxi();
/* metodos en Coche */
coche.vender("X.X.X" );
coche.matricular("PMM-000" );
coche.printInfo();
}
}

Ligadura dinámica

La ligadura dinámica se encarga de ligar o relacionar la llamada a un método con el cuerpo

del método que se ejecuta finalmente.

Existen dos tipos de ligadura: estática y dinámica.

Ligadura estática:

* Consiste en realizar el proceso de ligadura en tiempo de compilación según el tipo

declarado del objeto al que se manda el mensaje.

* La utilizan (en Java) los métodos de clase y los métodos de instancia que son privados o
final (ya que estos últimos no pueden ser sobrescritos).

Ligadura dinámica:

* Consiste en realizar el proceso de ligadura en tiempo de ejecución siendo la forma

dinámica del objeto la que determina la versión del método a ejecutar.

* Se utiliza en todos los métodos de instancia de Java que no son privados ni final.

Funcionamiento de la ligadura dinámica

Resolución de conflictos entre Superclases y Subclases:

* Cuando existe un conflicto entre un método de una superclase y un método de la

subclase, el comportamiento correcto es que el método de la subclase sobrescriba al de la
superclase.

* Si estamos llamando a un método de la subclase desde una variable que ha sido

declarada del tipo de la superclase. ¿Cómo se consigue que funcione correctamente?

Ligadura Dinámica:
* Significa que la forma dinámica del objeto determina la versión de la operación que se
aplicará.

* Esta capacidad de las operaciones para adaptarse automáticamente a los objetos a los
cuales se aplican es una de las propiedades más importantes de la orientación a objetos.

Características de la Ligadura Dinámica

* Puede variar de un lenguaje a otro, pero básicamente presentan unas características

comunes. Los métodos que necesitan ligadura dinámica:

* Deben presentar ligadura dinámica solo aquellos que pueden ser redefinidos.
* Por ejemplo, en Java, los métodos de clase y los métodos de instancia privados y/o
finales no presentan ligadura dinámica.

* En Java, si no se especifica nada se entenderá que el método puede ser redefinido y por
tanto debe presentar ligadura dinámica.