Beispielanalyse einer Java-internen Klasse

1. Konzept und Klassifizierung interner Klassen

Definieren Sie eine Klasse innerhalb einer anderen Klasse oder innerhalb einer Schnittstelle oder Methode Innerhalb der Körper, diese Klasse wird als innere Klasse bezeichnet. Zusätzlich zu den in Klassen, Schnittstellen und Methoden definierten inneren Klassen gibt es auch eine spezielle innere Klasse. welches den Schlüssel verwendet Das Wort new erstellt ein Objekt einer anonymen Klasse, und diese anonyme Klasse ist tatsächlich eine innere Klasse, insbesondere eine anonyme innere Klasse, die häufig zum Erstellen von Objekten durch Übergabe von Konstruktorargumenten verwendet wird, z. B. bei der Erstellung von PriorityQueue Objekte.

Wenn eine Klasse innerhalb einer anderen Klasse oder innerhalb einer Schnittstelle definiert ist und keine statische Änderung vorliegt, wird die interne Klasse als Instanz-interne Klasse bezeichnet. Wenn statische Änderung verwendet wird, wird die interne Klasse als a bezeichnet statische interne Klasse. Klasse (verschachtelte Klasse) definiert eine Klasse innerhalb eines Codeblocks, insbesondere innerhalb eines Methodenkörpers. Diese interne Klasse wird als lokale interne Klasse oder lokale interne Klasse bezeichnet.

2. Innere Instanzklasse

2.1 Erstellung der inneren Instanzklasse

Die Definition der inneren Instanzklasse ist sehr einfach, definieren Sie sie einfach direkt in Die äußere Klasse. Geh einfach hinein. Die Frage ist, wie man ein inneres Klassenobjekt erstellt. Zunächst müssen Sie verstehen, dass die Mitgliedsvariablen und -methoden in der inneren Klasse und der äußeren Klasse gleichwertig sind. Sie gehören alle zum äußeren Klassenobjekt (ohne Statik). Wenn Sie also ein inneres Klassenobjekt möchten, müssen Sie zuerst ein peripheres Klassenobjekt haben. Die erste Möglichkeit, ein inneres Klassenobjekt zu erstellen, besteht darin, eine Methode zu verwenden, um ein inneres Klassenobjekt zurückzugeben, und der Typ dieses inneren Klassenobjekts ist OutClassName.InnerClassName, also äußerer Klassenname.innerer Klassenname.

public class Outer {

    class Inner1 {
        private String str;
        public Inner1(String s) {
            this.str = s;
        }
        public String readStr() {
            return this.str;
        }
    }

    class Inner2 {
        private int val;
        public Inner2(int i) {
            this.val = i;
        }
        public int readVal() {
            return this.val;
        }
    }
    //创建内部类
    public Inner1 creatInner1(String s) {
        return new Inner1(s);
    }
    public Inner2 creatInner2(int i) {
        return new Inner2(i);
    }

    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner1 inner1 =  outer.creatInner1("Inner1");
        Outer.Inner2 inner2 = outer.creatInner2(2);

        System.out.println(inner1.readStr());
        System.out.println(inner2.readVal());
    }
}

//output:
Inner1
2

Process finished with exit code 0

2.2 Verwenden Sie .this und .new

Natürlich gibt es auch andere Möglichkeiten, eine innere Klasse zu erstellen, nämlich das Objekt der äußeren Klasse .new zu verwenden Erstellen Sie ein inneres Klassenobjekt. Die Syntax lautet:

Externes Klassenobjekt. Neue interne Klassenkonstruktionsmethode;

public class Outer {

    class Inner1 {
        private String str;
        public Inner1(String s) {
            this.str = s;
        }
        public String readStr() {
            return this.str;
        }
    }

    class Inner2 {
        private int val;
        public Inner2(int i) {
            this.val = i;
        }
        public int readVal() {
            return this.val;
        }
    }


    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner1 inner1 =  outer.new Inner1("Inner1");
        Outer.Inner2 inner2 = outer.new Inner2(2);

        System.out.println(inner1.readStr());
        System.out.println(inner2.readVal());
    }
}

//output:
Inner1
2

Process finished with exit code 0

Die Eigenschaften interner Klassen Nicht nur das, interne Klassen können auch mit einer äußeren Klasse verknüpft werden. Die Erstellung des Instanz-Innenklassenobjekts basiert zunächst auf der Referenz des Außenklassenobjekts. Die Mitgliedsvariablen der Instanz-Innenklasse und der Außenklasse denselben Status haben, wenn Sie über das Objekt der inneren Klasse (insbesondere Variablen mit demselben Namen) auf die Mitgliedsvariablen und -methoden der äußeren Klasse zugreifen möchten. In der inneren Klasse können Sie den Namen der äußeren Klasse verwenden.this, um das Objekt der äußeren Klasse abzurufen, und dann das erhaltene Objekt der äußeren Klasse verwenden, um die Variablen und Methoden der äußeren Klasse zu verwenden.

