动态绑定和静态绑定有什么区别啊

哦，是说父子类函数那个地方嗦。动态绑定我理解的就是 程序在 jvm 中执行的时候才进行符号索引的解析，静态绑定是在编译的时候就符号解析了。

静态绑定就是说在对象进堆得时候已经有固定的对象了。
而动态绑定则是在所属的对象是在运行中随机的。。

所谓绑定是指，对于参与多态行为的类型，他们具有多态行为的接口是在公共基类的设计中就预先确定的。而非绑定则对于参与多态行为的类型，他们的接口没有预先定义。  通过继承实现的多态是动态绑定，通过模板实现的多态是静态绑定。动态绑定的接口是在运行期间（动态）完成的，静态绑定的接口是在编译期间（静态）完成的

首先要了解多态，即父类型的引用指向子类型的对象。动态绑定就是在运行期让java虚拟机去联系到适合的函数分支，决定调用哪个类的方法。所谓静态绑定就是在程序编译时就绑定的。变量都是静态绑定的，方法的话只有static和final(所有private默认是final的)是静态绑定的。就是在编译的时候已经决定了变量的值和应该调用哪个类的方法。例如:
class A {
        static void method1()
        {
                System.out.println("A.method1()");
        }
        void method2()
        {
                System.out.println("A.method2()");
        }
}
public class B extends A
{
        static void method1() //这个方法将不会覆盖A的method1()
        {
                System.out.println("B.method1()");
        }  
        void method2() //这个方法将会覆盖A的method2()
        {
                System.out.println("B.method2()");
        }
        public static void main(String[] args)
        {
                A a = new B();
                a.method1(); //因为A里面的method1是static，编译时就静态绑定了，所以输出 A.method1()
                a.method2(); //而method2()不是static方 法，a是由B创建出来的，执行的时候会执行创建它的那个类的method2()方法,所以输 出B.method2(),这就是动态绑定
        }
}

绑定指的是一个方法的调用与方法所在的类(方法主体)关联起来。对java来说，绑定分为静态绑定和动态绑定；或者叫做前期绑定和后期绑定。
静态绑定：在程序执行前方法已经被绑定，针对java简单的可以理解为程序编译期的绑定；这里特别说明一点，java当中的方法只有final，static，private和构造方法是前期绑定(静态绑定)的。
动态绑定：在运行时根据具体对象的类型进行绑定。

采取动态绑定是为了实现多态，所以你要懂多态
静态绑定发生在编译时；而动态绑定发生在运行时。
重载的方法使用静态绑定；重写的方法在运行时绑定。

1. eg：
   
2. import java.util.*;
   
3. public class StaticBindTest{
   
4.         public Collection sort(Collection c){
   
5.                 System.out.println("Inside Collection sort method");
   
6.                 return c;
   
7.         }
   
8.         public Collection sort(HashSet hs){
   
9.                 System.out.println("Inside HashSet sort method");
   
10.                 return hs;
    
11.         }
    
12.         public static void main(Sting[] args)
    
13.                 Collection c = new HashSet();
    
14.                 StaticBindTest st = new StaticBindTest();
    
15.                 st.sort(c);
    
16.         }
    
17. }
    
18. 这是静态绑定，重载了sort()方法，sort()分别接受Collection和HashSet参数。
    
19. 这里调用sort()方法，传递的是HashSet对象作为参数，但是类型引用的是Collection对象，
    
20. 由于是编译时绑定，所以并没有“new HashSet()”，所以调用的是sort(Collection)；
    
21. 
    
22. class Vehicle{
    
23.         public void start(){
    
24.                 System.out.println("Inside start method of Vehicle");
    
25.         }
    
26. }
    
27. class Car extends Vehicle{
    
28.         @Override
    
29.         public void start(){
    
30.                 System.out.println("Inside start method of Car");
    
31.         }
    
32. }
    
33. public class DynBindTest{
    
34.         public static void main(String[] args){
    
35.                 Vehicle vehicle = new Car();
    
36.                 vehicle.start();
    
37.         }
    
38. }
    
39. 这个是动态绑定，Car继承了Vehide类并重写了start()方法。注意一点，对象只有在运行期间才会被创建，并被动态绑定。
    

复制代码

Java中的变量都是静态绑定的,方法的话只有static和final(所有private默认是final的)是静态绑定的.

就是在编译的时候已经决定了变量的值和应该调用哪个类的方法.你要把它同动态绑定联系起来才好理解.例如:



class A {

  static void method1() {

    System.out.println("A.method1()");

  }

  void method2() {

    System.out.println("A.method2()");

  }

}

public class B extends A{

  // will not override A.method1()

  static void method1() {

    System.out.println("B.method1()");

  }

  // will override the A. method2()

  void method2() {

    System.out.println("B.method2()");

  }

  public static void main(String[] args) {

    　　A a = new B();

       a.method1(); //因为A里面的method1是static,编译时就静态绑定了,所以输出 A.method1()

       a.method2(); //而method2()不是static方法,a是由B new出来的,执行的时候会执行new它的那个类的method2()方法,所以输出B.method2(),这是java的多态性

  }

}

动态绑定的的意义在于提高灵活性，降低耦合度。动态绑定就是用父类或接口指向子类或接口的实现类来提高代码的灵活性，你在一个方法中声明一个狗类的变量来指向一个狗类的实体，那么在需要用到猫类类进行这一动作的时候就需要另写代码，如果你使用一个动物类的接口来指向的话，那么这个方法对于所有实现了动物类这个接口的对象都适用。

另外一种动态就是利用反射技术在运行期动态生成对象，这样做是为了降低代码耦合度，因为软件开发一般不是一个人来完成的，在同步进行开发的时候你不清楚其他程序员会定义什么样的类和方法属性等，利用反射技术开发完以后只需要在配置文件配置好就可以集成了



方法前面加上private、static、final或者是构造器编译器就可以准确地知道应该调用哪个方法。这样的调用方式称为静态绑定

调用哪个方法将依赖于隐式参数的实际类型，并且在运行时动态绑定

所谓静态绑定是指在程序编译过程中，把函数（方法或者过程）调用与响应调用所需的代码结合的过程称之为静态绑定。

动态绑定是指在执行期间（非编译期）判断所引用对象的实际类型，根据其实际的类型调用其相应的方法

除了限制访问,访问方式也决定哪个方法将被子类调用或哪个属性将被子类访问. 函数调用与函数本身的关联,以及成员访问与变量内存地址间的关系,称为绑定.

在计算机语言中有两种主要的绑定方式，静态绑定和动态绑定. 静态绑定发生于数据结构和数据结构间,程序执行之前. 静态绑定发生于编译期, 因此不能利用任何运行期的信息. 它针对函数调用与函数的主体,或变量与内存中的区块..

动态绑定则针对运行期产生的访问请求,只用到运行期的可用信息. 在面向对象的代码中,动态绑定意味着决定哪个方法被调用或哪个属性被访问,将基于这个类本身而不基于访问范围.