多态的应用

1.多态的优势

可替换性：多态对已存在的代码具有可替换性。

可扩充性：多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性，以及其他特性的运行和操作。实际上新加子类更容易获得多态。

接口性：多态是父类向子类提供了一个共同接口，由子类来具体实现。

灵活性：多态在应用中体现了灵活多样的操作，提高了使用效率。

简化性：多态简化了应用软件的代码编写和修改过程，尤其在处理大量对象的运算和操作时，这个特点尤为突出和重要。

2.多态的应用

在多态的程序设计中，一般有以下两种主要的应用形式。

（1）.使用父类作为方法的参数

public class Pet {          //Pet类作为父类
    public void cry(){
    }
}

public class Dog extends Pet{
    public void cry(){      //重写父类cry()方法
        System.out.println("狗狗叫声：汪汪");
    }
}

public class Cat extends Pet{
    public void cry(){      //重写父类cry()方法
        System.out.println("猫的叫声：喵喵");
    }
}

public class Duck extends Pet{
    public void cry(){      //重写父类cry()方法
        System.out.println("鸭子叫声：嘎嘎");
    }
}

public class Host {
    public void letCry(Pet pet){//父类引用作为方法参数时，可以传入该类的任意子类对象，实现多态
        pet.cry();//调用宠物叫声的方法
    }
}

public class Test {
    public static void main(String[] args){
        //定义主人对象
        Host host=new Host();
        //选择宠物
        Scanner input = new Scanner(System.in);
        System.out.println("请输入宠物，1：狗狗；2：鸭子；3：猫");
        int choice = input.nextInt();
        Pet pet = null;
        switch (choice){
            case 1:
                System.out.println("主人选择的是狗狗");
                pet = new Dog();//先执行 = 右边：-> Dog类构造方法 ->Pet类构造方法（Dog继承Pet）->Object类（默认Pet继承Object类->Pet->Dog->执行 = 赋值，pet指向Dog）
               
                break;
            case 2:
                System.out.println("主人选择的是鸭子");
                pet = new Duck();
                break;
            case 3:
                System.out.println("主人选择的是猫");
                pet = new Cat();
                break;
        }
        //主人听宠物的叫声
        host.letCry(pet);       //Test->host.letCry(pet)->pet.cry() (ps：因为子类继承并重写了父类的cry方法，且父类引用此时指向所选择的宠物，所以下一步到该宠物下的cry方法) ->执行方法体到该方法结束 ->host.letCry()方法结束 -> 输出结束，main结束，程序结束。
        System.out.println("*********");
    }
}

（2）.父类作为方法返回值

public class Host {
    public void letCry(Pet pet){//父类引用作为方法参数时，可以传入该类的任意子类对象，实现多态
        pet.cry();//调用宠物叫声的方法
    }
    public Pet donateAnimal(String type){
        Pet pet = null;
        if ("dog".equals(type)){
            pet = new Dog();
        }else if ("cat".equals(type)){
            pet = new Cat();
        }else {
            pet = new Duck();
        }
        return pet;
    }
}

public class Test {
    public static void main(String[] args){
        //定义主人对象
        Host host=new Host();
        //选择宠物
        Scanner input = new Scanner(System.in);
        System.out.println("请输入宠物，1：狗狗；2：鸭子；3：猫");
        String type = input.next();
        Pet pet = host.donateAnimal(type);
        System.out.println("主人送出的是："+type);
        pet.cry()；
        System.out.println("*********");
    }
}
//父类引用作为方法返回值时，可以返回该类的任意子类对象，实现多态

抽象

1.概念

java中，当一个类被abstract关键字修饰的时候这个类称为抽象类。当一个类的方法被abstract关键字修饰的时候，该方法称为抽象方法。抽象方法必须定义在抽象类中。

当一个方法被定义为抽象方法后，意味着该方法不会有具体的实现，而是在抽象类的子类中通过方法重写进行实现。（抽象方法没有方法体）

public abstract class Pet {
    public abstract void sound() ;
}

区分：

1.抽象方法与抽象类需要用修饰符abstract修饰，普通方法不允许。

2.普通方法有方法体，抽象方法没有方法体。

3.普通类可以被实例化，抽象类不可以被实例化。

2.抽象类和抽象方法的规则

（1） 抽象类中可以包含普通方法或者抽象方法

（2） 抽象类中可以定义实例属性或者静态属性

（3） 如果一个类中包含了抽象方法，那么这个类就必须是抽象类

（4） 抽象类中不一定要包含抽象方法

（5）抽象类不允许实例化。因为抽象类是半成品，之所以说是半成品是因为抽象类的抽象方法没有方法体。

3.为什么使用抽象类？

抽象类在OOP的思想中，是专门用在继承关系中，抽象类在继承关系中当做父类，让子类继承抽象类。

​ 当子类继承抽象类后，子类也继承了父类中的抽象方法，此时子类有两种处理抽象方法的办法。第一种将子类定义为抽象类，但是这种处理办法导致子类不能被实例化。第二种处理方法是子类实现父类的抽象方法，实现抽象方法就是在子类中将抽象方法再定义一遍并且添加方法体。此时子类中就没有抽象方法了，子类就不是抽象类，因此可以实例化子类对象。

​ 为什么使用抽象类？

​ 抽象类中定义抽象方法，让子类继承抽象方法。父类通过抽象方法让子类遵守父类的规范，这里的规范是指父类的抽象方法，遵守规范是指子类实现父类的抽象方法。