Java创建型模式（二）——工厂模式（简单工厂模式、工厂方法模式、抽象工厂模式、工厂模式扩展等完整详解，附有代码—

文章目录

五.工厂模式
- 5.1 概述
- 5.2简单工厂模式
- - 5.2.1 概述
  - 5.2.2 结构
  - 5.2.3 实现
  - 5.2.4 优缺点
  - 5.2.5 扩展—静态工厂
- 5.3 工厂方法模式
- - 5.3.1概述
  - 5.3.2 结构
  - 5.3.3 实现
  - 5.3.4 优缺点
- 5.4 抽象工厂模式
- - 5.4.1 概述
  - 5.4.2 结构
  - 5.4.3 实现
  - 5.4.4 优缺点
  - 5.4.5 使用场景
- 5.5 工厂模式扩展

五.工厂模式

5.1 概述

引入工厂概念

需求：设计一个咖啡店点餐系统。

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

具体类的设计如下：

在这里插入图片描述

//咖啡类
public abstract class Coffee {
    public abstract String getName();

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

    public void addSugar(){
        System.out.println("加糖...");
    }
}
========================================================
//美式咖啡类
public class AmericanCoffee extends Coffee{
    @Override
    public String getName() {
        return "美式咖啡";
    }

    public void show(){
        System.out.println("我是美式咖啡....");
    }
}
======================================================
//拿铁咖啡类
public class LatteCoffee extends Coffee{
    @Override
    public String getName() {
        return "拿铁咖啡";
    }
}
==========================================================
//咖啡店类
public class CoffeeStore {
    public Coffee orderCoffee(String type){
        Coffee coffee = null;
        if ("american".equals(type)){
            //多态
            coffee = new AmericanCoffee();
        }else if ("latte".equals(type)){
            //多态
            coffee = new LatteCoffee();
        }else {
            throw new RuntimeException("没有这种咖啡！");
        }
        // 咖啡加糖加奶
        coffee.addMilk();
        coffee.addSugar();

        return coffee;
    }
}
=========================================================
  public class Test {
    public static void main(String[] args) {

        // 创建咖啡店类
        CoffeeStore coffeeStore = new CoffeeStore();
      // 点咖啡（多态）
      Coffee coffee = coffeeStore.orderCoffee("latte");
     //Coffee coffee2 = coffeeStore.orderCoffee("american");

        // coffee.show();//多态调用不到子类特有的方法

        // 获取所点咖啡的名字
        String name = coffee.getName();
        System.out.println(name);
        //输出：加奶...  加糖...  拿铁咖啡
    }
}

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

5.2简单工厂模式

5.2.1 概述

简单工厂不是一种设计模式，反而比较像是一种编程习惯。

不属于GOF的23种经典设计模式

5.2.2 结构

简单工厂包含下角色：

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

5.2.3 实现

对5.1 中案列进行修改

在这里插入图片描述

// 咖啡工厂
public class SimpleFactory {
    //提供方法,创建具体咖啡
    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;
    }
}
=========================================================
  // 咖啡类(父类)--抽象类
public abstract class Coffee {
  
  	//每个咖啡都有名字，所以抽取到父类，定义为抽象方法
    public abstract String getName();

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

    public void addSugar(){
        System.out.println("加糖...");
    }
}
==========================================================
  // 美式咖啡类 继承 咖啡类
public class AmericanCoffee extends Coffee {
    @Override
    public String getName() {
        return "美式咖啡";
    }

    public void show(){
        System.out.println("我是美式咖啡....");
    }
}
==========================================================
  // 拿铁咖啡类 继承 咖啡类
public class LatteCoffee extends Coffee {
    @Override
    public String getName() {
        return "拿铁咖啡";
    }
}
==========================================================
 // 咖啡店类
public class CoffeeStore {
    public Coffee orderCoffee(String type){
        //此处解除了咖啡店类和具体的咖啡类的依赖，降低了耦合

        // 创建工厂对象目的是创建具体的咖啡
       SimpleFactory sf = new SimpleFactory();
       // 创建咖啡，返回具体的咖啡对象
        Coffee coffee = sf.createCoffee(type);

        coffee.addSugar();
        coffee.addMilk();

        // 将具体的咖啡对象返回
        return coffee;
    }
}
=========================================================
  public class Test {
    public static void main(String[] args) {

        // 创建咖啡店对象，进行点咖啡
        CoffeeStore store = new CoffeeStore();
        //隐含了多态，在工厂里
        Coffee coffee = store.orderCoffee("american");

        String name = coffee.getName();
        System.out.println(name);
       //输出：加奶...  加糖...  美式咖啡
    }
}

