工厂方法模式与抽象工厂模式

简单工厂模式

传统方式的优缺点： 1、优点是比较好理解，简单易操作 2、缺点是违反了设计模式的ocp原则，当我们给类增加新功能的时候，尽量不修改代码，或者尽可能少修改代码

基本介绍：
1、简单工厂模式是属于创建型模式，是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单使用的模式
2、定义了一个创建对象的类，由这个类来封装实例化对象的行为
3、在软件开发中，当我们需要大量的创建某种、某类或某批对象时，就会使用到工厂模式
例如有一个电脑工厂，生产惠普和华硕2中品牌

public abstract class Computer {
    private String name;
    /**
     * 启动
     */
    public abstract void startup();
    public void setName(String name){
        this.name=name;
    }
}

public class HpComputer extends Computer {
    @Override
    public void startup() {
        System.out.println("启动惠普");
    }
}

public class HuashuoComputer extends Computer {
    @Override
    public void startup() {
        System.out.println("启动华硕");
    }
}

现在创建一个电脑工厂，这里创建实例用的是静态方法

public class ComputerFactory {
    public static Computer createComputer(String name){
        Computer computer = null;
        switch (name){
            case "hp":
                computer = new HpComputer();
                computer.setName(name);
                break;
            case "huashuo":
                computer = new HuashuoComputer();
                computer.setName(name);
                break;
            default:
                System.out.println("品牌有误");
        }
        return computer;
    }
}

然后可以通过电脑工厂来调用

public static void main(String[] args) {
    Computer hp = ComputerFactory.createComputer("hp");
    hp.startup();
    Computer huashuo = ComputerFactory.createComputer("huashuo");
    huashuo.startup();
}

工厂方法模式

工厂方法模式定义了一个创建对象的抽象方法，由子类决定要实例化的类，它将对象的实例化推迟到子类
简单的讲，就是在简单工厂方法模式上再加一层。将上述的工厂类改为抽象类，里面写抽象方法，方法是实现推迟到子类，这里方法的实现就是对象的实例化。
UML类图如下：

模式组成：

抽象工厂模式

基本介绍：
1、定义了一个interface用于创建相关或有依赖关系的对象簇，而无需指明具体的类
2、抽象工厂可以将简单工厂模式和工厂方法模式进行整合
3、从设计层面看，抽象工厂模式就是对简单工厂模式的改进（进一步的抽象）
4、将工厂抽象成两层，AbsFactory（抽象工厂）和具体实现的工厂子类。可以根据创建对象类型使用对应的工厂子类，这样将单个的简单工厂类变成了工厂簇，更利于代码的维护和扩展
下面有示例，一个卖Pizza的例子。

AbsFactory接口作为抽象工厂，它有两个实现类，各种订单需求直接调用接口即可。
代码示例：
抽象类Pizza，及其2个抽象子类，4个实现类

public abstract class Pizza {
    /**
     * 准备Pizza
     */
    public abstract void prepare();
    public void bake(){
        System.out.println("烘焙");
    }
    public void cut(){
        System.out.println("切");
    }
    public void box(){
        System.out.println("烤");
    }
}
public abstract class BJPizza extends Pizza{
}
public abstract class LDPizza extends Pizza {
}
public class BJCheesePizza extends BJPizza {
    @Override
    public void prepare() {
        System.out.println("准备北京奶酪Pizza");
    }
}
public class BJPepperPizza extends BJPizza{
    @Override
    public void prepare() {
        System.out.println("准备北京胡椒Pizza");
    }
}
public class LDCheesePizza extends LDPizza{
    @Override
    public void prepare() {
        System.out.println("准备伦敦奶酪Pizza");
    }
}
public class LDPepperPizza extends LDPizza {
    @Override
    public void prepare() {
        System.out.println("准备伦敦胡椒Pizza");
    }
}

抽象工厂接口及其两个实现类

public interface AbsFactory {
    /**
     * 制作Pizza
     * @param name
     * @return Pizza
     */
    Pizza createPizza(String name);
}
public class BJFactory implements AbsFactory {
    @Override
    public Pizza createPizza(String name) {
        switch (name){
            case "cheese":
                return new BJCheesePizza();
            case "pepper":
                return new BJPepperPizza();
            default:
                return null;
        }
    }
}
public class LDFactory implements AbsFactory {
    @Override
    public Pizza createPizza(String name) {
        switch (name){
            case "cheese":
                return new LDCheesePizza();
            case "pepper":
                return new LDPepperPizza();
            default:
                return null;
        }
    }
}

调用工厂接口

public class OrderPizza {
    public static Pizza createPizza(AbsFactory absFactory,String name){
        return absFactory.createPizza(name);
    }
    public static void main(String[] args) {
        createPizza(new BJFactory(),"cheese").prepare();
        createPizza(new BJFactory(),"pepper").prepare();
        createPizza(new LDFactory(),"cheese").prepare();
        createPizza(new LDFactory(),"pepper").prepare();
    }
}

调用结果

准备北京奶酪Pizza
准备北京胡椒Pizza
准备伦敦奶酪Pizza
准备伦敦胡椒Pizza

工厂模式在JDK-Calender应用：JDK中的Calendar类中，就使用了简单工厂模式

• 工厂模式的意义：将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的依赖关系的解耦，从而提高项目的扩展性和维护性
  
• 三种工厂模式：
  • 简单工厂模式（静态工厂模式）
    
  • 工厂方法模式
    
  • 抽象工厂模式
    

• 对比工厂方法模式与抽象工厂模式
  | 工厂方法模式 | 抽象工厂模式 | | —- | —- | | 针对的是一个产品等级结构 | 针对的是面向多个产品等级结构 | | 一个抽象产品类 | 多个抽象产品类 | | 可以派生出多个具体产品类 | 每个抽象产品类都可以派生出多个具体产品类 | | 一个抽象工厂类，可以派生出多个具体工厂类 | 一个抽象工厂类，可以派生出多个具体工厂类 | | 每个具体工厂类只能创建一个具体产品类的实例 | 每个具体工厂类可以创建多个具体产品类的实例 |

• 设计模式的依赖抽象原则：

  • 创建对象实例时，不要直接new类，而是把这个new类的动作放在一个工厂的方法中，并返回。换种说法，变量不要直接持有具体类的引用。
    
  • 不要让类继承具体类，而是继承抽象类或者是实现接口
    
  • 不要覆盖基类中已经实现的方