Inhaltsverzeichnis

Was ist Vererbung?
Was sind die Vorteile der Vererbung?
Merkmale der Vererbung
Hinweise zur Verwendung der Vererbung
Was ist der Unterschied zwischen super und this?
Methodenüberschreibung (Überschreiben)
Das Schlüsselwort final
Polymorphismus
Abstraktion (abstract)
Innere Klassen
Durch verschiedene Modifikatoren geänderter Inhalt (nicht im Zusammenhang mit inneren Klassen)
Vier Zugriffsmodifikatoren

Was ist Vererbung?

Wenn mehrere Klassen dieselben Attribute und Verhaltensweisen haben, extrahiere diese Inhalte in eine einzelne Klasse. Dann müssen die mehreren Klassen diese Attribute und Verhaltensweisen nicht mehr definieren; sie müssen nur von dieser Klasse erben.

Die mehreren Klassen können alsUnterklassenbezeichnet werden, und diese einzelne Klasse wird alsElternklasse、Oberklasseoder bezeichnetBasisklasse。

Unterklassen können direkt auf dienicht privatenAttribute und Verhaltensweisen in der Elternklasse zugreifen.

Durch dasextendsSchlüsselwort wird eine Vererbungsbeziehung zwischen Klassen erstellt.

class SubDemo extends Demo{}    //SubDemo是子类，Demo是父类

Was sind die Vorteile der Vererbung?

Verbessertdie Wiederverwendbarkeit von Code。
Erzeugt Beziehungen zwischen Klassen, was dieVoraussetzung für Polymorphismus ist.。

Merkmale der Vererbung

1. Java unterstützt nur Einfachvererbung, nicht Mehrfachvererbung.

//一个类只能有一个父类，不可以有多个父类。
class SubDemo extends Demo{} //ok
class SubDemo extends Demo1,Demo2...//error

2. Java unterstützt mehrstufige (wiederholte) Vererbung (Vererbungshierarchie).

class A{}
class B extends A{}
class C extends B{}

Hinweise zur Verwendung der Vererbung

Wenn zwischen Klassen eine "is a"-Beziehung besteht, sollte Vererbung in Betracht gezogen werden.
Verwende Vererbung nicht nur, um einen Teil der Funktionalität zu erben.

Was ist der Unterschied zwischen super und this?

supersuper ist ein Schlüsselwort, das denSpeicherplatzbezeichnerder Elternklasse darstellt. (Es kann als Referenz auf die Elternklasse verstanden werden.)

Die Verwendung von super und this ist ähnlich.

this repräsentierteine Referenz auf das Objekt(wer auch immer es aufruft, es repräsentiert dieses Objekt);
super repräsentiertdie auf diePairElternklasse bezogeneReferenz der aktuellen Unterklasse.

Anwendungsszenarien

Wenn die Kind- und die Elternklasse Mitglieder mit demselben Namen haben, kann super verwendet werden, um sie zu unterscheiden;
Wenn eine Unterklasse den Konstruktor der Elternklasse aufrufen muss, kann die super-Anweisung verwendet werden.

Unterschiede

1. Membervariablen

this.变量    --    本类的
super.变量    --    父类的

2. Konstruktoren

this(...)    --    本类的
super(...)    --    父类的

3. Membermethoden

this.方法名()    --    本类的    
super.方法名()    --    父类的

super(); und this(); müssen beide in der ersten Zeile des Konstruktors stehen, und sie dürfen nicht gleichzeitig auftreten.

Methodenüberschreibung (Überschreiben)

Wenn eine Unterklasse eine Methode hat, die genau mit der Methode der Elternklasse übereinstimmt (mit Ausnahme des Zugriffsmodifizierers; der Zugriffsmodifizierer muss größer oder gleich und nicht private sein; Rückgabetyp, Methodenname und Parameterliste sind gleich), kommt es zu einem Überschreibungsvorgang, der auch als Rewriting oder Overwriting bezeichnet wird.

Private Methoden der Elternklasse sind für die Unterklasse unsichtbar, daher kommt das Überschreiben privater Methoden der Elternklasse nicht infrage.

Hinweise zum Überschreiben：

Beim Überschreiben muss die Zugriffsebene der Methode der Unterklasse größer oder gleich derjenigen der Methode der Elternklasse sein;
Statische Methoden können nur statische Methoden überschreiben.

Anwendungsfälle für das Überschreiben：

