Modificateurs d'accès en Java

Salut! Dans la leçon d'aujourd'hui, nous nous familiariserons avec le concept des modificateurs d'accès et examinerons des exemples sur la façon de les utiliser. Bien sûr, dire "faire connaissance" n'est pas tout à fait correct : vous connaissez déjà la plupart d'entre eux dans les leçons précédentes. Au cas où, rafraîchissons-nous la mémoire du point le plus important. Les modificateurs d'accès sont le plus souvent des mots-clés qui réglementent l'accès à différentes parties de votre code. Pourquoi "le plus souvent" ? Parce que l'un d'eux est défini par défaut sans l'utilisation d'un mot-clé :) Java a quatre modificateurs d'accès. Nous les listons dans l'ordre du plus restrictif au plus "indulgent":

privé;
par défaut (paquet visible) ;
protégé;
public.

Jetons un coup d'œil à chacun d'eux et identifions quand ils pourraient être utiles. Et nous donnerons des exemples :)

Le modificateur privé

Modificateurs d'accès. Privé, protégé, par défaut, public - 2

private est le modificateur d'accès le plus restrictif. Il limite la visibilité des données et des méthodes à une seule classe. Vous connaissez ce modificateur depuis la leçon sur les getters et les setters. Vous souvenez-vous de cet exemple ?

public class Cat {

   public String name;
   public int age;
   public int weight;

   public Cat(String name, int age, int weight) {
       this.name = name;
       this.age = age;
       this.weight = weight;
   }

   public Cat() {
   }

   public void sayMeow() {
       System.out.println("Meow!");
   }
}

public class Main {

   public static void main(String[] args) {

       Cat cat = new Cat();
       cat.name = "";
       cat.age = -1000;
       cat.weight = 0;
   }
}

Nous y avons pensé dans une leçon précédente. Nous avons commis une grave erreur ici : nous rendons nos données publiques, ce qui a permis à d'autres programmeurs d'accéder directement aux champs et de modifier leurs valeurs. De plus... ces valeurs ont été attribuées sans aucune vérification. Cela signifie que notre programme pourrait créer un chat nommé "" avec un âge de -1000 ans et un poids de 0. Pour résoudre ce problème, nous avons utilisé des getters et des setters, ainsi que le modificateur privé pour limiter l'accès aux données.

public class Cat {

   private String name;
   private int age;
   private int weight;

   public Cat(String name, int age, int weight) {
       this.name = name;
       this.age = age;
       this.weight = weight;
   }

   public Cat() {
   }

   public void sayMeow() {
       System.out.println("Meow!");
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       // input parameter check
       this.name = name;
   }

   public int getAge() {
       return age;
   }

   public void setAge(int age) {
       // input parameter check
       this.age = age;
   }

   public int getWeight() {
       return weight;
   }

   public void setWeight(int weight) {
       // input parameter check
       this.weight = weight;
   }
}

Fondamentalement, limiter l'accès aux champs et implémenter des getters et des setters sont les exemples les plus courants de la façon dont la confidentialitéserait utilisé dans le vrai travail. En d'autres termes, le but principal de ce modificateur est de réaliser l'encapsulation dans un programme. Cela ne s'applique pas seulement aux champs, soit dit en passant. Imaginez que votre programme comporte une méthode qui implémente des fonctionnalités TRÈS complexes. Que pouvons-nous suggérer comme exemple ? Supposons que votre méthode readDataFromCollider() accepte en entrée une adresse de données, lit les données du Large Hadron Collider au format octet, convertit ces données en texte, les écrit dans un fichier et les imprime. Même une description de la méthode fait peur, sans parler du code :) Pour rendre le code plus lisible, il serait préférable de ne pas écrire toute la logique complexe de la méthode au même endroit. Au lieu de cela, nous devrions diviser la fonctionnalité en méthodes distinctes. Par exemple, le readByteData()est responsable de la lecture des données, la méthode convertBytesToSymbols() convertit les données lues du collisionneur en texte, la méthode saveToFile() enregistre le texte reçu dans un fichier et la méthode printColliderData() imprime notre fichier de données. Au final, notre méthode readDataFromCollider() sera bien plus simple :

