Java에서 객체의 유형 변환 소개(코드 포함)

이 기사는 Java의 객체 유형 변환(코드 포함)에 대한 소개를 제공합니다. 이는 특정 참조 값이 있으므로 도움이 될 수 있습니다.

상향 변환: 하위 클래스 객체가 상위 클래스로 변환되고, 상위 클래스가 인터페이스가 될 수 있습니다. 공식: Father f = new Son();Father는 상위 클래스 또는 인터페이스이고 son은 하위 클래스입니다.

하향 변환: 상위 클래스 객체가 하위 클래스로 변환됩니다. 공식: Son s = (Son)f;

test.f(c)를 실행할 때 형식 매개변수를 상위 클래스 Animal 유형으로 설정합니다. , 메모리 상황은 다음과 같습니다.

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을 상속하는 해당 클래스입니다. 이전 예제와 달리, 부모 클래스 참조를 사용하여 하위 클래스 객체를 가리킬 때 부모 클래스는 하위 클래스의 자체 멤버에 액세스할 수 없지만 메서드는 호출할 메서드가 데이터 멤버와 다르다는 점을 항상 강조했습니다. 새로운 객체가 무엇이든 해당 객체의 메서드가 호출됩니다. 이는 객체에 대한 참조가 아닌 실제 객체에 따라 달라집니다. 따라서 다른 동물 유형이 전달되면 mypetEnjoy()는 다른 메서드를 실행합니다.

위 내용은 Java에서 객체의 유형 변환 소개(코드 포함)의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!