public class Outer {
    private String outStr;
    public Outer(String str) {
        this.outStr = str;
    }

    public void printOuter() {
        System.out.println(this.outStr);
    }

    class Inner {
        private String str;
        public Inner(String s) {
            this.str = s;
        }
        public String readStr() {
            return this.str;
        }
        //使用.this获取父类对象引用
        public Outer outer() {
            return Outer.this;
        }
    }



    public static void main(String[] args) {
        Outer outer = new Outer("outerString");
        Outer.Inner inner = outer.new Inner("innerString");

        Outer out = inner.outer();
        out.printOuter();
    }
}

rrree

Tatsächlich gibt es zwei this im inneren Klassenobjekt, um die eigenen Mitglieder des inneren Klassenobjekts zu erhalten, und um das äußere Klassenobjekt wie oben zu erhalten Das äußere Klassenmitglied, das heißt in der inneren Klasse, zeigt auf die Referenz des inneren Klassenobjekts selbst und der Name der äußeren Klasse. Dies zeigt auf die Referenz des äußeren Klassenobjekts.

Wenn die Variablennamen der inneren Klasse und der äußeren Klasse denselben Namen haben, sind diese beiden von großem Nutzen.

//output:
outerString

Process finished with exit code 0

public class Outer {
    public int a = 12;
    public int b = 16;
    public int c = 20;

    class Inner{
        public int a = 8;
        public int c = 48;
        public int d = 2;

        public void printVal() {
            System.out.println("外围类变量a=" + Outer.this.a);
            System.out.println("外围类变量b=" + Outer.this.b);
            System.out.println("外围类变量c=" + Outer.this.c);
            System.out.println("内部类变量a=" + this.a);
            System.out.println("内部类变量c=" + this.c);
            System.out.println("内部类变量d=" + this.d);
        }
    }

    public Inner creatInner() {
        return new Inner();
    }

    public static void main(String[] args) {
        Outer outer = new Outer();

        Outer.Inner inner = outer.creatInner();
        inner.printVal();
    }
}

Wenn derselbe Name nicht angezeigt wird, rufen Sie das Mitglied einfach direkt ab. Sie müssen dies nicht wie oben erwähnt verwenden. Wenn derselbe Name angezeigt wird, ist das direkt aufgerufene Mitglied ein internes Klassenobjekt standardmäßig.

2.3 Innere Klasse implementiert iteratives Drucken

Die innere Klasse kann auf alle Elemente der äußeren Klasse zugreifen, sodass wir versuchen können, die innere Klasse zum Durchlaufen und Ausgeben zu verwenden Elemente in der äußeren Klasse. Obwohl der Mitgliedsstatus von inneren Klassen und äußeren Klassen gleich ist, sind innere Klassen schließlich auch Klassen und können auch Klassen erben und Schnittstellen wie äußere Klassen implementieren.

//output:
外围类变量a=12
外围类变量b=16
外围类变量c=20
内部类变量a=8
内部类变量c=48
内部类变量d=2

Process finished with exit code 0

import java.util.Arrays;

interface Selector{
    //判断是否迭代完全部元素
    public boolean end();
    //获取当前元素
    public Object current();
    //迭代下一个元素
    public void next();
}

public class SequeArray {
    private Object[] items;
    private int usedSize;

    public SequeArray(int capacity) {
        items = new Object[capacity];
    }
    public void add(Object val) {
        if (usedSize == items.length) items = Arrays.copyOf(items, 2 * usedSize);

        items[usedSize++] = val;
    }

    private class SequeSelector implements Selector{
        private int index;

        public boolean end() {
            return index == usedSize;
        }
        public Object current() {
            return items[index];
        }
        public void next() {
            if (index < usedSize) index++;
        }
    }
    public SequeSelector sequeSelector() {
        return new SequeSelector();
    }

    public static void main(String[] args) {
        SequeArray array = new SequeArray(10);

        for (int i = 0; i < 10; i++) {
            array.add(i+1);
        }
        //发生了向上转型
        Selector selector = array.sequeSelector();

        while (!selector.end()) {
            System.out.print(selector.current() + "   ");
            selector.next();
        }
    }
}

2.4 Vererbung innerer Klassen

Die Vererbung innerer Klassen ist etwas mühsam, da sich der Konstruktor der inneren Klasse auf die Referenz der äußeren Klasse verlassen muss, also a Es ist eine spezielle Syntax erforderlich. Erklären Sie die Beziehung zwischen internen Klassen und peripheren Klassen:

Peripheral class reference.super();

Siehe Folgendes Code zur Verwendung:# 🎜🎜#

//output:
1   2   3   4   5   6   7   8   9   10   
Process finished with exit code 0

Wenn eine innere Klasse geerbt wird, muss sie die Referenz der äußeren Klasse an den Konstruktor der übergeordneten Klasse übergeben und super() aufrufen, um die Kompilierung zu übergeben.

