Modificateurs d'accès et héritage

Introduction

Dans ce laboratoire, vous allez apprendre les modificateurs d'accès et l'héritage. Avec différents modificateurs, les niveaux d'accès sont différents. L'héritage en Java est comme l'héritage biologique dans le sens où les enfants peuvent conserver les caractéristiques des parents et se comporter différemment de certains points de vue.

Modificateurs d'accès

Jusqu'à présent, nous avons déjà écrit du code. Dans le laboratoire précédent, nous avons écrit une classe. Il existe des modificateurs tels que public et private. Alors, que signifient ces mots?

Java fournit un certain nombre de modificateurs d'accès pour définir les niveaux d'accès des classes, des variables, des méthodes et des constructeurs. Les quatre niveaux d'accès sont :

• par défaut : Visible dans le package, le niveau par défaut. Aucun modificateur n'est nécessaire.
• private : Visible uniquement dans la classe définissante.
• public : Visible dans l'univers Java (tous les types). Vous pouvez y accéder n'importe où.
• protected : Visible dans le package et toutes les sous-classes (même celles dans d'autres packages).

Java fournit un certain nombre de modificateurs non d'accès pour réaliser de nombreuses autres façons de paramétrer finement le comportement :

• static : Ce modificateur est utilisé pour créer des variables ou des méthodes qui existeront indépendamment de toute instance de la classe. Il n'existe qu'une seule copie de la variable static pour la classe, quelle que soit le nombre d'instances créées.
• final : Une variable final ne peut être initialisée explicitement qu'une seule fois. Une méthode final ne peut pas être redéfinie par aucune sous-classe. Une classe est déclarée final pour empêcher la classe d'être sous-classée.
• abstract : Une classe abstract ne peut jamais être instanciée. Une méthode abstract est une méthode déclarée sans aucune implémentation.
• synchronized/volatile : Les modificateurs synchronized et volatile sont utilisés en relation avec les threads.

Exemple :

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

public class modifierTest {
    // Les variables statiques sont initialisées lors du chargement de la classe.
    public static int i = 10;
    public static final int NUM = 5;
    // Les variables non statiques sont initialisées lors de la création de l'objet.
    public int j = 1;

    /*
     * Bloc de code statique ici, cela s'exécutera lors du chargement de la classe
     * la création d'un nouvel objet n'exécutera pas le bloc à nouveau, il s'exécute une seule fois.
    */
    static{
        System.out.println("Ceci est un bloc statique de classe.");
    }
    public static void main(String[] args)
    {
        System.out.println("Ceci est dans la méthode main");

        // Vous pouvez accéder à i et le modifier
        modifierTest.i = 20;  //idem que obj.i = 20
        System.out.println("Variable de classe i = " + modifierTest.i);
        // Vous pouvez accéder à NUM, mais ne pouvez pas le modifier
        // HelloWorld.NUM = 10;     Cela entraînera une erreur, NUM est final, il est immuable
        System.out.println("Variable de classe NUM = " + modifierTest.NUM);

        // Créez un nouvel objet
        modifierTest obj = new modifierTest();
        // Nous pouvons utiliser à la fois la classe et l'objet pour accéder aux méthodes statiques et aux propriétés statiques
        obj.staticMethod();  //idem que modifierTest.staticMethod()
        // Vous ne pouvez pas accéder à j de cette manière : modifierTest.j
        System.out.println("Variable d'objet j = " + obj.j);
    }
    // Le constructeur, seul la création d'un nouvel objet appellera cela.
    public modifierTest(){
        System.out.println("Ceci est dans le constructeur de l'objet.");
    }
    public static void staticMethod(){
        System.out.println("Ceci est une méthode statique");
    }
}

Sortie :

Exécutez le fichier modifierTest.java à l'aide des commandes suivantes :

javac /home/labex/project/modifierTest.java
java modifierTest

Voyez la sortie :

Ceci est un bloc statique de classe.
Ceci est dans la méthode main
Variable de classe i = 20
Variable de classe NUM = 5
Ceci est dans le constructeur de l'objet.
Ceci est une méthode statique
Variable d'objet j = 1

Héritage

Dans de nombreux cas, nous avons écrit une classe. Et puis, nous devons écrire une nouvelle classe juste pour modifier un peu le code de la classe précédente, et elles ont une certaine relation logique. Nous pouvons utiliser l'héritage ici. Nous utilisons le mot clé extends pour implémenter l'héritage. Les sous-classes obtiennent toutes les propriétés et méthodes accessibles de la superclasse par héritage, et les sous-classes peuvent également avoir les leurs propres propriétés et méthodes spécifiques. Dans les sous-classes, nous pouvons accéder à celles qui sont déclarées dans la superclasse comme public ou protected, mais celles déclarées private ne sont pas directement accessibles. Voici un exemple : La structure d'héritage est représentée dans l'image. Vous pouvez implémenter un héritage multi-niveaux (horizontal) ou un héritage hiérarchique (vertical) :

Exemple :

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

class Animal{
    // De quel type d'animal suis-je.
    private String species;
    private int age = 8;

    public Animal(){
        System.out.println("Constructeur de l'animal");
    }
    public void grow(){
        // Dans cette classe, nous pouvons accéder directement aux propriétés privées.
        System.out.println("J'ai "+ this.age + " ans, " +"Je grandis.");
    }
}
class Dog extends Animal{
    private String color;
    // Dans cette classe, nous ne pouvons pas accéder aux attributs privés de la superclasse, mais grow() est autorisé.
    public Dog(){
        System.out.println("Constructeur du chien");
    }
    public void run(){
        this.grow();
        System.out.println("Je suis un chien, je peux courir.");
    }
}
class Bird extends Animal{
    private double weight;

    public Bird(){
        // Si vous appelez explicitement le constructeur de la superclasse, il doit être à la première ligne ici.
        // super();
        System.out.println("Constructeur de l'oiseau");
    }
    public void fly(){
        this.grow();
        System.out.println("Je suis un oiseau, je peux voler.");
    }
}
public class inheritanceTest{
    public static void main(String[] args){
        Dog dog = new Dog();
        dog.run();

        Bird bird = new Bird();
        bird.fly();
    }
}

Sortie :

Exécutez le fichier inheritanceTest.java à l'aide des commandes suivantes :

javac /home/labex/project/inheritanceTest.java
java inheritanceTest

Voyez la sortie :

Constructeur de l'animal
Constructeur du chien
J'ai 8 ans, Je grandis.
Je suis un chien, je peux courir.
Constructeur de l'animal
Constructeur de l'oiseau
J'ai 8 ans, Je grandis.
Je suis un oiseau, je peux voler.

Lorsque vous voyez cette sortie, vous pouvez être confus. Ne vous inquiétez pas ; nous allons expliquer pourquoi. Lorsque nous créons un objet d'une sous-classe en utilisant new, il appelle par défaut d'abord le constructeur par défaut de la superclasse à partir de la structure d'arbre d'héritage "du haut vers le bas" et exécute finalement son propre constructeur. Le constructeur de la superclasse peut être appelé explicitement en utilisant le mot clé super, mais il doit être la première instruction dans un constructeur s'il y en a un. Le mot clé super fait référence à la superclasse, immédiatement au-dessus de la classe appelante dans la hiérarchie.

Résumé

Avec les modificateurs d'accès, nous pouvons écrire du code sécurisé, cacher les détails et réaliser un contrôle d'accès. Les autres utilisateurs n'ont pas besoin de savoir comment nous implémentons les détails des méthodes. Nous fournissons une interface aux autres invocateurs. Pour les modificateurs d'accès, vous pouvez lire les bibliothèques de code source Java pour comprendre les différences. Pour l'héritage, gardez à l'esprit la structure hiérarchique, qui est la relation entre les classes.