public class ColliderUtil {

   public void readDataFromCollider(Path pathToData) {
       byte[] colliderData = readByteData(pathToData);
       String[] textData = convertBytesToSymbols(colliderData);
       File fileWithData = saveToFile(textData);
       printColliderData(fileWithData);
   }

   public byte[] readByteData(Path pathToData) {

       // Reads data in bytes
   }

   public String[] convertBytesToSymbols(byte[] colliderDataInBytes) {

       // Converts bytes to characters
   }

   public File saveToFile(String[] colliderData) {

       // Saves read data to a file
   }

   public void printColliderData(File fileWithColliderData) {

       // Prints data from the file
   }
}

Cependant, comme vous vous en souviendrez dans la leçon sur les interfaces, l'utilisateur n'a accès qu'à l'interface externe. Et nos 4 méthodes n'en font pas partie. Ce sont des méthodes d'assistance : nous les avons créées pour améliorer la lisibilité du code et ne pas entasser quatre tâches différentes dans une seule méthode. Vous n'avez pas besoin de donner à l'utilisateur l'accès à ces méthodes. Si les utilisateurs ont accès à la méthode convertBytesToSymbols() lorsqu'ils travaillent avec le collisionneur, ils seront très probablement simplement confus par la méthode et se demanderont à quoi elle sert. Quels octets sont convertis ? D'où viennent-ils? Pourquoi les convertir en texte ? La logique exécutée dans cette méthode ne fait pas partie de l'interface exposée à l'utilisateur. Seul le readDataFromCollider()La méthode fait partie de l'interface. Alors que fait-on de ces quatre méthodes « internes » ? Droite! Utilisez le modificateur privé pour en limiter l'accès. Cela leur permet d'effectuer paisiblement leur travail à l'intérieur de la classe sans dérouter l'utilisateur, qui n'a pas besoin de connaître la logique de chaque méthode individuelle.

public class ColliderUtil {

   public void readDataFromCollider(Path pathToData) {
       byte[] colliderData = readByteData(pathToData);
       String[] textData = convertBytesToSymbols(colliderData);
       File fileWithData = saveToFile(textData);
       printColliderData(fileWithData);
   }

   private byte[] readByteData(Path pathToData) {
       // Reads data in bytes
   }

   private String[] convertBytesToSymbols(byte[] colliderDataInBytes) {
       // Converts bytes to characters
   }

   private File saveToFile(String[] colliderData) {
       // Saves read data to a file
   }

   private void printColliderData(File fileWithColliderData) {
       // Prints data from the file
   }
}

Le modificateur protégé

Le prochain modificateur le plus restrictif est protected . Modificateurs d'accès. Privé, protégé, par défaut, public - 3

Les champs et méthodes marqués par le modificateur d'accès protégé seront visibles :

dans toutes les classes incluses dans le même forfait que le nôtre;
dans toutes les classes qui héritent de notre classe.

Au début, il est difficile d'imaginer quand cela pourrait être nécessaire. Ne soyez pas surpris : il y a beaucoup moins de cas d'utilisation pour protected que pour private , et ils sont très spécifiques. Imaginez que nous ayons une classe abstraite AbstractSecretAgent qui représente un agent secret dans un service de renseignement, ainsi qu'un package top_secret qui contient cette classe et ses descendants. Les classes concrètes telles que FBISecretAgent , MI6SecretAgent , MossadSecretAgent , etc. en héritent. À l'intérieur de la classe abstraite, nous voulons implémenter un compteur d'agent. Il augmentera lorsqu'un nouvel agent sera créé quelque part dans le programme. paquet top_secret ;

public abstract class AbstractSecretAgent {

   public static int agentCount = 0;
}

Mais nos agents sont secrets ! Cela signifie qu'eux et personne d'autre ne devraient savoir combien d'entre eux existent. Nous pouvons facilement ajouter le modificateur protected au champ agent_counter . Ensuite, les instances d'autres classes d'agents secrets et d'autres classes situées dans notre package top_secret peuvent obtenir sa valeur.

public abstract class AbstractSecretAgent {

