什么叫动态绑定??听说了很多年,,,,与static 有何关系?

Question

动态绑定:
我的理解是,当父类和子类均不为static methods时.
如果子类重定义了此方法,那子类生成的对象调用子类自己的
是不是??

Answer 1

此回复为自动发出,仅用于显示而已，并无任何其他特殊作用
楼主【sure2003】截止到2008-07-27 20:57:26的历史汇总数据(不包括此帖)：
发帖的总数量:272                      发帖的总分数:11143                    每贴平均分数:40                       
回帖的总数量:237                      得分贴总数量:7                        回帖的得分率:2%                       
结贴的总数量:271                      结贴的总分数:11123                    
无满意结贴数:2                        无满意结贴分:50                       
未结的帖子数:1                        未结的总分数:20                       
结贴的百分比:99.63 %               结分的百分比:99.82 %                  
无满意结贴率:0.74  %               无满意结分率:0.45  %                  
值得尊敬

Answer 2

静态绑定是在编译时绑定，而动态绑定是在运行时根据对象的实际情况来选择绑定父类或者是某个子类的方法。在执行效率上，静态绑定要优于动态绑定，但丧失了灵活性。
Java中变量是动态绑定的，实例方法是动态绑定的。在进行“向上转型”的时候子类会覆盖父类的实例方法而不会覆盖父类的变量

Answer 3

static与动态绑定没有关系。
static是静态的。
当父类的引用指向子类的对象，通过这个引用调用父类覆盖的方法时，调用的是子类的方法，这就是多态。

Answer 4

很简单的例子：public class Main {
    public static void main(String[] args) {
        Fruit[] fruit = new Fruit[2];
        fruit[0] = new Apple();
        fruit[1] = new Banana();
        show(fruit);
    }    public static void show(Fruit[] fruit) {
        for (Fruit f : fruit) {
            f.print();
        }
    }
}abstract class Fruit {
    abstract public void print();
}class Apple extends Fruit {
    @Override
    public void print() {
        System.out.println("Apple");
    }
}class Banana extends Fruit {
    @Override
    public void print() {
        System.out.println("Banana");
    }
}

Answer 5

动态绑定，它的含义就是在运行时根据对象的类型进行绑定。
也就是说，编译器一直不知道对象的类型，但是方法调用机制能找到正确的方法体，并加以调用                                                                                       -------引自JAVA编程思想

Answer 6

这个应该对你有帮助
http://blog.csdn.net/yirentianran/archive/2008/04/25/2327349.aspx

Answer 7

这个形象
Thinking in Java 中好多这个，建议看一下

Answer 8

静态是编译时的，比如说变量的声明，普通方法的声明。
动态是运行时的。java中的多态和泛型都是动态绑定。

Answer 9

看这个例子：public class Main {    public static void main(String[] args) {
       Super s=new Sub();//Super类型的引用指向Sub类的对象
       System.out.println(s.name);//通过s访问name属性，访问到的是Super定义的name
       s.print();//多态，通过s调用print方法，调用的是Sub类中定义的print，动态绑定
    }
}class Super{
    public String name="super";
    public void print(){
        System.out.println(name);
    }
}
class Sub extends Super{
    public String name="sub";
    @Override
    public void print(){
        System.out.println(name);
    }
}

Answer 10

像这种形式：
List<String> list=new ArrayList<String>();
list.add(new String("abc"));
通过指定类型为String，使编译器可以在编译的时候静态确定类型，而不是像jdk1.5之前那样，必须通过运行的时候动态确定类型并进行强制转换。