怎么理解：多态的体现：父类的引用指向了自己的子类对象？

多态就是同一类型多个变量，在执行同一个方法时，表现出多种行为特征。
比如都是动物，都有走路的这种方法，鸡用俩条腿走，马用四条腿走。
详细请看：http://blog.sina.com.cn/u/2742093933

class A {
    private int i = 1;
    public A() {
            method();
    }
   
    public void method() {
            System.out.println(i);
    }
}

class B extends A {
    private  int i = 20;
   
    public B() {
            i = 10;
    }
   
  public void method() {
           System.out.println(i);
    }
}

public class Demo1 {
    public static void main(String[] args) {
           A a = new B();
           a.method();//返回结果：１０　　　　父类的引用，指向上子类的对象。
    }
}

给你看下毕老师视频的笔记和我个人的心得

多态
1，多态的体现
父类的引用指向了自己的子类对象
父类的引用也可以接收自己的子类对象

2，多态的前提
必须是类与类之间有关系：要么继承，要么实现
通常还有一个前提：存在覆盖（前期我预先调用功能，后期定义子类去实现功能，并把子类作为参数传递进来，这就实现了后期的扩展性 ）

3，多态好的好处
多态的出现大大提高了程序的扩展性

4，多态的弊端：
只能使用父类的引用访问父类中的成员


上一段代码：
class DuoTaiDemo2
{
        public static void main(String[] args)
        {
                Animal a = new Cat();//类型提升，向上转型
                a.eat();
               
                //如果想要调用猫的特有方法的时候，应该如何操作？
                //强制将父类的引用，转成子类类型，向下转型
                Cat c = (Cat)a;
                c.catchMouse();
               
                //千万不要出现这样的操作，就是将父类的对象转成子类类型
                //我们能转换的是父类应用指向了自己的子类对象时，该引用可以被提升，也可以被强制转换
                //多态：自始至终都是子类对象在做着变化！！！！！！！！！！！！
                Animal a = new Animal();
                Cat c = (Cat)a;
        }
}


再给你看一个多态的应用，里面也包括了接口的应用
这个是毕老师的代码，真心经典，好好看下
interface PCI
{
        public void open();
        public void close();
}

class MainBoard
{
        public void run()
        {
                System.out.println("mainboard run");
        }
        public void usePCI(PCI p)
        {
                if(p!=null)
                {
                        p.open();
                        p.close();
                }
        }
}

class NetCard implements PCI
{
        public void open()
        {
                System.out.println("netcard open");
        }
        public void close()
        {
                System.out.println("netcard close");
        }
}

class SoundCard implements PCI
{
        public void open()
        {
                System.out.println("soundcard open");
        }
        public void close()
        {
                System.out.println("soundcard close");
        }
}

class  DuoTaiDemo5
{
        public static void main(String[] args)
        {
                MainBoard mb = new MainBoard();
                mb.run();
                mb.usePCI(null);
                mb.usePCI(new NetCard());
                mb.usePCI(new SoundCard());
        }
}

其实，多态就是同样一个实体对象可以有不同的类型，这就是多态，比如你就是一个实体对象，我既可以说你是男人，人，动物，也可以说你是生物，这就是你的多态性！！！！！！！！！！！！！！

1. class Father
   
2. {
   
3.      String father = "father";
   
4.      public void show(){
   
5.              System.out.println("Father is show()");
   
6.      }
   
7.      public void show1(){
   
8.              System.out.println("Father  show1111()");
   
9.      }
   
10. }
    
11. class Son extends Father
    
12. {
    
13.      String father = "son";
    
14.      String son = "子类特有的";
    
15.      //重写了父类方法
    
16.      public void show(){
    
17.              System.out.println("Son is show()");
    
18.      }
    
19.      //重载父类的方法，但对于父类，是一个新增加的功能
    
20.      public void show(int i){
    
21.          System.out.println("Son is show() again");
    
22.      }
    
23. }
    
24. //    测试多态性
    
25. class ExtendsDemo
    
26. {
    
27.      public static void main(String []args){
    
28.             
    
29.          Father f = new Father();//
    
30.          Father s = new Son();//创建一个父类引用指向子类对象
    
31.          Son son = new Son();//
    
32.          f.show();//父亲访问自己的方法
    
33.          s.show();//由于父类引用指向了子类对象，子类又对父类的show()方法进行了重写，故访问子类的方法
    
34.          //s.show(1);//show(int i)由于是子类新增加的功能，父类并不知道，所以不能调用，会编译不过
    
35.          s.show1();//子类并没有重写父类show1()方法，故会去调用父类的方法show1()
    
36.          System.out.println("Father f :"+f.father);//调用父类属性
    
37.          System.out.println("Father s :"+s.father);//调用父类属性
    
38.           System.out.println("Father s:"+f.son);//为子类Son新增加的属性，父类不能调用，编译不过
    
39.      }
    
40. }
    
41. /*运行结果：
    
42.          Father is show()
    
43.          Son is show()
    
44.          Father  show1111()
    
45.          Father f :father
    
46.          Father s :father
    
47. */
    
48.      
    
49. /*
    
50.      多态的三个必要条件：
    
51.           1.继承   2.重写   3.父类引用指向子类对象。
    
52.      总结：
    
53.      
    
54.          一、使用父类类型的引用指向子类的对象；
    
55. 
    
56.          二、该引用只能调用父类中已经定义的方法和变量；
    
57. 
    
58.          三、如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法；（动态连接、动态调用）
    
59.                  动态绑定是指”在执行期间（而非编译期间）“判断所引用对象的实际类型，根据实际的类型调用其相应的方法。
    
60. 
    
61.          四、变量不会被重写（覆盖），”重写“的概念只针对方法，如果在子类中”重写“了父类中的变量，那么在调用时，还是会调用父类的变量
    
62.          
    
63. */

复制代码

其实多态 ，一句话说到点子上就是 同一个消息（来自父类）被不同的对象（同属一个类的不同子类对象）接收到会有不同的处理方式 。 为什么建立对象时父类的引用指向了自己的子类对象？ 个人理解就是 ，你可以随时根据要完成的不同事情或者相同的事情要选择一个比较适合的方法而替换一个干活的（子类），而不会出现不能干某些活的情况。

亲，