多态特性:

子类Child继承父类Father,我们可以编写一个指向子类的父类类型引用,该引用既可以处理父类Father对象,也可以处理子类Child对象,当相同的消息发送给子类或者父类对象时,该对象就会根据自己所属的引用而执行不同的行为,这就是多态。即多态性就是相同的消息使得不同的类做出不同的响应。

 /**
* 多态特性
*
* @author Wáng Chéng Dá
* @create 2017-02-21 14:39
*/
class Father {
String x = "Father--x";
static String y = "Father--y"; void eat() {
System.out.println("Father喜欢吃大蒜!");
} static void speak() {
System.out.println("Father:儿子去写作业!");
}
} class Son extends Father {
String x = "Son--x";
static String y = "Son--y"; void eat() {
System.out.println("Son喜欢爽歪歪!");
} static void speak() {
System.out.println("Son:爸爸我可不可以不写作业, 练字啊?");
}
} public class Polymorphic { public static void main(String[] args) { System.out.println("---------父类引用指向子类对象[Father f = new Son()]START-----------");
Father f = new Son(); // 父类引用指向了子类对象。
System.out.println(f.x);
System.out.println(f.y);
f.eat();
f.speak();
System.out.println("---------父类引用指向子类对象[Father f = new Son()]END-----------"); System.out.println("---------[Son son = new Son()]START-----------");
Son son = new Son();
System.out.println(son.x);
System.out.println(son.y);
son.eat();
son.speak();
System.out.println("---------[Son son = new Son()]END-----------"); System.out.println("---------[Father father = new Father()]START-----------");
Father father = new Father();
System.out.println(father.x);
System.out.println(father.y);
father.eat();
father.speak();
System.out.println("---------[Father father = new Father()]END-----------"); System.out.println("---------[Son s = new Father()]START-----------");
System.out.println("Son s = new Father()--子类引用指向父类会编译失败");
System.out.println("---------[Son s = new Father()]END-----------"); }
}

控制台输出:

---------父类引用指向了子类对象[Father f = new Son()]START-----------
Father--x
Father--y
Son喜欢爽歪歪!
Father:儿子去写作业!
---------父类引用指向了子类对象[Father f = new Son()]END-----------
---------[Son son = new Son()]START-----------
Son--x
Son--y
Son喜欢爽歪歪!
Son:爸爸我可不可以不写作业, 练字啊?
---------[Son son = new Son()]END-----------
---------[Father father = new Father()]START-----------
Father--x
Father--y
Father喜欢吃大蒜!
Father:儿子去写作业!
---------[Father father = new Father()]END-----------
---------[Son s = new Father()]START-----------
Son s = new Father()--子类引用指向父类会编译失败
---------[Son s = new Father()]END-----------

总结:

1:父类和子类有相同的成员变量 , 多态下访问的是父类的成员变量。 
2:当子类重写父类非静态方法,多态下访问的是子类的非静态方法。 
3:当子类重写父类静态方法,多态下访问的是父类的静态方法。

多态的实现:

Java实现多态有三个必要条件:继承、重写、向上转型。

继承:就是扩展已有类的功能,在继承中分为子类和父类,父类有时候也称为超类(super class),子类有时候称为派生类(一个父类可以有多个子类,一个子类必须只有一个父类)。

重写:子类对父类中某些方法进行重新定义(方法同时存在父子类关系中)。

向上转型:一个指向子类的父类类型引用[Father f = new Child()]。

 class Wine {
private String name; public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public Wine(){
} public String drink(){
return "喝的是 " + getName();
} /**
* 重写toString()
*/
public String toString(){
return "Wine中重写toString()";
}
} class Beer extends Wine{
public Beer(){
setName("啤酒");
} /**
* 重写父类方法,实现多态
*/
public String drink(){
return "喝的是 " + getName();
} /**
* 重写toString()
*/
public String toString(){
return "Wine : " + getName();
}
} class RedWine extends Wine{
public RedWine(){
setName("红酒");
} /**
* 重写父类方法,实现多态
*/
public String drink(){
return "喝的是 " + getName();
} /**
* 重写toString()
*/
public String toString(){
return "Wine : " + getName();
}
} public class Test {
public static void main(String[] args) {
//定义父类数组
Wine[] wines = new Wine[2];
//定义两个子类
Beer beer = new Beer();
RedWine redWine = new RedWine(); //父类引用子类对象
wines[0] = beer;
wines[1] = redWine; for(int i = 0 ; i < 2 ; i++){
System.out.println(wines[i].toString() + "\n这杯" + wines[i].drink());
System.out.println("-------------------------------");
}
}
}

