Anonyme innere Klassen im Detail

Anonyme innere Klassen eignen sich zum Erstellen von Klassen, die nur einmal verwendet werden müssen, z. B. das im Befehlsmodus erforderliche Command-Objekt. Die Syntax anonymer innerer Klassen ist etwas seltsam. Wenn eine anonyme innere Klasse erstellt wird, wird sofort eine Instanz der Klasse erstellt und die anonyme innere Klasse kann nicht wiederverwendet werden.
Das Format zum Definieren anonymer innerer Klassen lautet wie folgt:

new 父类构造器（参数列表）|实现接口（）  
{  
 //匿名内部类的类体部分  
}

Wie aus der obigen Definition ersichtlich ist, müssen anonyme innere Klassen eine übergeordnete Klasse erben oder eine Schnittstelle implementieren, sie können jedoch nur erben höchstens eine übergeordnete Klasse. Oder eine Schnittstelle implementieren.
Es gibt zwei 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 keine Konstruktoren, aber anonyme innere Klassen können Instanzinitialisierungsblöcke definieren.
Erfüllen Sie die Konstruktoranforderungen durch Instanzinitialisierungsblöcke Erledigt.
Die häufigste Methode zum Erstellen einer anonymen inneren Klasse besteht darin, ein Objekt eines Schnittstellentyps zu erstellen, wie im folgenden Programm gezeigt:

interface Product{  
   public double getPrice();  
   public String getName();  
}  
public class TestAnonymous{  
   public void test(Product p){  
   System.out.println("购买了一个"+p.getName()+"，花掉       了"+p.getPrice());  
  }  
 public static void main(String[]args){  
    TestAnonymous ta = new TestAnonymous();  
    ta.test(new Product(){  
    public double getPrice(){  
       return 567;  
    }  
   public String getName(){  
      return "AGP显卡";  
   }  
  });  
 }  
}

Die TestAnonymous-Klasse im obigen Programm definiert eine Testmethode , das ein Produktobjekt als Parameter benötigt, aber Produkt ist nur eine Schnittstelle,
kann kein Objekt direkt erstellen. Erwägen Sie daher, ein Objekt der Produktschnittstellen-Implementierungsklasse zu erstellen und es an diese Methode zu übergeben --- wenn dieses Produkt Die Schnittstellenimplementierungsklasse muss wiederholt werden
Zur Verwendung sollten Sie eine unabhängige Klasse über die Implementierungsklasse definieren. Wenn die Produktschnittstellenimplementierungsklasse nur einmal verwendet werden muss, können Sie die Methode im obigen Programm verwenden, um <🎜 zu definieren > eine anonyme innere Klasse.
Wie Sie im obigen Programm sehen können, ist das Schlüsselwort class nicht erforderlich, um eine anonyme Klasse zu definieren. Stattdessen wird beim Definieren einer anonymen inneren Klasse das Objekt der anonymen inneren Klasse direkt generiert. Der oben fett gedruckte Codeteil
ist der Klassenkörperteil der anonymen Klasse.
Da anonyme innere Klassen keine abstrakten Klassen sein können, müssen anonyme innere Klassen alle abstrakten Methoden implementieren, die in ihrer abstrakten übergeordneten Klasse oder Schnittstelle enthalten sind.
Der obige Code zum Erstellen von Produktimplementierungsklassenobjekten kann in den folgenden Code aufgeteilt werden:

class AnonymousProduct implements Product{  
  public double getPrice(){  
   return 567;  
    }  
  public String getName(){  
   return "AGP显卡";  
    }  
 }  
 ta.test(new AnonymousProduct());

Wenn eine anonyme innere Klasse durch Implementierung der Schnittstelle erstellt wird, kann die anonyme innere Klasse den Erstellungskonstruktor nicht anzeigen . Daher verfügen anonyme innere Klassen nur über einen impliziten parameterlosen Konstruktor

, sodass Parameterwerte nicht in Klammern nach dem neuen Schnittstellennamen übergeben werden können.
Wenn Sie jedoch eine anonyme innere Klasse erstellen, indem Sie die übergeordnete Klasse erben, verfügt die anonyme innere Klasse über einen ähnlichen Konstruktor wie die übergeordnete Klasse. Die Ähnlichkeit bezieht sich hier auf die gleiche Liste formaler Parameter
.

abstract class Device{  
  private String name;  
  public Device(){  
  }  
  public Device(String name){  
   this.name = name;  
  }  
  public abstract double getPrice();  
  //此处省略了name属性的setter和getter方法  
 }  
 public class AnonymousInner{  
  public void test(Device d){  
   System.out.println("购买了一个"+d.getName()+"，花掉了"+d.getPrice());  
  }  
  public static void main(String[] args){  
   AnonymousInner ai = new AnonymousInner();  
   //调用有参数的构造器创建Device匿名实现类的对象  
   ai.test(new Device("电子示波器"){  
    public double getPrice(){  
     return 67;  
    }  
   });  
   //调用无参数的构造器创建Device匿名实现类的对象  
   Device d = new Device(){  
    //初始化块  
    {  
     System.out.println("匿名内部类的初始化块...");  
    }  
    //实现抽象方法  
    public double getPrice(){  
     return 56;  
    }  
    public Sting getName(){  
     return "键盘";  
    }  
   }；  
   ai.test(d);  
  }  
 }

Das obige Programm erstellt eine abstrakte übergeordnete Klasse Device. Diese abstrakte übergeordnete Klasse enthält zwei Konstruktoren: einen ohne Parameter und einen mit Parametern. Wenn Sie eine anonyme innere Klasse mit Device

als übergeordneter Klasse erstellen, können Sie Parameter übergeben (z. B. den fett gedruckten Teil im ersten Absatz des obigen Programms) oder keine Parameter übergeben (z. B. den zweiten fett gedruckten Teil). Teil im obigen Programm).
Beim Erstellen einer anonymen inneren Klasse müssen Sie alle abstrakten Methoden in der Schnittstelle oder der abstrakten übergeordneten Klasse implementieren. Bei Bedarf können Sie auch die gewöhnlichen Methoden in der übergeordneten Klasse überschreiben. Im zweiten fett gedruckten Codeteil des
-Programms oben überschreibt die anonyme innere Klasse beispielsweise die getName-Methode der abstrakten übergeordneten Klasse Device-Klasse Die getName-Methode ist keine abstrakte Methode.
Wenn die anonyme innere Klasse auf die lokalen Variablen der äußeren Klasse zugreifen muss, muss sie den endgültigen Modifikator verwenden, um die lokalen Variablen der äußeren Klasse zu ändern.
Andernfalls meldet das System einen Fehler.

Der fettgedruckte Subcode im obigen Programm bedeutet, dass die anonyme innere Klasse auf die lokalen Variablen der externen Klasse zugreift. Da die Altersvariable nicht mit dem letzten Modifikator geändert wird, wird der fettgedruckte Code

interface A{  
  void test();  
 }  
 public class TestA{  
  public static void main(Strign[] args){  
   int age = 0;  
   A a = new A(){  
    public void test(){  
     //下面语句将提示错误：匿名内部类内访问局部变量必须使用final修饰  
     System.out.println(age);  
    }   
   };  
  }  
 }

verursacht eine Kompilierungsausnahme.

Weitere Artikel zu anonymen internen Klassen finden Sie auf der chinesischen PHP-Website!