Java.6--多态-设计模式-抽象父类-抽象方法

一、多态

1.定义--什么是多态？

a.同一个父类的不同子类对象，在做同一行为的时候，有不同的表现形式，这就是多态。
（总结为：一个父类下的不同子类，同一行为，不同表现形式。）
b."动态绑定"：开发阶段，以父类做参数，以父类做返回值类型 （代码的通用性比较好）；
程序运行时，会根据实际传入参数的类型，动态的调用该类型所对应的方法（扩展性好）。
c.多态的好处：提高代码的扩展性和可维护性。

【以父类做返回值】

【pizza父类】

package work.demo1;public class Pizza {//父类--子类有培根披萨，海鲜披萨//父类  1.声明共有属性 2.空参构造 有参构造 3.get set 方法 取值赋值  4.方法String  name;int price;int  size;public Pizza() {}public Pizza(String name, int price, int size) {this.name = name;this.price = price;this.size = size;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getPrice() {return price;}public void setPrice(int price) {this.price = price;}public int getSize() {return size;}public void setSize(int size) {this.size = size;}public void show() {//这个方法展示，所以子类共有的System.out.println("名称"+name);System.out.println("价格"+price);System.out.println("尺寸"+size);}
}

【Peigen子类】

package work.demo1;import java.util.Scanner;public class Peigen extends Pizza {//子类培根披萨private int g;//培根披萨私有属性--克数public Peigen() {//空参构造}public Peigen(String name, int price, int size, int g) {//有参构造super(name, price, size);this.g = g;}//get setpublic int getG() {return g;}public void setG(int g) {this.g = g;}public void show() {super.show();//引用父类方法System.out.println("请输入培根克数："+g);}}

【Haixian子类】

package work.demo1;import java.util.Scanner;public class Haixian extends Pizza {//子类海鲜披萨private String food;//配料public Haixian(String food) {this.food = food;}public Haixian(String name, int price, int size, String food) {super(name, price, size);this.food = food;}public String getFood() {return food;}public void setFood(String food) {this.food = food;}public void show() {super.show();System.out.println("输入配菜："+food);}}

【dopizza工厂类】

package work.demo1;import java.util.Scanner;public class Dopizza {public Pizza dopizza() {//方法签名  Pizza：返回类型，表示该方法返回一个 Pizza 对象//父类做返回值的含义//在 Java 中，父类作为返回类型是一种常见的设计模式，称为多态。// 具体来说，当一个方法的返回类型是父类时，该方法可以返回任何继承自该父类的子类对象。// 这种方式提供了更大的灵活性和扩展性。//在代码中，dopizza 方法的返回类型是 Pizza，这是一个父类。// 方法内部根据用户的输入创建了不同的子类对象（Peigen 和 Haixian），但最终返回的是一个 Pizza 类型的对象。Pizza pizza = null;//对象类型 对象名System.out.println("请选择想要制作的比萨(1.培根比萨2.海鲜比萨)：");Scanner sc = new Scanner(System.in);int i = sc.nextInt();if(i==1){System.out.println("请输入培根克数:");int weight= sc.nextInt();System.out.println("请输入比萨大小:");int size = sc.nextInt();System.out.println("请输入比萨价格:");int  price= sc.nextInt();pizza=new Peigen("培根披萨",price,size,weight);} else if (i==2) {System.out.println("请输入配料信息:");String food = sc.next();System.out.println("请输入比萨大小:");int size = sc.nextInt();System.out.println("请输入比萨价格:");int  price= sc.nextInt();pizza=new Haixian("海鲜披萨",price, size,food);}return  pizza;}
}

【Test测试类】

package work.demo1;import java.util.Scanner;public class Test {public static void main(String[] args) {Dopizza dopizza =new Dopizza();Pizza peigen = dopizza.dopizza();peigen.show();
//        这段代码的功能是创建一个 Dopizza 对象，并调用其 dopizza 方法生成一个 Pizza 对象，然后调用 Pizza 对象的 show 方法显示披萨的信息。
//        创建 Dopizza 对象 dopizza。
//        调用 dopizza 对象的 dopizza 方法，返回一个 Pizza 对象 peigen。
//        调用 peigen 对象的 show 方法，显示披萨的信息。}
}

【以父类做参数】

package work.demo1;import java.util.InputMismatchException;
import java.util.Scanner;public class Dopizza {public Pizza dopizza() {Pizza pizza = null;Scanner sc = new Scanner(System.in);System.out.println("请选择想要制作的比萨(1.培根比萨2.海鲜比萨)：");int choice = readInt(sc, 1, 2);if (choice == 1) {System.out.println("请输入培根克数:");int weight = readInt(sc, 0, Integer.MAX_VALUE);System.out.println("请输入比萨大小:");int size = readInt(sc, 0, Integer.MAX_VALUE);System.out.println("请输入比萨价格:");int price = readInt(sc, 0, Integer.MAX_VALUE);pizza = new Peigen("培根披萨", price, size, weight);} else if (choice == 2) {System.out.println("请输入配料信息:");String food = sc.next();System.out.println("请输入比萨大小:");int size = readInt(sc, 0, Integer.MAX_VALUE);System.out.println("请输入比萨价格:");int price = readInt(sc, 0, Integer.MAX_VALUE);pizza = new Haixian("海鲜披萨", price, size, food);}return pizza;}// 父类 Pizza 作为参数传递的地方public void processPizza(Pizza pizza) {if (pizza instanceof Peigen) {Peigen peigen = (Peigen) pizza;System.out.println("培根披萨信息：");peigen.show();} else if (pizza instanceof Haixian) {Haixian haixian = (Haixian) pizza;System.out.println("海鲜披萨信息：");haixian.show();} else {System.out.println("未知类型的披萨");}}//异常处理 private int readInt(Scanner sc, int min, int max) {while (true) {try {int value = sc.nextInt();if (value >= min && value <= max) {return value;} else {System.out.println("输入值不在有效范围内，请重新输入：");}} catch (InputMismatchException e) {System.out.println("输入无效，请输入一个整数：");sc.next(); // 清除错误输入}}}
}

【Test测试类】

package work.demo1;public class Test {public static void main(String[] args) {Dopizza dopizza = new Dopizza();Pizza pizza = dopizza.dopizza();dopizza.processPizza(pizza);}
}

PS：父类做参数子类父类都一样，只有工厂类和测试类有修改，异常处理在下一篇笔记

这部分会修改，因为工厂设计模式就是父类做返回值。

2.使用多态的场景

程序中一定有两条业务线：
一条是继承线由父子类组成的；一条是关联线，两条线有业务关联，第二天业务线中，父类做参数了；父类做返回值类型了。
例如：动物园，饲养员喂养动物，猫狗猴子

3.表现形式与实现条件

（1）表现形式

a.父类做参数：扩展性做的很好。
b.父类做返回值类型（工厂设计模式）：扩展性还不够好，反射的扩展性最好！

（2）实现条件：继承；重写；声明父类、new子类（ Person stu =new Student();）。
父类定义对象= new 子类();

4.多态中的类型转换

（1）向上类型转换（声明父类new子类）：

将对象由子类类型转成父类类型（缩小范围了：为了程序代码的通用）。
只能调用继承父类的，或者重写父亲的资源；不能调用自己特有的。

（2）向下类型转换（子类类型，声明父类new子类）：

可以调用子类特有的方法；为了防止类型转换错误，使用关键字instanceof
if(animal instanceof Cat){
((Cat) animal).play(); //向下类型转换：可以调用子类特有的资源了
}

5.声明父类new 子类

首先实现多态的条件：继承，重写，声明父类new 子类
声明父类new 子类是拼凑出来的
【👇声明父类】
public void feet(Animal animal){
animal.eat();
if(animal instanceof Cat){
((Cat) animal).play(); //向下类型转换：可以调用子类特有的资源了
}
}
【主方法里👇new 子类】
Cat cat=new Cat();
feeder.feet(cat);