控制台输出:

Wine : 啤酒

这杯喝的是 啤酒

-------------------------------

Wine : 红酒

这杯喝的是 红酒

-------------------------------

特性:

1. 当子类重写父类的方法被调用时,只有对象继承链中的最末端的方法才会被调用。

2. 对于引用子类的父类类型,在处理该引用时,它适用于继承该父类的所有子类,子类对象的不同,对方法的实现也就不同,执行相同动作产生的行为也就不同。

经典实例

 class A {
public String show(D obj) {
return ("A and D");
} public String show(A obj) {
return ("A and A");
} } class B extends A{
public String show(B obj){
return ("B and B");
} public String show(A obj){
return ("B and A");
}
} class C extends B{ } class D extends B{ } class Test {
public static void main(String[] args) {
A a1 = new A();
A a2 = new B();
B b = new B();
C c = new C();
D d = new D();
System.out.println("A----B----C");
System.out.println(" ┖----D");
System.out.println("this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)"); System.out.println("1--" + a1.show(b));
System.out.println("2--" + a1.show(c));
System.out.println("3--" + a1.show(d));
System.out.println("4--" + a2.show(b));
System.out.println("5--" + a2.show(c));
System.out.println("6--" + a2.show(d));
System.out.println("7--" + b.show(b));
System.out.println("8--" + b.show(c));
System.out.println("9--" + b.show(d));
}
}

控制台输出:

A----B----C
┖----D
this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)
1--A and A
2--A and A
3--A and D
4--B and A
5--B and A
6--A and D
7--B and B
8--B and B
9--A and D

关系图谱:

分析:

在这里看结果1、2、3还好理解,从4开始就开始糊涂了,对于4来说为什么输出不是“B and B”呢?

首先我们先看一句话:当超类对象引用变量引用子类对象时,被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法,但是这个被调用的方法必须是在超类中定义过的,也就是说被子类覆盖的方法。这句话对多态进行了一个概括。其实在继承链中对象方法的调用存在一个优先级:this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。

比如4,a2.show(b),a2是一个引用变量,类型为A,则this为a2,b是B的一个实例,于是它到类A里面找show(B obj)方法,没有找到,于是到A的super(超类)找,而A没有超类,因此转到第三优先级this.show((super)O),this仍然是a2,这里O为B,(super)O即(super)B即A,因此它到类A里面找show(A obj)的方法,类A有这个方法,但是由于a2引用的是类B的一个对象,B覆盖了A的show(A obj)方法,因此最终锁定到类B的show(A obj),输出为"B and A”。

再比如8,b.show(c),b是一个引用变量,类型为B,则this为b,c是C的一个实例,于是它到类B找show(C obj)方法,没有找到,转而到B的超类A里面找,A里面也没有,因此也转到第三优先级this.show((super)O),this为b,O为C,(super)O即(super)C即B,因此它到B里面找show(B obj)方法,找到了,由于b引用的是类B的一个对象,因此直接锁定到类B的show(B obj),输出为"B and B”。

当超类对象引用变量引用子类对象时,被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法,但是这个被调用的方法必须是在超类中定义过的,也就是说被子类覆盖的方法。

