Java多态的使用注意事项
Java多态是如何实现的？
Java的多态和C++一样，是通过延时绑定（late binding）或者说运行时绑定（runtime binding）来实现的。当调用某一个对象引用的方法时，因为编译器并不知道这个引用到底指向的是变量声明时说明的类型对象，还是该类型子类的对象。因此编译器无法为这次调用绑定到具体的某个方法。只有通过java中的运行时类型识别（RTTI, Runtime type identification）在运行时绑定到具体的方法。下面是一个具体的例子：
代码如下:
class shape
{
public void draw()
{
print("shape");
}
}
class triangle extends shape
{
public void draw()
{
print("triangle");
}
}
public class Polymorphism {
public static void main(String[] args)
{
shape s=new triangle();
s.draw();
}
结果是triangle
s是一个shape引用，但是在运行时因为是triangle对象，所以还是调用了triangle的draw方法。
Java多态中的一些陷阱
重写私有方法？
Java里面是不能重写私有方法的，这个其实很好理解，因为私有方法在子类是不可见的。子类没有继承父类的私有方法，更谈不上重写了。因此在子类中的同名方法是一个全新的方法。
代码如下:
public class Polymorphism {
private void show()
{
print("show parent");
}
public static void main(String[] args)
{
Polymorphism p=new privateMethod();
p.show();
}
}
class privateMethod extends Polymorphism
{
public void show()
{
print("show derived");
}
}
结果是 show parent
字段和静态方法的多态？
子类可以继承父类的非私有字段，子类的字段是否也具有多态性呢？我们来看一个实际的例子：
代码如下:
class shape
{
protected int perimeter=1;
public void draw()
{
print("shape");
}
public int getPerimeter()
{
return perimeter;
}
}
class triangle extends shape
{
int perimeter=3;
public void draw()
{
print("triangle");
}
public int getPerimeter()
{
return perimeter;
}
public int getSuperPerimeter()
{
return super.perimeter;
}
}
public class Polymorphism {
public static void main(String[] args)
{
shape s=new triangle();
print("s.perimeter:"+s.perimeter);
print("s.getperimeter:"+s.getPerimeter());
triangle t=new triangle();
print("t.perimeter:"+t.perimeter);
print("t.getperimeter:"+t.getPerimeter());
print("t.getsuperperimeter:"+t.getSuperPerimeter());
}
}
以下是运行结果：
这个运行结果包含了以下信息：
1.triangle对象向上转型成shape后字段直接访问都是由编译器确定的，因此不会表现出多态性，返回的是1。
2.triangle对象向上转型成shape后调用方法访问字段是根据运行时对象类型延时绑定调用了triangle的getperimeter方法，返回的是3
3.t对象中包含了两个perimeter字段，一个来自于他本身，一个来自于他的父类。同时用字段名去调用该字段时默认返回的是他本身的perimeter字段，要调用从父类继承的该字段，要用super.perimeter的方法。
这个结果看起来多多少少让人有些疑惑，为了避免这种情况出现，我们一般都把字段声明为private（子类就无法继承），同时我们在子类中声明的字段最好不要与从父类继承的字段同名。
静态方法是没有多态性的，因为静态方法是和类绑定的，不会存在不知道具体类型的情况。
构造函数的多态性？
构造函数是不具有多态性的，因为构造方法本身是静态方法（如果不是的话，就会陷入鸡生蛋，蛋生鸡的死循环了）。要引入我们的问题，先来看一下构造函数的调用顺序。
1.为这个对象分配的存储空间都被初始化为0（对象初始化为null）
2.父类的构造函数调用（这样才能保证在子类的构造函数中访问的字段被初始化）
3.成员变量初始化
4.子类的构造函数调用
现在假设如果在第二步中，我们在父类的构造函数里调用了某个方法，这个方法是不是多态的？还是来看一个具体的例子：
代码如下:
class shape
{
protected int perimeter=1;
public shape()
{
draw();
print("shape created");
}
public void draw()
{
print("draw shape "+perimeter);
}
}
class triangle extends shape
{
int perimeter=3;
public triangle()
{
print("triangle created");
}
public void draw()
{
print("draw triangle "+perimeter);
}
public int getPerimeter()
{
return perimeter;
}
}
public class Polymorphism {
public static void main(String[] args)
{
shape s=new triangle();
}
}
运行结果：
我们可以看到虽然triangle对象还没有构造完毕，draw方法仍是动态绑定到了triangle的draw方法。同时注意到perimeter的值还没有初始化为3，而是0。
这样的结果就是我们在triangle对象还没有被初始化之前就访问了其中的字段。因此我们在实际应用中要避免在构造函数中调用其他方法，或者只调用私有方法（不会被继承，因此不会引发该问题）
相关推荐
-
java 多态性详解及常见面试题
java多态性 多态分两种: (1) 编译时多态(设计时多态):方法重载. (2) 运行时多态:JAVA运行时系统根据调用该方法的实例的类型来决定选择调用哪个方法则被称为运行时多态.(我们平时说得多的事运行时多态,所以多态主要也是指运行时多态) 运行时多态存在的三个必要条件: 一.要有继承(包括接口的实现): 二.要有重写: 三.父类引用指向子类对象. 多态的好处: 1.可替换性(substitutability).多态对已存在代码具有可替换性.例如,多态对圆Circle类工作,对其他任
-
Java中的多态用法实例分析
本文实例讲述了Java中的多态用法.分享给大家供大家参考.具体分析如下: 多态,是面向对象的程序设计语言最核心的特征.封装性.继承性都比较简单,所以这里只对多态做一个小小的笔记... 1.什么是多态? 多态意味着一个对象可以多重特征,可以在特定的情况下,表现出不同的状态,从而应对不同的属性和方法.在Java中,多态的实现指的是使用同一个实现接口,以实现不同的对象实例. 例如,我们定义一个Parent类,再定义一个getName()方法返回一个字符串,定义一个形参为Parent类型的成员方法doS
-
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运行时多态性的实现
InterA a; a= new B(); a.fun(); a = new C(); a.fun(); } } 输出结果为: This is B This is C 上例中类B和类C是实现接口InterA的两个类,分别实现了接口的方法fun(),通过将类B和类C的实例赋给接口引用a而实现了方法在运行时的动态绑定,充分利用了"一个接口,多个方法"展示了Java的动态多态性. 需要注意的一点是:Java在利用接口变量调用其实现类的对象的方法时,该方法必须已经在接口中被声明,而且在接口的
-
Java中继承、多态、重载和重写介绍
什么是多态?它的实现机制是什么呢?重载和重写的区别在那里?这就是这一次我们要回顾的四个十分重要的概念:继承.多态.重载和重写. 继承(inheritance) 简单的说,继承就是在一个现有类型的基础上,通过增加新的方法或者重定义已有方法(下面会讲到,这种方式叫重写)的方式,产生一个新的类型.继承是面向对象的三个基本特征--封装.继承.多态的其中之一,我们在使用JAVA时编写的每一个类都是在继承,因为在JAVA语言中,java.lang.Object类是所有类最根本的基类(或者叫父类.超类),如果
-
Java静态方法不具有多态性详解
动态绑定机制使得基类的引用能够指向正确的子类对象,从而使得面向基类编程成为可能. 然而动态绑定在以下两种情况会失效. 1.基类方法是private或final修饰的 这个很好理解,因为private说明该方法对子类是不可见的,子类再写一个同名的方法并不是对父类方法进行复写(Override),而是重新生成一个新的方法,也就不存在多态的问题了.同理也可以解释final,因为方法同样是不可覆盖的. 2.方法是static修饰的 代码如下所示. class Base { public static v
-
运行时实现Java的多态性
运行时多态性是面向对象程序设计代码重用的一个最强大机制,动态性的概念也可以被说成"一个接口,多个方法".Java实现运行时多态性的基础是动态方法调度,它是一种在运行时而不是在编译期调用重载方法的机制,下面就继承和接口实现两方面谈谈java运行时多态性的实现. 一.通过继承中超类对象引用变量引用子类对象来实现 举例说明: //定义超类superA class superA { int i = 100; void fun() { System.out.println("This
-
java 多态性详解及简单实例
Java中多态性的实现 什么是多态 面向对象的三大特性:封装.继承.多态.从一定角度来看,封装和继承几乎都是为多态而准备的.这是我们最后一个概念,也是最重要的知识点. 多态的定义:指允许不同类的对象对同一消息做出响应.即同一消息可以根据发送对象的不同而采用多种不同的行为方式.(发送消息就是函数调用) 实现多态的技术称为:动态绑定(dynamic binding),是指在执行期间判断所引用对象的实际类型,根据其实际的类型调用其相应的方法. 多态的作用:消除类型之间的耦合关系. 现实中,关于多态的例
-
Java多态的使用注意事项
Java多态是如何实现的?Java的多态和C++一样,是通过延时绑定(late binding)或者说运行时绑定(runtime binding)来实现的.当调用某一个对象引用的方法时,因为编译器并不知道这个引用到底指向的是变量声明时说明的类型对象,还是该类型子类的对象.因此编译器无法为这次调用绑定到具体的某个方法.只有通过java中的运行时类型识别(RTTI, Runtime type identification)在运行时绑定到具体的方法.下面是一个具体的例子: 复制代码 代码如下: cla
-
Java多态(动力节点Java学院整理)
什么是多态 1. 面向对象的三大特性:封装.继承.多态.从一定角度来看,封装和继承几乎都是为多态而准备的.这是我们最后一个概念,也是最重要的知识点. 2. 多态的定义:指允许不同类的对象对同一消息做出响应.即同一消息可以根据发送对象的不同而采用多种不同的行为方式.(发送消息就是函数调用) 3. 实现多态的技术称为:动态绑定(dynamic binding),是指在执行期间判断所引用对象的实际类型,根据其实际的类型调用其相应的方法. 4. 多态的作用:消除类型之间的耦合关系. 5. 现实中,关于多
-
Java多态和实现接口的类的对象赋值给接口引用的方法(推荐)
接口的灵活性就在于"规定一个类必须做什么,而不管你如何做". 我们可以定义一个接口类型的引用变量来引用实现接口的类的实例,当这个引用调用方法时,它会根据实际引用的类的实例来判断具体调用哪个方法,这和上述的超类对象引用访问子类对象的机制相似. //定义接口InterA interface InterA { void fun(); } //实现接口InterA的类B class B implements InterA { public void fun() { System.out.pri
-
Java Spring-Cache key配置注意事项介绍
为了提升项目的并发性能,考虑引入本地内存Cache,对:外部数据源访问.Restful API调用.可重用的复杂计算 等3种类型的函数处理结果进行缓存.目前采用的是spring Cache的@Cacheable注解方式,缓存具体实现选取的是Guava Cache. 具体缓存的配置此处不再介绍,重点对于key的配置进行说明: 1.基本形式 @Cacheable(value="cacheName", key"#id") public ResultDTO method(i
-
详解Java多态对象的类型转换与动态绑定
Java多态对象的类型转换 这里所说的对象类型转换,是指存在继承关系的对象,不是任意类型的对象.当对不存在继承关系的对象进行强制类型转换时,java 运行时将抛出 java.lang.ClassCastException 异常. 在继承链中,我们将子类向父类转换称为"向上转型",将父类向子类转换称为"向下转型". 很多时候,我们会将变量定义为父类的类型,却引用子类的对象,这个过程就是向上转型.程序运行时通过动态绑定来实现对子类方法的调用,也就是多态性. 然而有些时候
-
浅谈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多态用法与注意点实例分析
本文实例讲述了Java多态用法与注意点.分享给大家供大家参考,具体如下: 一 点睛 向上转型:或者称为向父类转型.父类的对象通过子类对象实例化,实际上就是对象的向上转型.向上转型不需要进行强制类型转换,但是向上转型会丢失精度. 向下转型:或者称为向子类转型.也就是说父类对象可以转换为子类对象,但是,此时必须进行强制类型转换. 向上转型时,父类对象所能看见的方法依然是本类之中定义的方法(即被子类覆盖的方法).如果子类扩充了一些新的方法,父类是看不见的. 二 父类对象找不到子类的扩充方法 1 代码
-
Java list.remove( )方法注意事项
这篇文章给大家简单介绍了Java list.remove( )方法注意事项,具体内容如下: List<Integer> integerList = new ArrayList<>(); 当我们要移除某个Item的时候 remove(int position):移除某个位置的Item remove(object object):移除某个对象 那么remove(12)到底是移除第12的item,还是移除内容为12的Item. 那就要看12到底是int类型还是Integer类型,如果是i
-
通过实例分析java多态
这篇文章主要介绍了通过实例分析java多态,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 首先来看这样的一段代码,其中对于类的定义如下: class Parent{ public int myValue=100; public void printValue() { System.out.println("Parent.printValue(),myValue="+myValue); } } class Child extends P
-
java 多态实例代码
多态是同一个行为具有多个不同表现形式或形态的能力.多态就是同一个接口,使用不同的实例而执行不同操作. 多态性是对象多种表现形式的体现,比如: 在现实中,我们按下F1键这个动作: 如果当前在Flash界面下弹出的就是AS 3的帮助文档 如果当前在Word下弹出的就是Word帮助 在Windows下弹出的就是Windows帮助和支持 多态存在的三个必要条件 继承 重写 父类引用指向子类对象 Parent p = new Child(); 当使用多态方式调用方法时,首先检查父类中是否有该方法,如果没有