Pour résumer le contenu précédent, l'objet fait référence à une certaine chose et la classe fait référence au type d'objet. Les objets peuvent avoir des états et des actions, c'est-à-dire des données membres et des méthodes.
Jusqu'à présent, les données membres et les méthodes étaient ouvertes aux utilisateurs internes et externes. À l’intérieur de l’objet, nous l’utilisons pour appeler les données membres et les méthodes de l’objet. En dehors de l'objet, par exemple lorsque nous appelons l'objet dans une autre classe, nous pouvons utiliser les membres object.data et object.method() pour appeler les données membres et les méthodes de l'objet.
Nous allons encapsuler les membres de l'objet (les membres incluent les données membres et les méthodes), permettant ainsi à seulement certains membres d'être appelés de l'extérieur. Grâce à l'encapsulation, nous pouvons améliorer la facilité d'utilisation et la sécurité des objets.
Encapsulation et interface
L'encapsulation est un terme courant pour les ordinateurs, ce qui signifie conserver une interface externe limitée et masquer des détails d'implémentation spécifiques. Par exemple, dans l'architecture Linux, vous pouvez voir que le système d'exploitation Linux encapsule les détails spécifiques du matériel sous-jacent, en conservant uniquement l'interface d'appel système. L'utilisateur est extérieur au package et ne peut effectuer les opérations requises que via l'interface.
L'encapsulation est très courante dans la vie. Par exemple, voici une lampe de poche rechargeable :
Même sans lire le manuel, un utilisateur peut deviner le fonctionnement de cette lampe torche : commutation et chargement. Cette lampe de poche utilise une coque en plastique pour cacher les détails internes que les utilisateurs n'ont pas besoin de toucher, ne laissant que deux interfaces, l'interrupteur et la prise électrique. Grâce à ces deux interfaces, les utilisateurs peuvent utiliser les fonctions pour lesquelles le produit est conçu. Si tous les détails sont exposés à l'utilisateur en même temps, celui-ci se sentira dépassé par le produit (comme la télécommande non coque ci-dessous). L’encapsulation améliore donc la facilité d’utilisation du produit.
Si le produit n'est pas emballé, de nombreux détails de la lampe de poche ou de la télécommande seront exposés à l'utilisateur : batterie, circuit, caoutchouc scellé, etc. Bien que cela permette aux utilisateurs de faire fonctionner le produit plus librement, comme décharger directement la batterie, retirer une lumière LED, etc. Cependant, les utilisateurs courent souvent un plus grand risque d’endommager le produit. L’encapsulation améliore donc la sécurité du produit.
Un produit logiciel Java est identique à un produit courant. Un objet peut contenir de nombreux membres (données membres et méthodes). Certains membres de données et méthodes sont utilisés uniquement en interne. À ce stade, nous espérons avoir un mécanisme pour « emballer » l’objet afin d’encapsuler l’objet. De cette manière, les utilisateurs peuvent apprendre et utiliser plus facilement les interfaces externes sans avoir à contacter les membres internes.
Encapsulation des membres d'objet
Java utilise trois mots-clés pour contrôler la visibilité externe des membres d'un objet : public, privé, protégé.
1.public : le membre est visible en externe, c'est-à-dire que le membre fait partie de l'interface
2.private : ce membre n'est pas visible de l'extérieur et ne peut être utilisé qu'en interne et n'est pas accessible de l'extérieur.
(protégé implique la notion d'héritage, qui sera abordée plus tard)
Encapsulons d’abord la classe Human définie précédemment :
Copiez le code comme suit :
Test de classe publique
{
public static void main (String[] arguments)
{
Humain aPerson = nouvel Humain (160);
System.out.println(aPerson.getHeight());
aPerson.growHeight(170);
System.out.println(aPerson.getHeight());
aPerson.repeatBreath(100);
}
}
classeHumain
{
/**
* constructeur
*/
humain public (int h)
{
ceci.hauteur = h;
System.out.println("Je suis né");
}
/**
*accesseur
*/
public int getHeight()
{
renvoie this.height;
}
/**
* mutateur
*/
public void growHeight (int h)
{
ceci.hauteur = ceci.hauteur + h;
}
/**
* encapsulé, pour usage interne
*/
souffle vide privé()
{
System.out.println("hu...hu...");
}
/**
* appeler souffle()
*/
public void repeatBreath (int rep)
{
int je;
pour(i = 0; i < rep; i++) {
this.souffle();
}
}
private int height ; // encapsulé, pour usage interne
}
Les méthodes internes ne sont pas affectées par l'encapsulation. Les méthodes internes de l'humain peuvent appeler n'importe quel membre, même height et Breath() défini sur private
Les méthodes externes ne peuvent appeler que des membres publics. Lorsque nous sommes en dehors de Human, comme dans Test, nous ne pouvons appeler que les membres spécifiés comme publics dans Human, mais pas les membres spécifiés comme privés.
Grâce à l'encapsulation, la classe Human ne conserve que les méthodes suivantes comme interfaces :
1.getHeight()
2.growHeight()
3.repBreath()
Nous pouvons représenter la classe Human et son interface comme suit :
"Télécommande avec étui"
Si nous forçons la hauteur de l'appel depuis le principal :
Copiez le code comme suit :
System.out.println(aPerson.height);
Il y aura le message d'erreur suivant :
Copiez le code comme suit :
Test.java:6 : la hauteur a un accès privé chez l'humain
System.out.println(aPerson.height);
^
1 erreur
Bip, vous avez reçu un choc électrique ! Un membre déclaré privé ne peut pas être appelé en externe.
Dans la spécification habituelle de Java, les données membres qui expriment un état (comme la hauteur) sont définies comme privées. Les modifications des données membres doivent être effectuées via les méthodes fournies par l'interface (telles que getHeight() et growHeight()). Cette spécification joue un rôle dans la protection des données. Les utilisateurs ne peuvent pas modifier directement les données et doivent utiliser les méthodes correspondantes pour lire et écrire des données. Les concepteurs de classes peuvent ajouter des spécifications d'utilisation des données aux méthodes d'interface.
encapsulation de classe
Dans un fichier .java, il n'y a et ne peut y avoir qu'une seule classe avec le mot-clé public, comme la classe Test ci-dessus. Ainsi, depuis n’importe quelle autre classe, nous pouvons appeler directement cette classe. La classe humaine n'a pas de mot-clé. Auparavant, les membres de nos objets n'avaient pas de mots-clés. Ce manque de mots-clés représente aussi une sorte de visibilité, que j'approfondirai lors de l'explication des packages.
Entraînez-vous à encapsuler une classe Torch pour représenter une lampe de poche. L'interface a la commutation et la charge. Les membres internes ont le pouvoir.
Résumer
encapsulation, interface
privé, public