Detaillierte Erläuterung der Verwendung von statischen Schlüsselwörtern und inneren Klassen in Java

Dieser Artikel vermittelt Ihnen relevantes Wissen über Java und stellt die Verwendung statischer Schlüsselwörter und interner Klassen im Detail vor. Ich hoffe, dass dies der Fall ist allen hilfreich sein.

Empfohlene Studie: „Java-Video-Tutorial“

1. Durch statisches Schlüsselwort geänderte Mitglieder werden in Java als statische Mitglieder oder Klassenmitglieder bezeichnet, die nicht zu einem bestimmten Objekt gehören, das von allen gemeinsam genutzt wird Objekte.

1. Statisch geänderte Mitgliedsvariablen

Statisch geänderte Mitgliedsvariablen werden als statische Mitgliedsvariablen bezeichnet

[Eigenschaften statischer Mitgliedsvariablen]:

gehört nicht zu einem bestimmten Objekt, sondern ist ein Attribut der Klasse Objekte werden gemeinsam genutzt und nicht im Raum eines Objekts gespeichert

• Der Zugriff kann entweder über eine Objektreferenz (nicht empfohlen) oder über den Klassennamen erfolgen. Es wird jedoch allgemein empfohlen, für den Zugriff den Klassennamen zu verwenden.
• Klassenvariablen werden im Methodenbereich gespeichert
• Der Lebenszyklus folgt dem Leben der Klasse (d. h. wird erstellt, wenn die Klasse geladen wird, und wird zerstört, wenn die Klasse entladen wird). Auf „Privat“ wird die Member-Methode auf „public“ gesetzt. In Java wird die durch „Static“ geänderte Member-Methode als Methode der Klasse bezeichnet und ist nicht eindeutig für ein Objekt.
• Der Zugriff auf statische Mitglieder erfolgt im Allgemeinen über statische Methoden.

public class Student{
    public String name;
    public String gender;
    public int age;
    public double score;
    public static String classRoom = "rj2104";

    public Student(String name, String gender, int age, double score) {
        this.name = name;
        this.gender = gender;
        this.age = age;
        this.score = score;
    }

    // ...
    public static void main(String[] args) {
        // 静态成员变量可以直接通过类名访问
        System.out.println(Student.classRoom);
        
        Student s1 = new Student("Li leilei", "男", 18, 3.8);
        Student s2 = new Student("Han MeiMei", "女", 19, 4.0);
        Student s3 = new Student("Jim", "男", 18, 2.6);
        
        // 也可以通过对象访问：但是classRoom是三个对象共享的
        System.out.println(s1.classRoom);
        System.out.println(s2.classRoom);
        System.out.println(s3.classRoom);

    }
}

[Statische Methodeneigenschaften]:

gehört nicht zu einem bestimmten Objekt, es ist eine Klassenmethode

kann über das Objekt oder über den Namen der statischen Methode (...) aufgerufen werden. Es wird eher empfohlen, Letzteres zu verwenden

Sie können in statischen Methoden nicht auf nicht statische Mitgliedsvariablen und nicht statische Mitgliedsmethoden zugreifen, aber Sie können diese Referenz beim Aufruf von static nicht übergeben Methoden; es sei denn, Sie erstellen ein neues Objekt in der statischen Methode und greifen dann über eine Objektreferenz auf dieses Objekt zu

Statische Methoden können nicht überschrieben werden und können nicht zum Implementieren von Polymorphismus verwendet werden

Statisch Mitgliedsvariablen werden im Allgemeinen nicht zur Initialisierung in den Konstruktor gestellt. In der Konstruktormethode werden die mit dem Objekt verbundenen Instanzattribute initialisiert. Die Initialisierung statischer Mitgliedsvariablen ist in zwei Typen unterteilt: In-Place-Initialisierung und statische Codeblockinitialisierung.

• In-Place-Initialisierung: Geben Sie den Anfangswert direkt beim Definieren von

public class Student2{
    // ...
    private static String classRoom = "rj2104";
    // ...
    public static String getClassRoom(){
        return classRoom;
    }
}

