Verwendung innerer Klassen und anonymer innerer Klassen

1. Innere Klassen:

(1) Methoden mit demselben Namen wie die innere Klasse

Innere Klassen können Methoden der äußeren Klasse aufrufen Derselbe Name, „OuterClass.this“, muss verwendet werden. Formataufruf „.MethodName()“ (wobei OuterClass und MethodName durch den tatsächlichen Namen der externen Klasse und ihre Methode ersetzt werden; dies ist das Schlüsselwort, das einen Verweis auf die externe Klasse angibt); Wenn die interne Klasse keine Methode mit demselben Namen hat, kann die Methode der externen Klasse direkt aufgerufen werden.
Aber periphere Klassen können private Methoden innerer Klassen nicht direkt aufrufen, und externe Klassen können private Methoden anderer Klassen nicht direkt aufrufen. Hinweis: Die Berechtigung der inneren Klasse, die äußere Klasse direkt zu verwenden, hat nichts damit zu tun, ob die Methode statisch ist. Sie hängt davon ab, ob die innere Klasse eine Methode mit demselben Namen hat.

package innerclass;
public class OuterClass {
    private void outerMethod() {
        System.out.println("It's Method of OuterClass");
    }
    public static void main(String[] args) {
        OuterClass t = new OuterClass();
        OuterClass.Innerclass in = t.new Innerclass();
        in.innerMethod();
    }
 
    class Innerclass {
        public void innerMethod() {
           OuterClass.this.outerMethod();// 内部类成员方法与外部类成员方法同名时，使用this调用外部类的方法
           outerMethod();// 内部类没有同名方法时执行外部类的方法
        }
        private void outerMethod() {
            System.out.println("It's Method of Innerclass");
        }
    }
}

Das Ausgabeergebnis ist:

It's Method of OuterClass
It's Method of Innerclass

(2) Instanziierung interner Klassen

Die Instanziierung interner Klassen unterscheidet sich von gewöhnlichen Klassen Wird überall verwendet. Bei Bedarf instanziieren. Die innere Klasse muss nach der Instanziierung der äußeren Klasse instanziiert werden und eine Beziehung zur äußeren Klasse herstellen.

Daher ist in der nicht statischen Methode die äußere Klasse die innere Klasse kann instanziiert werden Objekt

private void outerMethod() {
    System.out.println("It's Method of OuterClass");
    Innerclass in = new Innerclass();//在外部类的outerMethod方法中实例化内部类是可以啊
}

Aber bei der statischen Methode sollten Sie aufpassen! ! ! ! Sie können die innere Klasse nicht direkt in der statischen Methode neu erstellen, da sonst ein Fehler auftritt:

Keine umschließende Instanz vom Typ OuterClass ist zugänglich. Die Zuordnung muss mit einer umschließenden Instanz vom Typ OuterClass qualifiziert werden (z. B. x.new A() where Egal wie Sie es verwenden, Sie können nichts aufrufen, was nicht existiert.

Wenn Sie eine neue innere Klasse in der statischen Methode erstellen möchten, können Sie die innere Klasse als statisch deklarieren

Natürlich wird die statische Methode im Allgemeinen nicht verwendet, aber dies ist der Fall Methode wird empfohlen: x.new A() , wobei x eine Instanz der äußeren Klasse OuterClass ist, A die innere Klasse Innerclass

public class OuterClass {
    private void outerMethod() {
        System.out.println("It's Method of OuterClass");
    }
 
    public static void main(String[] args) {
        Innerclass in = new Innerclass();
        in.innerMethod();
    }
 
    static class Innerclass {//把内部类声明为static
        public void innerMethod() {
            System.out.println("It's Method of innerMethod");
 
        }
    }
 
}

x.new A() , wobei x eine Instanz von ist Die äußere Klasse OuterClass, A ist die Klasse class Innerclass, kann natürlich wie folgt aufgeteilt werden, daher ist es offensichtlich klar:

package innerclass;
public class OuterClass {
    private void outerMethod() {
        System.out.println("It's Method of OuterClass");
    }
    public static void main(String[] args) {
        OuterClass.Innerclass in = new OuterClass().new Innerclass();//使用x.new A()的方式
        in.innerMethod();
    }
    class Innerclass {
        public void innerMethod() {
            System.out.println("It's Method of innerMethod");
        }
    }
}

(3) Wann interne Klassen verwendet werden sollen

public static void main(String[] args) {
    OuterClass out = new OuterClass();//外部实例
    OuterClass.Innerclass in = out.new Innerclass();//外部实例.new 外部类
    in.innerMethod();
}

Eine typische Situation ist, dass eine interne Klasse von einer bestimmten Klasse erbt oder eine bestimmte Klasse implementiert. Bei einer Schnittstelle arbeitet der Code der inneren Klasse mit dem Objekt der äußeren Klasse, die es erstellt. Man kann sich innere Klassen also als eine Art Fenster zu ihren äußeren Klassen vorstellen.

Der attraktivste Grund für die Verwendung innerer Klassen besteht darin, dass jede innere Klasse unabhängig von einer Implementierung (einer Schnittstelle) erben kann. Daher hat die Frage, ob die äußere Klasse eine Implementierung einer (Schnittstelle)
geerbt hat, keinen Einfluss darauf innere Klassen. Ohne die Fähigkeit innerer Klassen, von mehreren konkreten oder abstrakten Klassen zu erben, wären einige Design- und Programmierprobleme schwer zu lösen. Aus dieser Perspektive vervollständigen innere Klassen die Mehrfachvererbungslösung. Schnittstellen lösen einen Teil des Problems, während innere Klassen die „Mehrfachvererbung“ effektiv implementieren.

(4) Beispiel für die Instanziierung einer inneren Klasse in einer statischen Methode: (Die innere Klasse wird in einer statischen Methode platziert)

per.speak() ist aufrufbar und per .say( ) kann zu diesem Zeitpunkt nicht aufgerufen werden, da per ein Person-Objekt ist. Wenn Sie die Methode der Unterklasse aufrufen möchten, können Sie den Downcast erzwingen: ((Boy) per).say(); ändere es in Boy per = new Boy(); Es kann festgestellt werden, dass Sie, wenn Sie eine benutzerdefinierte Methode einer inneren Klasse aufrufen möchten, diese über das Objekt der inneren Klasse aufrufen müssen. Wenn also die anonyme innere Klasse nicht einmal einen Namen hat, wie ruft man dann die benutzerdefinierte Methode der inneren Klasse auf?

package javatest2;
public class JavaTest2 {
    public static void main(String[] args) {
        class Boy implements Person {
            public void say() {// 匿名内部类自定义的方法say
                System.out.println("say方法调用");
            }
            @Override
            public void speak() {// 实现接口的的方法speak
                System.out.println("speak方法调用");
            }
        }
        Person per = new Boy();
        per.speak();// 可调用
        per.say();// 不能调用
    }
}
interface Person {
    public void speak();
}

(2) Anonyme innere Klassen

Anonyme innere Klassen sind auch innere Klassen ohne Namen, daher können anonyme innere Klassen nur einmal verwendet werden Normalerweise wird es verwendet, um das Schreiben von Code zu vereinfachen. Für die Verwendung anonymer innerer Klassen gibt es jedoch eine Voraussetzung: Sie müssen eine übergeordnete Klasse erben oder eine Schnittstelle implementieren, Sie können jedoch höchstens eine übergeordnete Klasse erben oder eine Schnittstelle implementieren.

Es gibt zwei weitere Regeln für anonyme innere Klassen:

1) Anonyme innere Klassen können keine abstrakten Klassen sein, denn wenn das System eine anonyme innere Klasse erstellt, erstellt es sofort ein Objekt der inneren Klasse. Daher dürfen anonyme innere Klassen nicht als abstrakte Klassen definiert werden.

