Polimorfismo y Encapsulación

Introducción

La encapsulación es como una bolsa que encierra juntos las operaciones y los datos relacionados con un objeto. La polimorfismo es la capacidad de un objeto de adoptar muchas formas. En este laboratorio, verás cómo son.

Skills Graph

Polimorfismo

El polimorfismo es una de las características de la programación orientada a objetos (OOP por sus siglas en inglés) que nos permite realizar una sola acción de diferentes maneras. El polimorfismo que se resuelve durante la compilación es el polimorfismo estático o polimorfismo de tiempo de compilación (la sobrecarga es de este tipo). El polimorfismo que se resuelve durante la ejecución se llama polimorfismo de tiempo de ejecución (la sobreescritura es de este tipo). El polimorfismo también proporciona la característica de que un objeto puede adoptar muchas formas. Un uso muy común del polimorfismo en la programación orientada a objetos es cuando una referencia de clase padre se utiliza para referirse a un objeto de clase hija. Cualquier objeto de Java que puede pasar más de una prueba de "es un" (IS-A en inglés) se considera polimórfico. Una variable de referencia puede referirse a cualquier objeto de su tipo declarado o a cualquier subtipo de su tipo declarado. Una variable de referencia puede declararse como un tipo de clase o como un tipo de interfaz. El caso de la herencia es una forma de polimorfismo, porque hay diferentes tipos de comportamientos y características de animales. Pero aquí introducimos otra forma de polimorfismo:

Ejemplo:

Escribe el siguiente código en el archivo /home/labex/project/polymorphismTest.java:

// declaramos una interfaz life, tiene algunos métodos, los omitimos por simplicidad.
interface life{}
// y declaramos una clase para implementar el polimorfismo, el contenido interno, lo ignoramos para este caso.
class Animal{}
// declaramos una clase Human para usar la clase Animal y la interfaz life.
class Human extends Animal implements life{}

public class polymorphismTest{
    public static void main(String[] args){
        Human human = new Human();  // instanciamos un objeto Human
        // Human tiene una relación de herencia directa o indirecta con Animal, Object
        // Human implementa la interfaz life, por lo que la expresión instanceof devuelve true
        System.out.println("human es instancia de Human? " + (human instanceof Human));
        System.out.println("human es instancia de Animal? " + (human instanceof Animal));
        System.out.println("human es instancia de life? " + (human instanceof life));
        System.out.println("human es instancia de Object? " + (human instanceof Object));
    }
}

Salida:

Ejecuta el archivo polymorphismTest.java usando los siguientes comandos:

javac /home/labex/project/polymorphismTest.java
java polymorphismTest

Ver la salida:

human es instancia de Human? true
human es instancia de Animal? true
human es instancia de life? true
human es instancia de Object? true

Encapsulación

La encapsulación es un concepto que nos permite ocultar los detalles del programa. Otros invocadores solo necesitan saber lo que un programa puede ofrecerles sin conocer cómo funciona. La encapsulación simplifica el desarrollo. Es un mecanismo para envolver los datos (variables) y los algoritmos (código de métodos). En la encapsulación, las variables de una clase se ocultan de otras clases y solo se pueden acceder a través de los métodos de la clase. Por lo tanto, también se conoce como ocultamiento de datos. Por lo general, los campos de la clase se declaran privados y usamos métodos getter/setter para acceder y controlar los datos. Definimos métodos públicos solo para proporcionar funcionalidades a otras clases o para su uso exterior. A veces definimos métodos privados que se usan solo dentro de la clase para un uso específico. Así es como ocultamos los detalles.

Ejemplo:

Escribe el siguiente código en el archivo /home/labex/project/encapsulationTest.java:

class Person{
    /*
     * Hay dos variables miembro en Person
     * Son privadas, por lo que no se pueden acceder directamente fuera de esta clase.
    */
    private String name;
    private int age;
    // constructor vacío
    public Person(){

    }
    // constructor con dos parámetros
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    // usa este método para obtener el valor de name
    public String getName(){
        return this.name;
    }
    // usa este método para establecer el valor de name
    public void setName(String name){
        this.name = name;
    }
    // usa este método para obtener el valor de age
    public int getAge(){
        return this.age;
    }
    // usa este método para establecer el valor de age
    public void setAge(int age){
        this.age = age;
    }
}
public class encapsulationTest{
    public static void main(String[] args){
        Person p = new Person();
        // establecemos el nombre y la edad de una persona usando los métodos setXXX()
        p.setName("Mike");
        p.setAge(20);
        // obtenemos el nombre y la edad de una persona usando los métodos getXXX()
        System.out.println("Nombre: " + p.getName() + ", Edad: " + p.getAge());
    }
}

Salida:

Ejecuta el archivo encapsulationTest.java usando los siguientes comandos:

javac /home/labex/project/encapsulationTest.java
java encapsulationTest

Ver la salida:

Nombre: Mike, Edad: 20

Resumen

Con la encapsulación, no es necesario acceder directamente a los datos o propiedades de un objeto usando object.XXX, sino que usamos algunos métodos estándar en forma de getXXX(), setXXX() y otros métodos para hacer el trabajo. En la programación genérica, se mostrará la ventaja del polimorfismo, pero por ahora solo recuerda que el polimorfismo permite que un objeto adopte muchas formas.