Java-Verbesserung (7) ----- Detaillierte Erläuterung der internen Klassen

Sie können die Definition einer Klasse in die Definition einer anderen Klasse einfügen. Dies ist eine innere Klasse.

Interne Klassen sind eine sehr nützliche Funktion, aber schwer zu verstehen und zu verwenden (ich habe interne Klassen noch nie verwendet und weiß nur wenig über interne Klassen).

Erstes Treffen

Interne Klassen sind von außen sehr leicht zu verstehen. Sie sind nichts anderes als die Definition einer Klasse innerhalb einer Klasse.

public class OuterClass {  
    private String name ;  
    private int age;  
  
    public String getName() {  
        return name;  
    }  
  
    public void setName(String name) {  
        this.name = name;  
    }  
  
    public int getAge() {  
        return age;  
    }  
  
    public void setAge(int age) {  
        this.age = age;  
    }  
      
    class InnerClass{  
        public InnerClass(){  
            name = "chenssy";  
            age = 23;  
        }  
    }  
}

Hier ist InnerClass die innere Klasse, die ich als Anfänger noch nie verwendet habe (sie scheint nur bei Swing-Registrierungsveranstaltungen verwendet zu werden). Aber wenn sich unsere Programmierkenntnisse verbessern, werden wir seinen Charme erkennen und können ihn nutzen, um unsere Programmstruktur eleganter zu gestalten. Bevor wir innere Klassen verwenden, müssen wir verstehen, warum wir innere Klassen verwenden sollten und welche Vorteile uns innere Klassen bringen können.

1. Warum innere Klassen verwenden

Warum innere Klassen verwenden? In „Think in Java“ gibt es diesen Satz: Der attraktivste Grund für die Verwendung innerer Klassen besteht darin, dass jede innere Klasse unabhängig eine (Schnittstellen-)Implementierung erben kann. Unabhängig davon, ob die äußere Klasse eine (Schnittstellen-)Implementierung geerbt hat, gibt es keine Wirkung auf innere Klassen.

Manchmal gibt es in unserer Programmierung einige Probleme, die mithilfe von Schnittstellen schwer zu lösen sind. Zu diesem Zeitpunkt können wir die von internen Klassen bereitgestellte Fähigkeit nutzen, mehrere konkrete oder abstrakte Klassen zu erben, um diese Programmprobleme zu lösen . Man kann sagen, dass Schnittstellen nur einen Teil des Problems lösen und innere Klassen die Lösung der Mehrfachvererbung vollständiger machen.

public interface Father {  
  
}  
  
public interface Mother {  
  
}  
  
public class Son implements Father, Mother {  
  
}  
  
public class Daughter implements Father{  
  
    class Mother_ implements Mother{  
          
    }  
}

Tatsächlich können wir die Vorteile der Verwendung interner Klassen für dieses Beispiel nicht wirklich erkennen, aber was wäre, wenn Vater und Mutter keine Schnittstellen, sondern abstrakte Klassen oder konkrete Klassen wären? Derzeit können wir nur innere Klassen verwenden, um eine Mehrfachvererbung zu erreichen.

Tatsächlich besteht der größte Vorteil der Verwendung innerer Klassen darin, dass sie das Problem der Mehrfachvererbung sehr gut lösen kann. Wenn wir das Problem der Mehrfachvererbung jedoch nicht lösen müssen, können wir natürlich auch andere Codierung verwenden Methoden, verwenden aber innere Klassen. Es kann uns auch die folgenden Funktionen bringen (Auszug aus „Think in Java“):

1. Interne Klassen können mehrere Instanzen verwenden. Jede Instanz hat ihre eigenen Statusinformationen und ist damit verknüpft die Informationen anderer peripherer Objekte unabhängig voneinander.

2. In einer einzelnen Peripherieklasse können mehrere interne Klassen dieselbe Schnittstelle auf unterschiedliche Weise implementieren oder dieselbe Klasse erben.

3. Der Zeitpunkt, zu dem das innere Klassenobjekt erstellt wird, hängt nicht von der Erstellung des äußeren Klassenobjekts ab.

4. Es gibt keine verwirrende „ist-ein“-Beziehung zwischen inneren Klassen. Es handelt sich um eine unabhängige Einheit.

5. Die innere Klasse bietet eine bessere Kapselung. Mit Ausnahme der peripheren Klasse können andere Klassen nicht darauf zugreifen.

2. Grundlagen interner Klassen

In diesem Abschnitt stellen wir hauptsächlich vor, wie innere Klassen die Eigenschaften und Methoden externer Klassen nutzen, sowie die Verwendung von .this und .new.

Wenn wir eine innere Klasse erstellen, hat sie eine unsichtbare Verbindung mit der äußeren Klasse. Basierend auf dieser Verbindung kann sie unbegrenzten Zugriff auf die Elemente der äußeren Klasse haben.

public class OuterClass {  
    private String name ;  
    private int age;  
  
    /**省略getter和setter方法**/  
      
    public class InnerClass{  
        public InnerClass(){  
            name = "chenssy";  
            age = 23;  
        }  
          