Wenn die innere Klasse die äußere Klasse erbt, kann sie ohne großen Aufwand direkt geerbt werden.

Wenn das Programm eine Bytecode-Datei einer Java-Datei generiert, wird sie als öffentliche externe Klasse $ interne Klasse bezeichnet.

Innere Klassen können unendlich verschachtelt werden, aber im Allgemeinen macht das niemand.

3. Statische innere Klasse

Statische innere Klasse wird auch als verschachtelte Klasse bezeichnet. Sie dient dazu, vor der Definition der inneren Instanzklasse ein statisches Schlüsselwort hinzuzufügen: # 🎜🎜#

public class Outer {
    class Inner{
        
    }
}
class Person extends Outer.Inner {
    private String str;
    private int id;
    public Person(Outer out, String str, int id) {
        out.super();
        this.str = str;
        this.id = id;
    }
    public void readVal() {
        System.out.println(this.str + this.id);
        
    }
}

Der Unterschied zu inneren Instanzklassen besteht darin, dass statische innere Klassen zu Klassen und nicht zu Objekten gehören. Dies ist der größte Unterschied zu Instanzen innere Klassen.

public class Outer {
    
    static class Inner{
        
    }
}

public class Outer {
    static class Inner{
        private String str;
        public Inner(String s) {
            str = s;
        }
    }

    public static void main(String[] args) {
        Outer.Inner inner = new Outer.Inner("我是静态内部类！");
        System.out.println(inner.str);
    }
}

4. Anonyme innere Klassen

Wir haben bereits die Verwendung anonymer innerer Klassen gesehen, das heißt, beim Erstellen eines PriorityQueue-Objekts wird standardmäßig ein kleiner Heap erstellt muss zum Vergleich übergeben werden. Container zum Erstellen großer Heaps.

//output:
我是静态内部类！

Process finished with exit code 0

Verwenden Sie wie bei der obigen Methode das neue Schlüsselwort, um ein anonymes Klassenobjekt als tatsächlichen Parameter zu erstellen. Das anonyme Klassenobjekt des Komparators wird im Erstellungsprozess vererbt Der Parametertyp, der hier übergeben werden muss, ist die Comparator-Klasse.

Wenn Sie einen benutzerdefinierten Typ zur Übergabe an die Prioritätswarteschlange verwenden, müssen Sie einen Komparator implementieren. Die häufigste Methode zum Implementieren eines Komparators sind anonyme innere Klassen und Lambda-Ausdrücke.

假设我有一个Person类数组，需要对他们的name排序，如果不使用内部类，就需要在Person类中实现比较器。

import java.util.Arrays;
import java.util.Comparator;

class Preson {
    public String name;
    public Integer id;
    public Preson(String name, Integer id) {
        this.name = name;
        this.id = id;
    }

    @Override
    public String toString() {
        return "Preson{" +
                "name='" + name + '\'' +
                ", id=" + id +
                '}';
    }
}
class PersonComparator implements Comparator<Preson> {
    @Override
    public int compare(Preson o1, Preson o2) {
        return o1.name.compareTo(o2.name);
    }
}
public class Main {
    public static void main(String[] args) {
        Preson preson1 = new Preson("aboluo", 24);
        Preson preson2 = new Preson("zhousi", 25);
        Preson preson3 = new Preson("syyfjy", 2);
        Preson[] presons = {preson1, preson2, preson3};
        Arrays.parallelSort(presons, new PersonComparator());
        System.out.println(Arrays.toString(presons));
    }
}

//output:
[Preson{name='aboluo', id=24}, Preson{name='syyfjy', id=2}, Preson{name='zhousi', id=25}]

Process finished with exit code 0

使用内部类上述代码就变为：

import java.util.Arrays;
import java.util.Comparator;

class Preson {
    public String name;
    public Integer id;
    public Preson(String name, Integer id) {
        this.name = name;
        this.id = id;
    }


    @Override
    public String toString() {
        return "Preson{" +
                "name='" + name + '\'' +
                ", id=" + id +
                '}';
    }
}

public class Main {
    public static void main(String[] args) {
        Preson preson1 = new Preson("aboluo", 24);
        Preson preson2 = new Preson("zhousi", 25);
        Preson preson3 = new Preson("syyfjy", 2);
        Preson[] presons = {preson1, preson2, preson3};
        Arrays.parallelSort(presons, new Comparator<Preson>() {
            @Override
            public int compare(Preson o1, Preson o2) {
                return o1.name.compareTo(o2.name);
            }
        });
        System.out.println(Arrays.toString(presons));
    }
}

//output:
[Preson{name='aboluo', id=24}, Preson{name='syyfjy', id=2}, Preson{name='zhousi', id=25}]

Process finished with exit code 0

还有一个本地内部类，就是类定义在方法中，就不多说了，基本上不用，用法如下：

public class Outer {
    public void func() {
        class Inner{
            //
        }
    }
}

Das obige ist der detaillierte Inhalt vonBeispielanalyse einer Java-internen Klasse. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!