Programación en tres capas

Ejemplo de interfaz (Java)

public interface Caminar {

public void caminar();
}

/------------------------------------/------------------------------------------/---------------------------------------/

public interface Nadar {

public void nadar();

}

/------------------------------------/------------------------------------------/---------------------------------------/

public interface Volar {

public void volar();

}

/------------------------------------/------------------------------------------/---------------------------------------/

public class Mamifero implements Caminar{

public void caminar() {

}

}

/------------------------------------/------------------------------------------/---------------------------------------/

public class Ave implements Caminar{

public void caminar() {

}

}

/------------------------------------/------------------------------------------/---------------------------------------/

public class Felino extends Mamifero implements Nadar {

public void nadar() {

} 

}

/------------------------------------/------------------------------------------/---------------------------------------/

public class Gato extends Felino{

public void nadar()

{

System.out.println("Este Gato Nada");

}

public void caminar()

{

System.out.println("Este Gato Camina");

}

}

/------------------------------------/------------------------------------------/---------------------------------------/

public class Tigre extends Felino{

public void nadar()

{

System.out.println("Este Tigre Nada");

}

public void caminar()

{

System.out.println("Este Tigre Camina");

}

}

/------------------------------------/------------------------------------------/---------------------------------------/

public class Murcielago extends Mamifero implements Volar {

public void volar() {

System.out.println("Murcielago vuela");

}

public void caminar()

{

System.out.println("Murcielago camina");

}

}

/------------------------------------/------------------------------------------/---------------------------------------/

public class Avestuz extends Ave {

public void caminar()

{

System.out.println("Avestruz camina");

}

}

/------------------------------------/------------------------------------------/---------------------------------------/

public class Loro extends Ave implements Volar{

public void volar() {

System.out.println("Loro vuela");

}

public void caminar()

{

System.out.println("Loro camina");

}

}

/------------------------------------/------------------------------------------/---------------------------------------/

public class Run {

public static void main(String[]args)

{

Gato gato= new Gato();

Tigre tigre=new Tigre();

Murcielago murci=new Murcielago();

Avestuz aves=new Avestuz();

Loro loro=new Loro();

System.out.println("Gato: ");

gato.caminar();

gato.nadar();

System.out.println("\nTigre: ");

tigre.caminar();

tigre.nadar();

System.out.println("\nMurcielago: ");

murci.caminar();

murci.volar();

System.out.println("\nAvestruz: ");

aves.caminar();

System.out.println("\nLoro: ");

loro.caminar();

loro.volar();

}

}

Herencia, Polimorfismo, clase abstracta y sobreescritura

Herencia

Creación de nuevas clases basadas en clases existentes.
Cuando heredamos de una clase existente, reusamos métodos y campos, y agregamos nuevos campos y métodos para cumplir con la nueva situación.
A través de la referencia podemos agregar nuevos campos y podemos agregar o sobremontar métodos

Sobremontar: redefinir el método en la clase heredada

Sobreescritura

Se usa para que una sub clase se modifique o se agregue funcionalidades del método heredado

ejemplo:

class ClaseP{
           void nuevoMetodo(int valo)
            {
                .......
            }
          String unNuevoMetodo()
          {
               ........
           }
}


class ClaseQ extends ClaseP{

       void miMetodo(int valo)
        {
             System.out.println("Hola");
        }
      String unNuevoMetodo()
        {
           System.out.println("Hola, otra vez");
        }
 }

Clase abstracta

Sirve para unificar datos u operaciones de subclases
código:
             public abstract class NombreClase{
}

Características:

• No se pueden crear objetos de esta clase
• Al menos un método tiene que ser abstracto

Métodos abstractos (Características)

• No tiene cuerpo(Es decir, no lleva llaves)
• Termina en punto y coma
• Solo existe dentro de una clase abstracta
• Estos tienen que forzosamente ser sobreescritos en las sub clases

ejemplo: abstract public void generarNomina(Parametros);

Polimorfismo

Se refiere a la propiedad por la que es posible enviar mensajes sintácticamente iguales a objetos de tipos distintos, este concepto esta ligado directamente con el concepto de herencia.

El polimorfismo en palabras mas simple consiste en un pedazo de código que se puede utilizar de diferentes manera en las clases hijas, en caso de no especializarlas las clase hijas hacen los métodos de la clase padre

          

ejemplo:

public abstract class SeleccionFutbol{

   

   public abstract void entrenamiento();

 

  public void partidoFutbol(){

    

        System.out.println("Asiste al partido (Esta es la clase padre)");

   }

}

public class Entrenador extends SeleccionFutbol{

   @Override

   public void entrenador(){

  

        System.out.println("Direige un entrenamiento(Esta es la sub clase)");

    }

}

@Override

Sirve para sobreescribir el código, en el caso de un objeto abstracto, sirve para especializar un método en una sub clase y en un método normal es para cambiar la función del método.