java对象转型详解

对象转型（casting）：好处可以增强程序的可扩展性。

1）一个基类的引用类型变量可以“指向”其子类的对象。

2）一个基类的引用不可以访问其子类对象新增的成员（属性和方法）。

3）可以使用 引用 变量instanceof类名 来判断该引用型变量所“指向”的对象是否属于该类或该类的子类。

4）子类的对象可以当作基类的对象来使用称作向上转型（upcasting），反之称为向下转型（downcasting）。

（1）释例一：演示对象转型（验证上面四条）

/**
 * 说明：父类
 *
 * @author huayu
 * @date 2018/8/6 1:00 PM
 */
public class Animal {
    public String name;

    public Animal(String name) {
        this.name = name;
    }
}


/**
 * 说明：用于演示对象转型，pig类
 *
 * @author huayu
 * @date 2018/8/6 1:01 PM
 */
public class Pig extends Animal{
    public String eyesColor;

    public Pig(String name,String eyeColor) {
        super(name);
        this.eyesColor = eyeColor;
    }
}
package oop;

/**
 * 说明：用于演示对象转型，tiger类
 *
 * @author huayu
 * @date 2018/8/6 1:03 PM
 */
public class Tiger extends Animal{
    public String furColor;

    public Tiger(String name ,String furColor) {
        super(name);
        this.furColor = furColor;
    }
}

import oop.Animal;
import oop.Pig;
import oop.Tiger;

/**
 * 说明：用于演示对象转型，测试类
 *
 * @author huayu
 * @date 2018/8/6 1:08 PM
 */
public class TestCasting {
    public static void main(String[] args) {
        Animal animal=new Animal("");
        Pig pig=new Pig("xiaozhu","black");
        Tiger tiger=new Tiger("xiaohu","yellow");
        System.out.println(animal instanceof Animal);
        /*pig instanceof Animal 这句话用到的instanceof关键字，表达的意思是pig是不是 
        Animal的一个实例
        */
        System.out.println(pig instanceof Animal);
        System.out.println(tiger instanceof Animal);
        System.out.println(animal instanceof Pig);
        //向下造型，父类引用指向子类对象，自动转
        animal=new Tiger("tigername","white");
        System.out.println(animal.name);
        //父类拿不到访问子类自己成员的权限，故无法访问子类特有的成员furColor，这儿会报错
//1.    System.out.println(animal.furColor); //!error
        System.out.println(animal instanceof Animal);
        System.out.println(animal instanceof Tiger);
        //向上造型，子类引用指向父类对象，需强转
2.      Tiger tiger1=(Tiger) animal;
        //通过上面句2强转后，就可以访问它的特有成员furColor了
        System.out.println(tiger1.furColor);

    }
}
测试类输出结果：
true
true
true
false
tigername
true
true
white

为了能让大家更好的理解 1.System.out.println(animal.furColor); //!error  这一句，我对animal=new Tiger("tigername","white");这一句做了一个内存分析图，希望可以有助于大家的理解：

执行句2Tiger tiger1=(Tiger) animal;后的内存分布图：

（2）释例二：用于演示对象转型对程序可扩展性的有利影响

import oop.Animal;
import oop.Pig;
import oop.Tiger;

/**
 * 说明：用于演示对象转型扩展性，测试类
 * 以上Animal,Pig,Tiger的类依然沿用释例一部分的
 * @author huayu
 * @date 2018/8/6 1:08 PM
 */
public class TestCasting {
    public static void main(String[] args) {
        TestCasting testCasting=new TestCasting();
        Animal animal=new Animal("name");
        Pig pig=new Pig("xiaozhu","black");
        Tiger tiger=new Tiger("laohu","yellow");
        testCasting.f(animal);
        testCasting.f(pig);
        testCasting.f(tiger);
        /*有了通过对象造型对程序的扩展性提供了很大的帮助，比如这个程序内除了上面两种...
          其它的也照样可以测，比如再加什么苍蝇蚊子等等，只需要写方法调用方法就可以了。
        */
    }
    public void f(Animal animal){
        System.out.println("name: "+animal.name);
        if(animal instanceof Pig){
            Pig pig=(Pig) animal;
            System.out.println(" "+pig.eyesColor);
        }else if(animal instanceof Tiger){
            Tiger tiger= (Tiger) animal;
            System.out.println(" "+tiger.furColor+" fur");
        }
    }
}