Java多态用法与注意点实例分析

本文实例讲述了Java多态用法与注意点。分享给大家供大家参考，具体如下：

一 点睛

向上转型：或者称为向父类转型。父类的对象通过子类对象实例化，实际上就是对象的向上转型。向上转型不需要进行强制类型转换，但是向上转型会丢失精度。

向下转型：或者称为向子类转型。也就是说父类对象可以转换为子类对象，但是，此时必须进行强制类型转换。

向上转型时，父类对象所能看见的方法依然是本类之中定义的方法（即被子类覆盖的方法）。如果子类扩充了一些新的方法，父类是看不见的。

二 父类对象找不到子类的扩充方法

1 代码

class baseClass
{
  public void print()
  {
    System.out.println("*****--父类baseClass：public void print(){}") ;
  }
}
class subClass extends baseClass
{
  public void print() // 方法覆写
  {
    System.out.println("#####--子类subClass：public void print(){}") ;
  }
  public void getB() // 此方法为子类扩充的功能
  {
    System.out.println("#####--子类subClass：public void getB(){}，B类扩充方法。") ;
  }
}
public class NewMethodTest
{
  public static void main(String args[])
  {
    baseClass baseObj = new subClass() ; // 实例化子类对象
    baseObj.print() ;
    baseObj.getB() ; // 这个方法父类无法找到
  }
}

2 运行

编译失败

3 说明

尽管父类对象baseObj的实例化依靠子类完成，但是它能够看见的还是自己本类所定义的方法名称，如果方法被子类覆写了，则调用的方法体也是被子类覆写过的方法。

三 向下转型

1 代码

class baseClass
{
  public void print()
  {
    System.out.println("*****--父类baseClass：public void print(){}") ;
  }
}
class subClass extends baseClass
{
  public void print() // 方法覆写
  {
    System.out.println("#####--子类subClass：print()") ;
  }
  public void getB() // 此方法为子类扩充的功能
  {
    System.out.println("#####--子类subClass：getB()，子类扩充方法。") ;
  }
}
public class DownCastTest
{
  public static void main(String args[])
  {
    baseClass baseObj = new subClass() ; // 实例化子类对象
    baseObj.print() ;   //调用子类subClass的 print()
    subClass subObj = (subClass) baseObj ; // 向下转型，强制完成
    subObj.getB() ; // 这个方法父类无法找到，但子类对象可以找到
  }
}

2 运行

#####--子类subClass：print()
#####--子类subClass：getB()，子类扩充方法。

3 说明

在形式上，类定义的对象只能看到自己所属类中的成员，虽然通过向上类型转换，子类对象可以给父类对象赋值，但父类对象也仅能看到在子类中被覆盖的成员（这些方法也在父类定义过了），父类对象无法看到子类的新扩充方法。

四 隐藏

1 点睛

在某些场景下，我们不希望父类的方法被子类方法覆写，即子类实例化后会调用父类的方法，而不是子类的方法，这种情况要用到隐藏。被关键字static修饰的静态方法是不能被覆盖的，Java中就是利用这一特性达到隐藏的效果。

2 代码

class Father
{
  public static void overWritting()
  {
    System.out.println("#####--Father method");
  }
}
class Son extends Father
{
  public static void overWritting()
  {
    System.out.println("*****--Son method");
  }
}
public class HideSubClass
{
  public static void main(String args[])
  {
    Father dad  = new Son();
    dad.overWritting();
    Father.overWritting();
    Son.overWritting();
  }
}

3 运行

#####--Father method
#####--Father method
*****--Son method

更多java相关内容感兴趣的读者可查看本站专题：《Java面向对象程序设计入门与进阶教程》、《Java数据结构与算法教程》、《Java操作DOM节点技巧总结》、《Java文件与目录操作技巧汇总》和《Java缓存操作技巧汇总》

希望本文所述对大家java程序设计有所帮助。

赞 (0)

