Einige Zusammenfassungen interner Java-Klassen

Innere Klasse bezieht sich auf die Definition einer Klasse innerhalb einer externen Klasse. Der Klassenname muss nicht mit dem Ordnernamen übereinstimmen.

Interne Klassen sind unterteilt in: interne Mitgliedsklassen, lokale interne Klassen, statisch verschachtelte Klassen und anonyme interne Klassen.

1. Innere Klasse des Mitglieds

Die innere Klasse des Mitglieds ist die häufigste interne Klasse. Sie wird in der folgenden Form als innerhalb einer anderen Klasse gelegen definiert:

class Outter {
    private int age = 12;
      
    class Inner {
        private int age = 13;
        public void print() {
            int age = 14;
            System.out.println("局部变量：" + age);
            System.out.println("内部类变量：" + this.age);
            System.out.println("外部类变量：" + Outter.this.age);
        }
    }
}
  
public class test1 {
    public static void main(String[] args) {
        Outter out = new Outter();
        Outter.Inner in = out.new Inner();
        in.print();
    }
}

Ergebnis ausführen:

局部变量：14
内部类变量：13
外部类变量：12

Wie aus diesem Beispiel ersichtlich ist: Die innere Klasse des Mitglieds kann als Mitglied der äußeren Klasse direkt alle Mitglieder und Methoden der äußeren Klasse verwenden, auch wenn diese vorhanden sind sind privat von. Obwohl die innere Mitgliedsklasse bedingungslos auf die Mitglieder der äußeren Klasse zugreifen kann, ist die äußere Klasse nicht so frei, auf die Mitglieder der inneren Mitgliedsklasse zuzugreifen. Wenn Sie in einer externen Klasse auf Mitglieder der inneren Klasse eines Mitglieds zugreifen möchten, müssen Sie zunächst ein Objekt der inneren Klasse des Mitglieds erstellen und dann über eine Referenz darauf zugreifen, die auf dieses Objekt verweist:

class Outter {
    private int age = 12;
    public Outter(int age) {
        this.age = age;
        getInInstance().print();   //必须先创建成员内部类的对象，再进行访问!
    }
      
    private Inner getInInstance() {
        return new Inner();
    }
    class Inner {
        public void print() {
            System.out.println("内部类没同名，所以直接调用外部类成员变量：" + age);
        }
    }
}
  
public class test1 {
    public static void main(String[] args) {
        Outter out = new Outter(10);
    }
}

Laufendes Ergebnis:

内部类没同名，所以直接调用外部类成员变量：10

Interne Klassen können private Zugriffsrechte, geschützte Zugriffsrechte, öffentliche Zugriffsrechte und Paketzugriffsrechte haben.

Wenn im obigen Beispiel die interne Mitgliedsklasse Inner mit private geändert wird, kann nur innerhalb der externen Klasse darauf zugegriffen werden. Wenn sie mit public geändert wird, kann darauf zugegriffen werden Wird mit protected geändert, kann nur innerhalb der externen Klasse darauf zugegriffen werden. Wenn es sich um die Standardzugriffsberechtigung handelt, kann darauf nur unter demselben Paket zugegriffen werden.

Dies unterscheidet sich ein wenig von externen Klassen. Externe Klassen können nur mit öffentlichen und Paketzugriffsberechtigungen geändert werden.

Ich persönlich verstehe das so. Da die innere Klasse des Mitglieds wie ein Mitglied der äußeren Klasse aussieht, kann sie wie Mitglieder der Klasse mehrere Berechtigungsänderungen haben. Es ist zu beachten, dass innere Mitgliedsklassen keine statischen Variablen und Methoden enthalten können. Weil eine interne Mitgliedsklasse eine externe Klasse erstellen muss, bevor sie eine eigene erstellen kann

　2. Lokale interne Klasse