Wenn die Unterklasse die Funktionalität der Elternklasse benötigt, der Funktionskörper jedoch unterklassenspezifischen Inhalt hat, kann die Methode in der Elternklasse überschrieben werden. Auf diese Weise erbt sie nicht nur die Funktionalität der Elternklasse, sondern definiert auch unterklassenspezifischen Inhalt.

Was ist der Unterschied zwischen dem Überschreiben und dem Überladen von Methoden?？

Methodenüberschreibung wird verwendet, wenn die Methode der Unterklasse genau mit der Methode der Elternklasse übereinstimmt; außer dem Zugriffsmodifikator sind Rückgabetyp, Methodenname und Parameterliste alle gleich.
Überladen wird verwendet, wenn Methoden in derselben Klasse denselben Methodennamen, aber unterschiedliche Parameterlisten haben (es hat nichts mit dem Rückgabetyp zu tun).

Verwendung von Konstruktoren in Unter- und Elternklassen：

Während der Initialisierung einer Unterklasse wird zuerst die Initialisierung der Elternklasse ausgeführt. Das liegt daran, dass der Konstruktor der Unterklasse standardmäßig einen Aufruf von super() enthält. Die Unterklasse muss die Mitgliedsvariablen der Elternklasse verwenden, und diese Initialisierung muss vor der Initialisierung der Unterklasse abgeschlossen sein. Daher wird während der Initialisierung der Unterklasse zuerst die Initialisierung der Elternklasse ausgeführt.
Wenn die Elternklasse keinen parameterlosen Konstruktor hat

Verwenden Sie super, um den parametrisierten Konstruktor der Elternklasse aufzurufen. Empfohlene Vorgehensweise.
Verwenden Sie this, um andere Konstruktoren derselben Klasse aufzurufen.

Ausführungsreihenfolge von statischen Codeblöcken, Konstruktor-Codeblöcken und Konstruktoren：

Statischer Codeblock der Elternklasse → statischer Codeblock der Unterklasse → Konstruktor-Codeblock der Elternklasse → Konstruktor der Elternklasse → Konstruktor-Codeblock der Unterklasse → Konstruktor der Unterklasse

Das Schlüsselwort final

final ist ein Schlüsselwort, das verwendet werden kann, um Klassen, Mitgliedsvariablen und Mitgliedsmethoden zu modifizieren.

Eigenschaften：

Die Klasse, die es modifiziert, kann nicht vererbt werden.
Die von ihm modifizierte Mitgliedsvariable ist eine Konstante.
Die von ihm modifizierte Mitgliedsmethode kann nicht von Unterklassen überschrieben werden.

Durch final modifizierte Konstanten haben im Allgemeinen Namenskonventionen. Bei durch final modifizierten Konstanten sind alle Buchstabengroßgeschrieben.。

Eine durch final modifizierte Mitgliedsvariable muss initialisiert werden. Es gibt zwei Möglichkeiten, sie zu initialisieren:

Explizite Initialisierung;
Initialisierung durch den Konstruktor.
Die beiden können jedoch nicht zusammen zur Initialisierung verwendet werden.

Der Unterschied zwischen final und private：

Auf eine durch final modifizierte Klasse kann zugegriffen werden;
private kann keine äußeren Klassen modifizieren, aber es kann innere Klassen modifizieren (tatsächlich ist es sinnlos, eine äußere Klasse private zu machen).
Durch final modifizierte Methoden können nicht von Unterklassen überschrieben werden;
Mit private modifizierte Methoden scheinen für Unterklassen überschreibbar zu sein, aber tatsächlich können sie es nicht sein, weil Unterklassen die privaten Methoden der Oberklasse nicht sehen können.
Eine mit final modifizierte Variable kann während der expliziten Initialisierung oder der Konstruktorinitialisierung nur einmal zugewiesen werden und kann danach nicht geändert werden;
Auf eine mit private modifizierte Variable darf auch nicht direkt von Unterklassen oder anderen Klassen im selben Paket zugegriffen werden, und sie darf auch nicht direkt von ihnen geändert werden, aber sie kann über set- und get-Methoden geändert und abgerufen werden.

Polymorphismus

Konzept：

Die verschiedenen Zustände, die ein Objekt zu verschiedenen Zeiten aufweist.

Voraussetzungen für Polymorphismus：

Es muss eine Vererbungs- oder Implementierungsbeziehung geben.
Es muss Methodenüberschreibung geben.
Es muss eine Referenz der Oberklasse geben, die auf ein Unterklassenobjekt verweist.

