设计模式一工厂模式

1、概述

工厂模式提供了一种创建对象的方式，而无需指定要创建的具体类。
通过使用工厂模式，可以将对象的创建逻辑封装在一个工厂类中，而不是在客户端代码中直接实例化对象，这样可以提高代码的可维护性和可扩展性。
在java中，万物皆对象，这些对象都需要创建，如果创建的时候直接new该对象，就会对该对象耦合严重，假如我们要更换对象，所有new对象的地方都需要修改一遍，这显然违背了软件设计的开闭原则。如果我们使用工厂来生产对象，我们就只和工厂打交道就可以了，彻底和对象解耦，如果要更换对象，直接在工厂里更换该对象即可，达到了与对象解耦的目的；所以说，工厂模式最大的优点就是：解耦。

2、简单工厂模式

例子：

需求：设计一个咖啡店点餐系统。
设计一个咖啡类（Coffee），并定义其两个子类（美式咖啡【AmericanCoffee】和拿铁咖啡【LatteCoffee】）；再设计一个咖啡店类（CoffeeStore），咖啡店具有点咖啡的功能。

具体类的设计如下：

2.1、结构

工厂模式包含以下几个主要角色：

1.抽象产品（Abstract Product）：定义了产品的共同接口或抽象类。它可以是具体产品类的父类或接口，规定了产品对象的共同方法。
2.具体产品（Concrete Product）：实现了抽象产品接口，定义了具体产品的特定行为和属性。
3.具体工厂 ：提供了创建产品的方法，调用者通过该方法来获取产品。

2.2、实现

1. 抽象类：

/**
 * 咖啡类
 */
public abstract class Coffee {

    public abstract String getName();
    
    public void addSugar(){
        System.out.println("加糖");
    }
    public void addMilk(){
        System.out.println("加奶");
    }
}

2. 具体类：

/**
 * 美式咖啡（具体实现类1）
 */
public class AmericanCoffee extends Coffee {
    public String getName() {
        return "美式咖啡";
    }
}

/**
 * 拿铁咖啡（具体实现类2）
 */
public class NatieCoffee extends Coffee {
    public String getName() {
        return "拿铁咖啡";
    }
}

