Java基础教程之类型转换与多态

时间:2014-09-02 03:15来源:网络整理作者:网络点击: 次

分享到：

这篇文章主要介绍了Java基础教程之类型转换与多态,本文讲解了基本类型转换、 upcast与多态、 Object类等内容,需要的朋友可以参考下

我们之前使用类创造新的类型(type)，并使用继承来便利我们创建类的过程。我将在这一讲中深入类型，并介绍多态(polymorphism)的概念。

类型检查

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()方法。尽管aCup是Cup类型的引用，它实际上调用的是BrokenCup的addWater()方法！也就是说，即使我们经过upcast，将引用的类型宽松为其基类，Java依然能正确的识别对象本身的类型，并调用正确的方法。Java可以根据当前状况，识别对象的真实类型，这叫做多态(polymorphism)。多态是面向对象的一个重要方面。

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

比如下面的继承关系: