多态 继承 实例

Question

谁能够提供一个多态和继承的程序能，并且能够解释的。。？我在看书的时候怎么感觉继承和多态基本是一样的呢？？
 

Answer 1

JAVA里没有多继承，一个类之能有一个父类。  
而继承的表现就是多态。一个父类可以有多个子类，而在子类里可以重写父类的方法（例如方法print()），这样每个子类里重写的代码不一样，自然表现形式就不一样。这样用父类的变量去引用不同的子类，在调用这个相同的方法print()的时候得到的结果和表现形式就不一样了，这就是多态，相同的消息（也就是调用相同的方法）会有不同的结果。

Answer 2

    多态是java面向对象的基本特征之一，多态的表现形式主要有重载和覆盖，而只有当发生继承关系时才可以发生覆盖。

Answer 3

要理解多态性就首先理解方法的后期绑定。方法的后期绑定也叫做方法运行时的绑定。什么叫绑定？绑定就是方法名和方法体链接的过程。在编译时知道要调用的方法名，但是不知道要调用的方法主体,而运行时绑定就为我们解决了这个问题。java中除了static、final、private方法修饰的方法是前期绑定外其余的方法都是后期绑定，这也就是为什么static、final、private方法没有多态性的原因了。因为多态要依靠方法的后期绑定来完成。 比如一个父类：Shape 它有个方法draw()。 Shape有两个子类: Cricle、Square分别重写了Shape的draw()方法. 
Java codeclass Shape { 
  public void draw() {} 
  public void erase() {} 
}class Circle extends Shape { 
  public void draw() { 
      System.out.println("Circle.draw()"); 
  } 
  public void erase() { 
      System.out.println("Circle.erase()"); 
  } 
} class Square extends Shape { 
  public void draw() { 
      System.out.println("Square.draw()"); 
  } 
  public void erase() { 
      System.out.println("Square.erase()"); 
  } 
} public class Test62
{
    public static void main(String... args) {
        Shape s = new Circle();
        s.draw();    //输出: Circle.draw()        s = new Square();
        s.draw();    //输出: Square.draw()
    }
}
在编译时s唯一可以确定的就是要调用是draw()方法，但是具休要执行的方法体是哪一个没有确定。在执行时根据方法的后期绑定确定s所指向的是new Circle()的内存空间确定draw()的方法体是Circle里的draw()方法体。所以会执行其对应的draw()方法。同样对于 
s = new Square(); 
s.draw();    //输出: Square.draw() 
也是如此。 从以前回答的贴子上转过来的。

Answer 4

System.out.println()的方法是多態.可以看一下它的源代碼
繼承是類與類之間的關係!

Answer 5

class Driver{
void install(){
System.out.println("安装驱动！！！");
}
}class LenovoDriver extends Driver{
void install(){
System.out.println("安装联想驱动！！！");
}
}
class DellDriver extends Driver{
void install(){
System.out.println("安装戴尔驱动！！！");
}
}public class Driving{
public static void main(String args[]){
Driver abc=new LenovoDriver();
abc.install();
abc=new DellDriver();
abc.install();



}
}这个上面的安装驱动怎么无法实现呢？？
第二个问题： 教程上说这是一个多态的程序，可是我认为是继承的程序
不知道究竟是怎样的？

Answer 6

