Java 之类型转换与多态详情

目录
  • 一、类型检查
  • 二、基本类型转换
  • 三、upcast与多态
  • 四、downcast
  • 五、Object类型

一、类型检查

Java的任意变量和引用经过类型声明(type declaration),才能使用。我们之前见过对象数据、类数据、方法参数、方法返回值以及方法内部的自动变量,它们都需要声明其类型。Java是一种强类型(strongly typing)语言,它会对类型进行检查。如果我们错误的使用类型,将造成错误。

比如在下面的Test类中,我们将一个Cup类对象赋予给aPerson类引用:

public class Test
{
    public static void main(String[] args)
    {
        Human aPerson;
        aPerson = new Cup();
    }
}

class Human
{
    /**
     * constructor
     */
    public Human(int h)
    {
        this.height = h;
    }

    /**
     * accessor
     */
    public int getHeight()
    {
       return this.height;
    }

    /**
     * mutator
     */
    public void growHeight(int h)
    {
        this.height = this.height + h;
    }

    private int height;
}

class Cup
{
    public void addWater(int w)
    {
        this.water = this.water + w;
    }

    public void drinkWater(int w)
    {
        this.water = this.water - w;
    }

    private int water = 0;
}

javac将返回:

found   : Cup
required: Human
                aPerson = new Cup();
                          ^
1 error

二、基本类型转换

Java可以对基本类型的变量进行类型转换。不同的基本类型有不同的长度和存储范围。如果我们从一个高精度类型转换到低精度类型,比如从float转换到int,那么我们有可能会损失信息。这样的转换叫做收缩变换(narrowing conversion)。这种情况下,我们需要显示的声明类型转换,比如:

public class Test
{
    public static void main(String[] args)
    {
        int a;
        a = (int) 1.23;  // narrowing conversion
        System.out.println(a);
    }
}

如果我们从低精度类型转换成高精度类型,则不存在信息损失的顾虑。这样的变换叫做宽松变换(widening conversion)。我们不需要显示的要求类型转换,Java可以自动进行:

public class Test
{
    public static void main(String[] args)
    {
        int a = 3;
        double b;
        b = a;  // widening conversion
        System.out.println(a);
    }
}

 基本类型转换流程图:

三、upcast与多态

在Java中,引用也可以进行类型转换,但是有限制。

我们可以将一个衍生类引用转换为其基类引用,这叫做向上转换(upcast)或者宽松转换。下面的BrokenCup类继承自Cup类,并覆盖了Cup类中原有的addWater()和drinkWater()方法:


public class Test
{
    public static void main(String[] args)
    {
        Cup aCup;
        BrokenCup aBrokenCup = new BrokenCup();
        aCup = aBrokenCup; // upcast
        aCup.addWater(10); // method binding
    }
}

class Cup
{
    public void addWater(int w)
    {
        this.water = this.water + w;
    }

    public void drinkWater(int w)
    {
        this.water = this.water - w;
    }

    private int water = 0;
}

class BrokenCup extends Cup
{
    public void addWater(int w)
    {
        System.out.println("shit, broken cup");
    }

    public void drinkWater(int w)
    {
        System.out.println("om...num..., no water inside");
    }
}

程序运行结果:

shit, broken cup

在上面可以看到,不需要任何显示说明,我们将衍生类引用aBrokenCup赋予给它的基类引用aCup。类型转换将由Java自动进行。

我们随后调用了aCup(我们声明它为Cup类型)的addWater()方法。尽管aCupCup类型的引用,它实际上调用的是BrokenCupaddWater()方法!也就是说,即使我们经过upcast,将引用的类型宽松为其基类,Java依然能正确的识别对象本身的类型,并调用正确的方法。Java可以根据当前状况,识别对象的真实类型,这叫做多态(polymorphism)。多态是面向对象的一个重要方面。

多态是Java的支持的一种机制,同时也是面向对象的一个重要概念。这提出了一个分类学的问题,既子类对象实际上“是”父类对象。比如一只鸟,也是一个动物;一辆汽车,也必然是一个交通工具。Java告诉我们,一个衍生类对象可以当做一个基类对象使用,而Java会正确的处理这种情况。

比如下面的继承关系:

