1、简单/静态工厂模式概述

1. 简单工厂模式使属于创建型模式，是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式

1. 简单工厂模式：定义了一个创建对象的类，由这个类来封装实例化对象的行为（代码）

1. 在软件开发中，当我们会用到大量的创建某种，某类或者某批对象时，就会使用到工厂模式

1. 定义一个简单工厂类，它可以根据参数的不同返回不同类的实例，被创建的实例通常是具有共同的父亲

1. 在简单工厂模式中，创建实例的方法通常为静态方法，因此简单工厂模式又被称为静态工厂模式

2、简单工厂模式的优点：

• 工厂类包含了必要的逻辑判断，可以决定在什么情况下创建哪个类的实例，客户端可以免除直接创建产品对象的职责

• 客户端无需知道所创建的产品的类名，只需知道参数即可。

• 也可以引入配置文件，在不修改客户端代码的情况下更换和添加新的具体产品类

3、缺点

• 工厂类集中了所有的产品创建逻辑，职责过重，一旦异常，整个系统受到影响

• 使用简单工厂模式会增加系统中类的个数(引入新的工厂类)，增加系统的复杂度和理解难度

• 系统扩展困难，一旦增加新产品不得不修改工厂逻辑，在产品类型较多时，可能造成逻辑过于复杂

• 简单工厂模式使用了static工厂方法，造成工厂角色无法形成基于继承的等级结构。

4、简单工厂模式的使用场景：

• 工厂类负责创建对的对象比较少，因为不会造成工厂方法中的业务逻辑过于复杂

• 客户端只知道传入工厂类的参数，对如何创建对象不关心

5、代码实现

class Demo{
    public static void main(String[] args) {
        //调用工厂里的静态方法 创建对象
        Pizza hj = PizzaFactory.getPizza("胡椒");
        hj.getReady();
    }
}
public abstract class Pizza {
    //父类中的抽象方法
    public abstract void getReady();
}
class APizza extends Pizza{
    @Override
    public void getReady() {
        System.out.println("胡椒披萨正在制作");
    }
}
class BPizza extends Pizza{
    @Override
    public void getReady() {
        System.out.println("番茄披萨正在制作");
    }
}
//Pizza工厂类
class PizzaFactory{
    //静态方法 ，根据传入的值进行判断创建对象
    public static Pizza getPizza(String name){
        Pizza pizza = null;
        if ("胡椒".equals(name)){
            pizza = new APizza();
        }else if("番茄".equals(name)){
            pizza = new BPizza();
        }
        return pizza;
    }
}

6、简单工厂练习题

使用简单工厂模式设计一个可以创建不同几何图形（Shape），如Circle，Rectangle，Triangle等绘图工具类，每个几何图形均具有绘制Draw()和擦除Erase()两个方法

package com.yixuexi;
import java.util.Scanner;
/**
 * 2020/10/15   22:06
 */
public class ShapeDemo {
    public static void main(String[] args) {
        boolean loop = true;
        while (loop){
            System.out.println("请输入要打印的图形：");
            Scanner scanner = new Scanner(System.in);
            String next = scanner.next();
            switch (next){
                case "正方形":
                    Shape shape1 = ShapeFactory.getShape(next);
                    shape1.draw();
                    shape1.erase();
                    break;
                case "圆形":
                    Shape shape2 = ShapeFactory.getShape(next);
                    shape2.draw();
                    shape2.erase();
                    break;
                case "三角形":
                    Shape shape3 = ShapeFactory.getShape(next);
                    shape3.draw();
                    shape3.erase();
                    break;
                default:
                    System.out.println("没有该图形");
                    loop = false;
            }
        }
    }
}
interface Shape{
    void draw();
    void erase();
}
//圆形
class Circle implements Shape{
    @Override
    public void draw() {
        System.out.println("正在画圆形");
    }
    @Override
    public void erase() {
        System.out.println("正在擦除圆形");
    }
}
//正方形
class Rectangle implements Shape{
    @Override
    public void draw() {
        System.out.println("正在画正方形");
    }
    @Override
    public void erase() {
        System.out.println("正在擦除正方形");
    }
}
//三角形
class Triangle implements Shape{
    @Override
    public void draw() {
        System.out.println("正在画三角形");
    }
    @Override
    public void erase() {
        System.out.println("正在擦除三角形");
    }
}
// 简单图形工厂
class ShapeFactory{
    public static Shape getShape(String type){
        Shape shape = null;
        if ("三角形".equals(type)){
            shape = new Triangle();
        }else if("正方形".equals(type)){
            shape = new Rectangle();
        }else if("圆形".equals(type)){
            shape = new Circle();
        }
        return shape;
    }
}