04.Java-Grundlagen – Klassen

Grundkonzepte

Im objektorientierten Konzept wissen wir, dass alle Objekte durch Klassen dargestellt werden.

In Java werden Klassen durch das Schlüsselwort class definiert.

In ähnlicher Weise haben Klassen in Java viele Formen, einschließlich gewöhnlicher Klassen, abstrakter Klassen und innerer Klassen.

Zu den inneren Klassen gehören: innere Mitgliedsklassen, lokale innere Klassen, anonyme innere Klassen und statische innere Klassen.

---

Normaler Typ

Dazu gibt es nichts zu sagen.

public class Demo { }

---

Abstrakte Klasse

1. Grundkonzepte

Alle oben genannten Objekte werden durch dargestellt Klassen, aber nicht alle Klassen werden zur Beschreibung von Objekten verwendet.

Wenn eine Klasse nicht genügend Informationen enthält, um ein bestimmtes Objekt zu beschreiben (wir können sie als unvollständige Klasse verstehen), ist eine solche Klasse abstrakte Klasse.

Abstrakte Klassen werden mit dem Schlüsselwort absract definiert. Es kann abstrakte Methoden und nicht abstrakte Methoden enthalten.

---

2. Beispielstudie

• Abstrakte Klassendefinition

public abstract class Parent {

    // 1.成员变量，与普通类无差别
    private  String word="aa";    // 2.非抽象方法，与普通类无差
    private void talk(){
        System.out.println("Parent is talking");
    }    // 3.抽象方法，访问权限只能是 public 和 protected 
    abstract void print();
}

• Abstrakte Klassenvererbung

// 1.抽象类继承抽象类，抽象子类不用实现父类的方法public abstract class Son extends Parent { }
// 2.普通类继承抽象类，普通子类必须实现父类的所有抽象方法public class Grandson extends Son {
    @Override
    void print() {
        System.out.println("I am Grandson");
    }
}

• Abstrakter Klassenaufruf

// 错误，抽象类不允许被实例化//Parent parent = new Parent();

Durch den obigen Code können wir die folgenden Punkte zusammenfassen:

• Abstrakte Klassen und abstrakte Methoden können nicht durch private geändert werden. und muss mit dem Schlüsselwort abstract definiert werden.

• Wenn die Unterklasse keine abstrakte Klasse ist, muss sie alle abstrakten Methoden der übergeordneten Klasse implementieren.

• Abstrakte Klasse darf nicht instanziiert werden, Kompilierungsfehler.

• Abstrakte Klassen können auch gewöhnliche Methoden und Mitgliedsvariablen enthalten.

---

Mitgliederinterne Klasse

1. Grundkonzepte

Befindet sich innerhalb einer Klasse Die Klasse wird als innere Mitgliedsklasse bezeichnet.

Innere Mitgliedsklassen weisen die folgenden Eigenschaften auf: Auf alle Eigenschaften ihrer äußeren Klassen kann ohne besondere Bedingungen zugegriffen werden.

2. Beispielstudie

• Mitgliederinterne Klassendefinition:

public class Outter {
    private int a = 10;    static int b = 20;    int c = 30;    // 内部类
    class Inner {        void print(int d) {
            System.out.println(a + "-" +b+ "-" +c+ "-" + "-" +d;
        }
    }    // 取得内部类
    Inner getInner() {        return new Inner();
    }
}

• Mitgliederinterner Klassenaufruf

Outter out = new Outter();// 创建内部类的两种方式：
Outter.Inner inner = out.new Inner();Outter.Inner inner2 = out.getInner();inner.print(20);

3. Prinzipanalyse

Durch Dekompilieren der Klassendatei lautet der Befehl wie folgt :

javap -v Outter

Nachdem Sie den Befehl ausgeführt haben, erhalten Sie zwei Klassendateien: Oututter.Class und Oututter$Inner.Class.

Erklärung, dass interne Klassen für virtuelle Maschinen tatsächlich die gleichen sind wie reguläre Klassen. Daher wird Inner immer noch in eine unabhängige Klasse kompiliert und nicht in ein bestimmtes Feld der Outter-Klasse.

Da die innere Klasse des Mitglieds jedoch wie ein Mitglied der äußeren Klasse aussieht, kann sie dieselben Zugriffsrechte wie das Mitglied haben.

---

Lokale interne Klassen

1. Grundkonzepte

Es gibt zwei Arten von lokalen internen Klassen:

• Klasse innerhalb der Methode.

• Klassen im Umfang.

kann als interne lokale Variable einer Methode oder eines Bereichs betrachtet werden, sodass ihre Zugriffsrechte auf die Methode oder den Bereich beschränkt sind.

Wie lokale Variablen können sie nicht durch die Schlüsselwörter public, protected, private und static geändert werden.

2. Beispielstudie

public class Man {
    public Object getWoman() {        // 注意：三个变量都相互不受影响
        int age = 30;        // 1.方法内的类
        class Woman {            int age = 20;
        }        // 2.作用域内的类，此时作用域为 if 
        if(true){
            class Son{                int age = 10;
            }
        }   
        return new Woman();
    }
}

---

Anonyme innere Klasse

1

Anonyme innere Klassen sind die einzigen Klassen ohne Konstruktor. Aufgrund dieser Funktion ist der Einsatzbereich anonymer innerer Klassen sehr begrenzt und die meisten von ihnen werden für

Schnittstellenrückrufe

verwendet. Es hat die folgenden Eigenschaften:

Die anonyme innere Klasse wird vom System während der Kompilierung automatisch Oututter$1.class genannt.
Anonyme innere Klassen werden im Allgemeinen verwendet, um andere Klassen zu erben oder Schnittstellen zu implementieren. Sie müssen keine zusätzlichen Methoden hinzufügen, sondern nur geerbte Methoden implementieren oder neu schreiben.
Anonyme innere Klassen können nicht auf
• lokale Variablen