class TestStudent {
    public static void main(String[] args) {
        System.out.println(Student2.getClassRoom());
    }
}

an.
• Verwenden Sie einen statischen Codeblock, um die Initialisierung abzuschließen Erstere wird als innere Klasse bezeichnet, letztere als äußere Klasse. Auch innere Klassen sind Ausdruck der Kapselung.
• Interne Klassen und externe Klassen verwenden dieselbe Java-Quelldatei, aber nach der Kompilierung bildet die interne Klasse eine separate Bytecode-Datei. Der allgemein gebildete Dateiname der Bytecode-Datei lautet: Name der externen Klasse $ Name der internen Klasse.Klasse

public class Student2{
    // ...
    //就地初始化
    private static String classRoom = "rj2104";
    //...
}

Je nach den verschiedenen Orten, an denen interne Klassen definiert werden, können sie im Allgemeinen in die folgenden Formen unterteilt werden: 1. Interne Mitgliedsklassen (gewöhnliche interne Klassen)

Instanzinterne Klassen: Interne Mitgliedsklassen, die nicht statisch geändert wurden

Statische innere Klasse: innere Mitgliedsklasse

3. Anonyme innere Klasse

ist eine innere Mitgliedsklasse, die nicht statisch modifiziert ist.

【Hinweis】:

Auf jedes Mitglied in der externen Klasse kann direkt in der instanzinternen Klassenmethode zugegriffen werden.

In der instanzinternen Klasse können keine statischen Mitgliedsvariablen vorhanden sein. Wenn sie definiert werden müssen, können sie nur statisch sein final Modifizierte statische Konstanten, Konstanten werden beim Kompilieren des Programms bestimmt

Der Speicherort der internen Klasse der Instanz ist derselbe wie der Speicherort des externen Klassenmitglieds und unterliegt daher auch den Einschränkungen öffentlicher, privater und anderer Zugriffsqualifizierer

Das interne Klassenobjekt der Instanz muss nur erstellt werden, wenn zuerst ein externes Klassenobjekt vorhanden ist. Die nicht statische Methode der internen Klasse der Instanz enthält einen Verweis auf das externe Klassenobjekt und einen Verweis auf das interne Klassenobjekt davon Wenn Sie auf Mitglieder einer externen Klasse zugreifen, wird standardmäßig auf denselben Namen zugegriffen. Wenn Sie auf ein Mitglied der externen Klasse mit demselben Namen zugreifen möchten : externer Klassenname.this.Member mit demselben Namen, auf den zugegriffen werden soll

In der externen Klasse können Sie nicht direkt auf Mitglieder der internen Klasse der Instanz zugreifen. Wenn Sie darauf zugreifen möchten, müssen Sie zunächst ein Objekt der inneren Klasse erstellen.

public class Student2{
    // ...
    private static String classRoom;
    
    //静态代码块初始化
    static {
        classRoom = "rj2104";
    }

    // ...
}

2. Statische innere Klasse

Die durch Statik geänderte interne Mitgliedsklasse wird als statische innere Klasse bezeichnet. ,

[Hinweis]:

In einer statischen inneren Klasse können Sie nur auf statische Mitglieder in der äußeren Klasse zugreifen, es sei denn, Sie erstellen ein neues Objekt der äußeren Klasse in der inneren Klasse und greifen über die Referenz auf die nicht statischen Mitglieder zu des äußeren Klassenobjekts. Beim Erstellen eines statischen inneren Klassenobjekts müssen Sie nicht zuerst ein externes Klassenobjekt erstellen

public class OutClass {
    class InnerClass{
    }
}
// OutClass是外部类
// InnerClass是内部类

3 Lokale interne Klassen

werden im Methodenkörper oder {} der externen Klasse definiert und im Allgemeinen sehr häufig verwendet selten.

【Notizen】