        public void display(){  
            System.out.println("name：" + getName() +"   ;age：" + getAge());  
        }  
    }  
      
    public static void main(String[] args) {  
        OuterClass outerClass = new OuterClass();  
        OuterClass.InnerClass innerClass = outerClass.new InnerClass();  
        innerClass.display();  
    }  
}  
--------------  
Output：  
name：chenssy   ;age：23

In dieser Anwendung können wir sehen, dass die innere InnerClass nahtlos auf die Eigenschaften der äußeren Klasse OuterClass zugreifen kann, obwohl diese privat geändert wird. Dies liegt daran, dass, wenn wir ein inneres Klassenobjekt einer äußeren Klasse erstellen, das innere Klassenobjekt definitiv einen Verweis auf dieses äußere Klassenobjekt erfasst. Solange wir auf Mitglieder der äußeren Klasse zugreifen, verwenden wir diese Referenz die umschließende Klasse.

Tatsächlich haben wir in dieser Anwendung auch gesehen, wie man auf innere Klassen verweist: Um auf innere Klassen zu verweisen, müssen wir den Typ dieses Objekts angeben: OuterClasName.InnerClassName. Wenn wir gleichzeitig ein inneres Klassenobjekt erstellen müssen, müssen wir das Objekt der äußeren Klasse verwenden, um die innere Klasse über .new zu erstellen: OuterClass.InnerClass innerClass = OuterClass.new InnerClass();.

Wenn wir gleichzeitig einen Verweis auf ein externes Klassenobjekt generieren müssen, können wir OuterClassName.this verwenden, damit ein Verweis auf die externe Klasse korrekt generiert werden kann. Dies ist natürlich zur Kompilierungszeit bekannt und es fallen keine Laufzeitkosten an.

public class OuterClass {  
    public void display(){  
        System.out.println("OuterClass...");  
    }  
      
    public class InnerClass{  
        public OuterClass getOuterClass(){  
            return OuterClass.this;  
        }  
    }  
      
    public static void main(String[] args) {  
        OuterClass outerClass = new OuterClass();  
        OuterClass.InnerClass innerClass = outerClass.new InnerClass();  
        innerClass.getOuterClass().display();  
    }  
}  
-------------  
Output:  
OuterClass...

 到这里了我们需要明确一点，内部类是个编译时的概念，一旦编译成功后，它就与外围类属于两个完全不同的类（当然他们之间还是有联系的）。对于一个名为OuterClass的外围类和一个名为InnerClass的内部类，在编译成功后，会出现这样两个class文件：OuterClass.class和OuterClass$InnerClass.class。

       在Java中内部类主要分为成员内部类、局部内部类、匿名内部类、静态内部类。

       三、成员内部类

       成员内部类也是最普通的内部类，它是外围类的一个成员，所以他是可以无限制的访问外围类的所有 成员属性和方法，尽管是private的，但是外围类要访问内部类的成员属性和方法则需要通过内部类实例来访问。

       在成员内部类中要注意两点，第一：成员内部类中不能存在任何static的变量和方法；第二：成员内部类是依附于外围类的，所以只有先创建了外围类才能够创建内部类。

public class OuterClass {  
    private String str;  
      
    public void outerDisplay(){  
        System.out.println("outerClass...");  
    }  
      
    public class InnerClass{  
        public void innerDisplay(){  
            //使用外围内的属性  
            str = "chenssy...";  
            System.out.println(str);  
            //使用外围内的方法  
            outerDisplay();  
        }  
    }  
      
    /*推荐使用getxxx()来获取成员内部类，尤其是该内部类的构造函数无参数时 */  
    public InnerClass getInnerClass(){  
        return new InnerClass();  
    }  
      
    public static void main(String[] args) {  
        OuterClass outer = new OuterClass();  
        OuterClass.InnerClass inner = outer.getInnerClass();  
        inner.innerDisplay();  
    }  
}  
--------------------  
chenssy...  
outerClass...

推荐使用getxxx()来获取成员内部类，尤其是该内部类的构造函数无参数时 。

       四、局部内部类

       有这样一种内部类，它是嵌套在方法和作用于内的，对于这个类的使用主要是应用与解决比较复杂的问题，想创建一个类来辅助我们的解决方案，到那时又不希望这个类是公共可用的，所以就产生了局部内部类，局部内部类和成员内部类一样被编译，只是它的作用域发生了改变，它只能在该方法和属性中被使用，出了该方法和属性就会失效。

       对于局部内部类实在是想不出什么好例子，所以就引用《Think in java》中的经典例子了。

       定义在方法里：

public class Parcel5 {  
    public Destionation destionation(String str){  
        class PDestionation implements Destionation{  
            private String label;  
            private PDestionation(String whereTo){  
                label = whereTo;  
            }  
            public String readLabel(){  
                return label;  
            }  
        }  
        return new PDestionation(str);  
    }  
      
    public static void main(String[] args) {  
        Parcel5 parcel5 = new Parcel5();  
        Destionation d = parcel5.destionation("chenssy");  
    }  
}

       定义在作用域内:

