07.Java-Grundlagen – Statische Bindung und dynamische Bindung

Grundlegende Konzepte

Bindung bezieht sich auf die Verknüpfung eines Methodenaufrufs mit der Klasse, in der er sich befindet.

Bindung kann in statische Bindung und dynamische Bindung unterteilt werden.

Einige Konzepte, die Sie kennen müssen, bevor Sie die statische Bindung und die dynamische Bindung analysieren:

• Kompilierungszeitraum: Der Kompilierungsprozess dient der Konvertierung der Java-Quelle Der Prozess des Kompilierens einer Datei in Bytecode (.class-Datei, ausführbarer JVM-Code). Während dieses Prozesses führt der Compiler eine Syntaxanalyse durch gemeldet.

• Laufzeit: Der laufende Prozess bedeutet, dass die JVM (Java Virtual Machine) die Bytecode-Datei lädt und zur Ausführung interpretiert. Dieser Prozess ist die eigentliche Erstellung Speicher. Java-Programm ausführen.

Methodenaufruf

Der Methodenaufrufprozess in Java ist wie folgt:

• Editor Zeigt die deklarierten Typ- und Methodennamen des Objekts an. Rufen Sie alle Kandidatenmethoden ab, die möglicherweise aufgrund einer Methodenüberladung aufgerufen werden. Beispiel: Methode eins ist print(String str), Methode zwei ist print(int).

• Der Compiler prüft den Eingabeparametertyp der aufrufenden Methode. Wählen Sie die passende Methode aus den Kandidatenmethoden aus. Wenn der Eingabeparameter beispielsweise „Hallo“ lautet, wählen Sie print(String str) aus.

• Wenn die Methode privat, statisch, final oder Konstruktor ist, kann der Compiler bestimmen, welche Methode aufgerufen werden soll. Dies ist eine statische Bindung.

• Wenn dies nicht der Fall ist, muss eine Laufzeitbindung (dynamisch) verwendet werden.

Statische Bindung

Statische Bindung, auch bekannt als frühe Bindung und Bindung zur Kompilierungszeit. Zeigt die Bindung zur Kompilierungszeit an, d. h. die Methode wurde gebunden, bevor das Programm ausgeführt wird.

Nur ​​Methoden, Mitgliedsvariablen und Konstruktoren, die durch final, static und private geändert wurden, sind statisch gebunden:

Sehen Sie sich das folgende Beispiel an:

// 父类class Parent{    // 变量
    String name="Parent";    // 静态方法
    static void print(){
        System.out.println("Parent print");
    }    // 私有方法
    private void say(){
        System.out.println("Parent say");
    }    // 终态方法
    final void look(){
        System.out.println("Parent look");
    }
}// 子类class Son extends Parent{
    String name ="Son";    static void print(){
        System.out.println("Son print");
    }    // 编译错误，无法重写父类的 final方法
    final void look(){};
}public class Test{
    public static void main(String[] args) {        // 发生向上转型
        Parent p = new Son();        // 输出 Parent
        System.out.println(p.name);        // 输出 Parent print
        p.print();        // 编译错误，对外不可见
        p.say();
    }
}

Dynamische Bindung

Dynamische Bindung, auch als späte Bindung und Laufzeitbindung bekannt, bedeutet Bindung entsprechend dem Typ eines bestimmten Objekts zur Laufzeit.

Dynamischer Bindungsprozess:

• Die virtuelle Maschine extrahiert die Methodentabelle des tatsächlichen Typs des Objekts;

• Virtuell Maschinensuche Methodensignatur

• ruft die Methode auf.

Sehen wir uns ein Beispiel an:

class A {    int x = 5;
}

class B extends A {    int x = 6;
}

class Parent {    public A getValue() {
        System.out.print("Parent Method ");        return new A();
    }
}

class Son extends Parent {    public B getValue() {
        System.out.print("Son Method ");        return new B();
    }
}public class Test {
    public static void main(String[] args) {        // 向上转型
        Parent p = new Son();        // 输出结果：Son Method 5
        // 注意：是 5 不是 6 ！
        System.out.println(p.getValue().x);
    }
}

Beobachten Sie die Ausgabeanalyse wie folgt:

• p.getValue( ), Da eine Aufwärtstransformation stattgefunden hat, sucht es zunächst nach der Methode aus der Unterklasse (Son) und ruft zu diesem Zeitpunkt die Methode von Son auf. Dies ist eine dynamische Bindung.

• p.getValue( ).x Da x eine Mitgliedsvariable ist, wird ihr Objekt (das zu Parent gehört) bestimmt, bevor das Programm ausgeführt wird.

Wenn Sie es immer noch nicht verstehen, schauen wir uns ein Beispiel an:

class Parent {
    String name = "Parent " + this.getClass().getName();
}

class Son extends Parent {
    String name = "Son" + this.getClass().getName();
}public class Test {
    public static void main(String[] args) {        // 向上转型
        Parent p = new Son();        // 输出：Parent Son
        System.out.println(p.name);
    }
}

Beobachten Sie die Ausgabeanalyse wie folgt:

• p .name: Name ist eine Mitgliedsvariable. Zu diesem Zeitpunkt erfolgt eine statische Bindung, daher wird die Eigenschaft von Parent aufgerufen.

• this.getClass( ): getClass ist eine Methode, da zu diesem Zeitpunkt eine Aufwärtstransformation stattfindet, sucht das Standardprogramm ausgehend von der Unterklasse nach dieser Methode, die zufällig auch in existiert die Unterklasse. Daher wird die Methode der Unterklasse aufgerufen und zu diesem Zeitpunkt erfolgt eine dynamische Bindung.

Das Obige ist der Inhalt von 07.Java Basics – Statische Bindung und dynamische Bindung. Für weitere verwandte Inhalte achten Sie bitte auf PHP-Chinesisch Website (m.sbmmt.com)!