2) Anonyme innere Klassen definieren nicht unbedingt Konstruktoren (Konstruktoren). Da anonyme innere Klassen keinen Klassennamen haben, können sie keinen Konstruktor definieren, aber anonyme innere Klassen können Instanzinitialisierungsblöcke definieren Wie beurteilt man? Gibt es eine anonyme Klasse? Ich kann den Namen nicht sehen, es fühlt sich an, als wäre es nur ein Objekt, das von new aus der übergeordneten Klasse erstellt wurde, und es gibt keinen Namen für die anonyme Klasse.

Schauen wir uns zuerst den Pseudocode an


Im Allgemeinen sollte bei einem neuen Objekt nach den Klammern ein Semikolon stehen, d. h. die Anweisung, dass das Objekt neu ist, endet. Anders verhält es sich jedoch, wenn anonyme innere Klassen vorhanden sind. Den Klammern folgen geschweifte Klammern, und die geschweiften Klammern enthalten die spezifische Implementierungsmethode des neuen Objekts. Weil wir wissen, dass eine abstrakte Klasse nicht direkt neu sein kann. Es muss eine Implementierungsklasse geben, bevor wir ihre Implementierungsklasse neu erstellen können. Der obige Pseudocode zeigt an, dass new die Implementierungsklasse von Father ist und diese Implementierungsklasse eine anonyme innere Klasse ist.

Tatsächlich kann die obige anonyme innere Klasse wie folgt aufgeteilt werden:

Schauen wir uns zunächst ein Beispiel an, um die Verwendung anonymer innerer Klassen zu erleben:

abstract class Father(){
....
}
public class Test{
   Father f1 = new Father(){ .... }  //这里就是有个匿名内部类
}

运行结果：eat something
可以看到，我们直接将抽象类Person中的方法在大括号中实现了，这样便可以省略一个类的书写。并且，匿名内部类还能用于接口上

public class JavaTest2 {
    public static void main(String[] args) {
        Person per = new Person() {
            public void say() {// 匿名内部类自定义的方法say
                System.out.println("say方法调用");
            }
            @Override
            public void speak() {// 实现接口的的方法speak
                System.out.println("speak方法调用");
            }
        };
        per.speak();// 可调用
        per.say();// 出错，不能调用
    }
}
 
interface Person {
    public void speak();
}

这里per.speak()是可以正常调用的，但per.say()不能调用，为什么呢？注意Person per = new Person()创建的是Person的对象，而非匿名内部类的对象。其实匿名内部类连名字都没有，你咋实例对象去调用它的方法呢？但继承父类的方法和实现的方法是可以正常调用的，本例子中，匿名内部类实现了接口Person的speak方法，因此可以借助Person的对象去调用。

若你确实想调用匿名内部类的自定义的方法say()，当然也有方法：

（1）类似于speak方法的使用，先在Person接口中声明say()方法，再在匿名内部类中覆写此方法。

（2）其实匿名内部类中隐含一个匿名对象，通过该方法可以直接调用say()和speak()方法；代码修改如下：

public class JavaTest2 {
    public static void main(String[] args) {
        new Person() {
            public void say() {// 匿名内部类自定义的方法say
                System.out.println("say方法调用");
            }
 
            @Override
            public void speak() {// 实现接口的的方法speak
                System.out.println("speak方法调用");
            }
        }.say();// 直接调用匿名内部类的方法
    }
}
interface Person {
    public void speak();
}

更多内部类和匿名内部类的用法相关文章请关注PHP中文网！