Java基础-对象类型转换

类型转换总结

 

 

示例

对象的类型转换

class Animal {
    public String name = "Animal：动物";
    public static String staticName = "Animal：可爱的动物";

    public void eat() {
        System.out.println("Animal：吃饭");
    }

    public static void staticEat() {
        System.out.println("Animal：动物在吃饭");
    }
}
class Cat extends Animal {
    public String name = "Cat：猫";
    public String str = "Cat：可爱的小猫";
    public static String staticName = "Dog：我是喵星人";

    @Override
    public void eat() {
        System.out.println("Cat：吃饭");
    }

    public static void staticEat() {
        System.out.println("Cat：猫在吃饭");
    }

    public void eatMethod() {
        System.out.println("Cat：猫喜欢吃鱼");
    }
}
public class TransType {
    public static void main(String[] args) {
        Animal animal = new Cat();
        // 向下转型
        Cat cat = (Cat) animal;

        // 输出Animal类的name变量 --Animal：动物
        System.out.println(animal.name);

        // 输出Animal类的staticName变量 --Animal：可爱的动物
        System.out.println(Animal.staticName);

        // 输出Cat类的eat()方法 --Cat：吃饭
        animal.eat();

        // 输出Animal类的staticEat()方法 --Animal：动物在吃饭
        Animal.staticEat();

        // 调用Cat类的str变量 --Cat：可爱的小猫
        System.out.println(cat.str);

        // 调用Cat类的name变量 --Cat：猫
        System.out.println(cat.name);

        // 调用Cat类的eatMethod()方法 --Cat：猫喜欢吃鱼
        cat.eatMethod();
    }
}

 

通过引用类型变量来访问所引用对象的属性和方法时，Java 虚拟机将采用以下绑定规则：

1、实例方法与引用变量实际引用的对象的方法进行绑定，这种绑定属于动态绑定，因为是在运行时由 Java 虚拟机动态决定的。例如，animal.eat() 是将 eat() 方法与 Cat 类绑定。

2、静态方法与引用变量所声明的类型的方法绑定，这种绑定属于静态绑定，因为是在编译阶段已经做了绑定。例如，animal.staticEat() 是将 staticEat() 方法与 Animal 类进行绑定。

3、成员变量（包括静态变量和实例变量）与引用变量所声明的类型的成员变量绑定，这种绑定属于静态绑定，因为在编译阶段已经做了绑定。例如，animal.name 和 Animal.staticName 都是与 Animal 类进行绑定。

 

强制类型转换

Java 编译器允许在具有直接或间接继承关系的类之间进行类型转换。对于向下转型，必须进行强制类型转换；对于向上转型，不必使用强制类型转换。

例如，对于一个引用类型的变量，Java 编译器按照它声明的类型来处理。如果使用 animal 调用 str 和 eatMethod() 方法将会出错，如下：

animal.str = ""; // 编译出错，提示Animal类中没有str属性
animal.eatMethod(); // 编译出错，提示Animal类中没有eatMethod()方法

如果要访问 Cat 类的成员，必须通过强制类型转换，如下：

((Cat)animal).str = ""; // 编译成功
((Cat)animal).eatMethod(); // 编译成功

把 Animal 对象类型强制转换为 Cat 对象类型，这时上面两句编译成功。对于如下语句，由于使用了强制类型转换，所以也会编译成功，例如：

Cat cat = (Cat)animal; // 编译成功，将Animal对象类型强制转换为Cat对象类型

子类的对象可以转换成父类类型，而父类的对象实际上无法转换为子类类型。因为通俗地讲，父类拥有的成员子类肯定也有，而子类拥有的成员，父类不一定有。因此，对于向上转型，不必使用强制类型转换。例如：

Cat cat = new Cat();
Animal animal = cat; // 向上转型，不必使用强制类型转换

如果两种类型之间没有继承关系，那么将不允许进行类型转换。例如：

Integer i = 1;
String s  = (String) i;  // 编译出错，不允许把Integer对象类型转换为String对象类型

我们可以使用isinstanceof来判断是否可以强制类型转换：

public class TransType {
    public static void main(String[] args) {
        Object i = Integer.valueOf(1);
        Animal animal = new Cat();
        if(animal instanceof Cat){
            Cat cat = (Cat) animal;
            System.out.println(cat.name);
        }
        if(i instanceof String){
            String s  = (String) i;
            System.out.println(s);
        }else{
            System.out.println("不能类型转换");
        }
    }
}