Ausprägung in Programmen：
A reference of the parent class or interface points to or receives its ownUnterklassenobjekt oder nimmt es entgegen.。

Vorteile und Auswirkungen：
The existence of polymorphism improves the program'sErweiterbarkeit des Programmsund die spätereWartbarkeit.。

Nachteile:
Wenn eine Oberklasse aufgerufen wird, können nur Methoden der Oberklasse aufgerufen werden, nicht die spezifischen Methoden der Unterklasse, weil man nicht weiß, welche Art von Unterklassen sie in Zukunft erben wird.

Member-Merkmale der Polymorphie：

Membervariablen: Zur Kompilierzeit: Prüfen, ob die Klasse, zu der die Referenzvariable gehört, die aufgerufene Variable besitzt;
Zur Laufzeit: ebenfalls prüfen, ob die Klasse, zu der die Referenzvariable gehört, die aufgerufene Variable besitzt.
Bei Membervariablen hängen sowohl Kompilierzeit als auch Laufzeit von der Klasse ab, zu der die Referenzvariable gehört. Einfach merken:Bei Membervariablen schauen sowohl Kompilierung als auch Laufzeit auf die linke Seite des Gleichheitszeichens.。
Membermethoden: Zur Kompilierzeit: Prüfen, ob die Klasse, zu der die Referenzvariable gehört, das aufgerufene Member besitzt;
Zur Laufzeit: Prüfen, ob die Klasse, zu der das Objekt gehört, das aufgerufene Member besitzt. Wenn Ober- und Unterklasse Methoden mit demselben Namen haben, wird die Methode der Unterklasse ausgeführt, weil Methoden die Eigenschaft des Überschreibens besitzen.
Die Kompilierung schaut nach links, die Laufzeit schaut nach rechts.。
Statische Methoden: Zur Kompilierzeit: Prüfen, ob die Klasse, zu der die Referenzvariable gehört, die aufgerufene Variable besitzt;
Zur Laufzeit: ebenfalls prüfen, ob die Klasse, zu der die Referenzvariable gehört, die aufgerufene Variable besitzt.
Sowohl die Kompilierung als auch die Laufzeit schauen auf die linke Seite des Gleichheitszeichens.。

Man darf auf keinen Fall ein Objekt der Oberklasse in einen Unterklassentyp umwandeln!

Eine Referenz der Oberklasse, die auf ein Objekt der Unterklasse zeigt, kann upgecastet werden und kann aucherzwungen/gecastet werden.。

Bei der Polymorphie ist es immer das Unterklassenobjekt, das sich ändert!

//多态向下转型和向上转型的例子，多态转型解决了多态中父类引用不能使用子类特有成员的弊端。
class PolymorphicTest2 {
    public static void main(String[] args) {
        Phone p1 = new Nokia();        //向上转型，类型提升
        Nokia no = (Nokia)p1;          //向下转型，强制将父类的引用转换成子类类型，不能将Nokia类型转成Moto或Nexus类型
        no.print();                    //输出结果为Phone---null---0，因为继承了父类的方法

        Phone p2 = new Moto();
        Moto m = (Moto)p2;
        m.print();                    //输出结果为Moto---yellow---1599，方法重写，子类方法覆盖父类方法

        Phone p3 = new Nexus();
        Nexus ne = (Nexus)p3;
        ne.print();
    }
}

class Phone{    
    String color;
    int price;

    public void print(){
        System.out.println("Phone---" + color + "---" + price );
    }    
}

class Nokia extends Phone{
    String color = "red";
    int price = 1009;

    //public void print(){
    //    System.out.println("Nokia---" + color + "---" + price);
    //}
}

class Moto extends Phone{
    String color = "yellow";
    int price = 1599;

    public void print(){
        System.out.println("Moto---" + color + "---" + price);
    }
}

class Nexus extends Phone{
    String color = "black";
    int price = 1999;

    public void print(){
        System.out.println("Nexus---" + color + "---" + price);
    }
}
}

Abstraktion (abstract)

Abstraktion bedeutet, gemeinsame und wesentliche Inhalte aus mehreren Dingen zu extrahieren.

Abstrakte Klassen：

In Java können SieMethoden ohne Methodenkörper definieren.Die konkrete Implementierung einer solchen Methode wird vonUnterklassebereitgestellt. Eine unvollständige Methode wird als abstrakte Methode bezeichnet, und eine Klasse, die eine abstrakte Methode enthält, ist eine abstrakte Klasse.