工厂处理创建对象的细节，一旦有了SimpleCoffeeFactory类，CoffeeStore类中的orderCoffee就变成了SimpleCoffeeFactory类的客户，后期如果需要Coffee对象直接从工厂获取即可。这样解除了具体咖啡类和Coffee类的耦合，同时又产生了新的耦合，如：CoffeeStore对象和SimpleCoffeeFactory工厂对象的耦合，工厂对象和具体咖啡对象的耦合。

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

5.2.4 优缺点

优点：

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

缺点：

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

5.2.5 扩展—静态工厂

将工厂类中的创建对象的功能定义为静态的，这个就是静态工厂模式，它也不是23种设计模式中的。代码如下：

// 咖啡工厂-----静态工厂
public class SimpleFactory {
    // 工厂类中的创建对象的功能定义为静态，就是静态工厂模式，
    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;
    }
}
=======================================================
  // 咖啡类(父类)
public abstract class Coffee {
    public abstract String getName();

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

    public void addSugar(){
        System.out.println("加糖...");
    }
}
====================================================
  // 美式咖啡类
public class AmericanCoffee extends Coffee {
    @Override
    public String getName() {
        return "美式咖啡";
    }

    public void show(){
        System.out.println("我是美式咖啡....");
    }
}
=========================================================
  // 拿铁咖啡类
public class LatteCoffee extends Coffee {
    @Override
    public String getName() {
        return "拿铁咖啡";
    }
}
=======================================================
  // 咖啡店类
public class CoffeeStore {
    public Coffee orderCoffee(String type){
        //此处解除了咖啡店类和具体的咖啡类的依赖，降低了耦合

       //  // 创创建工厂对象目的是创建具体的咖啡
       // SimpleFactory sf = new SimpleFactory();
       // // 创建咖啡，返回具体的咖啡对象
       //  Coffee coffee = sf.createCoffee(type);

        // 用静态工厂模式，就不用创建工厂对象
        //直接用工厂类名调用里面的创建具体咖啡对象的静态方法即可
        Coffee coffee = SimpleFactory.createCoffee(type);

        coffee.addSugar();
        coffee.addMilk();

        // 将具体的咖啡对象返回
        return coffee;
    }
}
=========================================================
  public class Test {
    public static void main(String[] args) {

        // 创建咖啡店对象，进行点咖啡
        CoffeeStore store = new CoffeeStore();
        //隐含了多态，在工厂里
        Coffee coffee = store.orderCoffee("american");

        String name = coffee.getName();
        System.out.println(name);
    }
}

5.3 工厂方法模式

针对5.2.3中的缺点，使用工厂方法模式就可以完美的解决，完全遵循开闭原则。

5.3.1概述

工厂方法模式：定义一个创建对象的接口（这里的接口指的是工厂），让子类（子类指实现工厂接口的子类）决定实例化哪个产品类对象。工厂方法使一个产品类的实例化延迟到其工厂的子类。

5.3.2 结构

工厂方法模式的主要角色：

抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过抽象工厂访问具体工厂（多态）的工厂方法来创建产品对象。
具体工厂（ConcreteFactory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。
具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。

5.3.3 实现

使用工厂方法模式对5.2.3中的案列进行改进，类图如下：

在这里插入图片描述

// 咖啡抽象类
public abstract class Coffee {
    public abstract String getName();

    public void addMilk(){
        System.out.println("加奶...");
    }
    public void addSugar(){
        System.out.println("加糖...");
    }
}
============================================================
  //拿铁咖啡类 实现 抽象咖啡类接口
  public class LatteCoffee extends Coffee{
    @Override
    public String getName() {
        return "拿铁咖啡";
    }
}
===========================================================
  // 美式咖啡类 实现 抽象咖啡类接口
public class AmericanCoffee extends Coffee{
    @Override
    public String getName() {
        return "美式咖啡";
    }
}
===========================================================
// 定义咖啡工厂接口
public interface CoffeeFactory {
    public abstract Coffee creatCoffee();
}
========================================================
  // 创建拿铁咖啡工厂类 实现 咖啡工厂类接口
public class LatteCoffeeFactory implements CoffeeFactory{
    @Override
    public Coffee creatCoffee() {
        return new LatteCoffee();
    }
}
==========================================================
  // 创建美式咖啡工厂类 实现 咖啡工厂类接口
