java 向上转型、向下转型

java 向上转型、向下转型实例

 

父类：

public class Animal {

    private String name = "animal";

    public int i = 1;

    Animal() {
        speak();
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    /**
     * 静态方法不会被子类继承，调用的时候，不要用实例来调用，可以用类来调用
     */
    static void eat() {
        System.out.println("I am a animal, i am eating");
    }

    /**
     * 被子类重写
     */
    public void speak() {
        System.out.println("i am animal, i am speaking");
    }

    /**
     * 父类私有方法
     */
    void sleep() {
        System.out.println("i am animal, i am sleeping");
    }
}

子类：

public class Dog extends Animal {
    private String name = "dog";

    public int i = 2;
    Dog() {
    }
    @Override
    public String getName() {
        return name;
    }
    @Override
    public void setName(String name) {
        this.name = name;
    }
    /**
     * 子类的静态方法，不会重写父类的方法
     */
    public static void eat() {
        System.out.println("i am a dog, i am eating");
    }
    /**
     * 重写父类同名、同参数、同参数类型的方法
     */
    @Override
    public void speak() {
        System.out.println("i am dog, i am speaking");
    }
    /**
     * 子类私有的方法
     */
    public void run() {
        System.out.println("i am dog, i am running");
    }
}

测试类：

public class Test {
    public static void main(String[] args) {
        System.out.println("-------向上转型：--------- ");
        // 向上转型，可以调用父类的所有方法，被子类覆盖的方法（没有用static标明的）会执行子类方法的具体功能
        Animal animal = new Dog();

        System.out.println(animal.getName());
        // 输出父类的变量，变量不会被子类覆盖
        System.out.println(animal.i);
        // 被子类覆盖，执行子类的speak()
        animal.speak();
        // 当static 修饰的方法，向上转型的时候，父类不会被覆盖。也不应该用实例访问静态方法
        Animal.eat();
        // 向上转型的时候，不能调用子类独有的函数
        // animal.run();
        // 向上转型可以调用父类独有的方法
        animal.sleep();

        System.out.println("-------向下转型-------");
        // 向上转型的引用，再向下转型，则可以调用父类和子类的所有函数
        Dog dog = (Dog) animal;
        dog.sleep();  // 父类独有的方法，也可以调用
        dog.speak();  // 父类和子类共有的方法，调用子类覆盖的结果
        Dog.eat();  // 也可以调用子类中被static修饰的方法，不应该用实例访问静态方法，用类可以访问
        dog.run();   // 子类独有的方法，也可以调用

        Animal animal1 = new Animal();
        if (animal1 instanceof Dog) {
            System.out.println("animal class is Dog class");
        } else {
            System.out.println("animal class is not Dog class");
        }

        Dog dog2 = new Dog();
        if (dog2 instanceof Animal) {
            System.out.println("dog class is animal class");
        } else {
            System.out.println("dog class is not animal class");
        }

        Animal animal2 = new Dog();
        if (animal2 instanceof Dog) {
            System.out.println("animal2 class is Dog class");
        } else {
            System.out.println("animal2 class is not Dog class");
        }

        System.out.println("判断两个引用对象是属于什么类：");
        if (animal instanceof Dog) {
            System.out.println("animal is Dog class");
        } else {
            System.out.println("animal is not Dog class");
        }
        if (animal instanceof Animal) {
            System.out.println("animal is Animal class");
        } else {
            System.out.println("animal is not Animal class");
        }
        if (dog instanceof Animal) {
            System.out.println("dog is Animal class");
        } else {
            System.out.println("dog is not Animal class");
        }
        if (dog instanceof Dog) {
            System.out.println("dog is Dog class");
        } else {
            System.out.println("dog is not Dog class");
        }

        System.out.println("Dog class : ");
        Dog dog1 = new Dog();
        dog1.speak();
        dog1.sleep();
        dog1.run();

        // 判断对象初始化是否为空
        Cat cat = new Cat();
        if (cat == null) {
            System.out.println("空");
        } else {
            System.out.println("不空");
        }
        Cat cat1 = new Cat();

        if (cat1.getCatFriend() == null) {
            System.out.println("空");
        } else {
            System.out.println("不空");
        }

    }
}