Ursprung：

Wenn mehrere Objekte alle dieselbe Funktion haben, aber der konkrete Inhalt der Funktion unterschiedlich ist, wird beim Extrahieren nur die Funktionsdefinition extrahiert, nicht der Funktionskörper. Eine Methode, die nur eine Funktionsdeklaration und keinen Funktionskörper hat, wird als abstrakte Methode bezeichnet.

Eigenschaften abstrakter Klassen：

Abstrakte Methoden müssen in einer abstrakten Klasse sein;
Sowohl abstrakte Methoden als auch abstrakte Klassen müssen mit dem Schlüsselwort `abstract` modifiziert werden;
Abstrakte Klassen können nicht `new` verwenden, um Objekte zu erstellen, da das Aufrufen einer abstrakten Methode sinnlos ist;
Damit die abstrakten Methoden in einer abstrakten Klasse verwendet werden können, muss eine Unterklasse alle ihre abstrakten Methoden überschreiben und dann ein Unterklassenobjekt erstellen, um sie aufzurufen; wenn eine Unterklasse nur einen Teil der abstrakten Methoden überschreibt, ist sie immer noch eine abstrakte Klasse;
Eine abstrakte Klasse kann abstrakte Methoden oder nicht-abstrakte Methoden haben; abstrakte Methoden werden für die Instanziierung von Unterklassen verwendet;
Wenn eine Klasse eine abstrakte Klasse ist, müssen die Unterklassen, die von ihr erben, entweder abstrakte Klassen sein oder alle abstrakten Methoden überschreiben.
Sonderfall: Eine abstrakte Klasse darf keine abstrakten Methoden definieren; dies dient nur dazu, zu verhindern, dass die Klasse Objekte erzeugt.

Member-Eigenschaften abstrakter Klassen：

Member-Variablen: können Variablen oder Konstanten sein;
Konstruktoren: es gibt Konstruktoren;
Member-Methoden: können abstrakte Methoden oder nicht abstrakte Methoden sein.

abstract class 葵花宝典 {
    public abstract void 自宫();
}

class 岳不群 extends 葵花宝典 {
    public void 自宫(){
        System.out.println("剪刀");
    }
}

class 林平之 extends 葵花宝典{
    public void 自宫(){
        System.out.println("指甲刀");
    }
}
class AbstractTest  {
    public static void main(String[] args) {
        岳不群 岳 = new 岳不群();
        岳.自宫();

        林平之 林 = new 林平之();
        林.自宫();
    }
}

Hinweise zu abstrakten Klassen：

Eine abstrakte Klasse kann nicht instanziiert werden; warum hat sie trotzdem einen Konstruktor?？

Jede Klasse, die mit `class` definiert wird, muss einen Konstruktor haben. Der Konstruktor in einer abstrakten Klasse wird verwendet, um Unterklassen zu instanziieren.

Eine Klasse hat keine abstrakten Methoden; warum wird sie als abstrakte Klasse definiert??

Sie möchte vererbt, aber nicht instanziiert werden.

Welche Schlüsselwörter können nicht zusammen mit dem Schlüsselwort `abstract` koexistieren?？

`final`: Wenn eine Methode abstrakt ist, muss sie überschrieben werden, aber `final` kann nicht überschrieben werden, also widersprechen sie sich.
`private`: Wenn eine Methode privat ist, können Unterklassen nicht direkt darauf zugreifen, wie kann sie dann überschrieben werden?
`static`: Es wird kein Objekt benötigt, und die abstrakte Methode kann über den Klassennamen aufgerufen werden. Aber eine abstrakte Methode aufzurufen ist sinnlos.

Schnittstelle (`interface`)

SchnittstelleJaAbstrakte MethodenundKonstante WerteEine Sammlung von. Im Wesentlichen ist eine Schnittstelle eine spezielle Art abstrakter Klasse, die nur Konstanten und Methodendefinitionen enthält, ohne Variablen und Methodenimplementierungen.

Format:`interface InterfaceName {}`

Die Entstehung von Schnittstellen drückt "Mehrfachvererbung" in einer anderen Form aus, nämlich "Mehrfachimplementierung".

Implementierung (`implements`)

Format:`class ClassName implements InterfaceName {}`

Eigenschaften：

