来源:http://blog.csdn.net/hikvision_java_gyh/article/details/8957456

面向对象编程有三个特征,即封装、继承和多态。

  封装隐藏了类的内部实现机制,从而可以在不影响使用者的前提下改变类的内部结构,同时保护了数据。

  继承是为了重用父类代码,同时为实现多态性作准备。那么什么是多态呢?

  方法的重写、重载与动态连接构成多态性。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类型的对象的。那么这样做有什么意义呢?因为子类是对父类的一个改进和扩充,所以一般子类在功能上较父类更强大,属性较父类更独特,

  定义一个父类类型的引用指向一个子类的对象既可以使用子类强大的功能,又可以抽取父类的共性。

  所以,父类类型的引用可以调用父类中定义的所有属性和方法,而对于子类中定义而父类中没有的方法,它是无可奈何的;

  同时,父类中的一个方法只有在在父类中定义而在子类中没有重写的情况下,才可以被父类类型的引用调用;

  对于父类中定义的方法,如果子类中重写了该方法,那么父类类型的引用将会调用子类中的这个方法,这就是动态连接。

  看下面这段程序:

  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”。

  对于多态,可以总结它为:

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

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

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

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

  ****************************************************************************************************************************

  多态详解(整理)2008-09-03 19:29多态是通过:

  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(),这样才可以...

  对接口来说,情况是类似的...

  实例:

  package domatic;

  //定义超类superA

  class superA {

  int i = 100;

  void fun(int j) {

  j = i;

  System.out.println("This is superA");

  }

  }

  // 定义superA的子类subB

  class subB extends superA {

  int m = 1;

  void fun(int aa) {

  System.out.println("This is subB");

  }

  }

  // 定义superA的子类subC

  class subC extends superA {

  int n = 1;

  void fun(int cc) {

  System.out.println("This is subC");

  }

  }

 class Test {

  public static void main(String[] args) {

  superA a = new superA();

  subB b = new subB();

  subC c = new subC();

  a = b;

  a.fun(100);

  a = c;

  a.fun(200);

  }

  }

  /*

  * 上述代码中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()的时候得到的结果和表现形式就不一样了,这就是多态,相同的消息(也就是调用相同的方法)会有不同的结果。举例说明:

  //父类

  public class Father{

  //父类有一个打孩子方法

  public void hitChild(){

  }

  }

  //子类1

  public class Son1 extends Father{

  //重写父类打孩子方法

  public void hitChild(){

  System.out.println("为什么打我?我做错什么了!");

  }

  }

  //子类2

  public class Son2 extends Father{

  //重写父类打孩子方法

  public void hitChild(){

  System.out.println("我知道错了,别打了!");

  }

  }

  //子类3

  public class Son3 extends Father{

  //重写父类打孩子方法

  public void hitChild(){

  System.out.println("我跑,你打不着!");

  }

  }

  //测试

  public class Test{

  public static void main(String args[]){

  Father father;

  father = new Son1();

  father.hitChild();

  father = new Son2();

  father.hitChild();

  father = new Son3();

  father.hitChild();

  }

  }

  都调用了相同的方法,出现了不同的结果!这就是多态的表现!

Java多态性详解——父类引用子类对象的更多相关文章

  1. Java多态性详解 (父类引用子类对象)

    面向对象编程有三个特征,即封装.继承和多态. 封装隐藏了类的内部实现机制,从而可以在不影响使用者的前提下改变类的内部结构,同时保护了数据. 继承是为了重用父类代码,同时为实现多态性作准备.那么什么是多 ...

  2. 【转】Java内部类详解

    一.内部类基础 在Java中,可以将一个类定义在另一个类里面或者一个方法里面,这样的类称为内部类.广泛意义上的内部类一般来说包括这四种:成员内部类.局部内部类.匿名内部类和静态内部类.下面就先来了解一 ...

  3. Java面向对象详解

    Java面向对象详解 前言:接触项目开发也有很长一段时间了,最近开始萌发出想回过头来写写以前学 过的基础知识的想法.一是原来刚开始学习接触编程,一个人跌跌撞撞摸索着往前走,初学的时候很多东西理解的也懵 ...

  4. Java虚拟机详解----JVM常见问题总结

    [声明] 欢迎转载,但请保留文章原始出处→_→ 生命壹号:http://www.cnblogs.com/smyhvae/ 文章来源:http://www.cnblogs.com/smyhvae/p/4 ...

  5. java 泛型详解-绝对是对泛型方法讲解最详细的,没有之一

    对java的泛型特性的了解仅限于表面的浅浅一层,直到在学习设计模式时发现有不了解的用法,才想起详细的记录一下. 本文参考java 泛型详解.Java中的泛型方法. java泛型详解 1. 概述 泛型在 ...

  6. Java IO 详解

    Java IO 详解 初学java,一直搞不懂java里面的io关系,在网上找了很多大多都是给个结构图草草描述也看的不是很懂.而且没有结合到java7 的最新技术,所以自己来整理一下,有错的话请指正, ...

  7. java关键字(详解)

    目录 1. 基本类型 1) boolean 布尔型 2) byte 字节型 3) char 字符型 4) double 双精度 5) float 浮点 6) int 整型 7) long 长整型 8) ...

  8. Java集合详解8:Java的集合类细节精讲

    Java集合详解8:Java集合类细节精讲 今天我们来探索一下Java集合类中的一些技术细节.主要是对一些比较容易被遗漏和误解的知识点做一些讲解和补充.可能不全面,还请谅解. 本文参考:http:// ...

  9. 【Java_基础】Java内部类详解

    1.四种内部类 java中的四种内部类:成员内部类.静态内部类.局部内部类和匿名内部类.其中匿名内部类用到的最多. 1.1.成员内部类 若一个类定义在另一个类的内部作为实例成员,我们把这个作为实例成员 ...

随机推荐

  1. JWT的认识和session的区别

    1.前后端分离框架中前端和后端域名不同,不能跨域请求,加上移动端无cookie,所以无法使用session.2.基于token的认证和传统的session认证的区别: 传统的session认证: 我们 ...

  2. T100——读取系统程序临时表数据

    SELECT   * FROM   USER_OBJECTS ORDER  BY  CREATED DESC SELECT   * FROM   USER_OBJECTS WHERE  OBJECT_ ...

  3. 怎样在 Vue 中使用 v-model 实现双向数据绑定?

    1. 所谓 双向数据绑定, 可以理解为: 修改 A , B 会跟着被修改, 修改 B , A 会跟着被修改. 常用在需要 进行用户输入的地方, 比如 这些 html 标签:  input.select ...

  4. ZOOKEEPER进阶

    集群个数: 2n+1,因为集群当宕机大于等于二分之一的机子时,集群选举会失败.故 2n+1台机器和3n台机器可靠性相同 Leader的作用: 为了实现各个节点数据的一致性,需要一个负责协调数据同步的操 ...

  5. websocket vue

    /* eslint-disable */ let tt; let count = 1; let lockReconnect = false; function isJsonString(str) { ...

  6. vue打包后css背景图片地址找不到

    背景图片变成了这样:static/css/static/imgs/xxx.jpg 解决方法,修改build/utils,添加   publicPath: '../../'    就行 对比了下,com ...

  7. 自定义事件 Event 、CustomEvent的使用

    通过Event和dispathEvents触发自定义事件 <span id="btn">获取</span> <script> var event ...

  8. 由于MTU设置不当导致的访问超时

    现象 工作中遇到一件怪事:搭建好服务器后(VPN服务器,创建了虚拟网卡),服务器和客户端之间响应正常且很稳定,客户端也能正常通过服务器访问外网.但是访问个别网站时可以打开文字,但是部分图片打不开(也不 ...

  9. MySQL数据库笔记三:数据查询语言(DQL)与事务控制语言(TCL)

    五.数据查询语言(DQL) (重中之重) 完整语法格式: select 表达式1|字段,.... [from 表名 where 条件] [group by 列名] [having 条件] [order ...

  10. apk 查看sha1签名

    1,首先使用解压工具解开apk. 2,进入meta-inf文件夹,进入命令行模式 输入如下命令 keytool -printcert -file CERT.RSA