相关推荐

  • Java中继承、多态、重载和重写介绍

    什么是多态?它的实现机制是什么呢?重载和重写的区别在那里?这就是这一次我们要回顾的四个十分重要的概念:继承.多态.重载和重写. 继承(inheritance) 简单的说,继承就是在一个现有类型的基础上,通过增加新的方法或者重定义已有方法(下面会讲到,这种方式叫重写)的方式,产生一个新的类型.继承是面向对象的三个基本特征--封装.继承.多态的其中之一,我们在使用JAVA时编写的每一个类都是在继承,因为在JAVA语言中,java.lang.Object类是所有类最根本的基类(或者叫父类.超类),如果

  • Java基础之方法重写和多态示例

    本文实例讲述了Java基础之方法重写和多态.分享给大家供大家参考,具体如下: 示例代码: 子类的方法与父类的方法具有相同的返回类型和签名,子类方法重写父类方法. class A{ int i,j; //父类变量 A(int a,int b){ //父类构造 i=a; j=b; } void show(){ //父类方法 System.out.println(i+" "+j); } } class B extends A{ //继承父类 int k; //子类变量 B(int a,int

  • java中重载，继承，重写和多态的区别

    重载,继承,重写和多态的区别: 1)继承是子类获得父类的成员. 2)重写是继承后重新实现父类的方法. 3)重载是在一个类里一系列参数不同名字相同的方法. 4)多态则是为了避免在父类里大量重载引起代码臃肿且难于维护. 网上看到一个有趣的说法是:继承是子类使用父类的方法,而多态则是父类使用子类的方法. 下面的例子包含了这四种实现: class Triangle extends Shape { public int getSides() {   return 3;  } } class Rectang

  • Java封装、继承、多态三大特征的理解

    首先先简单的说一下其3大特性的定义: 封装:隐藏对象的属性和实现细节,仅对外公开接口,控制在程序中属性的读和修改的访问级别.将抽象得到的数据和行为(或功能)相结合,形成一个有机的整体,也就是将数据与操作数据的源代码进行有机的结合,形成"类",其中数据和函数都是类的成员.封装的目的是增强安全性和简化编程,使用者不必了解具体的实现细节,而只是要通过外部接口,一特定的访问权限来使用类的成员.封装的基本要求是: 把所有的属性私有化,对每个属性提供getter和setter方法,如果有一个带参的

  • Java中的多态用法实例分析

    Java中的多态用法实例分析

    本文实例讲述了Java中的多态用法.分享给大家供大家参考.具体分析如下: 多态,是面向对象的程序设计语言最核心的特征.封装性.继承性都比较简单,所以这里只对多态做一个小小的笔记... 1.什么是多态? 多态意味着一个对象可以多重特征,可以在特定的情况下,表现出不同的状态,从而应对不同的属性和方法.在Java中,多态的实现指的是使用同一个实现接口,以实现不同的对象实例. 例如,我们定义一个Parent类,再定义一个getName()方法返回一个字符串,定义一个形参为Parent类型的成员方法doS

  • Java面向对象编程（封装/继承/多态）实例解析

    本文主要介绍了面向对象的三大特征实例解析,下面看看具体内容. 封装 封装一个Teacher和Student类 package com.hz.test; public class Teacher { private String name; private String majorDirection; private String teachCourse; private int teachAge; public Teacher() { super(); } public Teacher(Stri

  • 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三大特性之多态的总结

    面向对象的三大特性:封装.继承.多态.从一定角度来看,封装和继承几乎都是为多态而准备的.这是我们最后一个概念,也是最重要的知识点. 1.定义: 多态:指允许不同类的对象对同一消息做出响应.即同一消息可以根据发送对象的不同而采用多种不同的行为方式.(发送消息就是函数调用) 2.实现多态的技术称为:动态绑定(dynamicbinding),是指在执行期间判断所引用对象的实际类型,根据其实际的类型调用其相应的方法. 3.作用:消除类型之间的耦合关系. 4.现实中,关于多态的例子不胜枚举.比方说按下F1

  • 详解Java多态对象的类型转换与动态绑定

    Java多态对象的类型转换 这里所说的对象类型转换,是指存在继承关系的对象,不是任意类型的对象.当对不存在继承关系的对象进行强制类型转换时,java 运行时将抛出 java.lang.ClassCastException 异常. 在继承链中,我们将子类向父类转换称为"向上转型",将父类向子类转换称为"向下转型". 很多时候,我们会将变量定义为父类的类型,却引用子类的对象,这个过程就是向上转型.程序运行时通过动态绑定来实现对子类方法的调用,也就是多态性. 然而有些时候

  • JAVA 多态 由浅及深介绍

    什么是多态? 多态分两种: (1)   编译时多态(设计时多态):方法重载. (2)   运行时多态:JAVA运行时系统根据调用该方法的实例的类型来决定选择调用哪个方法则被称为运行时多态.(我们平时说得多的事运行时多态,所以多态主要也是指运行时多态) 运行时多态存在的三个必要条件:一.要有继承(包括接口的实现):二.要有重写:三.父类引用指向子类对象. ------------------------------------------------------------------------

  • java中多态概念、实现原理详解

    一.什么是多态? 1.多态的定义 指允许不同类的对象对同一消息做出响应.即同一消息可以根据发送对象的不同而采用多种不同的行为方式(发送消息就是函数调用) 2.多态的作用 消除类型之间的耦合关系 3.多态的说明 近代网络小说泛滥,我们可以用它来举一个例子 某日你看见你手机上有多部小说同时更新了,比如有大主宰,雪鹰领主,龙王传说-在这里我们可以描述成如下: 小说a=大主宰 小说b=雪鹰领主 小说c=龙王传说 - 这里所表现的就是多态,大主宰,雪鹰领主,龙王传说都是小说的子类,我们仅仅可以通过小说这个

随机推荐