Schnittstellen können nicht instanziiert werden.
Wenn eine Klasse eine Schnittstelle implementiert, muss sie entweder eine abstrakte Klasse sein oder alle Methoden der Schnittstelle implementieren.

Member-Eigenschaften von Schnittstellen：

Die Member-Modifikatoren in einem Interface sind festgelegt!

Member-Konstanten: `public static final`. In einem Interface definierte Variablen sind globale Konstanten, und die Modifikatoren können nur diese drei Schlüsselwörter sein; alle von ihnen können weggelassen werden. Konstantennamen müssen großgeschrieben werden.
Member-Methoden: `public abstract`. In einem Interface definierte Methoden sind alle abstrakt, und die beiden Modifikator-Schlüsselwörter können weggelassen werden.
Empfehlung: die Modifikatoren immer manuell angeben.

Unterschiede zwischen Vererbung und Implementierung：

Die Beziehung zwischen Klassen und Klassen wird als Vererbung bezeichnet: Denn unabhängig davon, ob eine Klasse abstrakt oder nicht abstrakt ist, kann sie im Inneren nicht abstrakte Methoden definieren, und diese Methoden können direkt von Unterklassen verwendet werden; Unterklassen müssen nur erben. Nur Einfachvererbung ist erlaubt, und mehrstufige Vererbung ist erlaubt.(class)）
Die Beziehung zwischen einer Klasse und einem Interface ist die Implementierung: Denn alle Methoden in einem Interface sind abstrakt, sie müssen von einer Unterklasse implementiert werden, bevor sie instanziiert werden kann. Eine Klasse kann eine einzelne Implementierung oder mehrere Implementierungen haben; sie kann auch mehrere Interfaces implementieren, während sie eine Klasse erbt.(class) extends (class) implements (interface1,interface2…)）
Die Beziehung zwischen Interfaces und Interfaces ist Vererbung: Ein Interface kann ein anderes Interface erben und neue Eigenschaften und abstrakte Methoden hinzufügen, und Interfaces können Mehrfachvererbung haben.(interface) extends (interface1,interface2…)）

Unterschiede zwischen abstrakten Klassen und Interfaces：

Mitgliedsvariablen

Eine abstrakte Klasse kann Variablen und Konstanten haben
Ein Interface kann nur Konstanten haben

Member-Methoden

Eine abstrakte Klasse kann nicht-abstrakte Methoden und abstrakte Methoden haben
Ein Interface kann nur abstrakte Methoden haben

Konstruktoren

- Abstrakte Klassen haben Konstruktoren
- Interfaces haben keine Konstruktoren

Beziehung zwischen Klassen, abstrakten Klassen und Interfaces

Die Beziehung zwischen einer Klasse und einer abstrakten Klasse ist Vererbung `extends`
Die Beziehung zwischen einer Klasse und einem Interface ist Implementierung `implements`

Konzeptionelle Merkmale von Interfaces：

Ein Interface istnach außen offengelegteRegeln;
Ein Interface ist diefunktionale Erweiterung；
eines Programms;Die Entstehung von Schnittstellenreduziert die Kopplung; (es implementiert modulare Entwicklung: Regeln werden definiert, jeder implementiert sein eigenes Modul, was die Entwicklungseffizienz stark verbessert)
Schnittstellen können fürmehrfache Implementierung verwendet werden；
Mehrerenicht verwandte Klassen können dieselbe Schnittstelle implementieren;
Eine Klasse kannmehrereSchnittstellen implementieren, die keine direkte Beziehung zueinander haben;
Ähnlich wie bei der Vererbungsbeziehung existiert zwischen einer Schnittstelle und ihrer ImplementierungsklassePolymorphie。

//运动员和教练的案例（下图是思路分析）

/*
    篮球运动员和教练
    乒乓球运动员和教练
    现在篮球运动员和教练要出国访问,需要学习英语
    请根据你所学的知识,分析出来哪些是类,哪些是抽象类,哪些是接口
*/
interface SpeakEnglish {
    public abstract void speak();
}

interface GoAboard{
    public abstract void aboard();
}

abstract class Person {
    private String name;
    private int age;

    public Person(){}

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

    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }

    public void setAge(int age){
        this.age = age;
    }
    public int getAge(){
        return age;
    }

    //吃饭
    public abstract void eat();
    //睡觉
    public void sleep(){
        System.out.println("Zzz...");
    }
}
//运动员
abstract class Player extends Person {
    public abstract void study();
}
//教练
abstract class Coach extends Person {
    public abstract void teach();
}