3. 简单·工厂(具体工厂）

public class SimpleCoffeeFactory {

    public Coffee createCoffee(String type){
        //声明Coffee类型的变量，根据不同的类型创建不同的coffee子类对象
        Coffee coffee = null;
        if("american".equals(type)){
            coffee = new AmericanCoffee();
        }else if("latte".equals(type)){
            coffee = new LatteCoffee();
        }else{
            throw new RuntimeException("对不起，您点的咖啡没有");
        }

        return coffee;
    }
}

分析

工厂（factory）处理创建对象的细节，一旦有了SimpleCoffeeFactory，CoffeeStore类中的orderCoffee()就变成此对象的客户，后期如果需要Coffee对象直接从工厂中获取即可。这样也就解除了和Coffee实现类的耦合，同时又产生了新的耦合，CoffeeStore对象和SimpleCoffeeFactory****工厂对象的耦合，工厂对象和商品对象的耦合。

后期如果再加新品种的咖啡，我们势必要需求修改SimpleCoffeeFactory的代码，违反了开闭原则。工厂类的客户端可能有很多，比如创建其他咖啡类等，这样只需要修改工厂类的代码，省去其他的修改操作。

优缺点
优点：

封装了创建对象的过程，可以通过参数直接获取对象。把对象的创建和业务逻辑层分开，这样以后就避免了修改客户代码，如果要实现新产品直接修改工厂类，而不需要在原代码中修改，这样就降低了客户代码修改的可能性，更加容易扩展。

缺点：

增加新产品时还是需要修改工厂类的代码，违背了“开闭原则”。

2.3、扩展

静态工厂模式：通过调用工厂类直接调用方法。

/**
 * 静态工厂方法模式
 */
public class SimpleCoffeeFactory {

    public static Coffee createCoffee(String type){
        //声明Coffee类型的变量，根据不同的类型创建不同的coffee子类对象
        Coffee coffee = null;
        if("american".equals(type)){
            coffee = new AmericanCoffee();
        }else if("latte".equals(type)){
            coffee = new LatteCoffee();
        }else{
            throw new RuntimeException("对不起，您点的咖啡没有");
        }

        return coffee;
    }
}

3、工厂方法模式

具体类的设计如下：

3.1、结构

1.抽象产品（Abstract Product）：定义了产品的共同接口或抽象类。它可以是具体产品类的父类或接口，规定了产品对象的共同方法。
2.具体产品（Concrete Product）：实现了抽象产品接口，定义了具体产品的特定行为和属性。
3.抽象工厂（Abstract Factory）：声明了创建产品的抽象方法，可以是接口或抽象类。它可以有多个方法用于创建不同类型的产品。
4.具体工厂（Concrete Factory）：实现了抽象工厂接口，负责实际创建具体产品的对象。

3.2、实现（参照之前例子）

抽象工厂：

public interface CoffeeFactory {

    //创建咖啡对象的方法
    Coffee createCoffee();
}

具体工厂：

/**
 * 美式咖啡工厂对象，专门用来生产美式咖啡
 */
public class AmericanCoffeeFactory implements CoffeeFactory{
    public Coffee createCoffee() {
        return new AmericanCoffee();
    }
}
/**
 * 拿铁咖啡工厂，专门用来生产拿铁咖啡
 */
public class LatteCoffeeFactory implements CoffeeFactory{
    public Coffee createCoffee() {
        return new LatteCoffee();
    }
}

咖啡店(实现每个工厂创建一种产品）：

public class CoffeeStore {

    private CoffeeFactory factory;

    public void setFactory(CoffeeFactory factory){
        this.factory = factory;
    }

    public Coffee orderCoffee(){
        Coffee coffee = factory.createCoffee();
        coffee.addMilk();
        coffee.addSugar();
        return coffee;
    }
}

分析

从以上的编写的代码可以看到，要增加产品类时也要相应地增加工厂类，不需要修改工厂类的代码了，这样就解决了简单工厂模式的缺点。

工厂方法模式是简单工厂模式的进一步抽象。由于使用了多态性，工厂方法模式保持了简单工厂模式的优点，而且克服了它的缺点。

优缺点
优点：

用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程；
在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类，无须对原工厂进行任何修改，满足开闭原则；

缺点：

每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度。

4、抽象工厂模式

4.1、概述

抽象工厂：是一种创建型设计模式，用于提供一个接口来创建一系列相关或相互依赖的对象，而无需指定它们具体的类。这种模式强调的是创建一组产品族而不是单一的产品对象，而且这些产品的创建过程是通过一个抽象工厂类来进行的。

4.2、结构

1.抽象工厂 (Abstract Factory)：这是一个接口或者抽象类，声明了创建一系列相关或相互依赖的对象的方法，但不声明任何具体实现。
2.具体工厂 (Concrete Factory)：实现了抽象工厂接口，负责生成具体的产品对象。
3.抽象产品 (Abstract Product)：定义了产品对象的接口，即所创建的产品对象应遵循的共同接口或抽象基类。
4.具体产品 (Concrete Product)：实现了抽象产品接口，是实际被创建的对象。

4.3、实现

现咖啡店业务发生改变，不仅要生产咖啡还要生产甜点，如提拉米苏、抹茶慕斯等，要是按照工厂方法模式，需要定义提拉米苏类、抹茶慕斯类、提拉米苏工厂、抹茶慕斯工厂、甜点工厂类，很容易发生类爆炸情况。其中拿铁咖啡、美式咖啡是一个产品等级，都是咖啡；提拉米苏、抹茶慕斯也是一个产品等级；拿铁咖啡和提拉米苏是同一产品族（也就是都属于意大利风味），美式咖啡和抹茶慕斯是同一产品族（也就是都属于美式风味）。所以这个案例可以使用抽象工厂模式实现。

类图如下：

抽象工厂：

public interface DessertFactory{

    //创建咖啡对象的方法
    Coffee createCoffee();
	//生产甜品的功能
    Dessert createDessert();
}

具体工厂：

/**
 * 美式风味的甜品工厂，可以生产美式咖啡和抹茶慕斯
 */
public class AmericanCoffeeFactory implements CoffeeFactory{
    public Coffee createCoffee() {
        return new AmericanCoffee();
    }
    public Dessert createDessert() {
        return new MatchaMousse();
    }
}
/**
 * 意大利风味的甜品工厂，能生产拿铁和提拉米苏
 */
public class LatteCoffeeFactory implements CoffeeFactory{
    public Coffee createCoffee() {
        return new LatteCoffee();
    }
    public Dessert createDessert() {
        return new Tiramisu();
    }
}

分析

如果要加同一个产品族的话，只需要再加一个对应的工厂类即可，不需要修改其他的类。

优缺点
优点：

当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

缺点：

当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。

应用场景

1当需要创建的对象是一系列相互关联或相互依赖的产品族时，如电器工厂中的电视机、洗衣机、空调等。
2.系统中有多个产品族，但每次只使用其中的某一族产品。如有人只喜欢穿某一个品牌的衣服和鞋。