Java多态与向上向下转型

多态的必要三要素

1.继承 2.方法重写 3.向上转型

多态的作用

1.增加代码的复用性

2.便于代码的管理与维护

案例引入

代码：

//测试类
public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog("八嘎");
        Bone bone = new Bone("骨头");
        Cat cat = new Cat("西巴");
        Fish fish = new Fish("汉江怪鱼");
        Master master = new Master("张三");
        master.feed(dog, bone);
        master.feed(cat, fish);
    }
}

//主人类
public class Master {
    private String name;

    public Master(String name) {
        this.setName(name);
    }

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

    public String getName() {
        return name;
    }
    public void feed(Dog dog, Bone bone) {//给狗喂食
        System.out.println("主人" + this.name + "给" + dog.getName() + "吃" + bone.getName());
    }
public void feed(Cat cat, Fish fish) {//给猫喂食
       System.out.println("主人" + this.name + "给" + cat.getName() + "吃" + fish.getName());
    }
   
}

//动物类
public class Animal {
    private String name;
    public Animal(String name){
        this.setName(name);
    }
    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}
//狗类
public class Dog extends Animal{
    public Dog(String name){
        super(name);
    }
}
//猫类
public class Cat extends Animal{
    public Cat(String name){
        super(name);
    }
}
//食物类
public class Food {
    private String name;
    public Food(String name){
        this.setName(name);
    }
    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}
//骨头类
public class Bone extends Food{
    public Bone(String name){
        super(name);
    }
}
//鱼类
public class Fish extends Food{
    public Fish(String name){
        super(name);
    }
}

我们看到在mather类中有俩个对不同动物喂食的方法，乍一看我们的代码没有什么问题，但是我们将动物增加时，mather类中就要写出对应的喂食方法，这对于代码的复用性极低，对于代码的维护也不好，那我们能不能将这俩个方法抽象出来呢？将其集成为一个方法：

将Test类中代码修改

代码：

        Animal dog = new Dog("八嘎");
        Food bone = new Bone("骨头");
        Animal cet = new Cet("西巴");
        Food fish = new Fish("汉江怪鱼");

将mather类中的喂食方法修改

代码：

 public void feed(Animal animal, Food food) {
        System.out.println("主人" + this.name + "给" + animal.getName() + "吃" + food.getName());
    }

输出：

这里就有疑问了，为什么我们能将一个父类的引用指向了子类的对象呢？

这里我们引出向上转型

向上转型是什么？

所谓的向上转型就是将父类的引用指向了子类的对象，换而言之就是将子类的对象地址赋值给了父类引用

语法：

父类类型引用 = new 子类类型();

左边为编译类型，右边为运行类型

编译类型确定我们可以调用的成员，但是实际运行的方法看我们的运行类型（下面代码可以体会到）

作用：

可以调用父类中的属性（需遵守访问权限）与父类中方法但没有在子类中重写的方法，如果在子类中重写，那么只能调用子类这个方法，且不能调用子类中特有的方法

代码：

​
public class Test {
    public static void main(String[] args) {
        Animal animal = new Cat();
        animal.eat();//这里输出的是子类的方法   
    }
}

public class Cat extends Animal{
    public void eat(){
        System.out.println("猫吃鱼");
    }
    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }
}

public class Animal {
    public void eat(){
        System.out.println("吃");
    }
    public void run(){
        System.out.println("跑");
    }
    public void sleep(){
        System.out.println("睡");
    }
}

​

输出：

 上面讲了我们使用向上转型后我们不能调用子类中特有的方法，那我们为什么不直接new一个子类的对象呢？反正它也有父类的属性与方法，还能继续使用我们子类特有的方法，那为何要多此一举呢，那还是要回归我们代码复用性问题上来，当我们使用子类对象对mather类feed方法传参时，只能一个方法实现一只动物的喂食，无法用一个方法对不同的动物进行喂食，所以我们使用父类作为形参能够实现不同的动物喂食，增加了代码的复用性便于日后代码的维护与管理！！！

那么使用了向上转型后我们一定要调用子类中特有的方法怎么办？java开发者为我们提供了向下转型

向下转型

必要条件：

要求父类的引用必须指向的是当前目标类型的对象；通俗来讲就是必须先要向上转型，且要指向你之前向上转型的类型对象；打个比方就是你将一只猫变成了一只狗(Dog dog =(doganimal);)，但是我们的java编译器会让其通过（语法没错），但无法运行；

作用：

可以调用子类特有的方法

语法：

子类引用 = （子类类型） 父类引用

代码：

     Cat cat =(Cat) animal;
     cat.catchMouse();

输出：

（此文谨个人学习记录，如有错误欢迎指出，对您有帮助的话，恳请您点个赞~）