多态（Java基础）

多态

多态：父类类型指向子类对象

调用父类的方法，执行的是子类的方法

多态的要求：

1.继承

2.方法重写

下面的例子：调用Pet里的eat,在Dog里重写,执行Dog里的eat

下面看一份代码：

public class Pet {
    String name;
    public void eat(){
        System.out.println(this.name + "正在吃骨头");
    }
}

public class Dog extends Pet {
  public void eat(){
      System.out.println(name + "正在吃东西");
  }
  public void play(){
      System.out.println(name + "正在玩耍");
  }
}

public class Demo {
    public static void main(String[] args){
        
        Pet pet = new Dog();//向上转型 -- 继承 + 重写
        
        pet.name = "修狗";
        
        pet.eat();//多态的表现形式 -- 调用父类的方法,执行子类的方法
        //调用Pet里的eat,在Dog里重写,执行Dog里的eat
​
        //pet.play(); 错误  只能调用Pet里的方法
    }
}
/*
修狗正在吃东西
*/

应用：1.使用父类作为方法形参实现多态，使方法的参数类型更为宽泛

可传递的实参包括：本类型对象 + 其所有的子类对象

父类类型作为形参，实际上是指向的子类对象

例：在一个宠物店，有主人这个父类

店里有各种宠物

主人可以执行“喂食”这个行为，但这个行为实际上是宠物执行的

public class Master {
    //m.feed(new Cat()); 主函数中的这句话体现了 向上转型
    public void feed(Pet pet){
        pet.eat();//实际上执行的还是子类的方法
    }
}

public class Pet extends Master{
    String name;
    public void eat(){
        System.out.println("宠物正在吃东西");
    }
}

public class Cat extends Pet {
    public void eat(){
        System.out.println("coke小猫正在吃鱼 <。)#)))≦ ");
    }
}

public class Dog extends Pet {
    public void eat(){
        System.out.println("骨架狗 U•ェ•*U 正在演戏");
    }
}

public class Demo {
    public static void main(String[] args){
        Master m = new Master();
​
        m.feed(new Pet());
        m.feed(new Cat());
        m.feed(new Dog());
​
    }
}
​
/*输出
宠物正在吃东西
coke小猫正在吃鱼 <。)#)))≦ 
骨架狗 U•ェ•*U 正在演戏
*/

2.父类类型作为返回值类型

        可以返回的类型：本类型对象 + 其所有的子类对象

public class Master {
    public Pet getPet(String Type){
        if(Type.equals("Cat"))return new Cat();
        else return new Dog();
    }
}

public class Pet extends Master{
    String name;
    public void eat(){
        System.out.println("宠物正在吃东西");
    }
}

public class Cat extends Pet {
    public void eat(){
        System.out.println("coke小猫正在吃鱼 <。)#)))≦ ");
    }
}

public class Dog extends Pet {
    public void eat(){
        System.out.println("骨架狗 U•ェ•*U 正在演戏");
    }
}

public class Demo {
    public static void main(String[] args){
        Master m = new Master();
        //Pet 指向了 Cat
        Pet pet = m.getPet("Cat");
        pet.eat();
        //Pet 指向了 Dog
        pet = m.getPet("Dog");
        pet.eat();
    }
}
​
/*输出
coke小猫正在吃鱼 <。)#)))≦ 
骨架狗 U•ェ•*U 正在演戏
*/

向下转型

目的：为了使用子类独有的方法

public class Master {
      public void play(Pet pet){
          //实例  是  这种类吗？
        if(pet instanceof Dog){
            Dog dog = (Dog)pet;//向下转型(拆箱)
            dog.Action();
        }
        else{
            Cat cat = (Cat)pet;
            cat.Live();
        }
    }
​
}

public class Pet extends Master{
    String name;
    public void eat(){
        System.out.println("宠物正在吃东西");
    }
}

public class Cat extends Pet {
    public void Live(){
        System.out.println("coke小猫正在直播吃鱼ing <。)#)))≦ ");
    }
}

public class Dog extends Pet {
    public void Action(){
        System.out.println("骨架狗 U•ェ•*U 正在演戏");
    }
}

public class Demo {
    public static void main(String[] args){
        Master m = new Master();
        //能够调用的方法，只有对象类型的方法 ->Master
        //执行的方法是实际类型的方法  -> Dog / Cat
        m.play(new Dog());
        m.play(new Cat());
        //只有转回子类真实类型,才可以执行子类独有的属性和方法
    }
}
/*输出
骨架狗 U•ェ•*U 正在演戏
coke小猫正在直播吃鱼ing <。)#)))≦ 
*/

多态的作用

屏蔽子类间的差异

灵活，耦合度低