欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

Java中的对象转型

程序员文章站 2022-04-30 20:28:37
向上转型:子类对象转为父类,父类可以是接口。公式:Father f = new Son();Father是父类或接口,son是子类。 向下转型:父类对象转为子类。公式:Son s = (Son)f; 我们将形参设为父类Animal类型,当执行test.f(c)时,内存情况如下图: c作为Cat类型传 ......

向上转型:子类对象转为父类,父类可以是接口。公式:father f = new son();father是父类或接口,son是子类。

向下转型:父类对象转为子类。公式:son s = (son)f;

Java中的对象转型

我们将形参设为父类animal类型,当执行test.f(c)时,内存情况如下图:

Java中的对象转型

c作为cat类型传入,animal a作为形参,相当于执行了animal a = new cat(),这时a和c同时指向cat对象,但此时a不能访问cat类扩展的数据成员,所以再将a强转成cat类型即可。如果不存在这样的转型机制,则针对猫和狗我们还要分别写两个函数f(cat c)和f(dog d)。但其实上图程序的可扩展性也不是最好的。我们还可以利用动态绑定(即多态)将扩展性进一步提升。多态机制的三个前提分别是:(1)要有继承,(2)要重写,即子类对父类中某些方法进行重新定义,(3)要向上转型,用父类引用指向子类对象。下面来看一个例子:

class animal {
    private string name;
    /**
     * 在animal类自定义的构造方法
     * @param name
     */
    animal(string name) {
        this.name = name;
    }

    /**
     * 在animal类里面自定义一个方法enjoy
     */
    public void enjoy() {
        system.out.println("动物的叫声……");
    }
}

class cat extends animal {
    private string eyescolor;

    /**
     * 在子类cat里面定义cat类的构造方法
     * @param n
     * @param c
     */
    cat(string n, string c) {
        /**
         * 在构造方法的实现里面首先使用super调用父类animal的构造方法animal(string name)。
         * 把子类对象里面的父类对象先造出来。
         */
        super(n);
        eyescolor = c;
    }

    /**
     * 子类cat对从父类animal继承下来的enjoy方法不满意,在这里重写了enjoy方法。
     */
    public void enjoy() {
        system.out.println("我养的猫高兴地叫了一声……");
    }
}

/**
 * 子类dog从父类animal继承下来,dog类拥有了animal类所有的属性和方法。
 * @author gacl
 *
 */
class dog extends animal {
    /**
     * 在子类dog里面定义自己的私有成员变量
     */
    private string furcolor;

    /**
     * 在子类dog里面定义dog类的构造方法
     * @param n
     * @param c
     */
    dog(string n, string c) {
        /**
         * 在构造方法的实现里面首先使用super调用父类animal的构造方法animal(string name)。
         * 把子类对象里面的父类对象先造出来。
         */
        super(n);
        furcolor = c;
    }

    /**
     * 子类dog对从父类animal继承下来的enjoy方法不满意,在这里重写了enjoy方法。
     */
    public void enjoy() {
        system.out.println("我养的狗高兴地叫了一声……");
    }
}

/**
 * 子类bird从父类animal继承下来,bird类拥有animal类所有的属性和方法
 * @author gacl
 *
 */
class bird extends animal {
    /**
     * 在子类bird里面定义bird类的构造方法
     */
    bird() {
        /**
         * 在构造方法的实现里面首先使用super调用父类animal的构造方法animal(string name)。
         * 把子类对象里面的父类对象先造出来。
         */
        super("bird");
    }

    /**
     * 子类bird对从父类animal继承下来的enjoy方法不满意,在这里重写了enjoy方法。
     */
    public void enjoy() {
        system.out.println("我养的鸟高兴地叫了一声……");
    }
}

/**
 * 定义一个类lady(女士)
 * @author gacl
 *
 */
class lady {
    /**
     * 定义lady类的私有成员变量name和pet
     */
    private string name;
    private animal pet;

    /**
     * 在lady类里面定义自己的构造方法lady(),
     * 这个构造方法有两个参数,分别为string类型的name和animal类型的pet,
     * 这里的第二个参数设置成animal类型可以给我们的程序带来最大的灵活性,
     * 因为作为养宠物来说,可以养猫,养狗,养鸟,只要是你喜欢的都可以养,
     * 因此把它设置为父类对象的引用最为灵活。
     * 因为这个animal类型的参数是父类对象的引用类型,因此当我们传参数的时候,
     * 可以把这个父类的子类对象传过去,即传dog、cat和bird等都可以。
     * @param name
     * @param pet
     */
    lady(string name, animal pet) {
        this.name = name;
        this.pet = pet;
    }

    /**
     * 在lady类里面自定义一个方法mypetenjoy()
     * 方法体内是让lady对象养的宠物自己调用自己的enjoy()方法发出自己的叫声。
     */
    public void mypetenjoy() {
        pet.enjoy();
    }
}

public class jerque {
    public static void main(string args[]) {
        /**
         * 在堆内存里面new了一只蓝猫对象出来,这个蓝猫对象里面包含有一个父类对象animal。
         */
        cat c = new cat("catname", "blue");
        /**
         * 在堆内存里面new了一只黑狗对象出来,这个黑狗对象里面包含有一个父类对象animal。
         */
        dog d = new dog("dogname", "black");
        /**
         * 在堆内存里面new了一只小鸟对象出来,这个小鸟对象里面包含有一个父类对象animal。
         */
        bird b = new bird();

        /**
         * 在堆内存里面new出来3个小姑娘,名字分别是l1,l2,l3。
    * l1养了一只宠物是c(cat),l2养了一只宠物是d(dog),l3养了一只宠物是b(bird)。
         * 注意:调用lady类的构造方法时,传递过来的c,d,b是当成animal来传递的,
         * 因此使用c,d,b这三个引用对象只能访问父类animal里面的enjoy()方法。
         */
        lady l1 = new lady("l1", c);
        lady l2 = new lady("l2", d);
        lady l3 = new lady("l3", b);
        /**
         * 这三个小姑娘都调用mypetenjoy()方法使自己养的宠物高兴地叫起来。
         */
        l1.mypetenjoy();
        l2.mypetenjoy();
        l3.mypetenjoy();
    }
}

上面的例子中,我们发现,如果我们想要加入新的动物,只需定义相应的类继承animal,完全不用动任何一处代码,因为这里运用了面向对象最核心的东西——多态。与之前的例子不同,虽然我们一直强调当用父类的引用指向子类对象,父类无法访问子类自己的成员,但是方法与数据成员不同,具体调哪一个方法是等到运行时决定的,new出了什么对象就调用相应对象的方法,取决于实际new出的对象而不是指向对象的引用,所以当传入不同动物类型,mypetenjoy()就会去执行不同的方法。

Java中的对象转型