多态:不同的实例对同一消息的不同响应,(同一个类的不同表现形态,而不同的形态正是通过其不同的子类进行体现!而子类的出现正是因为继承才有的)
通过将子类对象引用赋值给超类对象变量, 来实现动态方法调用。 
      java 的这种机制遵循一个原则：当超类对象引用变量, 引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。   
      1. 如果a是类A的一个引用，那么，a可以指向类A的一个实例,或者说指向类A的一个子类。 
      2. 如果a是接口A的一个引用，那么,a必须指向实现了接口A的一个类的实例。 二、Java多态性实现机制 
      SUN目前的JVM实现机制，类实例的引用就是指向一个句柄（handle）的指针，这个句柄是一对指针： 
      一个指针指向一张表格，实际上这个表格也有两个指针（一个指针指向一个包含了对象的方法表，另外一个指向类对象，表明该对象所属的类型）； 
      另一个指针指向一块从java堆中为分配出来内存空间。 
      The Java Virtual Machine does not require any particular internal structure for objects. In Sun's current implementation of the Java Virtual Machine,  a reference to a class instance is a pointer to a handle that is itself a pair of pointers:  one to a table containing the methods of the object and a pointer to the Class object that represents the type of the object,  and the other to the memory allocated from the Java heap for the object data.  （jvm规范中关于对象内存布局的说明） 三、总结 
      1、通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。 
         DerivedC c2=new DerivedC(); 
         BaseClass a1= c2;            //BaseClass 基类，DerivedC是继承自BaseClass的子类 
         a1.play();                   //play()在BaseClass，DerivedC中均有定义，即子类覆写了该方法 
         分析： 
         *  为什么子类的类型的对象实例可以覆给超类引用？ 
         自动实现向上转型。通过该语句，编译器自动将子类实例向上移动，成为通用类型BaseClass； 
         *  a.play()将执行子类还是父类定义的方法？ 
         子类的。在运行时期，将根据a这个对象引用实际的类型来获取对应的方法。所以才有多态性。一个基类的对象引用，被赋予不同的子类对象引用，执行该方法时，将表现出不同的行为。 
         在a1=c2的时候，仍然是存在两个句柄，a1和c2，但是a1和c2拥有同一块数据内存块和不同的函数表。 
      2、不能把父类对象引用赋给子类对象引用变量 
         BaseClass a2=new BaseClass(); 
         DerivedC c1=a2;//出错 
         在java里面，向上转型是自动进行的,但是向下转型却不是，需要我们自己定义强制进行。 
         c1=(DerivedC)a2; 进行强制转化,也就是向下转型.   
      3、记住一个很简单又很复杂的规则，一个类型引用只能引用引用类型自身含有的方法和变量。 
         你可能说这个规则不对的，因为父类引用指向子类对象的时候，最后执行的是子类的方法的。 
         其实这并不矛盾，那是因为采用了后期绑定，动态运行的时候又根据型别去调用了子类的方法。而假若子类的这个方法在父类中并没有定义，则会出错。 
         例如，DerivedC类在继承BaseClass中定义的函数外，还增加了几个函数（例如 myFun()） 
         分析： 
         当你使用父类引用指向子类的时候，其实jvm已经使用了编译器产生的类型信息调整转换了。 
         这里你可以这样理解，相当于把不是父类中含有的函数从虚拟函数表中设置为不可见的。注意有可能虚拟函数表中有些函数地址由于在子类中已经被改写了，所以对象虚拟函数表中虚拟函数项目地址已经被设置为子类中完成的方法体的地址了。 

Answer 7

如果想要安装驱动出来，在main方法中就应该这么写
Driver abc=new Driver();
abc.install();继承通常是实现多态的方式，上面这段代码就是通过继承来实现多态的
因为子类重写了父类的install()方法，
通过让Driver abc指向不同的对象，调用install()方法时显示不同的结果，这个就是典型的多态。

Answer 8

多态表象为  类的多态--->继承（父子类）
            方法的多态-->重载（同一个类）

Answer 9

多态有三个必要条件
1继承 2重写 3父类引用指向子类对象
class Animal {
public void say() {
}
}// 继承
class Dog extends Animal {
// 重写
public void say() {
System.out.println("i'm a dog");
}
}// 继承
class Cat extends Animal {
// 重写
public void say() {
System.out.println("i'm a cat");
}
}public class Client {
public static void main(String[] args) {
//父类引用
Animal animal;

//指向子类对象
animal = new Dog();
animal.say();

//指向子类对象
animal = new Cat();
animal.say();
}
}
打印
i'm a dog
i'm a cat

Answer 10

你这里定义的对象的时候虽然都是定义成Driver的，但后面new的是Driver的继承的类，所以执行abc.install()的时候就相当于多态了，执行的是子类里面的install()方法，而不是父类里面的了。

Answer 11

父类install()方法已经别子类覆盖（重写）了，所以不会打印出“安装驱动”