Polymorphisme et Encapsulation

Introduction

L'encapsulation est comme un sac qui enferme ensemble les opérations et les données liées à un objet. La polymorphisme est la capacité d'un objet à prendre de nombreuses formes. Dans ce laboratoire, vous allez voir à quoi ils ressemblent.

Skills Graph

Polymorphisme

Le polymorphisme est l'un des caractéristiques de la programmation orientée objet qui nous permet d'effectuer une seule action de différentes manières. Le polymorphisme qui est résolu pendant la compilation est le polymorphisme statique ou polymorphisme de compilation (le surchargement est de ce type). Le polymorphisme qui est résolu pendant l'exécution est appelé polymorphisme d'exécution (le chevauchement est de ce type). Le polymorphisme fournit également la caractéristique d'un objet de prendre de nombreuses formes. Un usage très courant du polymorphisme en programmation orientée objet est lorsque l'on utilise une référence de classe mère pour se référer à un objet de classe enfant. Tout objet Java qui peut passer plus d'un test IS-A est considéré comme polymorphe. Une variable de référence peut se référer à n'importe quel objet de son type déclaré ou à n'importe quel sous-type de son type déclaré. Une variable de référence peut être déclarée comme un type de classe ou comme un type d'interface. Le cas de l'héritage est une forme de polymorphisme, car il existe différents types de comportements et de caractéristiques des animaux. Mais ici, nous présentons une autre forme de polymorphisme :

Exemple :

Écrivez le code suivant dans le fichier /home/labex/project/polymorphismTest.java :

// nous déclarons une interface life, elle a certaines méthodes, nous les omettons simplement.
interface life{}
// et déclarons une classe pour réaliser le polymorphisme, le contenu interne, nous l'ignorons simplement pour ce cas.
class Animal{}
// nous déclarons une classe Human pour utiliser la classe Animal et l'interface life.
class Human extends Animal implements life{}

public class polymorphismTest{
    public static void main(String[] args){
        Human human = new Human();  // instancie un objet Human
        // Human a une relation d'héritage directe ou indirecte avec Animal, Object
        // Human implémente l'interface life, donc l'expression instanceof renvoie true
        System.out.println("human est instance de Human? " + (human instanceof Human));
        System.out.println("human est instance de Animal? " + (human instanceof Animal));
        System.out.println("human est instance de life? " + (human instanceof life));
        System.out.println("human est instance de Object? " + (human instanceof Object));
    }
}

Sortie :

Exécutez le fichier polymorphismTest.java en utilisant les commandes suivantes :

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

Voyez la sortie :

human est instance de Human? true
human est instance de Animal? true
human est instance de life? true
human est instance de Object? true

Encapsulation

L'encapsulation est un concept qui nous permet de cacher les détails d'un programme. Les autres invocateurs n'ont qu'à savoir ce que le programme peut vous offrir sans savoir comment il fonctionne. L'encapsulation simplifie le développement. C'est un mécanisme de regroupement des données (variables) et des algorithmes (code de méthode). Dans l'encapsulation, les variables d'une classe sont cachées aux autres classes et ne peuvent être accessibles que par les méthodes de la classe. Par conséquent, elle est également connue sous le nom de masquage des données. En général, les champs de la classe sont déclarés privés et nous utilisons des méthodes getter/setter pour accéder et contrôler les données. Nous définissons des méthodes publiques uniquement pour fournir des fonctionnalités à d'autres classes ou pour une utilisation externe. Parfois, nous définissons des méthodes privées qui sont utilisées uniquement à l'intérieur de la classe pour une utilisation spécifique. C'est ainsi que nous cachons les détails.

Exemple :

Écrivez le code suivant dans le fichier /home/labex/project/encapsulationTest.java :

class Person{
    /*
     * Il y a deux variables membres dans Person
     * Elles sont privées, donc ne peuvent pas être accessibles directement en dehors de cette classe.
    */
    private String name;
    private int age;
    // constructeur vide
    public Person(){

    }
    // constructeur avec deux paramètres
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    // utilisez cette méthode pour obtenir la valeur de name
    public String getName(){
        return this.name;
    }
    // utilisez cette méthode pour définir la valeur de name
    public void setName(String name){
        this.name = name;
    }
    // utilisez cette méthode pour obtenir la valeur d'age
    public int getAge(){
        return this.age;
    }
    // utilisez cette méthode pour définir la valeur d'age
    public void setAge(int age){
        this.age = age;
    }
}
public class encapsulationTest{
    public static void main(String[] args){
        Person p = new Person();
        // nous définissons le nom et l'âge d'une personne en utilisant les méthodes setXXX()
        p.setName("Mike");
        p.setAge(20);
        // nous obtenons le nom et l'âge d'une personne en utilisant les méthodes getXXX()
        System.out.println("Nom : " + p.getName() + ", Âge : " + p.getAge());
    }
}

Sortie :

Exécutez le fichier encapsulationTest.java en utilisant les commandes suivantes :

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

Voyez la sortie :

Nom : Mike, Âge : 20

Résumé

Avec l'encapsulation, nous n'avons pas besoin d'accéder directement aux données ou aux propriétés de l'objet en utilisant objet.XXX, mais plutôt nous utilisons certaines méthodes standard sous forme de getXXX(), setXXX() et d'autres méthodes pour effectuer cette tâche. En programmation générique, l'avantage du polymorphisme sera montré, mais pour l'instant, vous devez simplement vous souvenir que le polymorphisme permet à un objet de prendre de nombreuses formes.