新手问一下多态的问题，多态到底怎么理解？

Question

public  abstract class Shape{
         abstract viod draw();  
}
class Square extends Shape{
     viod draw(){}
  
}class Circle extends Shape{
     viod draw(){}
  
}class Test{
      static viod test(){
         Shape s= new Square();
         a.draw();        Shape c=new Circle();
        c.draw();
}
}这里我都看的懂，但后面又加了个方法那个test里面的东西就变了  static viod drawIt(Shape s){}
class Test{
      static viod test(){
         Shape s= new Square();
         drawIt(s);        Shape c=new Circle();
        drawIt(c);
}这里我就看不懂了，为啥要把父类变量放在参数里面，为啥只放了Shape s,不放Shape c,然后 a.draw();为啥变成了drawIt(s);？

Answer 1

Java多态性探悉 一、基本概念       多态性：发送消息给某个对象，让该对象自行决定响应何种行为。 
      通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。       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已经使用了编译器产生的类型信息调整转换了。 
        这里你可以这样理解，相当于把不是父类中含有的函数从虚拟函数表中设置为不可见的。注意有可能虚拟函数表中有些函数地址由于在子类中已经被改写了，所以对象虚拟函数表中虚拟函数项目地址已经被设置为子类中完成的方法体的地址了。 
      4、Java与C++多态性的比较       jvm关于多态性支持解决方法是和c++中几乎一样的， 
      只是c++中编译器很多是把类型信息和虚拟函数信息都放在一个虚拟函数表中，但是利用某种技术来区别。       Java把类型信息和函数信息分开放。Java中在继承以后，子类会重新设置自己的虚拟函数表，这个虚拟函数表中的项目有由两部分组成。从父类继承的虚拟函数和子类自己的虚拟函数。 
      虚拟函数调用是经过虚拟函数表间接调用的，所以才得以实现多态的。       Java的所有函数，除了被声明为final的，都是用后期绑定。 
      C++实现多态性，使用关键字virtual，为了引起晚捆绑，使用虚函数。若一个函数在基类被声明为virtual，则所有子类中都是virtual的。对虚函数的重定义成为越位。 

Answer 2

在实际操作中，多态可以让我们不用关心某个对象到底是什么具体类型，就可以使用该对象的某些方法，而这些方法通过一个抽象类或者接口来实现，多态就是提供父类调用子类代码的一个手段而已。下面给一个例子 
abstract class Person
{
    private String name;
    private int age;
    Person(String name,int age)
    {
        this.name = name;
        this.age = age;
    }
    
    abstract void say();
}class Student extends Person
{
    Student(String name,int age)
    {
        super(name,age);
    }
    public void say()
    {
        System.out.println("I'am a Student");
    }
}class Teacher extends Person
{
    private String profession;
    Teacher(String name,int age,String profession)
    {
        super(name,age);
        this.profession = profession;
    }
    public void say()
    {
        System.out.println("I'am a Teacher");
    }
}class School
{
    private String schoolname;
    private Person person;
    School(String schoolname,Person person)
    {
        this.schoolname = schoolname;
        this.person = person;
    }
    public void foundPerson()
    {
        person.say();
    }
}public class TestPolymoph 
{
    public static void main(String[] args) 
    {
        Student studnet = new Student("lisi",21);
        Teacher teacher = new Teacher("dudu",29,"maths");
        School school1 = new School("changning",studnet);
        School school2 = new School("changning",teacher);
        school1.foundPerson();//I'am a Student
        school2.foundPerson();//I'am a Teacher
    }
}
School方法传递了抽象类Person，具体调用时是根据具体的实际实例化的对象调用对应的方法强调一下：多态可以让我们不用关心某个对象到底是什么具体类型，就可以使用该对象的某些方法，这就是多态的好处。

Answer 3

这里只是一个形式参数，形式参数明白，顾名思义就是代表这样的类型传入了这个方法，drawIt是个静态方法，这个例子想说明，只要是使用了多态的子类，即使传入的对象是父类对象，java中仍然认的是new方法中的那个对象

Answer 4

通过基类的方法， 展现出不同子类功能。这就是多态.比方一下:你和你朋友都是烟鬼,某日,你没有带烟, 而你朋友有n种烟,你说: 来根烟,朋友给你一根;你吸了一下，品出为白沙烟你再要一根,你吸了一下，品出这次是芙蓉王,再要一根,你吸了一下，品出这次是熊猫...上面描述的就是多态!烟 a = 白沙
烟 b = 芙蓉王
烟 c = 熊猫但发现没有, 仅仅通过"烟"基类, 引用到不同的具体类对象(各种品牌的烟韵味),就能让你调用到不同的对象, 这就是多态.而烟到你嘴里[此时你还没有发现是那种烟], 你仅仅凭借"吸"的动作(基类方法),就识别出来,到底是哪种烟对象这就是多态的悬机.多态须具备:1. 基类 和各个子类2. 基类的引用指向实例化的子类对象.
再举一个鸡的例子,鸡是所有其它鸡的基类, 定义了一个方法shape(), 此方法能指明鸡的形态. 所有的子类[火鸡,山鸡,田鸡等],都有这个shape方法, 表明自己的形态,如果用下面的方法定义我需要具体的鸡,[基类 引用 =  实现类的对象]
for example:鸡 a = new 火鸡();鸡 a = new 田鸡();鸡 a = new 山鸡();鸡 a = new 母鸡();
当我使用的时候, 我采用 a 这个引用,a.shape(), 就会得到鸡的形态.
如果我定义的是鸡 a = new 火鸡();那么a.shape得到的是火鸡的形态, 而不需要用具体的火鸡 a = new 火鸡(); 再通过a.shape得到火鸡的形态

Answer 5

Shape是父类，Square、Circle都继承shape,
所以Square、Circle都是一个Shape。
像老师，学生都继承自人。老师和学生当然都是一个人。父类变量放在参数里面，是为了可以把父类的子类传递进去。
这个方法就可以对父类和子类，执行某些通用的语句。就像人可以吃饭，只要你是个要就要吃饭一样，
老师和学生都要吃饭。

Answer 6

zl：“为啥要把父类变量放在参数里面，为啥只放了Shape s,不放Shape c”上面的Shape s 中的s是一个类型名而已嘛！你自己可以随便定义的当然也可以定义成C啊！

Answer 7

现在对多态有更深入的理解了.thanks

Answer 8

   5楼的朋友~~你的列子确实很有创意~~不过在解释的时候有点问题~~
通常将“实现接口类的对象或者继承父类的的子类对象作为参数传入，调用相应方法时，其传入参数都是已经确定的。
    比方说你说的那两个烟鬼,暂定需求者为A,供应者为B。
    A说:"朋友来根烟"，这里的"烟"应该已经确定的对象——如果A一直是抽白沙烟，那么此时他需要的是白沙烟、如果一直抽芙蓉王，那么需要的肯定时芙蓉王,其它的都一样...
    此时的B听到朋友A要烟时，肯定会给相应的烟(白沙烟、芙蓉王...,这样看A平时抽什么烟)，应为他们是朋友所以很了解对方抽的是什么烟。
    A根本不用要抽就知道B给他的是什么烟，因为A在要烟的时候“这里的接口或者父类：烟”其实是已经被实现了的接口类对象或者说被继承的子类对象，他等同于"朋友来根烟==朋友来根白沙烟、朋友来根烟==朋友来根芙蓉王"    第一次来着喊一嗓子 表达能力有限，说的不好还望见谅~
"