进一步理解Java中的多态概念
多态性有两种:
1）编译时多态性
对于多个同名方法,如果在编译时能够确定执行同名方法中的哪一个,则称为编译时多态性.
2）运行时多态性
如果在编译时不能确定,只能在运行时才能确定执行多个同名方法中的哪一个,则称为运行时多态性.
方法覆盖表现出两种多态性,当对象获得本类实例时,为编译时多态性,否则为运行时多态性,例如:
XXXX x1 = new XXXX(参数列表); //对象获得本类实例,对象与其引用的实例类型一致
XXX xx1 = new XXX(参数列表);
x1.toString(); //编译时多态性,执行XXX类的方法.
xx1.toString(); //编译时多态性,执行XXXX类覆盖的方法.
XXXX为XXX的父类.
由于子类对象既是父类对象,父类对象与子类对象之间具有赋值相容性,父类对象能够被赋值为子类对象.例如,
XXXX x2 = new XXX(参数列表); //父类对象获得子类实例,子类对象即是父类对象
x2.toString(); //运行时多态
x2声明为父类对象却获得子类XXX的实例,那么x2.toString()究竟执行父类方法还是执行子类覆盖的方法呢?
这分为两种情况:
取决于子类是否覆盖父类方法.如果子类覆盖父类方法,则执行子类方法;
如果没有覆盖,则执行父类方法.
在编译时,仅仅依据对象所属的类,系统无法确定到底应该执行那个类的方法,只有运行时才能确定,因此这是运行时多态.
父类对象并不能执行所有的子类方法,只能执行那些父类中声明\子类覆盖的子类方法.
java多态实现
java的多态和c++一样，是通过动态绑定或者说运行时绑定来实现的。当调用某一个对象引用的方法时，因为编译器并不知道这个引用到底指向的是变量声明时说明的类型对象，还是该类型子类的对象。因此编译器无法为这次调用绑定到具体的某个方法。只有通过java中运行时类型识别（RTT）在运行时绑定到具体的方法
方法的重写overriding和方法的重载overloading是java多态的不同表现。重写overriding是父类和子类之间多态性的一种表现，重载overloading是一个类中多态性的表现。
给出一个具体例子：
class People {
public String toString() {
return "I am a people!";
}
public void eat() {
};
public void speak() {
};
}
class Boy extends People {
public String toString() {
return "I am a boy!";
}
public void fight() {
};
public void speak() {
};
}
class Girl extends People {
public String toString() {
return "I am a girl!";
}
public void sing() {
};
public void speak() {
};
}
public class TestToString {
public static void main(String args[]) {
People p = new Girl();
System.out.println(p.toString());
}
}
运行结果是：
I am a girl!
p是People的一个引用，但是在运行时因为是Girl对象，所以还是调用了Girl的toString方法
深入理解java多态
声明，这里借鉴了其他同学的例子，原文链接：http://blog.csdn.net/thinkghoster/article/details/2307001
测试题目
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 {
}
public class Main {
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(a1.show(b)); // 1
System.out.println(a1.show(c)); // 2
System.out.println(a1.show(d)); // 3
System.out.println(a2.show(b)); // 4
System.out.println(a2.show(c)); // 5
System.out.println(a2.show(d)); // 6
System.out.println(b.show(b)); // 7
System.out.println(b.show(c)); // 8
System.out.println(b.show(d)); // 9
}
}
答案
A and A A and A A and D B and A B and A A and D B and B B and B A and D
解析
我开始做这道题目，4、5、6、9全部做错了，原因就是没能很好的理解java的多态性，这里说明一下
首先，要深刻的理解重写和重载，重写不仅仅包括了函数名称相同，也包括参数类型和返回值类型
其次，深刻理解这句话“当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类重写的方法”
然后，我们在来分析一下这几道题目
问题：你认为B重写了父类A的show方法了吗？如果重写了，重写了几个？
答案：重写了，重写了一个，也就是public String show(A obj),为什么public String show(B obj)不算重写父类方法呢，很简单，因为参数类型不同
举例分析
看了上面的分析，我们也来分析两个例子：
一、a2.show(b)：
a2是一个引用变量，类型为A，b是B的一个实例。首先，在类A中找show(B obj)，没有找到。于是到A的超类中找，而A没有超类，因此转向了A.this((super)B),(super)B为A，因此在A中找到了show(A obj)的方法，但是由于a2引用的类B的一个对象，B重写了A的show(A obj)方法，因此最终锁定到类B的show(A obj)，输出为“B and A”
二、a2.show(c)：
a2是一个引用变量，类型为A，b是B的一个实例。首先，在类A中找show(C obj),没有找到。于是到A的超类中找，而A没有超类，因此转向了A.this((super)C),(super)C为B，到这里为止，这个a2.show(c)变成了a2.show(b)的问题，而a2.show(b)上面已经分析了是输出"B and A",因此这里也是输出“B and A”
相关推荐
-
Java中的多态用法实例分析
本文实例讲述了Java中的多态用法.分享给大家供大家参考.具体分析如下: 多态,是面向对象的程序设计语言最核心的特征.封装性.继承性都比较简单,所以这里只对多态做一个小小的笔记... 1.什么是多态? 多态意味着一个对象可以多重特征,可以在特定的情况下,表现出不同的状态,从而应对不同的属性和方法.在Java中,多态的实现指的是使用同一个实现接口,以实现不同的对象实例. 例如,我们定义一个Parent类,再定义一个getName()方法返回一个字符串,定义一个形参为Parent类型的成员方法doS
-
Java多态(动力节点Java学院整理)
什么是多态 1. 面向对象的三大特性:封装.继承.多态.从一定角度来看,封装和继承几乎都是为多态而准备的.这是我们最后一个概念,也是最重要的知识点. 2. 多态的定义:指允许不同类的对象对同一消息做出响应.即同一消息可以根据发送对象的不同而采用多种不同的行为方式.(发送消息就是函数调用) 3. 实现多态的技术称为:动态绑定(dynamic binding),是指在执行期间判断所引用对象的实际类型,根据其实际的类型调用其相应的方法. 4. 多态的作用:消除类型之间的耦合关系. 5. 现实中,关于多
-
浅谈java多态的实现主要体现在哪些方面
thinking in java3中的多态 People are often confused by other, non-object-oriented features of Java, like method overloading, which are sometimes presented as object-oriented. Don't be fooled: If it isn't late binding, it isn't polymorphism 按文面翻译 人们总是被jav
-
Java中继承、多态、重载和重写介绍
什么是多态?它的实现机制是什么呢?重载和重写的区别在那里?这就是这一次我们要回顾的四个十分重要的概念:继承.多态.重载和重写. 继承(inheritance) 简单的说,继承就是在一个现有类型的基础上,通过增加新的方法或者重定义已有方法(下面会讲到,这种方式叫重写)的方式,产生一个新的类型.继承是面向对象的三个基本特征--封装.继承.多态的其中之一,我们在使用JAVA时编写的每一个类都是在继承,因为在JAVA语言中,java.lang.Object类是所有类最根本的基类(或者叫父类.超类),如果
-
java 多态性详解及常见面试题
java多态性 多态分两种: (1) 编译时多态(设计时多态):方法重载. (2) 运行时多态:JAVA运行时系统根据调用该方法的实例的类型来决定选择调用哪个方法则被称为运行时多态.(我们平时说得多的事运行时多态,所以多态主要也是指运行时多态) 运行时多态存在的三个必要条件: 一.要有继承(包括接口的实现): 二.要有重写: 三.父类引用指向子类对象. 多态的好处: 1.可替换性(substitutability).多态对已存在代码具有可替换性.例如,多态对圆Circle类工作,对其他任
-
java用接口、多态、继承、类计算三角形和矩形周长及面积的方法
本文实例讲述了java用接口.多态.继承.类计算三角形和矩形周长及面积的方法.分享给大家供大家参考.具体如下: 定义接口规范: /** * @author vvv * @date 2013-8-10 上午08:56:48 */ package com.duotai; /** * * */ public interface Shape { public double area(); public double longer(); } /** * @author vvv * @date 2013-8
-
详解Java多态对象的类型转换与动态绑定
Java多态对象的类型转换 这里所说的对象类型转换,是指存在继承关系的对象,不是任意类型的对象.当对不存在继承关系的对象进行强制类型转换时,java 运行时将抛出 java.lang.ClassCastException 异常. 在继承链中,我们将子类向父类转换称为"向上转型",将父类向子类转换称为"向下转型". 很多时候,我们会将变量定义为父类的类型,却引用子类的对象,这个过程就是向上转型.程序运行时通过动态绑定来实现对子类方法的调用,也就是多态性. 然而有些时候
-
Java封装、继承、多态三大特征的理解
首先先简单的说一下其3大特性的定义: 封装:隐藏对象的属性和实现细节,仅对外公开接口,控制在程序中属性的读和修改的访问级别.将抽象得到的数据和行为(或功能)相结合,形成一个有机的整体,也就是将数据与操作数据的源代码进行有机的结合,形成"类",其中数据和函数都是类的成员.封装的目的是增强安全性和简化编程,使用者不必了解具体的实现细节,而只是要通过外部接口,一特定的访问权限来使用类的成员.封装的基本要求是: 把所有的属性私有化,对每个属性提供getter和setter方法,如果有一个带参的
-
进一步理解Java中的多态概念
多态性有两种: 1)编译时多态性 对于多个同名方法,如果在编译时能够确定执行同名方法中的哪一个,则称为编译时多态性. 2)运行时多态性 如果在编译时不能确定,只能在运行时才能确定执行多个同名方法中的哪一个,则称为运行时多态性. 方法覆盖表现出两种多态性,当对象获得本类实例时,为编译时多态性,否则为运行时多态性,例如: XXXX x1 = new XXXX(参数列表); //对象获得本类实例,对象与其引用的实例类型一致 XXX xx1 = new XXX(参数列表); x1.toString();
-
透彻理解Java中Synchronized（对象锁）和Static Synchronized（类锁）的区别
本文讲述了Java中Synchronized(对象锁)和Static Synchronized(类锁)的区别.分享给大家供大家参考,具体如下: Synchronized和Static Synchronized区别 通过分析这两个用法的分析,我们可以理解java中锁的概念.一个是实例锁(锁在某一个实例对象上,如果该类是单例,那么该锁也具有全局锁的概念),一个是全局锁(该锁针对的是类,无论实例多少个对象,那么线程都共享该锁).实例锁对应的就是synchronized关键字,而类锁(全局锁)对应的就是
-
浅谈java中OO的概念和设计原则(必看)
一．OO(面向对象)的设计基础 面向对象(OO):就是基于对象概念,以对象为中心,以类和继承为构造机制,充分利用接口和多态提供灵活性,来认识.理解.刻划客观世界和设计.构建相应的软件系统.面向对象的特征:虽然各种面向对象编程语言相互有别,但都能看到它们对面向对象基本特征的支持, 即 "抽象.封装.继承.多态" : – 抽象,先不考虑细节 – 封装,隐藏内部实现 – 继承,复用现有代码 – 多态,改写对象行为 面向对象设计模式:是"好的面向对象设计",所谓"
-
java中面向对象的概念及知识点总结
作为java中的一个重要理念,说起面向对象也是老生常谈了.在找资料的时候多是很专业的术语,又或者很多框架的知识点合集,其实大部分人刚看资料的时候是不能理解的.本篇对面向对象的一些基础概念进行介绍,尽量以通俗的语言展现给大家,分为概念.好处.与面向过程区别和最重要的三大特征. 1.概念 面向过程是以函数为基础,完成各种操作,强调过程:就是分析出解决问题所需要的步骤,然后用函数把这些步骤一步一步实现,使用的时候一个一个依次调用就可以了. 2.设计和开发程序的好处 (1)交流更加流畅 (2)提高设计和
-
深入理解Java中的字符串类型
1.Java内置对字符串的支持: 所谓的内置支持,即不用像C语言通过char指针实现字符串类型,并且Java的字符串编码是符合Unicode编码标准,这也意味着不用像C++那样通过使用string和wstring类实现与C语言兼容和Unicode标准.Java内部通过String类实现对字符串类型的支持.这意味着:我们可以直接对字符串常量调用和String对象同样的方法: //可以再"abc"上直接调用String对象的所有方法 int length="abc".l
-
10分钟带你理解Java中的弱引用
前言 本文尝试从What.Why.How这三个角度来探索Java中的弱引用,帮助大家理解Java中弱引用的定义.基本使用场景和使用方法. 一. What--什么是弱引用? Java中的弱引用具体指的是java.lang.ref.WeakReference<T>类,我们首先来看一下官方文档对它做的说明: 弱引用对象的存在不会阻止它所指向的对象被垃圾回收器回收.弱引用最常见的用途是实现规范映射(canonicalizing mappings,比如哈希表). 假设垃圾收集器在某个时间点决定一个对象是
-
彻底理解Java中的ThreadLocal
ThreadLocal翻译成中文比较准确的叫法应该是:线程局部变量. ThreadLocal是什么 早在JDK 1.2的版本中就提供Java.lang.ThreadLocal,ThreadLocal为解决多线程程序的并发问题提供了一种新的思路.使用这个工具类可以很简洁地编写出优美的多线程程序. 当使用ThreadLocal维护变量时,ThreadLocal为每个使用该变量的线程提供独立的变量副本,所以每一个线程都可以独立地改变自己的副本,而不会影响其它线程所对应的副本. 从线程的角度看,目标变
-
理解java中的深复制和浅复制
Java语言的一个优点就是取消了指针的概念,但也导致了许多程序员在编程中常常忽略了对象与引用的区别,本文会试图澄清这一概念.并且由于Java不能通过简单的赋值来解决对象复制的问题,在开发过程中,也常常要要应用clone()方法来复制对象.本文会让你了解什么是影子clone与深度clone,认识它们的区别.优点及缺点. 看到这个标题,是不是有点困惑:Java语言明确说明取消了指针,因为指针往往是在带来方便的同时也是导致代码不安全的根源,同时也会使程序的变得非常复杂难以理解,滥用指针写成的代码不亚于
-
全面理解java中的异常处理机制
一.java异常总结: 异常就是程序运行时出现不正常运行情况 1.异常由来: 通过java的类的形式对现实事物中问题的描述,并封住成了对象 其实就是java对不正常情况描述后的对象体现 2.对于问题的划分有两种:一种是严重的问题,一种是非严重的问题 对于严重的,java通过Error类来描述 对于Error一般不编写针对性的代码对其进行处理 对于非严重的,java通过Exception类来描述 对于Exception可以使用针对性的处理方式进行处理 3.常见的异常有:数组角标越界异常,空指针异常
-
深入理解java中的重载和覆盖
说到java中的重载和覆盖呢,大家都很熟悉了吧,但是呢我今天就要写这个. 本文主题: 一.什么是重载 二.什么是覆盖 三.两者之间的区别 重载(overload): 在一个类中,如果出现了两个或者两个以上的同名函数,只要它们的参数的个数,或者参数的类型不同,即可称之为该函数重载了. 即当函数同名时,只看参数列表.和返回值类型没关系. 重载使用的时候需要注意: 1.在使用重载时只能通过不同的参数样式.例如,不同的参数类型,不同的参数个数,不同的参数顺序. 2.方法的异常类型和数目不会对重载造成影响