//篮球运动员
class BasketballPlayer extends Player implements SpeakEnglish,GoAboard{
    public void eat(){
        System.out.println(getAge() + "岁的" + getName() + "吃鸡腿");
    }

    public void study(){
        System.out.println(getAge() + "岁的" + getName() + "学扣篮");
    }

    public void speak(){
        System.out.println(getAge() + "岁的" + getName() + " Say Hello World");
    }

    public void aboard(){
        System.out.println(getAge() + "岁的" + getName() + " Go Aboard");
    }
}
//乒乓运动员
class PingPangPlayer extends Player{
    public void eat(){
        System.out.println(getAge() + "岁的" + getName() + "吃鸡蛋");
    }

    public void study(){
        System.out.println(getAge() + "岁的" + getName() + "学扣球");
    }
}
//篮球教练
class BasketballCoach extends Coach implements SpeakEnglish {
    public void eat(){
        System.out.println(getAge() + "岁的" + getName() + "啃鸡爪");
    }

    public void teach(){
        System.out.println(getAge() + "岁的" + getName() + "教扣篮");
    }

    public void speak(){
        System.out.println(getAge() + "岁的" + getName() + " Say Hello Java");
    }

    public void aboard(){
        System.out.println(getAge() + "岁的" + getName() + " Go Aboard");
    }
}
//乒乓球教练
class PingPangCoach extends Coach{
    public void eat(){
        System.out.println(getAge() + "岁的" + getName() + "吃鸡蛋皮");
    }

    public void teach(){
        System.out.println(getAge() + "岁的" + getName() + "教扣球");
    }
}
class PlayerAndCoach {
    public static void main(String[] args) {
        //篮球运动员
        BasketballPlayer bp = new BasketballPlayer();
        bp.setName("郭艾伦");
        bp.setAge(33);
        bp.eat();
        bp.sleep();
        bp.study();
        bp.speak();
        bp.aboard();
        System.out.println("***********************");
        //篮球教练
        BasketballCoach bc = new BasketballCoach();
        bc.setName("波波维奇");
        bc.setAge(65);
        bc.eat();
        bc.sleep();
        bc.teach();
        bc.speak();
        bc.aboard();
        System.out.println("***********************");
        //多态
        Person p = new BasketballPlayer();
        p.setName("Kobe Bryant");
        p.setAge(33);
        p.eat();
        p.sleep();
        //p.study();
        //p.speak();

        BasketballPlayer bp2 = (BasketballPlayer)p;
        bp2.study();
        bp2.speak();
        bp2.aboard();
        System.out.println("***********************");
    }
}

Innere Klassen

Definiert man eine Klasse innerhalb einer anderen Klasse; die innere Klasse wird als innere Klasse bezeichnet. Die Entstehung innerer Klassen durchbricht erneut die Beschränkung der Einfachvererbung von Java.

Zugriffseigenschaften：

Eine innere Klasse kann direkt auf Mitglieder der äußeren Klasse zugreifen, einschließlich privater Mitglieder.
Damit die äußere Klasse auf Mitglieder der inneren Klasse zugreifen kann, muss sie ein Objekt der inneren Klasse erzeugen.
Klassifizierung und Gemeinsamkeit innerer Klassen：

Gemeinsamkeit：

Eine innere Klasse ist immer noch eine eigenständige Klasse. Nach der Kompilierung wird die innere Klasse in eine eigenständige `.class`-Datei kompiliert, aber ihr wird der Name der äußeren Klasse und das `$`-Symbol vorangestellt.
Auf innere Klassen kann nicht auf die übliche Weise zugegriffen werden. Eine innere Klasse ist ein Mitglied der äußeren Klasse, daher kann sie frei auf die Mitgliedsvariablen der äußeren Klasse zugreifen, unabhängig davon, ob sie privat sind oder nicht.

Member-Innere-Klasse

In der äußeren Klasse gibt es Mitgliedsvariablen und Mitgliedsmethoden; eine Member-Innere-Klasse behandelt eine ganze Klasse als Mitglied der äußeren Klasse.
Eine Member-Innere-Klasse wirdinnerhalb der Klasse, aber außerhalb der Methodender Klasse definiert.
Das Format zum Erstellen eines Objekts ist:`OuterClassName.InnerClassName objectName = outerClassObject.innerClassObject`；
Der Grund, warum eine Member-Innere-Klasse direkt auf Mitglieder der äußeren Klasse zugreifen kann, ist, dass die innere Klasse eine Referenz auf ein Objekt der äußeren Klasse hält:`OuterClassName.this`；
Die Modifizierer, die für Member-Innere-Klassen verwendet werden können, sind `final`, `abstract`, `public`, `private`, `protected`, `static`.