  in Methoden äußerer Klassen zugreifen, es sei denn, die Variablen sind als endgültiger Typ

2. Beispielstudie

---

3. Prinzipanalyse

public class Test {
    // a 属于全局变量
    int a =100;    public static void main(String[] args) {
        Test t = new Test();
        t.test(200);
    }    // b 属于局部变量
    public void test(final int b) {        // c 属于局部变量
        final int c = 300;        //  匿名内部类
        new Thread() {            int  d = 400;            public void run() {
                System.out.println(a+"-"+b+"-"+c+"-"+d);
            };
        }.start();
    }
}

---

Sie können zwei Klassen erhalten, indem Sie die Befehlsdateien dekompilieren : Oututter.class und Oututter$1.class. Über den Lebenszyklus lokaler Variablen:

Wenn eine Methode aufgerufen wird, werden lokale Variablen auf dem Stapel erstellt. Wenn die Methode endet, wird sie vom Stapel entfernt und die lokalen Variablen werden gelöscht.

• Über den Deklarationszyklus innerer Klassenobjekte:

Erstellen Sie ein anonymes inneres Klassenobjekt, und das System weist dem Objekt bis Nr. Speicher zu Variablen verweisen auf den Speicher, der dem Objekt zugewiesen ist, bevor es von GC verarbeitet wird.

• Es gibt also eine Situation:

Die Mitgliedsmethode wurde bis zum Ende aufgerufen, die lokale Variable ist gestorben, aber das Objekt von Die anonyme innere Klasse lebt noch.

• Also wird in Java die letzte Methode Schlüsselwort + Kopieren verwendet, um das Problem zu lösen:

  • final 关键字：因为它的特性是一旦变量被赋值后，就不能被修改。

  • 复制：在匿名内部类中直接复制了一个与局部变量值的数，让它变成自己的局部变量。

  所以当局部变量的生命周期结束后，匿名内部类照样可以访问 final 类型的局部变量，因为它自己拷贝了一份，且与原局部变量的值始终一致。

  下面针对上面的代码来分析：

  • 当 test 方法执行完毕之后，变量 b、c 的生命周期就结束了。然而 Thread 对象的生命周期很可能还没有结束。因此要将 b、c 设置为 final 。

  • a 之所以不采用 final 修饰，因为它是全局变量，生命周期是随着类的结束而结束。而类的生命周期肯定大于匿名内部类。

  ---

  静态内部类

  1.基本概念

  静态内部类也是定义在一个类里面的类，只不过在类的前面多了一个关键字static。

  静态内部类和静态成员变量其实具有相同的特点：

  • 它只有类有关，与对象无关。因此可以在没有外部类对象情况下，创建静态内部类。

  • 不能访问外部类的非静态成员或方法

  ---

  2.实例探究

  • 内部静态类定义：

  public class Outter {
      int a = 5;    static int b = 500;    // 静态内部类
      static class Inner {        public Inner() {            // 只能访问外部类的静态成员
              System.out.println(b);
          }
      }
  }

  • 静态内部类调用：

  // 静态内部类的调用不依赖外部类对象Outter.Inner inner= new Outter.Inner();

  ---

  接口内部类

  1.基本概念

  接口内部类，顾名思义就是在接口内定义的类。

  ---

  2.实例探究

  • 接口内部类定义：

  public interface People{
      class Man {        public void print() {
              System.out.println("man.print()...");
          }
      }
  }

  • 接口内部类调用：

  People.Man  man = new People.Man();

   以上就是04.Java 基础 - 类的内容，更多相关内容请关注PHP中文网（www.php.cn）！
  

  ---