• 局部内部类只能在所定义的方法体内部使用

  不能被public、static等修饰符修饰

  局部内部类生成的字节码文件稍有区别：外部类名字$数字内部类名字.class

  

  ppublic class OutClass {
      int a = 10;
      
      public void method(){
          int b = 10;
          // 局部内部类：定义在方法体内部
          // 不能被public、static等访问限定符修饰
          class InnerClass{
              public void methodInnerClass(){
                  System.out.println(a);
                  System.out.println(b);
              }
          }
          // 只能在该方法体内部使用，其他位置都不能用
          InnerClass innerClass = new InnerClass();
          innerClass.methodInnerClass();
      }
      
      public static void main(String[] args) {
      // OutClass.InnerClass innerClass = null; 编译失败
      }
  }

  4. 匿名内部类

  匿名内部类，就是没有名字的一种嵌套类

  匿名内部类形成的字节码文件文件名为：外部类名字$数字.class

  

  4.1 使用匿名内部的好处与演示

  在实际开发中，我们会遇到下面的情况：

  一个接口/类的方法的某个执行过程在程序中只会执行一次，但为了使用它，我们需要创建它的实现类/子类去实现/重写方法。

  代码中为了这一次的使用去创建一个类，未免太过麻烦，此时就可以使用匿名内部类来解决这个问题

  首先来看我们正常的实现逻辑，假设有一个接口，接口当中只有一个方法

  public interface Interface {
      void show();
  }

  为了使用该接口的show方法，我们需要去创建一个实现类，重写show方法的具体实现

  public class Test implements Interface{
      @Override
      public void show() {
          System.out.println("只执行一次show()");
      }
  }
  
  public class Main {
      public static void main(String[] args) {
          Test test = new Test();
          test.show();
      }
  }

  如果实现类Test在程序中只使用一次，那么为了这一次的使用去创建一个类太过繁琐，这种情况下就可以用匿名内部类来实现，无需创建新的类，减少代码冗余，

  看下面代码：

  class Main {
      public static void main(String[] args) {
          //写法一
          Interface in = new Interface() {
              @Override
              public void show() {
                  System.out.println("匿名内部类中重写show()");
              }
          };
          //调用接口方法
          in.show();
          
          //写法二
          new Interface() {
              @Override
              public void show() {
                  System.out.println("匿名内部类中重写show()");
              }
          }.show();//调用接口方法
      }
  }

  4.2 匿名内部类的定义格式和使用

  定义格式1：

  接口名称 引用名 = new 接口名称() {
      // 覆盖重写所有抽象方法
  };
  
  引用名.方法调用

  定义格式2：

  new 接口名称() {
      // 覆盖重写所有抽象方法
  }.方法调用;

  对格式“new 接口名称() {…}”的理解：

  new代表创建一个新的对象对象

  接口名称就是匿名内部类需要实现哪个接口

  {…}中是匿名内部类的内容

  【注意事项】：

  • 匿名内部类，在【创建对象】的时候，只能使用唯一 一次。
  • 匿名对象，在【调用方法】的时候，只能调用唯一 一次。
  • 匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】
  • 匿名内部类可以用在具体类、抽象类、接口上，且对方法个数没有要求。

  public class Class {
      public void show(String s){
          System.out.println("Class::show()");
      }
  }
  
  public abstract class AbstractClass {
      abstract void show(String s);
  }
  
  public interface Interface {
      void show(String s);
  }
  
  public class TestDome {
      public static void main(String[] args) {
  
          //重写普通类的方法
          new Class(){
              @Override
              public void show(String s) {
                  System.out.println(s);
              }
          }.show("普通类");
  
          //重写抽象类的抽象方法
          new AbstractClass(){
              @Override
              void show(String s) {
                  System.out.println(s);
              }
          }.show("抽象类");
  
          //实现接口的抽象方法
          new Interface(){
              @Override
              public void show(String s) {
                  System.out.println(s);
              }
          }.show("接口");
  
      }
  }

  执行结果：

  

  推荐学习：《java视频教程》

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung der Verwendung von statischen Schlüsselwörtern und inneren Klassen in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!