public class Parcel6 {  
    private void internalTracking(boolean b){  
        if(b){  
            class TrackingSlip{  
                private String id;  
                TrackingSlip(String s) {  
                    id = s;  
                }  
                String getSlip(){  
                    return id;  
                }  
            }  
            TrackingSlip ts = new TrackingSlip("chenssy");  
            String string = ts.getSlip();  
        }  
    }  
      
    public void track(){  
        internalTracking(true);  
    }  
      
    public static void main(String[] args) {  
        Parcel6 parcel6 = new Parcel6();  
        parcel6.track();  
    }  
}

 五、匿名内部类

       在做Swing编程中，我们经常使用这种方式来绑定事件

button2.addActionListener(    
                new ActionListener(){    
                    public void actionPerformed(ActionEvent e) {    
                        System.out.println("你按了按钮二");    
                    }    
                });

        我们咋一看可能觉得非常奇怪，因为这个内部类是没有名字的，在看如下这个例子：

public class OuterClass {  
    public InnerClass getInnerClass(final int num,String str2){  
        return new InnerClass(){  
            int number = num + 3;  
            public int getNumber(){  
                return number;  
            }  
        };        /* 注意：分号不能省 */  
    }  
      
    public static void main(String[] args) {  
        OuterClass out = new OuterClass();  
        InnerClass inner = out.getInnerClass(2, "chenssy");  
        System.out.println(inner.getNumber());  
    }  
}  
  
interface InnerClass {  
    int getNumber();  
}  
  
----------------  
Output:  
5

这里我们就需要看清几个地方

      1、 匿名内部类是没有访问修饰符的。

      2、 new 匿名内部类，这个类首先是要存在的。如果我们将那个InnerClass接口注释掉，就会出现编译出错。

      3、 注意getInnerClass()方法的形参，第一个形参是用final修饰的，而第二个却没有。同时我们也发现第二个形参在匿名内部类中没有使用过，所以当所在方法的形参需要被匿名内部类使用，那么这个形参就必须为final。

      4、 匿名内部类是没有构造方法的。因为它连名字都没有何来构造方法。

PS：由于篇幅有限，对匿名内部类就介绍到这里，有关更多关于匿名内部类的知识，我就会在下篇博客（java提高篇-----详解匿名内部类）做详细的介绍，包括为何形参要定义成final，怎么对匿名内部类进行初始化等等，敬请期待……

       六、静态内部类

       在java提高篇-----关键字static中提到Static可以修饰成员变量、方法、代码块，其他它还可以修饰内部类，使用static修饰的内部类我们称之为静态内部类，不过我们更喜欢称之为嵌套内部类。静态内部类与非静态内部类之间存在一个最大的区别，我们知道非静态内部类在编译完成之后会隐含地保存着一个引用，该引用是指向创建它的外围内，但是静态内部类却没有。没有这个引用就意味着：

      1、 它的创建是不需要依赖于外围类的。

      2、 它不能使用任何外围类的非static成员变量和方法。

public class OuterClass {  
    private String sex;  
    public static String name = "chenssy";  
      
    /** 
     *静态内部类 
     */  
    static class InnerClass1{  
        /* 在静态内部类中可以存在静态成员 */  
        public static String _name1 = "chenssy_static";  
          
        public void display(){  
            /*  
             * 静态内部类只能访问外围类的静态成员变量和方法 
             * 不能访问外围类的非静态成员变量和方法 
             */  
            System.out.println("OutClass name :" + name);  
        }  
    }  
      
    /** 
     * 非静态内部类 
     */  
    class InnerClass2{  
        /* 非静态内部类中不能存在静态成员 */  
        public String _name2 = "chenssy_inner";  
        /* 非静态内部类中可以调用外围类的任何成员,不管是静态的还是非静态的 */  
        public void display(){  
            System.out.println("OuterClass name：" + name);  
        }  
    }  
      
    /** 
     * @desc 外围类方法 
     * @author chenssy 
     * @data 2013-10-25 
     * @return void 
     */  
    public void display(){  
        /* 外围类访问静态内部类：内部类. */  
        System.out.println(InnerClass1._name1);  
        /* 静态内部类 可以直接创建实例不需要依赖于外围类 */  
        new InnerClass1().display();  
          
        /* 非静态内部的创建需要依赖于外围类 */  
        OuterClass.InnerClass2 inner2 = new OuterClass().new InnerClass2();  
        /* 方位非静态内部类的成员需要使用非静态内部类的实例 */  
        System.out.println(inner2._name2);  
        inner2.display();  
    }  
      
    public static void main(String[] args) {  
        OuterClass outer = new OuterClass();  
        outer.display();  
    }  
}  
----------------  
Output:  
chenssy_static  
OutClass name :chenssy  
chenssy_inner  
OuterClass name：chenssy

上面这个例子充分展现了静态内部类和非静态内部类的区别。

Die Einführung in interne Kurse ist im Grunde hier vorbei! Tatsächlich sind meine Kenntnisse über interne Klassen nur oberflächlich. Ich bin fast ein Anfänger mit begrenzten Kenntnissen! Ich werde diese paar Tage nutzen, um interne Klassen zu studieren! die chinesische PHP-Website (www.php.cn)!