Clase 10 - Herencia, jerarquía de clases abstractas.

Herencia, jerarquía de clases abstractas. 

Material pdf: Descargar pdf

HERENCIA

—      Definición

—      Permite a una clase compartir la misma estructura de datos y comportamiento de otra clase.

—      La herencia minimiza la necesidad de duplicar código.

—      El Polimorfismo permite utilizar el método de acuerdo al objeto heredado.

—      Una subclase se define indicando a que superclase extiende.

—      public class padre  {

—      // Definición de la superclase Item.

—      }

—      public class hijo extends padre{

—      // Atributos y métodos adicionales para distinguir una 

—      // hijo de otros tipos de item

—      }

—      Una subclase hereda todas las variables instancia de la superclase.

—      Las variables de instancia deben ser private para que instancias de la subclase hereden sus valores.

—      public class Item {

—      protected float precio = 0;

—      protected String estado = "Excelente";

—      }

—      public class Pelicula extends Item {

—      private String titulo = "";

—      private int duracion = 0;

—      }

—      Una subclase no hereda ningún constructor de la superclase, debe declararse explícitamente.

—      Solo en caso no se declare explícitamente, se ejecutaran los constructores por defecto de las superclases y finalmente de la subclase.

—      Pelicula pelicula = new Pelicula ();

—      //Inicia variables de la clase Item. Constructor por defecto.

—      // Inicia variables de la clase Pelicula. Constructor por defecto.

La referencia super

—                 Se refiere a la clase padre

—                 Se usa para invocar constructores de la clase padre

—                 Debe ser la primera sentencia del constructor de la clase hijo

—                 Esta referencia también se usa para invocar cualquier método del padre.

—                 public class Item {

—                 protected float precio = 0;

—                 Item (float precio) {

—                 this.precio = precio;

—                 }

—                 }

—                 public class Pelicula extends Item {

—                 private String titulo = "";

—                 Pelicula (float precio, String titulo) {

—                 super(precio);

—                 this.titulo = titulo;

—                 }

—                 }

Métodos

—        La superclase define los métodos para todas las subclases.

—        La subclase puede especificar métodos propios.

—        File:item0.java

—        package herencia;

—        public class item0 {

—        protected float precio=0;

—        public item0(float precio) {

—        this.precio=precio;

—        }

—        public float getPrecio() {

—        return precio;

—        }

—        public void setPrecio(float precio) {

—        this.precio = precio;

—        }

—        }

—        File: pelicula.java

—        package herencia;

—        public class pelicula extends item0 {

—        private String titulo="";

—        public pelicula(float precio, String titulo) {

—        super(precio);

—        this.titulo=titulo;

—        }

—        public String getTitulo() {

—        return titulo;

—        }

—        public void setTitulo(String titulo) {

—        this.titulo = titulo;

—        }    

—        }

—        package herencia;

—        File:testsuper.java

—        public class testsuper {

—        public static void main(String []args){

—        pelicula pelicula=new pelicula(2.2f,"Araña");

—        System.out.println(pelicula.getPrecio());

—        System.out.println(pelicula.getTitulo());

—        }

—        }

Ejemplo

—        public class Mamifero{

—        private int patas;

—        private String nombre;

—        public void imprimirPatas(){

—        System.out.print(" Tiene "+patas+" patas\n");

—        }

—        public Mamifero(String nombre, int patas){

—        this.nombre = nombre;

—        this.patas = patas;

—        }

—        }

—        //clases gato

—        public class gato extends Mamifero {

—        public gato(String nombre){

—        super(nombre,4);

—        }

—        }

—        //clase perro

—        public class perro extends Mamifero {

—        public perro(String nombre){

—        super(nombre,4);

—        }

—        }

—        //Creando perro

—        public class crear_perro {

—        public static void main(String []args){

—        perro perrito=new perro("Pantaleon");

—        perrito.imprimirPatas();

—        }

—        }

Clase Abstracta

— La herencia permite que existan clases que nunca serán instanciadas directamente. En el ejemplo anterior, una clase "perro" heredaría los atributos y métodos de la clase "mamífero", así como también "gato", "delfín" o cualquier otra subclase; pero, en ejecución, no habrá ningún objeto "mamífero" que no pertenezca a alguna de las subclases. En ese caso, a una clase así se la conocería como Clase Abstracta. La ausencia de instancias específicas es su única particularidad, para todo lo demás es como cualquier otra clase.

Herencia y ocultación de información

—  En ciertos lenguajes, el diseñador puede definir qué variables de instancia y métodos de los objetos de una clase son visibles. En C++ y java esto se consigue con las especificaciones private, protected y public. Sólo las variables y métodos definidos como públicos en un objeto serán visibles por todos los objetos. 

—  Dependiendo del lenguaje que se utilice, el diseñador también puede controlar qué miembros de las superclases son visibles en las subclases. En el caso de java y C++ los especificadores de acceso (private, protected, public) de los miembros de la superclase afectan también a la herencia:

—  Private: ningún miembro privado de la superclase es visible en la subclase.

—  Protected: los miembros protegidos de la superclase son visibles en la subclase, pero no visibles para el exterior.

—  Public: los miembros públicos de la superclase siguen siendo públicos en la subclase.

Ventajas

—  Ayuda a los programadores a ahorrar código y tiempo, ya que la clase padre ha sido implementada y verificada con anterioridad, restando solo referenciar desde la clase derivada a la clase base (que suele ser extends, inherits, subclass u otras palabras clave similares, dependiendo del lenguaje).

—  Los objetos pueden ser construidos a partir de otros similares. Para ello es necesario que exista una clase base (que incluso puede formar parte de una jerarquía de clases más amplia).

—  La clase derivada hereda el comportamiento y los atributos de la clase base, y es común que se le añada su propio comportamiento o que modifique lo heredado.

—  Toda clase pueden servir como clase base para crear otras.

Ejemplo – clase humano

—         class humano {

—         protected String nombre;

—         protected String apellido;

—         public humano(String nombre,String apellido) {

—         this.nombre = nombre;

—         this.apellido = apellido;

—         }

—         public String nombreCompleto() {

—         return this.apellido + ", " + this.nombre;

—         }

—         public String identificacion() {

—         return this.nombreCompleto();

—         }

—         }

—         public class ciudadano extends humano {

—         protected String documento;

—         public ciudadano(String nombre,String apellido, String documento) {

—         super(nombre,apellido);

—         this.documento = documento;

—         }

—         public String identificacion() {

—         return super.identificacion() + ", documento: " + this.documento;

—         }

—         }

—         public class herencia {

—         public static void main(String []args){

—         ciudadano a=new ciudadano("Christian","Garcia","42809561");    

—         System.out.println(a.identificacion());        

—         }

—         }