栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

Java编程思想笔记五:多态

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

Java编程思想笔记五:多态

这里写自定义目录标题
  • 1.什么是多态
  • 2.多态是怎么实现的
    • 多态的特性
  • 3.向下转型

这一章节主要介绍了 Java 语言多态的概念和特性,具体内容如下:

1.什么是多态

我们先看这样一个例子:有三种乐器 Wind(管乐)、Brass(铜管乐)和 Stringed(弦乐)都继承自 Instrument(乐器)

基类有一个演奏乐符(Note)的方法 play:

public enum Note {
    MIDDLE_C, C_SHARP, B_FLAT;
}

class Instrument {
    public void play(Note n) {
        print("Instrument.play() " + n);
    }
}

Wind 想演奏属于自己乐器的音符,它需要实现自己的 play 方法:

class Wind extends Instrument {
    public void play(Note n) {
        print("Wind.play() " + n);
    }
}

我们在演奏时可以这样调用:

public class Music {
    public static void tune(Instrument i) {
        i.play(Note.MIDDLE_C);
    }

    public static void main(String[] args) {
        Wind flute = new Wind();
        tune(flute);
    }
}

输出结果为:

Wind.play() MIDDLE_C

我们定义的 tune 方法接收一个 Instrument 类型参数,也可以接收导出自 Instrument 的参数,同时会根据参数类型执行对应类型提供的方法,这就是多态。

2.多态是怎么实现的

多态让我们省了很多冗余的代码,但是再深入想想,编译器是如何根据入参的类型找到要执行的对应的方法的呢?像在 C 语言中,编译器和连接器会把每个方法调用同方法主体在程序执行前关联起来,这种机制叫前期绑定,哪个方法接收哪种类型的参数在程序运行前就确定了,不存在根据入参类型判断执行哪个方法的问题,所以 C 语言也就不存在多态的概念。

Java 的方法调用和方法主体是在运行时绑定的,调用机制会根据实际的入参类型判断调用哪个方法,这种机制叫后期绑定。Java 中除了 static 方法和 final 方法(private 方法属于 final 方法)之外,其他所有方法都是后期绑定,所以对方法使用 static 或 final 修饰就是关闭其动态绑定机制。

多态的特性
  • 特性1:final 方法(包括 private 方法)不具有多态性

下面我们来看一个典型的例子:

public class PrivateOverride {
    private void f() { print("private f()"); }
    public static void main(String[] args) {
        PrivateOverride po = new Derived();
        po.f();
    }
}

class Derived extends PrivateOverride {
    public void f() { print("public f()"); }
}

输出结果:

private f()

你期望的输出结果是不是 public f()?可结果恰恰相反……因为基类中的 f() 是 private 方法,被自动认为是 final 方法,且对于导出类不可见,因此,Derived 类中的 f() 方法是一个全新独立的方法,所以上述案例基类中的对象 po 在方法调用时不会发生多态,只会向上转型为基类对象并执行基类的 private 方法。

  • 特性2: 静态方法不具有多态性

静态方法是与类,而非与单个对象关联的。

  • 特性3: 方法有多态性,域没有多态性

下面看一个简单的例子:

class Super {
    public int field = 0;
    public int getField() { return field; }
}

class Sub extends Super {
    public int field = 1;
    public int getField() { return super.field;}
}

public class FieldAccess {
    public static void main(String[] args) {
        Super sup = new Sub();
        System.out.println("sup.field = " + sup.field + 
            ", sup.getField() = " + sup.getField());
    }
}

输出结果:

sup.field = 0, sup.getField() = 1

field 是域不具备多态性,只会向上转型为基类 Super,然后获取 Super.field 的值;getField 是 public 方法,具备多态性,会执行 Sub.getField() 方法。

3.向下转型

向上转型(在继承层次中向上移动)会丢失具体的类型信息,而向下转型(在继承层次中向下移动)可以获取具体的类型信息,但是向下转型并不是安全的。

如果方法调用的入参为基类,但是又想访问导出类对象的扩展接口,此时可以尝试向下转型,但是向下转型并非安全的。在 Java 语言中,进入运行时后会对每一个类型转换(包括普通的加括号形式的类型转换,也包括向下转型)进行检查,以确保它是我们希望的那种类型,如果不是就会返回一个 ClassCastExecption 异常,这种行为称为“运行时类型识别(RTTI)”。

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/950514.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号