public class AmericanCoffeeFactory implements CoffeeFactory {
    @Override
    public Coffee creatCoffee() {
        return new AmericanCoffee();
    }
}
==========================================================
  //咖啡店类
  public class CoffeeStore {

    private CoffeeFactory coffeeFactory;

 public void setCoffeeFactory(CoffeeFactory coffeeFactory) {
        this.coffeeFactory = coffeeFactory;
    }

    public Coffee orderCoffee(){

        // 咖啡工厂来创建具体的咖啡
        Coffee coffee = coffeeFactory.creatCoffee();

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

        return coffee;
    }

}
====================================================
  public class ClientTest {
    public static void main(String[] args) {

        // 创建咖啡店类对象
        CoffeeStore coffeeStore = new CoffeeStore();

    //创建拿铁咖啡工厂，多态
    CoffeeFactory coffeeFactory = new LatteCoffeeFactory();
 //CoffeeFactory amerFactory  = new AmericanCoffeeFactory();

        coffeeStore.setCoffeeFactory(coffeeFactory);
      
        // 点咖啡
        Coffee coffee = coffeeStore.orderCoffee();
        System.out.println(coffee.getName());
        //输出：加奶...  加糖...  拿铁咖啡

    }
}

5.3.4 优缺点

优点：

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

缺点：

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

5.4 抽象工厂模式

5.4.1 概述

是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。

同族的不同等级的产品:通俗讲就是一个综合工厂里的不同商品种类

抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级（即，同种的产品）的产品，而抽象工厂模式可生产多个等级（即，多种产品）的产品。

5.4.2 结构

抽象工厂模式的主要角色如下：

抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法，可以创建多个不同等级的产品。
具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。

5.4.3 实现

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

在这里插入图片描述

咖啡系列

// 抽象咖啡类
public abstract class Coffee {
    // 定义获取具体咖啡名字的规范
    public abstract String getName();

    // 咖啡加奶
    public  void addMilk(){
        System.out.println("加奶...");
    };
    // 咖啡加糖
    public void addSugar(){
        System.out.println("加糖...");
    };
}
========================================================
// 具体的 美式咖啡类  继承抽象咖啡类
public class AmericanCoffee extends Coffee{
    @Override
    public String getName() {
        return "美式咖啡";
    }
}
==========================================================
  // 具体的 拿铁咖啡类  继承抽象咖啡类
public class LatteCoffee extends Coffee{

    @Override
    public String getName() {
        return "拿铁咖啡";
    }
}

甜品系列

// 抽象甜品类
public abstract class Dessert {
    // 定义展示具体甜品的规范
    public abstract void show();
}
========================================================
  // 具体甜品--提拉米苏类 继承 抽象甜品类
public class Tiramisu extends Dessert{
    @Override
    public void show() {
        System.out.println("提拉米苏...");
    }
}
========================================================
  // 具体甜品--抹茶慕斯类  继承 抽象甜品类
public class MatchaMousse extends Dessert {
    @Override
    public void show() {
        System.out.println("抹茶慕斯...");
    }
}

工厂系列

 //抽象工厂

// 综合工厂 生产咖啡类  生产甜品类
public interface DessertFactory {

    // 生产咖啡
    public abstract Coffee createCoffee();

    // 生产甜品
    public abstract Dessert createDessert();

}
==========================================================
  //具体工厂
  
  // 意大利风味甜品工厂
  // 生产拿铁咖啡和提拉米苏甜品
public class ItalyDessertFactory implements DessertFactory{
    // 生产拿铁咖啡
    @Override
    public Coffee createCoffee() {
        return new LatteCoffee();
    }
    // 生产提拉米苏
    @Override
    public Dessert createDessert() {
        return new Tiramisu();
    }
}
=======================================================
  //具体工厂
  
  // 美式风味的甜品工厂
  // 生美式咖啡 和 抹茶慕斯
public class AmericanDessertFactory implements DessertFactory{
    // 生产美式咖啡
    @Override
    public Coffee createCoffee() {
        return new AmericanCoffee();
    }

    // 生产抹茶慕斯
    @Override
    public Dessert createDessert() {
        return new MatchaMousse();
    }
}

客户端测试