我们可以说用杯子(Cup)喝水(drinkWater)。实际上,喝水这个动作具体含义会在衍生类中发生很大变换。比如用吸管喝水,和从一个破杯子喝水,这两个动作差别会很大,虽然我们抽象中都讲“喝水”。我们当然可以针对每个衍生类分别编程,调用不同的drinkWater方法。然而,作为程序员,我们可以对杯子编程,调用CupdrinkWater()方法,而无论这个杯子是什么样的衍生类杯子。Java会调用相应的正确方法,正如我们在上面程序中看到的。

看一个更加有意义的例子,我们给Human类增加一个drink()方法,这个方法接收一个杯子对象和一个整数作为参数。整数表示喝水的水量:

public class Test
{
    public static void main(String[] args)
    {
        Human guest = new Human();
        BrokenCup hisCup  = new BrokenCup();
        guest.drink(hisCup, 10);
    }
}

class Human
{
    void drink(Cup aCup, int w)
    {
        aCup.drinkWater(w);
    }
}

程序运行结果:

shit, no water inside

我们在Human类的drink()的定义中,要求第一个参量为Cup类型的引用。但在实际运用时(Test类),将CupBrokenCup衍生类对象。这实际上是将hisCup向上转型称为Cup类,传递给drink()方法。在方法中,我们调用了drinkWater()方法。Java发现这个对象实际上是BrokenCup对象,所以实际调用了BrokenCup的相应方法。

四、downcast

我们可以将一个基类引用向下转型(downcast)成为衍生类的引用,但要求该基类引用所指向的对象,已经是所要downcast的衍生类对象。比如可以将上面的hisCup向上转型为Cup类引用后,再向下转型成为BrokenCup类引用。

五、Object类型

Java中,所有的类实际上都有一个共同的继承祖先,即Object类Object类提供了一些方法,比如toString()。我们可以在自己的类定义中覆盖这些方法。

Object: 祖先

我们可以编写一个操作Object对象的程序,就可以通过upcast,将任意对象传递给该程序。

我将在以后深入Object类

多态的实现是依靠RTTI的支持

