Java教程26—Java静态绑定和动态绑定

妖狐艹你老母 2022-05-13 01:54 251阅读 0赞

## 静态和动态绑定 ##

方法调用与方法体的关联称为**绑定**。  
有两种类型的绑定：**在编译时发生的静态绑定和在运行时发生的动态绑定。**  
在我解释java中的静态和动态绑定之前，让我们看一些可以帮助您更好地理解这个概念的术语。

--------------------

## 什么是引用和对象？ ##

class Human{
        
    ....
    }
    class Boy extends Human{
        
        public static void main( String args[]) {
            /*这句代码简单创建了个Boy类型对象
             *并赋值了个引用*/
            Boy obj1 = new Boy();
    
            /* 因为Boy对象继承自Human对象，对象可以以这种方式创建。
             * 父类引用可以使用子类对象赋值
             */
            Human obj2 = new Boy();
        }
    }

--------------------

## Java中的静态和动态绑定 ##

如上所述，方法定义与方法调用的关联称为绑定。  
有两种类型的绑定：静态绑定和动态绑定。让我们讨论一下。

#### 静态绑定或早期绑定 ####

编译器在编译时可以解析的绑定称为静态或早期绑定。  
static，private和final方法的绑定是编译时的。  
为什么？原因是无法覆盖这些方法，并且在编译时确定类的类型。  
让我们看一个例子来理解这个：

**静态绑定示例**  
这里我们有两个类Human和Boy。  
这两个类都有相同的方法walk()，但方法是静态的，这意味着它不能被覆盖。  
所以即使我在创建对象obj时使用了Boy类的对象，它也会调用父类方法。  
因为引用是Human类型(父类)。  
因此，每当static，private和final方法的绑定发生时，类的类型由编译器在编译时确定，即绑定在编译时发生。

class Human{
        
        public static void walk()
        {
            System.out.println("Human walks");
        }
    }
    class Boy extends Human{
        
        public static void walk(){
            System.out.println("Boy walks");
        }
        public static void main( String args[]) {
            /* 引用是Human类型
             * 对象是Boy类型
             */
            Human obj = new Boy();
            /* 引用是Human类型
             * 对象是Human类型
             */
            Human obj2 = new Human();
            obj.walk();
            obj2.walk();
        }
    }
    
    Output:
    
    Human walks
    Human walks

--------------------

#### 动态绑定或后期绑定 ####

当编译器无法在编译时解析调用/绑定时，此类绑定称为动态绑定或后期绑定。  
方法重写是动态绑定的一个完美示例。  
因为在重写父类和子类时都有相同的方法，在这种情况下，**对象的类型决定了要执行哪个方法**。  
对象的类型在运行时确定，因此称为动态绑定。

**动态绑定示例**  
这是我们在上面看到的相同的例子。  
这里唯一的区别是，在这个例子中，覆盖实际上正在发生，因为这些方法不是static，private和final的。  
在覆盖的情况下，对覆盖方法的调用在运行时由对象类型确定，从而发生后期绑定。让我们看一个例子来理解这个：

class Human{
        
        //被重写的方法
        public void walk()
        {
            System.out.println("Human walks");
        }
    }
    class Demo extends Human{
        
        //重写方法
        public void walk(){
            System.out.println("Boy walks");
        }
        public static void main( String args[]) {
            /* 引用是Human类型
             * 对象是Boy类型
             */
            Human obj = new Demo();
            /* 引用是Human类型
             * 对象是Human类型
             */
            Human obj2 = new Human();
            obj.walk();
            obj2.walk();
        }
    }
    Output:
    
    Boy walks
    Human walks

正如您所看到的那样，输出与我们在静态绑定示例中看到的不同.  
因为在这种情况下，在创建对象obj时，对象的类型被确定为Boy类型，因此调用Boy类的方法。  
请记住，对象的类型是在运行时确定的。

--------------------

## 静态绑定与动态绑定的区别 ##

*  静态绑定在编译时发生，而动态绑定在运行时发生。
 *  static，private和final方法的绑定总是在编译时发生，因为这些方法无法被覆盖。
 *  当实际发生方法重写并将父类型的引用分配给子类类型的对象时，则在运行时期间解析此类绑定。
 *  重载方法是静态绑定，覆盖方法是动态绑定。

--------------------

原文地址：

[https://beginnersbook.com/2013/04/java-static-dynamic-binding/][https_beginnersbook.com_2013_04_java-static-dynamic-binding]

[https_beginnersbook.com_2013_04_java-static-dynamic-binding]: https://beginnersbook.com/2013/04/java-static-dynamic-binding/