Java面向对象编程三大特性 --- 多态的更多相关文章

  1. 3.java面向对象编程三大特性之多态

    面向对象编程的三大特性:封装.继承.多态 封装隐藏了类的内部实现机制,可以在不影响使用的情况下改变类的内部结构,同时也保护了数据.对类的外部而言它的内部实现细节是隐藏的,暴露给外界的只是它的实现方法. ...

  2. java面向对象的三大特性——多态

    多态 所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定,而是在程序运行期间才确定,即一个引用变量倒底会指向哪个类的实例对象,该引用变量发出的方法调用到底 ...

  3. 2.Java面向对象编程三大特性之继承

    在<Think in Java>中有这样一句话:复用代码是java众多引人注目的功能之一.但要想成为极具革命性的语言,仅仅能够复用代码并对其加以改变是不够的,他还必须能够做更多的事情.复用 ...

  4. 1.java面向对象编程三大特性之封装

    封装即把一个对象的属性.行为等放在一个实体类中隐藏起来,不允许外部对其进行修改,但是被封装的属性.行为会对外提供一个接口与外部联系,这个对外的接口通常情况下就是set().get()方法.可以通过se ...

  5. Java面向对象的三大特性 多态

    多态 对象的多种形态 继承是实现多态的基础 1,引用多态    父类的引用可以指向本类的对象    父类的引用可以指向子类的对象 2,方法多态    创建本类对象时,调用的方法为本类方法    创建子 ...

  6. Java学习笔记二十五:Java面向对象的三大特性之多态

    Java面向对象的三大特性之多态 一:什么是多态: 多态是同一个行为具有多个不同表现形式或形态的能力. 多态就是同一个接口,使用不同的实例而执行不同操作. 多态性是对象多种表现形式的体现. 现实中,比 ...

  7. 谈谈Java面向对象的三大特性

    Java面向对象的三大特性就是指封装.继承.多态了. 一.封装: 概念:封装是指隐藏对象的属性和实现细节,仅对外提供公共访问方式. (举例:笔记本电脑就是一个封装体,Java语言中最小的封装体就是函数 ...

  8. Java学习笔记二十一:Java面向对象的三大特性之继承

    Java面向对象的三大特性之继承 一:继承的概念: 继承是java面向对象编程技术的一块基石,因为它允许创建分等级层次的类. 继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方 ...

  9. Java学习笔记十八:Java面向对象的三大特性之封装

    Java面向对象的三大特性之封装 一:面向对象的三大特性: 封装 继承 多态   二:封装的概念: 将类的某些信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访 ...

随机推荐

  1. python2.7练习小例子(十七)

        17):题目:求s=a+aa+aaa+aaaa+aa...a的值,其中a是一个数字.例如2+22+222+2222+22222(此时共有5个数相加),几个数相加由键盘控制.     程序分析: ...

  2. PHP.45-TP框架商城应用实例-后台20-权限管理-RBAC表构造与代码生成

    权限管理 三张主表{p39_privilege(权限).p39_role(角色).p39_admin(管理)} 两张中间表{p39_role_pri(角色-权限).p39_admin_role(管理- ...

  3. 2019js面试题前端必问点小视频

    其实市面上的面试题有很多,但是大部分都是总结的blog居多,有时候说明一个事物也许口述几分钟就可以搞定,但是看帖子可能要分析半天 所以我就出一部分前端js必考的小视频,不管我们什么时候面试基本都绕不过 ...

  4. IdFTP中FEAT命令的问题

    IdFTP控件很方便开发FTP客户端,用于传输文件.一次笔者的一个在阿里云的服务器突发故障,显示无法登陆FTP,而使用其他客户端(如FlashFxp)经过该项目设置,又可正常使用. 查询后说是FEAT ...

  5. fsync体会

    看这个链接:http://www.postgresql.org/docs/9.1/static/runtime-config-wal.html 是这样说的: fsync (boolean) If th ...

  6. 初步学习pg_control文件之五

    接前文 初步学习pg_control文件之四,继续看何时出现  DB_IN_CRASH_RECOVERY: 看下面代码就比较清楚了:如果对 InArchiveRecovery 判断值为假,而且 读取出 ...

  7. [转载]压力测试工具siege的用法

    压力测试工具siege 原文:http://blog.csdn.net/qingye2008/article/details/34500949 Siege是Linux下的一个web系统的压力测试工具, ...

  8. C#非托管跨线程委托调试

    使用C#调用mingw的so文件,拿视频数据回wpf的界面进行显示,注册了回调函数.C++在调用回调函数时遇到了委托被回收的问题,提示:“类型的已垃圾回收委托进行了回调.这可能会导致应用程序崩溃.损坏 ...

  9. Spring MVC自动为对象注入枚举数据

    一.实现转换工厂,定义转换实现,如下:     package com.mafwo; import org.springframework.core.convert.converter.Convert ...

  10. 【集训试题】exam 信心考 最小割

    题意概述: 有N个人,A,B两个考场.如果学生i在A考场,总信心值增加xi:如果学生i在B考场,总信心值增加yi.其中还有m对好友,当第i对好友的两个人都在A考场时,总信心值增加ai:如果两人都在B考 ...