Statische innere Klasse

Eine statische innere Klasse ist eine Member-Innere-Klasse mit dem statischen Modifizierer `static`, definiertinnerhalb der Klasse, aber außerhalb der Methoden.。

Es gibt zwei Szenarien für den Zugriff auf eine statische innere Klasse von der äußeren Klasse aus:

Zugriff auf nicht-statische Mitglieder einer statischen inneren Klasse von der äußeren Klasse aus:`*OuterClassName.InnerClassName objectName = OuterClassName.innerObject*`Sie müssen darauf zugreifen, indem Sie ein Objekt erstellen;
Zugriff auf statische Mitglieder einer statischen inneren Klasse von der äußeren Klasse aus: Sie können auch das obige Format verwenden oder direkt`OuterClassName.InnerClassName.member` verwenden。

Lokale innere Klasse

Eine lokale innere Klasse ist eine Klasse, die innerhalb einer Methode definiert wird.

Eine methodenlokale innere Klasse kann nur instanziiert werdeninnerhalb der Methode, in der sie definiert ist,und kann nicht außerhalb dieser Methode instanziiert werden.
Ein Objekt einer methodenlokalen inneren Klasse kann keine nicht-finalen lokalen Variablen der Methode verwenden, in der sich die innere Klasse befindet.

Die Modifikatoren, die für eine methodenlokale innere Klasse verwendet werden können, sindfinal，abstract；

Eine methodenlokale innere Klasse in einer statischen Methode kann nur aufdie statischen Mitglieder der äußeren Klasse zugreifen。

Anonyme innere Klasse

Eine anonyme innere Klasse ist eine vereinfachte Form einer inneren Klasse; sie erzeugt ein anonymes Unterklassenobjekt mit Inhalt, der eine äußere Klasse erbt oder ein Interface implementiert.
Voraussetzung:
Eine innere Klasse kann eine äußere Klasse oder ein Interface erben oder implementieren.
Format:
`new OuterClassNameOrInterfaceName() { override methods };`
Üblicherweise, wenn ein formaler Parameter einer Methode ein Interface oder eine abstrakte Klasse ist und das Interface nicht mehr als drei Methoden hat, kann eine anonyme innere Klasse als Argument übergeben werden.

Durch verschiedene Modifikatoren geänderter Inhalt (nicht im Zusammenhang mit inneren Klassen)

	Klasse	Mitgliedsvariablen	Member-Methoden	Konstruktoren
private		Y	Y	Y
Standard	Y	Y	Y	Y
protected		Y	Y	Y
public	Y	Y	Y	Y
abstract	Y		Y
static		Y	Y	Y
final	Y	Y	Y

Hinweis: Übliche Regeln sind wie folgt:

In Zukunft sollten alle Klassen mit `public` modifiziert werden. Außerdem sollte in einer Java-Datei nur eine Klasse geschrieben werden.
In Zukunft sollten alle Membervariablen mit `private` modifiziert werden.
In Zukunft sollten alle Membermethoden mit `public` modifiziert werden.
Wenn es eine abstrakte Klasse oder ein Interface ist: `public abstract` + ...
Ab jetzt sollten alle Konstruktoren mit public modifiziert werden.
Wenn die Klasse eine Utility-Klasse oder eine Singleton-Klasse ist: Verwenden Sie private, um den Konstruktor zu modifizieren.

Vier Zugriffsmodifikatoren

	Gleiche Klasse	Gleiches Paket (nicht verwandte Klassen oder Unterklassen)	Anderes Paket (Unterklassen)	Anderes Paket (nicht verwandte Klassen)
private	Y
Standard	Y	Y
protected	Y	Y	Y
public	Y	Y	Y	Y

Empfehlung:

Membervariablen: private
Konstruktor: public
Membermethoden: public

Weitere Tutorials

Für ausführlichere Tutorials siehe:Java-Tutorial

Quelle: http://www.codeceo.com/article/java-extends.html

Java-Vererbung erklärt

Kategorie Programmiertechnologie