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);

二、设计模式

1.定义--什么时设计模式？

a.为了解决一类问题的，一种固定的功能代码。
b.一共有23种设计模式：
            单例模式：构造方法私有化
            工厂模式：父类做返回值类型
            代理模式：多个实现类，实现同一个接口

2.简单工厂模式的基本要求

a.定义一个static方法，通过类名直接调用。
b.返回值类型是父类类型，返回的可以是其任意子类类型。
c.传入一个字符串类型的参数，工厂根据参数创建对应的子类产品。

三、抽象父类

1.抽象类的作用--为什么要学习抽象类？

因为父类没有创建对象的必要！所以就不让父类创建对象了，然后就父类为抽象的，抽象类就不能new 对象。
public abstract class Pizza {  }

2.抽象类不能创建对象了，它还有必要拥有构造方法吗？--为了让子类调用！

四、抽象方法

1.定义--为什么要学习抽象方法？

为了告诉子类，必须重写该方法！
public abstract void show( );

总结 ：A.一个类如果拥有抽象方法，那么这个类一定是抽象类；
              但是一个类是抽象类，可以没有抽象方法。
           B.以后再写父类，都要写成抽象的；
              父类里，尽可能多的创建抽象方法。

五、fianl关键字：final 最终的，可以修饰属性.方法.类

1.final 类：不可以被继承。
2.final 方法：不可以被重写。
3.final 属性：基本类型：值不可以被改变。
                    引用类型：地址不可以被改变,对象属性可以变。

4.补充：
基本数据类型和引用数据类型的区别：基本类型传值，引用类型传地址