Polimorfismo e Encapsulamento

Introdução

Encapsulamento (Encapsulation) é como uma bolsa que agrupa as operações e os dados relacionados a um objeto. Polimorfismo (Polymorphism) é a capacidade de um objeto assumir múltiplas formas. Neste laboratório, você verá como eles funcionam.

Polimorfismo

Polimorfismo é uma das características da Programação Orientada a Objetos (POO) que nos permite realizar uma única ação de diferentes maneiras. Polimorfismo que é resolvido durante o tempo de compilação é polimorfismo estático ou polimorfismo em tempo de compilação (sobrecarga (overloading) é deste tipo). Polimorfismo que é resolvido durante o tempo de execução é chamado de polimorfismo em tempo de execução (sobrescrita (overriding) é deste tipo). Polimorfismo também fornece a característica de um objeto assumir múltiplas formas. Um uso muito comum de polimorfismo em POO é quando uma referência de classe pai é usada para se referir a um objeto de classe filho. Qualquer objeto Java que possa passar em mais de um teste IS-A é considerado polimórfico. Uma variável de referência pode se referir a qualquer objeto de seu tipo declarado ou qualquer subtipo de seu tipo declarado. Uma variável de referência pode ser declarada como um tipo de classe ou como um tipo de interface. O caso de herança é uma forma de polimorfismo, porque existem diferentes tipos de comportamentos e características de animais. Mas aqui introduzimos outra forma de polimorfismo:

Exemplo:

Escreva o seguinte código no arquivo /home/labex/project/polymorphismTest.java:

// we declare an interface life, it has some methods, we just omit them.
interface life{}
// and declare a class to realize polymorphism, the inner content, we just ignore that for this case.
class Animal{}
// we declare a Human class to use class of Animal and the life interface.
class Human extends Animal implements life{}

public class polymorphismTest{
    public static void main(String[] args){
        Human human = new Human();  // instantiate a Human object
        // Human has direct or indirect inheritance relationship with Animal, Object
        // Human implements life interface, so the instanceof expression returns true
        System.out.println("human is instance of Human? " + (human instanceof Human));
        System.out.println("human is instance of Animal? " + (human instanceof Animal));
        System.out.println("human is instance of life? " + (human instanceof life));
        System.out.println("human is instance of Object? " + (human instanceof Object));
    }
}

Saída:

Execute o arquivo polymorphismTest.java usando os seguintes comandos:

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

Veja a saída:

human is instance of Human? true
human is instance of Animal? true
human is instance of life? true
human is instance of Object? true

Encapsulamento

Encapsulamento é um conceito que nos permite esconder os detalhes de um programa. Outros invocadores só precisam saber o que um programa pode fornecer sem saber como ele funciona. O encapsulamento simplifica o desenvolvimento. É um mecanismo de encapsulamento dos dados (variáveis) e algoritmos (código do método). No encapsulamento, as variáveis de uma classe serão ocultadas de outras classes e só podem ser acessadas através dos métodos da classe. Portanto, também é conhecido como ocultação de dados (data hiding). Comumente, os campos da classe são declarados como privados e usamos métodos getter/setter para acessar e controlar os dados. Definimos métodos públicos apenas para fornecer funcionalidades a outras classes ou para uso externo. Às vezes, definimos métodos privados que são usados apenas dentro da classe para algum uso específico. É assim que escondemos os detalhes.

Exemplo:

Escreva o seguinte código no arquivo /home/labex/project/encapsulationTest.java:

class Person{
    /*
     * there are two member variables in Person
     * they are private, so can't be accessed outside this class directly.
    */
    private String name;
    private int age;
    // empty constructor
    public Person(){

    }
    // constructor with two parameters
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    // use this method to get name value
    public String getName(){
        return this.name;
    }
    // use this method to set name value
    public void setName(String name){
        this.name = name;
    }
    // use this method to get age value
    public int getAge(){
        return this.age;
    }
    // use this method to set age value
    public void setAge(int age){
        this.age = age;
    }
}
public class encapsulationTest{
    public static void main(String[] args){
        Person p = new Person();
        // we set a person's name and age using setXXX() methods
        p.setName("Mike");
        p.setAge(20);
        // we get a person's name and age using getXXX() methods
        System.out.println("Name: " + p.getName() + ", Age: " + p.getAge());
    }
}

Saída:

Execute o arquivo encapsulationTest.java usando os seguintes comandos:

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

Veja a saída:

Name: Mike, Age: 20

Resumo

Com encapsulamento, não precisamos acessar dados ou propriedades do objeto diretamente usando object.XXX, mas sim usar algum método padrão na forma de getXXX(), setXXX() e outros métodos para fazer o trabalho. Na programação genérica, a vantagem do polimorfismo será demonstrada, mas por enquanto, lembre-se de que o polimorfismo permite que um objeto assuma muitas formas.