父类引用指向子类对象指的是：

例如父类Animal，子类Cat，Dog。此中Animal可所以类也可所以接口，Cat和Dog是持续或实现Animal的子类。

Animal animal = new Cat（）;

即声明的是父类，实际指向的是子类的一个对象。

那这么应用的长处是什么，为什么要这么用？可以用这几个关键词来概括：多态、动态链接，向上转型

也有人说这是面向接口编程，可以降落法度的耦合性，即调用者不必关怀调用的是哪个对象，只须要针对接口编程就可以了，被调用者对于调用者是完全透明的。让你更存眷父类能做什么，而不去关怀子类是具体怎么做的，你可以随时调换一个子类，也就是随时调换一个具体实现，而不消批改其他.

今后连络设计模式（如工厂模式，模式）和反射机制可能有更深懂得。

  下面介绍java的多态性和此中的动态链接，向上转型：

  面向对象的三个特点：封装、持续和多态；

   封装隐蔽了类的内部实现机制，可以在不影响应用者的前提下批改类的内部布局，同时保护了数据；

   持续是为了重用父类代码，子类持续父类就拥有了父类的成员。

   办法的重写、重载与动态连接构成多态性。Java之所以引入多态的概念，原因之一是它在类的持续题目上和C++不合，后者允很多持续，这确切给其带来的很是强大的功能，然则错杂的持续关系也给C++开辟者带来了更大的麻烦，为了规避风险，Java只容许单持续，派生类与基类间有IS-A的关系（即“猫”is a “动物”）。如许做固然包管了持续关系的简单了然，然则势必在功能上有很大的限制，所以，Java引入了多态性的概念以弥补这点的不足，此外，抽象类和接口也是解决单持续规定限制的首要手段。同时，多态也是面向对象编程的精华地点。 

  懂得多态，起首要知道“向上转型”。

我定义了一个子类Cat，它持续了Animal类，那么后者就是前者是父类。我可以经由过程 

Cat c = new Cat（）; 
实例化一个Cat的对象，这个不难懂得。但当我如许定义时： 

Animal a = new Cat（）; 
这代表什么意思呢？ 

    很简单，它默示我定义了一个Animal类型的引用，指向新建的Cat类型的对象。因为Cat是持续自它的父类Animal，所以Animal类型的引用是可以指向Cat类型的对象的。这就是“向上转型”。

    那么如许做有什么意义呢？因为子类是对父类的一个改进和扩充，所以一般子类在功能上较父类更强大，属性较父类更独特， 定义一个父类类型的引用指向一个子类的对象既可以应用子类强大的功能，又可以抽取父类的共性。 所以，父类类型的引用可以调用父类中定义的所有属性和办法，而对于子类中定义而父类中没有的办法，父类引用是无法调用的； 

那什么是动态链接呢？当父类中的一个办法只有在父类中定义而在子类中没有重写的景象下，才可以被父类类型的引用调用； 对于父类中定义的办法，若是子类中重写了该办法，那么父类类型的引用将会调用子类中的这个办法，这就是动态连接。 

  下面看一下典范的多态例子：

    上方的法度是个很典范的多态的例子。子类Child持续了父类Father，并重载了父类的func1（）办法，重写了父类的func2（）办法。重载后的func1（int i）和func1（）不再是同一个办法，因为父类中没有func1（int i），那么，父类类型的引用child就不克不及调用func1（int i）办法。而子类重写了func2（）办法，那么父类类型的引用child在调用该办法时将会调用子类中重写的func2（）。 

    那么该法度将会打印出什么样的成果呢？ 
    很显然，应当是“CCC”。 

   对于多态，可以总结以下几点：

    一、应用父类类型的引用指向子类的对象； 
    二、该引用只能调用父类中定义的办法和变量； 
    三、若是子类中重写了父类中的一个办法，那么在调用这个办法的时辰，将会调用子类中的这个办法；（动态连接、动态调用） 
    四、变量不克不及被重写（覆盖），”重写“的概念只针对办法，若是在子类中”重写“了父类中的变量，那么在编译时会报错。 

另转载：

多态是经由过程: 
1 接口 和 实现接口并覆盖接口中同一办法的几不合的类表现的 
2 父类 和 持续父类并覆盖父类中同一办法的几个不合子类实现的. 

一、根蒂根基概念 

多态性：发送消息给某个对象，让该对象自行决意响应何种行动。 
经由过程将子类对象引用赋值给超类对象引用变量来实现动态办法调用。 

