[Java] Divers résumés joints aux chefs de classe et aux membres

Membre statique

Mettez simplement «statique» au début. L'exemple ci-dessous est une image de plusieurs personnes tenant un portefeuille. Dans ce cas, l'idée est que la classe «Human» a des champs, plutôt que chaque instance Human «h1», «h2» ayant un champ. Les champs statiques sont donc également appelés ** variables de classe **.

Human.java

public class Human{
     static int money=100;
}

Main.java

public class Main{
     public static void main(String[] args){
          //Créer la première instance
          Human h1 = new Human();
          //Créer une seconde instance
          Human h2 = new Human();

          // h1.Réécrire la variable de classe monétaire
          h1.money=200;

          // h2.Afficher la variable monétaire
          System.out.println(h2.money);
          //Puisque l'argent est une variable de classe, il doit être affiché comme 200
     }
}

Les méthodes statiques peuvent être appelées sans créer d'instance. Donc, dans l'exemple ci-dessus, soudainement

Main.java

System.out.println(Human.money);

C'est normal d'écrire quelque chose comme ça. C'est pourquoi la méthode main est une méthode statique.

Encapsulation

Une façon de réaliser l'encapsulation consiste à ajouter des modificateurs d'accès aux classes et aux membres pour définir la visibilité.

--public: Toutes les classes --protected: Classes qui appartiennent au même package que vous ou héritent de vous --packaged private (par défaut): les classes qui appartiennent au même package que vous --private: Seulement votre propre classe

Test.java

public class Test{
     private int i=1;
     public void calc(int j){
          return this.i+j;
     }
}

getter et setter

Définissez le champ sur private et la méthode sur public, et écrivez la manière de base de transmettre des valeurs avec getter et setter.

Test.java

public class Test{
    private int num;

    public int getNum(){
        return this.num;
    }

    public void setNum(int num){
        this.num = num;
    }
}

Héritage / implémentation

--Héritage: ʻexetends`

• Implémentation: ʻimplements`

• Le * ʻabstract` * attaché au début de la classe abstraite peut être pris lorsque la partie abstraite est écrasée. *

Héritage (exetends)

Ici, la relation d'héritage de ʻInu←Shibainu. Notez que la méthode ʻosuwari est abstraite et doit être remplacée par la classe Shibainu.

Inu.java

public abstract class Inu{
    public void ote(){
        System.out.println("Tends ta main gauche");
    }
    
    public abstract void osuwari();
        //Je n'écris rien ici
}

Shibainu.java

public class Shibainu extends Inu{
    public void osuwari(){
        System.out.println("Asseyez-vous sur le sol");
    }

    public void mate(){
        System.out.println("Accepte le riz");
    }
}

Main.java

public class Main{
    public static void main(Strgin[] args){
        Shibainu dog = new Shibainu();

        dog.ote();      //Méthode dérivée d'Inu
        dog.osuwari();  // Inu(←Shibainu)Méthode d'origine
        dog.mate();     //Méthode dérivée de Shibainu
    }
}

Utilisation du ** polymorphisme **

Main.java

Inu dog = new Shibainu();

dog.osuwari();

Vous pouvez aussi le dire.

Dans ce cas, les seules méthodes qui peuvent être appelées sont celles que possède la classe ʻInu. Par conséquent, dog.mate ne peut pas être appelé même si l'instance réellement créée est Shibainu. Lorsque la méthode ʻosuwari est appelée, la méthode de Shibainu est traitée à la place de la méthode de ʻInu`.

En utilisant ce polymorphisme, le traitement suivant peut également être écrit.

Main.java

Inu[] dogs = new Inu[3];

Inu[0] = new Shibainu();
Inu[1] = new Akitaken();
Inu[2] = new Tosaken();

for (Inu d: dogs){
    d.osuwari();
}

C'est très pratique lorsque le contenu de la même méthode mate, comme" s'asseoir sur le sol "," dormir "et" ne pas écouter ", diffère selon la classe.

• Vous devez faire attention au constructeur en ce qui concerne l'héritage. C'est parce qu'il y a des moments où vous devez explicitement donner un argument en utilisant super. Il vaut mieux reconnaître que le «super» utilisé ici est différent du «super» lors de l'appel de la méthode de la classe parente dans la méthode de la classe enfant (c'est la même chose pour «this»). *

Implémentations

Deux conditions peuvent faire d'une classe une interface.

• ** Toutes les méthodes sont des méthodes abstraites. ** **
• ** Fondamentalement, il n'a aucun champ. ** **

"Fondamentalement", c'est parce que seuls les champs (constantes) avec public static final sont autorisés à être déclarés. Cependant, dans ce cas, «public static final» peut être omis.

Déclarez ʻinterface au lieu de class`.

Animal.java

public interface Animal{
    void run();
}

Inu.java

public class Neko implements Animal{
    void run(){
        System.out.println("Courir sur quatre jambes");
    }
}

Puisque l'interface permet plusieurs implémentations

Neko.java

public calss Neko extends Mammal implements Animal, Organic{
    //Il a la classe mammifère, l'interface animale et l'interface organique en tant que parents.
}

Vous pouvez également écrire comme ça. La classe des chats a une classe de mammifères comme parent et a une interface entre les animaux et les substances organiques. Ce n'est pas un très bon exemple.

La beauté de l'interface / méthode abstraite est

• ** Forcé de passer outre. ** **
• ** Évitez l'instanciation involontaire. ** **
• ** Se distingue clairement des méthodes qui ne font rien. ** **

Un tel endroit.

Livre de référence

[Introduction à Java 2nd Edition] (https://www.amazon.co.jp/%E3%82%B9%E3%83%83%E3%82%AD%E3%83%AA%E3%82%8F%E3%81%8B%E3%82%8BJava%E5%85%A5%E9%96%80-%E7%AC%AC2%E7%89%88-%E3%82%B9%E3%83%83%E3%82%AD%E3%83%AA%E3%82%B7%E3%83%AA%E3%83%BC%E3%82%BA-%E4%B8%AD%E5%B1%B1-%E6%B8%85%E5%96%AC/dp/484433638X) Pp.332-524