public class ClientTest {
    public static void main(String[] args) {
// 客户端测试类

        // 创建意大利风味甜品工厂对象
        // 该工厂生产拿铁咖啡 和提拉米苏
        ItalyDessertFactory factory = 
          new ItalyDessertFactory();

        // 获取拿铁咖啡
        Coffee coffee = factory.createCoffee();
        System.out.println(coffee.getName());//拿铁咖啡

        // 获取提拉米苏
        Dessert dessert = factory.createDessert();
        dessert.show();//提拉米苏...


        // 创建美式风味的甜品工厂对象
        //该工厂生产美式咖啡 和抹茶慕斯
        AmericanDessertFactory factory1 = 
          new AmericanDessertFactory();

        // 获取美式咖啡
        Coffee coffee1 = factory1.createCoffee();
        System.out.println(coffee1.getName());//美式咖啡

        // 获取抹茶慕斯
        Dessert dessert1 = factory1.createDessert();
        dessert1.show();//抹茶慕斯...

    }
}

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

5.4.4 优缺点

优点：

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

缺点：

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

5.4.5 使用场景

当需要创建的对象是一系列相互关联或相互依赖的产品族时，如电器工厂中的电视机、洗衣机、空调等。
系统中有多个产品族，但每次只使用其中的某一族产品。如有人只喜欢穿某一个品牌的衣服和鞋。
系统中提供了产品的类库，且所有产品的接口相同，客户端不依赖产品实例的创建细节和内部结构。

如：输入法换皮肤，一整套一起换。生成不同操作系统的程序。

5.5 工厂模式扩展

简单工厂+配置文件解除耦合

（spring底层类似）

可以通过工厂模式+配置文件的方式解除工厂对象和产品对象的耦合。在工厂类中加载配置文件中的全类名，并通过反射技术创建对象进行存储，客户端如果需要对象，直接进行获取即可。

为了演示方便，我们使用properties文件作为配置文件，名称为bean.properties

american=factory.config_factory.AmericanCoffee
latte=factory.config_factory.LatteCoffee

#如果冰咖啡饮品，直接添加全类名即可,咖啡工厂中代码不用修改
icecoffee =factory.config_factory.IceCoffee

//咖啡工厂
public class CoffeeFactory {

    //加载配置文件，获取配置文件中配置的全类名，并创建全类名的类的对象进行存储

    // 1.定义容器存储咖啡对象
    private static Map<String,Coffee> map = new HashMap();

    // 2.静态代码块 加载配置文件，只需加载一次
    static {
        // 2.1创建Properties对象
        Properties p = new Properties();
        // 2.2调用p对象中的load方法进行配置文件的加载
        InputStream is = 
                     CoffeeFactory.class
                    .getClassLoader()
                    .getResourceAsStream("bean.properties");
        try {
            p.load(is);
            //从p集合中获取全名并创建对象
            //遍历Properties集合对象
            Set<Object> keys = p.keySet();
            for (Object key : keys) {
                //根据键获取值（全类名）
             String className = p.getProperty((String) key);
                // 通过反射技术创建对象
                //获取字节码对象
                Class clazz = Class.forName(className);
                Coffee obj = (Coffee) clazz.newInstance();
                map.put((String)key,obj);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 根据名称获取对象
    public static Coffee createCoffee(String name) {
        return map.get(name);
    }

}
============================================================
// 咖啡类(父类)
public abstract class Coffee {
    public abstract String getName();

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

    public void addSugar(){
        System.out.println("加糖...");
    }
}
=================================================
  // 美式咖啡类
public class AmericanCoffee extends Coffee {
    @Override
    public String getName() {
        return "美式咖啡";
    }

    public void show(){
        System.out.println("我是美式咖啡....");
    }
}
================================================
  // 拿铁咖啡类
public class LatteCoffee extends Coffee {
    @Override
    public String getName() {
        return "拿铁咖啡";
    }
}
=======================================================
  //新增冰咖啡饮品，咖啡工厂类不用修改
public class MiXue extends Coffee{
    @Override
    public String getName() {
        return "冰咖啡";
    }
}
==================================================
  public class Test {
    public static void main(String[] args) {

        //直接通过配置文件中对应的美式咖啡名字 获取美式咖啡对象
   Coffee american = CoffeeFactory.createCoffee("american");
        american.addMilk();
        american.addSugar();
        System.out.println(american.getName());

       //直接通过配置文件中对应的冰咖啡名字 获取冰咖啡对象
        //新增冰咖啡
 Coffee icecoffee = CoffeeFactory.createCoffee("icecoffee");
        icecoffee.addSugar();
        icecoffee.addMilk();
        System.out.println(icecoffee.getName());

    }
}