java 的这种机制遵守一个原则：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决意了调用谁的成员办法，然则这个被调用的办法必须是在超类中定义过的，也就是说被子类覆盖的办法。 

1. 若是a是类A的一个引用，那么，a可以指向类A的一个实例，或者说指向类A的一个子类。 
2. 若是a是接口A的一个引用，那么，a必须指向实现了接口A的一个类的实例。 


二、Java多态性实现机制 

SUN今朝的JVM实现机制，类实例的引用就是指向一个句柄（handle）的指针，这个句柄是一对指针： 
一个指针指向一张表格，实际上这个表格也有两个指针（一个指针指向一个包含了对象的办法表，别的一个指向类对象，注解该对象所属的类型）； 
另一个指针指向一块从java堆中为分派出来内存空间。 

三、总结 

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的，都是用后期绑定。 

四.  示例：1个行动，不合的对象，他们具体表现出来的体式格式不一样， 
        比如:    办法重载 overloading 以及 办法重写（覆盖）override 
                  class Human{ 
                void run（）{输出 人在跑} 
                      } 
                class Man extends Human{ 
            void run（）{输出 汉子在跑} 
                  } 
                这个时辰，同是跑，不合的对象，不一样（这个是办法覆盖的例子） 
                class Test{ 
            void out（String str）{输出 str} 
            void out（int i）{输出 i} 
                } 
                这个例子是办法重载，办法名雷同，参数表不合 

              ok，熟悉打听了这些还不敷，还用人在跑举例 
              Human ahuman=new Man（）; 
              如许我便是实例化了一个Man的对象，并声了然一个Human的引用，让它去指向Man这个对象 
              意思是说，把 Man这个对象当 Human看了. 

              比如去动物园，你看见了一个动物，不知道它是什么， 这是什么动物？ 这是大熊猫!  
              这2句话，就是好的证实，因为不知道它是大熊猫，但知道它的父类是动物，所以， 
              这个大熊猫对象，你把它当成其父类 动物看，如许子合情公道. 

              这种体式格式下要重视 new Man（）;的确切例化了Man对象，所以 ahuman.run（）这个办法 输出的  是 汉子在跑  

              若是在子类 Man下你 写了一些它独有的办法 比如 eat（），而Human没有这个办法， 在调用eat办法时，必然要重视 强迫类型转换 （（Man）ahuman）.eat（），如许才可以... 对接口来说，景象是类似的... 

    

/ 
上述代码中subB和subC是超类superA的子类，我们在类Test中声了然3个引用变量a， b， 
c，经由过程将子类对象引用赋值给超类对象引用变量来实现动态办法调用。也许有人会问： 
为什么（1）和（2）不输出：This is superA。 
java的这种机制遵守一个原则：当超类对象引用变量引用子类对象时， 
被引用对象的类型而不是引用变量的类型决意了调用谁的成员办法， 
然则这个被调用的办法必须是在超类中定义过的， 
也就是说被子类覆盖的办法。 
所以，不要被上例中（1）和（2）所困惑，固然写成a.fun（），然则因为（1）中的a被b赋值， 
指向了子类subB的一个实例，因而（1）所调用的fun（）实际上是子类subB的成员办法fun（）， 
它覆盖了超类superA的成员办法fun（）；同样（2）调用的是子类subC的成员办法fun（）。 
别的，若是子类持续的超类是一个抽象类，固然抽象类不克不及经由过程new操纵符实例化， 
然则可以创建抽象类的对象引用指向子类对象，以实现运行时多态性。具体的实现办法同上例。 
不过，抽象类的子类必须覆盖实现超类中的所有的抽象办法， 
不然子类必须被abstract润饰符润饰，当然也就不克不及被实例化了 
/ 

1.JAVA里没有多持续，一个类之能有一个父类。而持续的发挥解析就是多态。一个父类可以有多个子类，而在子类里可以重写父类的办法（例如办法print（）），如许每个子类里重写的代码不一样，天然发挥解析情势就不一样。如许用父类的变量去引用不合的子类，在调用这个雷同的办法print（）的时辰获得的成果和发挥解析情势就不一样了，这就是多态，雷同的消息（也就是调用雷同的办法）会有不合的成果。举例申明： 

都调用了雷同的办法，呈现了不合的成果！这就是多态的发挥解析。

上方的示例也就是工厂模式的一个简单表现