到此这篇关于Java 之类型转换与多态详情的文章就介绍到这了,更多相关Java 之类型转换与多态内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Java单例模式继承覆盖多态原理详解

    1.单例模式: 1)提出原因 是由gof 也就是四人组提出来的.为了保证jvm中某一类型的java对象永远只有一个,同时也是为了节省内存的开销.因为外面程序可以通过new的方法直接调用类里面的构造方法.导致该类的对象不止一个. 2)定义 单例模式的意思就是只有一个实例.单例模式确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例.这个类称为单例类. A.构造方法私有化: B.对外提供一个公开的.静态的.获取当前类型对象的方法 C.提供一个当前类型的静态变量. 3)分类 A.饿汉式单例

  • Java面向对象基础之多态性,抽象类和接口

    一.多态性 多态是指一个对象可以拥有多种不同的形态,继承是实现多态的基础. 1.1 引用多态和方法多态 引用多态:父类引用可以指向本类的对象,也可以指向子类的对象 方法多态: 1.创建本类对象时,调用的方法为本类方法: 2.创建子类对象时,调用的方法为子类重写或继承的方法. 首先建立父类Animal,包含一个eat()方法,如下代码所示: public class Animal { public void eat(){ System.out.println("动物可以吃东西"); }

  • Java抽象类、继承及多态和适配器的实现代码

    Java继承 方法重写是Java语言多态的特性,必须满足以下条件 在子类中,方法名称与父类方法名称完全相同 方法的参数个数和类型完全相同,返回类型完全相同 方法的访问修饰符访问级别不低于父类同名方法的访问级别 在方法上添加@override注释,如果报错说明不是重写 方法重写限制 final修饰的父类方法在子类中不能被重写 static修饰的父类方法在子类中不能被重写,只能覆盖 super关键字 super关键字和this类似,super修饰的是父类的对象,如super();调用的是父类的默认无

  • JAVA回顾:封装,继承,多态

    目录 知识点回顾 封装 继承 super注意点: Vs this: 前提: 构造方法 多态 总结 知识点回顾 封装 封装(有时称为数据隐藏)是与对象有关的一个重要概念.从形式上来看,封装不过是将数据和行为组合在一个包中,并对对象的使用者隐藏了数据的实现方式.对象中的数据称为实例域,操作数据的过程称为方法.对于每个特定的类实例(对象)都有一组特定的实例域值.这些值的集合就是这个对象的当前状态.无论何时,只要向对象发送一个消息,它的状态就有可能改变. 实现封装的关键在于绝对不能让类中的方法直接地访问

  • Java必须学会的类的继承与多态

    继承是类的一个很重要的特性,什么?你连继承都不知道?你是想气死爸爸好继承爸爸的遗产吗?(滑稽) 开个玩笑,这里的继承跟我们现实生活的中继承还是有很大区别的,一个类可以继承另一个类,继承的内容包括属性跟方法,被继承的类被称为父类或者基类,继承的类称为子类或者导出类,在子类中可以调用父类的方法和变量.在java中,只允许单继承,也就是说 一个类最多只能显示地继承于一个父类.但是一个类却可以被多个类继承,也就是说一个类可以拥有多个子类.这就相当于一个人不能有多个父亲一样(滑稽,老王表示不服). 话不多

  • 一篇文章带你了解Java基础-多态

    目录 Java基础知识(多态) 多态 多态的定义和存在的必要条件 多态的案例 多态的弊端 引用类型转换 总结 Java基础知识(多态) 多态 多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定,而是在程序运行期间才确定,即一个引用变量到底会指向哪个类的实例对象,该引用变量发出的方法调用到底是哪个类中实现的方法,必须在由程序运行期间才能决定. 因为在程序运行时才确定具体的类,这样,不用修改源程序代码,就可以让引用变量绑定到各种不同的类实现上,从而导致该引用

  • Java基础之面向对象机制(多态、继承)底层实现

    一.Java的前世 为什么会产生Java?Java的特点是什么? 从C语言开始讲,C语言是一种结构化语言,模块化编程,便于程序的调试,依靠非常全面的运算符和多样的数据类型,可以轻易完成各种数据结构的构建,通过指针类型更可对内存直接寻址以及对硬件进行直接操作,因此既能够用于开发系统程序,也可用于开发应用软件.其缺点就是封装性弱,程序的安全性上不是很好.C语言的异常处理一般使用setjmp()与longjmp(),在捕获到异常时进行跳转:或者使用abort()和exit()两个函数,强行终止程序的运

  • Java面向对象三大特性及多态解析

    大家好,本文将会给大家带来Java多态. 以上就是本次学习的6大任务.我们依次来看. 1 Object类 Object类是所有Java类的根基类. 如果在类的声明中未使用extends关键字指明其基类,则默认基类为Object类. class Person{ } 等价于 class Person extends Object{ } 1.对象的实例化过程 实例化一个类是从最顶级的超类开始实例化的, 是一层一层的包裹结构. "先父类后子类,先静态后成员". ⑴toString方法 toSt

  • Java多态到底都有啥好处

    多态到底是啥,就是当子类继承父类的方法时,对其继承下来的方法按照自己的方式重新定义(覆盖重写). 1.向上转型. 之前继承有提到过.父类引用指向子类对象.这时的引用只能调用子类覆盖重写了的方法,不能调用子类特有方法.自动转换 public class Main { public static void main(String[]args) { Father f = new Son(); f.money(); } } class Father{ void money() { System.out.

  • Java语法之 Java 的多态、抽象类和接口

    目录 一.多态 1. 向上转型 2. 动态绑定 3. 方法重写 4. 向下转型 5. 关键字 super 6. 在构造方法中调用重写方法(坑) 7. 理解多态 8. 小结 二.抽象类 1. 概念 2. 注意事项 3. 抽象类的意义 3. 抽象类的作用 三.接口 1. 语法规则 2. 实现多个接口 3. 接口的继承 4. Comparable 接口 4. Comparator 接口 5. Cloneable 接口和深拷贝 上一篇文章:Java 基础语法之解析 Java 的包和继承 今天这章主要介绍

  • Java多态性抽象类与接口细致详解

    目录 1.多态性 1.1 向上转型 1.2 向下转型 2.抽象类 2.1 抽象类的基本概念 3.接口 3.1 接口的基本概念 3.2 接口的使用限制 3.3 使用接口定义标准 3.4 抽象类与接口的区别 1.多态性 多态性是面向对象的最后一个特征,它本身主要分为两个方面: ​ 方法的多态性:重载与覆写 ​ 1 重载:同一个方法名称,根据参数类型以及个数完成不同功能: ​ 2 覆写:通一个方法,根据操作的子类不同,所完成的功能也不同. ​ 对象的多态性:父子类对象的转换. ​ 1 向上转型:子类对

随机推荐