   protected static int agent_counter = 0;
}

Et c'est le genre de tâche spécialisée qui nécessite le modificateur protected :)

Le modificateur visible du package

Le prochain sur la liste est le modificateur par défaut , également connu sous le nom de modificateur visible du package . Il n'est pas indiqué par un mot-clé, car Java l'applique par défaut à tous les champs et méthodes. Si vous écrivez ce qui suit dans votre code :

int x = 10

la variable x aura un accès visible à ce package . Il est facile de se souvenir de ce qu'il fait. Fondamentalement, default = héritage protégé :) Comme le modificateur protected , son application est limitée. Le plus souvent, l'accès par défaut est utilisé dans un package qui contient des classes utilitaires qui n'implémentent pas les fonctionnalités de toutes les autres classes du package. Donnons un exemple. Imaginons que nous disposions d'un ensemble de « services ». Il contient diverses classes qui fonctionnent avec une base de données. Par exemple, il existe une classe UserService qui lit les données utilisateur de la base de données, une classe CarServiceclasse qui lit les données de la voiture à partir de la même base de données, et d'autres classes, chacune fonctionnant avec des types d'objets spécifiques et lisant les données correspondantes à partir de la base de données.

package services;

public class UserService {
}

package services;

public class CarService {
}

Mais il serait facile que les données de la base de données soient dans un format et nous en avons besoin dans un autre. Imaginez que les dates de naissance des utilisateurs dans la base de données soient stockées sous la forme <TIMESTAMP WITH TIME ZONE>...

2014-04-04 20:32:59.390583+02

... et à la place, nous avons besoin de l'objet le plus simple - un java.util.Date . Pour résoudre ce problème, dans le package de services , nous pouvons créer une classe Mapper spéciale. Il sera responsable de la conversion des données de la base de données en nos objets Java familiers. Une classe d'assistance simple. Nous déclarons généralement toutes les classes en tant que classe publique ClassName , mais ce n'est pas une obligation. Nous pouvons déclarer notre classe d'assistance simplement en tant que classe Mapper . Dans ce cas, il fait toujours son travail, mais il n'est visible par personne en dehors du forfait de services !

package services;

class Mapper {
}


package services;

public class CarService {

   Mapper mapper;
}

Et voici le raisonnement de base : pourquoi quelqu'un en dehors d'un package aurait-il besoin de voir une classe d'assistance qui ne fonctionne qu'avec les classes de ce package ?

Le modificateur public

Et enfin, le modificateur public ! Vous avez rencontré ce modificateur lors de votre premier jour d'étude sur CodeGym la première fois que vous avez exécuté public static void main(String[] args) . Modificateurs d'accès. Privé, protégé, par défaut, public - 4

Modificateurs d'accès. Privé, protégé, par défaut, public - 4

Maintenant que vous avez étudié la leçon sur les interfaces, son but est évident pour vous :) Après tout, le modificateur public a été créé pour donner quelque chose aux utilisateurs. Par exemple, l'interface de votre programme. Supposons que vous ayez écrit un programme de traduction capable de traduire du texte russe en anglais. Vous avez créé une méthode translate(String textInRussian) qui implémente toute la logique nécessaire. Vous avez marqué cette méthode avec le mot public , et maintenant elle fait partie de l'interface :

public class Translator {

   public String translate(String textInRussian) {

       // Translates text from Russian to English
   }
}

Vous pouvez lier cette méthode au bouton "Traduire" à l'écran et le tour est joué ! N'importe qui peut l'utiliser. Les parties de code marquées du modificateur public sont destinées à l'utilisateur final. Pour donner un exemple concret, privé concerne tous les processus qui se produisent à l'intérieur d'un téléviseur, mais public concerne les boutons de la télécommande utilisée pour gérer le téléviseur. De plus, l'utilisateur n'a pas besoin de savoir comment le téléviseur est construit ou comment il fonctionne. La télécommande est l'ensemble des méthodes publiques : on() , off() , nextChannel() , previousChannel() , augmentationVolume() , diminutionVolume() etc. Pour renforcer ce que vous avez appris, nous vous suggérons de regarder une leçon vidéo de notre cours Java