Java多态的三个必要条件：

1、 继承

2、 子类重写父类方法

3、 父类引用指向子类对象

然后看一个例子

输出结果为：

给出结论：Father  c  =  new  Child()    在c的眼里只能看到 child 里面的 father 属性！

当满Java多态的三个条件时，可以发现c.eat()调用的实际上是子类的eat(是因为子类重写覆盖了父类方法)，

但c.age调用的还是父类的age(属性/变量不存在重写和覆盖)，而c.play()则不会通过编译。

但是在java的引用中Father不但指定了c以何种方式访问内存，也规定了能够访问内存空间的大小。

我们看Father实例对象的大小是占两行，但Child实例对象占三行(这里就是简单量化一下)。

所以虽然c指向的是Child实例对象，但是前面有Father修饰它，它也只能访问两行的数据，也就是说c根本访问不到Child类中的age！！！只能访问到Father类的age，所以输出40

我们看到Parent的方法表占三行，Child的方法表占4行，c虽然指向了Child类的实例对象，

而对象中也有指针指向Child类的方法表，但是由于c受到了Father的修饰，通过c也只能访问到Child方法表中前3行的内容！！！！

然而前面说过，在方法表的形成过程中，子类重写的方法会覆盖掉表中原来的数据，也就是Child类的方法表的第三行是指向Child.eat的引用，

而不是指向Parent.eat(因为方法表产生了覆盖)，所以c访问到的是Child.eat。也就是子类的方法！！！这种情况下，c是没有办法直接访问到父类的eat方法的。

1. 无论是泛型还是普通父类引用指向子类对象，父类引用可见范围都是父类自己的变量或函数

2. 说明见注释

代码如下：父类

package com.atguigu.spring.beans;

public class Father {

public String fatherName;

public String fatherGetName(){

return "";

}

public void sonUnImplementMethod(){

}

}子类

package com.atguigu.spring.beans;

import java.util.ArrayList;

import java.util.List;

/**

*

* @author jaloLi

* @usage 综上所述(无论泛型，还是普通引用)，如果父类引用指向子类对象，父类引用可见范围都是父类自己的变量或函数

*

*/

public class Son extends Father{

public String sonName;

public Son(String name){

this.sonName = name + fatherName;//正确，子类直接使用，父类的字段

sonUnImplementMethod();//正确，子类直接使用，父类的函数，即使子类未实现的父类函数，子类也可以调用

}

@Override

public String fatherGetName() {

return super.fatherGetName() + sonName;

}

public String sonGetName() {

return sonName;

}

public static void main(String args[]){

List list = new ArrayList();

Son son = new Son("aaa");

Son son1 = new Son("bbb");

Son son2 = new Son("ccc");

list.add(son);

list.add(son1);

list.add(son2);

System.out.println(list.get(0).fatherGetName());//正确，list 中是father 类引用，father 引用的可见范围只是子类的继承函数

System.out.println(list.get(0).sonGetName());//错误，father 类引用无法引用非继承函数

System.out.println(list.get(0).fatherName);//正确，father 引用的可见范围只是子类的继承字段

System.out.println(list.get(0).sonName);//错误

}

}

java多态，如何理解父类引用指向子类对象

要理解多态性，首先要知道什么是“向上转型”。

我定义了一个子类Cat，它继承了Animal类，那么后者就是前者是父类。我可以通过   Cat c = new Cat(); 实例化一个Cat的对象，这个不难理解。

但当我这样定义时：   Animal a = new Cat();

表示定义了一个Animal类型的引用，指向新建的Cat类型的对象。由于Cat是继承自它的父类Animal，所以Animal类型的引用是可以指向Cat类型的对象的。

那么这样做有什么意义呢？因为子类是对父类的一个改进和扩充，所以一般子类在功能上较父类更强大，属性较父类更独特，   定义一个父类类型的引用指向一个子类的对象既可以使用子类强大的功能，又可以抽取父类的共性。

所以，父类类型的引用可以调用父类中定义的所有属性和方法，而对于子类中定义而父类中没有的方法，它是无可奈何的；   同时，父类中的一个方法只有在父类中定义而在子类中没有重写的情况下，才可以被父类类型的引用调用；   对于父类中定义的方法，如果子类中重写了该方法，那么父类类型的引用将会调用子类中的这个方法，这就是动态连接。也可以叫做动态绑定。

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

看下面这段程序：

class Father {

public void func1()

{

func2();

}

// 这是父类中的func2()方法，因为下面的子类中重写了该方法 ，所以在父类类型的引用中调用时，这个方法将不再有效，取而代之的是将调用子类中重写的func2()方法

public void func2() {

System.out.println("AAA");

}

}

class Child extends Father { // func1(int i)是对func1()方法的一个重载

由于在父类中没有定义这个方法，所以它不能被父类类型的引用调用

所以在下面的main方法中child.func1(68)是不对的

public void func1(int i) {

System.out.println("BBB");

} // func2()重写了父类Father中的func2()方法   如果父类类型的引用中调用了func2()方法，那么必然是子类中重写的这个方法

public void func2() {

System.out.println("CCC");

}

}

public class PolymorphismTest {

public static void main(String[] args) {

Father child = new Child();

child.func1();// 打印结果将会是什么？ } }

上面的程序是个很典型的多态的例子。子类Child继承了父类Father，并重载了父类的func1()方法，重写了父类的func2()方法。重载后的 func1(int i)和func1()不再是同一个方法，由于父类中没有func1(int i)，那么，父类类型的引用child就不能调用func1(int  i)方法。而子类重写了func2()方法，那么父类类型的引用child在调用该方法时将会调用子类中重写的func2()

}

}

那么该程序将会打印出什么样的结果呢？       很显然，应该是“CCC”。

对于多态，可以总结它为：

一、使用父类类型的引用指向子类的对象；

二、该引用只能调用父类中定义的方法和变量；

三、如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法；(动态连接、动态调用)

四、变量不能被重写(覆盖)，”重写“的概念只针对方法，如果在子类中”重写“了父类中的变量，那么在编译时会报错。

多态的3个必要条件：

1.继承   2.重写   3.父类引用指向子类对象。