Eine lokale interne Klasse ist eine Klasse, die in einer Methode oder einem Bereich definiert ist Der Unterschied zu inneren Mitgliedsklassen besteht darin, dass der Zugriff auf lokale innere Klassen auf Methoden oder innerhalb des Bereichs beschränkt ist.

In der Methode definierte innere Klasse:

class Outter {
  
    private int age = 12;
      
    public void Print(final int x) {    //这里局部变量x必须设置为final类型！
        class Inner {
            public void inPrint() {
                System.out.println(x);
                System.out.println(age);
            }
        }
        new Inner().inPrint();
    }
      
  
}
  
public class test1 {
    public static void main(String[] args) {
        Outter out = new Outter();
        out.Print(10);
    }
}

Laufendes Ergebnis:

10
12

In diesem Beispiel haben wir die innere Klasse in die Methode der äußeren Klasse verschoben. Generieren Sie dann ein inneres Klassenobjekt in der Methode der äußeren Klasse, um die Methode der inneren Klasse aufzurufen. Wenn wir zu diesem Zeitpunkt Parameter an die Methode der externen Klasse übergeben müssen, müssen die Methodenparameter der externen Klasse als endgültig definiert werden.

Mit anderen Worten, die in der Methode definierte innere Klasse kann nur auf den endgültigen Typ lokaler Variablen in der Methode zugreifen. Dies liegt daran, dass die in der Methode definierte lokale Variable einer Konstante und ihrem Lebenszyklus entspricht den Ausführungszyklus der Methode überschreitet, da die lokale Variable auf final gesetzt ist, kann der Wert der lokalen Variablen in der inneren Klasse nicht geändert werden. (Ich habe hier verschiedene Erklärungen im Internet gesehen, aber ich habe es noch nicht vollständig verstanden ==)

Interne Klassen, die im Geltungsbereich definiert sind:

class Outter {
　　private int age = 12;
　　public void Print(final boolean x) {  //这里局部变量x必须设置为final类型！
        if(x){
             class Inner {
                    public void inPrint() {
                        System.out.println(age);
                    }
                }
             new Inner().inPrint();
        }      
    }
}
  
public class test1 {
    public static void main(String[] args) {
        Outter out = new Outter();
        out.Print(true);
    }
}

3 🎜>

class Outter {
    private static int age = 12;
    static class Inner {
        public void print() {
            System.out.println(age);
        }
    }
}
  
public class test1 {
    public static void main(String[] args) {
        Outter.Inner in = new Outter.Inner();
        in.print();
    }
}

scan_bt.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                  
            }
        });
          
        history_bt.setOnClickListener(new OnClickListener() {      
            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                  
            }
        });

这段代码为两个按钮设置监听器，这里面就使用了匿名内部类。具体位置是这段：

new OnClickListener() {  
            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                  
            }
        }

代码中需要给按钮设置监听器对象，使用匿名内部类能够在实现父类或者接口中的方法情况下同时产生一个相应的对象，但是前提是这个父类或者接口必须先存在才能这样使用。当然像下面这种写法也是可以的，跟上面使用匿名内部类达到效果相同：

private void setListener()
{
    scan_bt.setOnClickListener(new Listener1());      
    history_bt.setOnClickListener(new Listener2());
}
  
class Listener1 implements View.OnClickListener{
    @Override
    public void onClick(View v) {
    // TODO Auto-generated method stub
              
    }
}
  
class Listener2 implements View.OnClickListener{
    @Override
    public void onClick(View v) {
    // TODO Auto-generated method stub
              
    }
}

　这种写法虽然能达到一样的效果，但是既冗长又难以维护，所以一般使用匿名内部类的方法来编写事件监听代码。同样的，匿名内部类也是不能有访问修饰符和static修饰符的。

　　匿名内部类是唯一一种没有构造器的类。正因为其没有构造器，所以匿名内部类的使用范围非常有限，大部分匿名内部类用于接口回调。匿名内部类在编译的时候由系统自动起名为Outter$1.class。一般来说，匿名内部类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的实现或是重写。