在java中，万物皆对象，这些对象都需要创建，如果创建的时候直接new该对象，就会对该对象耦合严重，假如我们要更换对象，所有new对象的地方都需要修改一遍，这显然违背了软件设计的开闭原则。如果我们使用工厂来生产对象，我们就只和工厂打交道就可以了，彻底和对象解耦，如果要更换对象，直接在工厂里更换该对象即可，达到了与对象解耦的目的；所以说，工厂模式最大的优点就是：解耦。

简单工厂模式/静态工厂模式其实不是一种设计模式，而算是一种编程思想。

以下讲解使用咖啡厅点咖啡来说明。

1.简单工厂模式

1.1.结构

简单工厂包含以下角色:

• 抽象产品 ：定义了产品的规范，描述了产品的主要特性和功能。
• 具体产品 ：实现或者继承抽象产品的子类
• 具体工厂 ：提供了创建产品的方法，调用者通过该方法来获取产品。

1.2.类图

解释：CoffeeStore类依赖于SimpleCoffeeFactory，SimpleCoffeeFactory依赖于抽象类Coffee，AmericanCoffee类和LatteCoffee类继承了Coffee类。

1.3.实现

抽象Coffee类

/**
 * @author 晓风残月Lx
 * @date 2023/6/18 21:58
 *      抽象咖啡
 */
public abstract class Coffee {

    public abstract String getName();

    // 加糖
    public void addSugar() {
        System.out.println("加糖");
    }

    // 加奶
    public void addMilk() {
        System.out.println("加奶");
    }

}

拿铁咖啡LatteCoffee类

/**
 * @author 晓风残月Lx
 * @date 2023/6/18 22:01
 *       拿铁咖啡
 */
public class LatteCoffee extends Coffee {
    @Override
    public String getName() {
        return "拿铁咖啡";
    }
}

美式咖啡AmericanCoffee类

/**
 * @author 晓风残月Lx
 * @date 2023/6/18 22:01
 *      美式咖啡
 */
public class AmericanCoffee extends Coffee {
    @Override
    public String getName() {
        return "美式咖啡";
    }
}

简单咖啡工厂SimpleCoffeeFactory 类

/**
 * @author 晓风残月Lx
 * @date 2023/6/18 22:17
 *      简单咖啡工厂类，用来生产咖啡
 */
public class SimpleCoffeeFactory {

    public Coffee createCoffee(String type) {
        Coffee coffee = null;
        if ("american".equals(type)) {
            coffee = new AmericanCoffee();
        } else if ("latte".equals(type)) {
            coffee = new LatteCoffee();
        } else {
            throw new RuntimeException("对不起，您点的咖啡没有");
        }
        return coffee;
    }
}

咖啡店CoffeeStore类

/**
 * @author 晓风残月Lx
 * @date 2023/6/18 22:02
 *      咖啡店
 */
public class CoffeeStore {

    public Coffee orderCoffee(String type) {

        SimpleCoffeeFactory factory = new SimpleCoffeeFactory();

        Coffee coffee = factory.createCoffee(type);

        // 加配料
        coffee.addMilk();
        coffee.addSugar();
        return coffee;
    }

}

测试类

/**
 * @author 晓风残月Lx
 * @date 2023/6/18 22:
 *      测试类
 */
public class Client {

    public static void main(String[] args) {
        // 1.创建咖啡店类
        CoffeeStore coffeeStore = new CoffeeStore();
        Coffee latteCoffee = coffeeStore.orderCoffee("latte");

        System.out.println(latteCoffee.getName());
     
    }
}

1.4.优缺点

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

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

2.静态工厂模式

静态工厂模式与简单工厂模式一致，只是在工厂类中的创建对象的功能定位为静态的。

2.1.实现

工厂类

/**
 * @author 晓风残月Lx
 * @date 2023/6/18 22:17
 *      静态咖啡工厂类，用来生产咖啡
 */
public class StaticCoffeeFactory {

    // 在方法上加个static（与简单工厂相比）
    public static Coffee createCoffee(String type) {
        Coffee coffee = null;
        if ("american".equals(type)) {
            coffee = new AmericanCoffee();
        } else if ("latte".equals(type)) {
            coffee = new LatteCoffee();
        } else {
            throw new RuntimeException("对不起，您点的咖啡没有");
        }
        return coffee;
    }
}

咖啡店CoffeeStore类

/**
 * @author 晓风残月Lx
 * @date 2023/6/18 22:02
 *      咖啡店
 */
public class CoffeeStore {

    public Coffee orderCoffee(String type) {

        // 好处就是直接的调用方法
        Coffee coffee = StaticCoffeeFactory.createCoffee(type);

        // 加配料
        coffee.addMilk();
        coffee.addSugar();
        return coffee;
    }

}