向上转型

实际就是创建一个子类对象，将其当成父类对象来使用。格式：父类类型 对象名=new 子类类型（）；eg：Animal animal=new Cat（）；animal是父类类型，但可以引用一个子类对象，因为是从小范围向大范围的装换

public class Main {
    public static void main(String[] args) {
        dog dog=new dog("az",1);
        dog.bark();
        dog.eat();
        System.out.println("=======");
        animal animal=new dog("ss",2);
//      animal.bark();调用不会成功
        animal.eat();
    }
}
class animal{
    public String name;
    public int age;
    public animal(String name,int age){
        this.age=age;
        this.name =name;
    }
    public void eat(){
        System.out.println(this.name+"正在吃饭...");
    }
}
class dog extends animal{
    public dog(String name,int age){
        super(name,age);
    }

    @Override
    public void eat() {
        System.out.println(this.name+"正在吃饭.");
    }
    public void bark(){
        System.out.println(this.name+"叫");
    }
}

animal.bark（）调用不成功是因为bark（）只有子类有，父类没有

向上转型的优点：让代码实现更简单灵活；缺点：不能调用到子类特有的方法

向下转型

将一个子类对象经过向上转型之后当成父类方法使用，再无法调用子类的方法，但有时候可能需要调用到子类特有的方法，此时：将父类引用再还原为子类对象即可，即向下转型

将上面的代码main改成如下：

public class Main {
    public static void main(String[] args) {
        dog dog=new dog("元宝",1);
        animal animal=dog;//向下转型
        dog.eat();
        //animal.bark();编译不成功，编译时编译器将animal当成animal对象处理，而animal类中没有bark方法

        //向上转型
        dog=(dog) animal;
        dog.bark();
    }
}

instanceof关键字

如果该表达式为true则可以安全转换

多态体现

 

public class Main {
    public static void main(String[] args) {
    rect rect=new rect();
    cycle cycle=new cycle();
    drawMap(rect);
    drawMap(cycle);
    }
    public static void drawMap(shape shape){
        shape.draw();
    }
}
class shape{
    //属性
    public void draw(){
        System.out.println("画图形");
    }
}
class rect extends shape{
    @Override
    public void draw() {
        System.out.println("※");
    }
}
class cycle extends shape{
    @Override
    public void draw() {
        System.out.println("圆");
    }
}