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:

类型	解释
final	被其修饰的方法可以被继承，但不能被重写；子类对象可以调用，但是调用的是父类中定义的那个方法；间接表明将方法声明为 final 可以避免重写，关闭动态绑定。
private	被其修饰地方法隐式地包含了 final 关键字。由于它对外是不可见的，所以不能被继承，重写；只能通过类自身的对象来调用，因此在方法运行之前就可以明确对象。
static	静态方法是依赖于类而依赖于对象的。它可以被子类继承（实质是被子类隐藏），但是不能被子类重写。当子类对象向上转型为父类对象时，不论子类中有没有定义这个静态方法，该对象都会使用父类中的静态方法。因此这里说静态方法可以被隐藏。
成员变量	默认 Java 对属性采用静态绑定，这样在编译期就能发现程序错误，能够提供效率。
构造方法	构造方法不能被继承的，子类继承父类时默认要先调用父类的构造方法（无论显示或隐式）。因此在程序运行之前就可以知道构造方法术语哪个对象。

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 (www.php.cn)!