[Java] Verschiedene Zusammenfassungen an die Leiter von Klassen und Mitgliedern

Statisches Mitglied

Setzen Sie einfach "statisch" in den Anfang. Das folgende Beispiel zeigt mehrere Personen, die eine Brieftasche halten. In diesem Fall besteht die Idee darin, dass die Klasse "Mensch" keine Felder hat, aber jede menschliche Instanz "h1", "h2" Felder hat. Daher werden statische Felder auch als ** Klassenvariablen ** bezeichnet.

Human.java

public class Human{
     static int money=100;
}

Main.java

public class Main{
     public static void main(String[] args){
          //Erstellen Sie die erste Instanz
          Human h1 = new Human();
          //Erstellen Sie eine zweite Instanz
          Human h2 = new Human();

          // h1.Schreiben Sie die Geldklassenvariable neu
          h1.money=200;

          // h2.Geldvariable anzeigen
          System.out.println(h2.money);
          //Da Geld eine Klassenvariable ist, sollte es als 200 angezeigt werden
     }
}

Statische Methoden können aufgerufen werden, ohne eine Instanz zu erstellen. Also im obigen Beispiel plötzlich

Main.java

System.out.println(Human.money);

Es ist okay, so etwas zu schreiben. Deshalb ist die Hauptmethode eine statische Methode.

Verkapselung#

Eine Möglichkeit, eine Kapselung zu erreichen, besteht darin, Klassen und Mitgliedern Zugriffsmodifikatoren hinzuzufügen, um die Sichtbarkeit festzulegen.

--public: Alle Klassen --protected: Klassen, die zum selben Paket gehören wie Sie oder von Ihnen erben --packaged private (Standard): Klassen, die zum selben Paket gehören wie Sie --private: Nur deine eigene Klasse

Test.java

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

Getter und Setter

Setzen Sie das Feld auf "privat" und die Methode auf "öffentlich" und schreiben Sie die grundlegende Methode zum Übergeben von Werten mit Getter und Setter.

Test.java

public class Test{
    private int num;

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

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

Vererbung / Implementierung

• Vererbung: "exetends"
• Implementierung: implementiert

• Das am Anfang der abstrakten Klasse angehängte * abstract * kann verwendet werden, wenn der abstrakte Teil überschrieben wird. * *

Vererbung (erweitert)

Hier die Vererbungsbeziehung von Inu ← Shibainu. Beachten Sie, dass die "osuwari" -Methode abstrahiert ist und von der "Shibainu" -Klasse überschrieben werden muss.

Inu.java

public abstract class Inu{
    public void ote(){
        System.out.println("Halten Sie Ihre linke Hand aus");
    }
    
    public abstract void osuwari();
        //Ich schreibe hier nichts
}

Shibainu.java

public class Shibainu extends Inu{
    public void osuwari(){
        System.out.println("Setz dich auf den Boden");
    }

    public void mate(){
        System.out.println("Mit Reis aushalten");
    }
}

Main.java

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

        dog.ote();      //Inu-abgeleitete Methode
        dog.osuwari();  // Inu(←Shibainu)Ursprungsmethode
        dog.mate();     //Von Shibainu abgeleitete Methode
    }
}

Verwendung von ** Polymorphismus **

Main.java

Inu dog = new Shibainu();

dog.osuwari();

Das kann man auch sagen.

In diesem Fall können nur die Methoden aufgerufen werden, über die die Inu-Klasse verfügt. Selbst wenn die tatsächlich erstellte Instanz "Shibainu" ist, kann "dog.mate" daher nicht aufgerufen werden. Wenn die "osuwari" -Methode aufgerufen wird, wird die Methode von "Shibainu" anstelle der Methode von "Inu" verarbeitet.

Unter Verwendung dieses Polymorphismus kann auch die folgende Verarbeitung geschrieben werden.

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();
}

Es ist sehr praktisch, wenn sich die Inhalte derselben "Mate" -Methode wie "auf dem Boden sitzen", "schlafen" und "nicht zuhören" je nach Klasse unterscheiden.

• Sie müssen auf den Konstruktor für die Vererbung achten. Dies liegt daran, dass Sie manchmal explizit ein Argument mit "super" angeben müssen. Es ist besser zu erkennen, dass sich das hier verwendete "Super" vom "Super" unterscheidet, wenn die Methode der übergeordneten Klasse in der Methode der untergeordneten Klasse aufgerufen wird (dies gilt auch für "this"). * *

Implementierungen

Es gibt zwei Bedingungen, die eine Klasse zu einer Schnittstelle machen können.

• ** Alle Methoden sind abstrakte Methoden. ** ** **
• ** Grundsätzlich hat es keine Felder. ** ** **

"Grundsätzlich" liegt daran, dass nur Felder (Konstanten) mit "public static final" deklariert werden dürfen. In diesem Fall kann jedoch "public static final" weggelassen werden.

Deklarieren Sie "Schnittstelle" anstelle von "Klasse".

Animal.java

public interface Animal{
    void run();
}

Inu.java

public class Neko implements Animal{
    void run(){
        System.out.println("Laufen Sie auf vier Beinen");
    }
}

Da die Schnittstelle mehrere Implementierungen erlaubt

Neko.java

public calss Neko extends Mammal implements Animal, Organic{
    //Es hat Säugetierklasse, Tierschnittstelle und organische Schnittstelle als Eltern.
}

Sie können auch so schreiben. Die Katzenklasse hat eine Säugetierklasse als Eltern und eine Schnittstelle zwischen Tieren und organischen Substanzen. Es ist kein sehr gutes Beispiel.

Das Schöne an der Interface / Abstract-Methode ist

• ** Zum Überschreiben gezwungen. ** ** **
• ** Vermeiden Sie unbeabsichtigte Instanziierungen. ** ** **
• ** Deutlich unterscheidbar von Methoden, die nichts bewirken. ** ** **

So ein Ort.

Nachschlagewerk

[Einführung in 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