Diferencias

Muestra las diferencias entre dos versiones de la página.

--- bloque4:herencia [05/03/2018 11:19] – [Palabra clave Extends] Fernando Valdeón
+++ bloque4:herencia [05/03/2018 11:35] (actual) – borrado Fernando Valdeón
@@ Línea 1: / Línea 1: @@
-====== Herencia de Clases ======
-En Java podemos tener clases que heredan de otras (extends, o extienden). Cuando una clase hereda de otra puede hacer uso de los atributos de su clase padre. Además, permite reescribir métodos en caso de que en una subclase queramos concretar su funcionamiento.
-Debemos tener en cuenta que toda clase en Java hereda de la clase ''Object'', y que por tanto hay una serie de métodos que heredan todas las clases.
-{{ :bloque4:herencia-clases.png?300|}}
-==== ¿Para qué sirve? ====
-La herencia es un mecanismo mediante el cual aprovechamos la implementación de operaciones de una clase padre (reutilización de código) y creamos nuevas clases hijas a partir de esa clase:
-  * Heredando y posiblemente modificando y/o añadiendo operaciones.
-  * Heredando y posiblemente añadiendo atributos.
-**Debemos tener en cuenta que un método o atributo heredado mediante el mecanismo de herencia no puede ser suprimido en la subclase.**
-Podríamos decir que la herencia nos permite usar el código empleando en una clase para no tener que volverlo a escribir en una subclase. Todas las subclases tienen las operaciones de la superclase, y así no tenemos que repetir el código en cada una.
-===== Declaración de una Subclase =====
-Si entendemos que una clase son “los planos” que definen la creación de un ejemplar de esa clase, podemos entender que cuando una clase hereda de otra, lo que está haciendo es usar los planos de la clase padre, y añadirle más información para crear más o diferentes funcionalidades a las que tenía.
-Podemos llamar a las clases hijas ''subclases'' y a la clase padre, ''superclase''.
-Para que una subclase herede de una superclase debe usarse ''extends'' al definir la clase.
-Ejemplo de superclase: ''Vehiculo''. Hay muchos tipos de vehículos (avión, moto agua, coche, moto). Es una clase estándar como cualquier otra.
-<code java>
-public class Vehiculo{
-   private int Km;
-   private String matricula;
-   public int getKm(){
-      return Km;
-   }
-   public void setKm(int Km){
-      this.Km = Km;
-   }
-   public String getMatricula(){
-      return matricula;
-   }
-   public void setMatricula(String matricula){
-      this.matricula = matricula;
-   }
-}
-</code>
-{{:bloque4:vehiculoherencia.png?400 |}}
-Ahora vemos su uso y vemos que aparecen los métodos ''getKm()'', ''setKm()'', ''getMatricula()'' y ''setMatricula()''.
-Además del resto de métodos heredados de la clase ''Object''.
-----
-==== Palabra clave Extends ====
-Vamos a crear ahora la clase ''Coche'' que //extiende// las funcionalidades de la clase ''Vehiculo'':
-<code java>
-public class Coche extends Vehiculo{
-   //Campo específico de Coche
-   private int cilindrada;
-   //Metodos específicos de Coche
-   public void setCilindrada(int cilindrada){
-      this.cilindrada = cilindrada;
-   }
-   public int getCilindrada(){
-      return cilindrada;
-   }
-}
-</code>
-{{:bloque3:cocheherencia.png?400 |}}
-Aquí vemos como aparecen los métodos heredados de la superclase Vehiculo: ''getKm()'', ''setKm()'', ''getMatricula()'' y ''setMatricula()''.
-Además tiene sus propios miembros específicos ''setCilindrada()'' y ''getCilindrada()''.
-También  están  los  miembros  heredados  de  la
-clase ''Object'', comunes a todas las clases.
-Ambas clases (Vehiculo y Coche) tienen el constructor estándar sin parámetros.
-----
-Hay que tener en cuenta que una subclase solo podrá acceder a los miembros de la superclase que sean ''public'' o ''protectec''.
-==== Impedir la herencia ====
-Si queremos que una clase no permita extender su funcionalidad, o lo que es lo mismo, no permita ser heredada, definiremos dicha clase como ''final''.
-<code java>
-public final class Vehiculo{
-   ...
-}
-</code>
-La palabra clave ''final'' la hemos usado en otras ocasiones para crear variables que no se puedan modificar (constantes), y también se aplica a las clases y a los métodos con dicha finalidad.
-Por ejemplo las clases ''String'' o ''Math'' no se pueden heredar, ya que están definidas como ''final''.
-===== Constructor de la subclase =====
-**Los constructores no se heredan**. __Siempre que se crea una instancia de una subclase, se crea primero una instancia de la superclase__. Esta instanciación puede ser implícita, o explícita, o lo que es lo mismo, invisible o visible.
-En una clase se puede definir un constructor de forma explícita, o no definir ninguno. **Cuando no definimos un constructor, Java crea implícitamente uno**. No tiene parámetros, y no hace nada, pero sirve para crear instancias de la clase. Se conoce como constructor **no-args**, sin argumentos (parámetros).
-Atendiendo a lo anterior, con los constructores de la subclase puede ocurrir 2 cosas:
-  * **La superclase tiene un constructor sin parámetros** (ya sea el que define Java de forma implícita, o uno definido por nosotros que no tiene parámetros). En este caso en la subclase podemos definir un constructor, o no definir ninguno (Java crea un constructor **no-args** implícitamente). Cada vez que creemos una instancia de la subclase, Java llamará automáticamente al constructor de la superclase de forma implícita, invisible.
-  * **La superclase no tiene un constructor sin parámetros** (o sea, se ha definido uno con parámetros). En este caso Java no puede llamar de forma implícita al constructor de la superclase, ya que necesita saber qué valor dar a sus parámetros. Entonces estamos obligados a crear también un constructor en la subclase, cuya primera primera instrucción es una llamada al constructor de la superclase. Esto se hace usando la instrucción ''super()''.
-==== Palabra clave super ====
-Si en cualquier clase tenemos la palabra ''this'' que representa una referencia al objeto actual de propia clase, en una subclase tenemos además la palabra ''super'' que contiene una referencia al objeto actual de la superclase.
-Esto tiene su explicación, en que para crear una instancia de una subclase, obligatoriamente se debe crear primero una instancia de la superclase.
-A la hora de crear un constructor para la subclase, es necesario llamar al constructor de la superclase. Cuando el constructor/es de la superclase recibe parámetros, no nos queda más remedio que llamarlo nosotros:
-<code java>
-//Constructor de la superclase
-public Vehiculo(int km, String matricula) {
-   this.km = km;
-   this.matricula = matricula;
-}
-........
-//Constructor de la subclase
-public Coche(int km, String matricula) {
-   super(km, matricula);
-}
-//Ó podemos tener también otro constructor en la subclase
-public Coche(int km, String matricula, int cilindrada) {
-   super(km, matricula);
-   this.cilindrada = cilindrada; //Atributo específico de la subclase.
-}
-</code>
-Como vemos, si una clase hereda de otra, **y la superclase solo tiene constructores con argumentos, la subclase debe llamar a dicho constructor con al menos el mismo número de argumentos**, aunque puede usar más.
-Una vez vez que se crea el constructor de la superclase, podemos crear los constructores de la subclase.
-**Si una superclase no tiene contructor no-args, la subclase debe tener al menos los mismos constructores, ya que estos no se heredan.**
-La palabra ''super'' también me permite acceder a los métodos de una superclase -> ''super.arrancar()''
-===== Sobrescritura de métodos: Override =====
-Cada vez que una clase hereda un método, se tiene la posibilidad de sobrescribir el método.
-La sobrescritura de métodos se usa para definir el comportamiento específico de un método que tiene un comportamiento demasiado general en la superclase. Esto se denomina ''Override''.
-<code java>
-//Superclase Vehiculo
-public class Vehiculo{
-   ...
-   public void arrancar(){
-      System.out.println("Vehiculo arrancado...");
-   }
-}
-//Subclase Coche
-public class Coche extends Vehiculo{
-   ...
-   @Override
-   public void arrancar(){
-      //modificamos el comportamiento del método
-      System.out.println("Coche arrancado...");
-   }
-}
-//Clase con método main
-...
-public static void main(String[] args){
-   Vehiculo miVehiculo = new Vehiculo();
-   Coche miCoche = new Coche();
-   miVehiculo.arrancar();  //Muestra: "Vehiculo arrancado..."
-   miCoche.arrancar();     //Muestra: "Coche arrancado..."
-}
-</code>
-**Cuando llama a un método, este se busca primero en su propia clase, y si no está, se buscará en la superclase, y así sucesivamente hasta llegar a la clase Object**.
-====Etiqueta @Override====
-Cuando sobrescribimos un método es aconsejable (aunque no obligatorio) indicarle sobre su declaración, la etiqueta ''@Override'':
-<code java>
-@Override
-public String toString(){
-   return "Coche- matricula : " + matricula + " cilindrada: " + cilindrada;
-}
-</code>
-**Existen una serie de normas que se deben cumplir al sobrescribir un método**, y la la etiqueta ''@Override'' nos ayuda a cumplirlas:
-  * La lista de parámetros del método sobrescrito debe ser exactamente la misma que el original (tipo y cantidad). Si no estaríamos sobrecargándolo (2 métodos distintos con el mismo nombre).
-  * El tipo de retorno debe ser el mismo o un subtipo del tipo de retorno del método original.
-  * El modificador de visibilidad **no puede ser más restrictivo** que el original, aunque si menos restrictivo.
-  * No se puede sobrescribir un método marcado como ''final'' o ''static''.
-__Si incumplimos alguna de estas reglas__ y estamos usando el tag ''@Override'', __el compilador nos lo indicará__.
-==== Impedir el Override de un método ====
-Si quiero que un método no pueda ser sobrescrito (redefinido) en una subclase, debo indicarle en su definición el modificador ''final'':
-<code java>
-public class Vehiculo{
-   public final void arrancar(){
-      System.out.println("Vehiculo arrancado...");
-   }
-}
-</code>
-Ahora ninguna subclase de Vehiculo puede sobrescribir el método: **está obligada a usar el método original de Vehículo sin poder modificarlo**.
-===== Modificador Protected =====
-En el mecanismo de herencia, una subclase solo puede acceder a los miembros que tengan visbilidad ''public'' o ''protected''.
-El modificador de visibilidad ''protected'' actúa igual que el modificador ''private'', pero permite que una subclase puede acceder a los miembros marcados como ''protected'', incluso aunque estén en paquetes diferentes.
-**Un miembro protected permite ser accedido por la misma clase o por sus subclases, mientras que private solo permite por la propia clase**.
-<code java>
-public class Vehiculo{
-   private int kilometros;  //Ninguna clase más tiene acceso a él
-   protected int matricula; //La subclase tiene acceso
-   protected void arrancar(){
-      System.out.println("Vehiculo arrancado...");
-   }
-}
-public class Coche extends Vehiculo{
-   public void mostrarDatos(){
-      //puedo acceder al atributo matricula
-      System.out.println("La matricula del coche es: " + matricula);
-      //No puedo acceder al atributo kilometros
-      System.out.println("Los km del coche son: " + kilometros); //Error de compilación
-   }
-   //Sobrescribo el método arrancar y lo hago público
-   @Override
-   public void arrancar(){
-      System.out.println("Coche arrancado...");
-   }
-//Clase con método main
-public static void main(String[] args){
-   Vehiculo miVehiculo = new Vehiculo();
-   Coche miCoche = new Coche();
-   miVehiculo.arrancar(); //Error de compilación: no tengo acceso
-   miCoche.arrancar(); //Muestra: "Coche arrancado...");
-   miCoche.mostrarDatos(); //Muestra la matrícula
-}
-</code>
-----
-(c) {{date> %Y}} Fernando Valdeón