设计模式之工厂模式（简单工厂、工厂方法、抽象工厂模式）

素颜马尾好姑娘i 2023-01-22 09:49 3阅读 0赞

# 工厂模式 #

### 文章目录 ###

*  工厂模式
 *   *  一、前言
     *  二 、简单工厂模式
     *   *  1. 结构
         *  2. 实现
         *  3. 静态工厂
     *  三、工厂方法模式
     *   *  1. 结构
         *  2. 实现
     *  四、抽象工厂模式
     *   *  1. 结构
         *  2. 实现

## 一、前言 ##

需要设计一个咖啡店点餐系统，需要创建的类有：

*  咖啡类（Coffee）
    
     *  子类美式咖啡（AmericanCoffee）
     *  子类拿铁咖啡（LatteCoffee）
 *  咖啡店类（CoffeeStore）
    
     *  具有点餐功能（orderCoffee）

具体的UML类图如下所示：

![image-20210510181742449][]

这种设计结构的缺点：

在咖啡店类的点餐方法中创建对象的时候直接new对象，就会对该对象耦合严重，如果要新增一种咖啡的品种，就需要修改点餐方法，违背了软件设计的开闭原则。

由此引入了工厂模式，目的是为了解耦合，工厂模式分为三种：

*  简单工厂模式（不属于23种经典设计模式）
 *  工厂方法模式
 *  抽象工厂模式

## 二 、简单工厂模式 ##

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

### 1. 结构 ###

简单工厂包含如下角色：

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

### 2. 实现 ###

使用简单工厂模式对上面的案例进行改进，类图如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80OTM0MzE5MA_size_16_color_FFFFFF_t_70][]

*  抽象的Coffee类
    
        public abstract class Coffee { 
        
            //抽象方法，需要子类去实现
            public abstract String getName();
        
            //加糖
            public void addsugar() { 
                System.out.println("加糖");
            }
        
            //加奶
            public void addMilk() { 
                System.out.println("加奶");
            }
        }
 *  美式咖啡子类
    
        public class AmericanCoffee extends Coffee { 
        
            @Override
            public String getName() { 
                return "美式咖啡";
            }
        }
 *  拿铁咖啡子类
    
        public class LatteCoffee extends Coffee { 
        
            @Override
            public String getName() { 
                return "拿铁咖啡";
            }
        }
 *  咖啡工厂类
    
        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;
            }
        }
 *  咖啡店类
    
        public class CoffeeStore { 
        
            //调用工厂中生产具体咖啡的方法
            public Coffee orderCoffee(String type) { 
        
                //创建工厂对象
                SimpleCoffeeFactory factory = new SimpleCoffeeFactory();
                
                //调用生产咖啡的方法
                Coffee coffee = factory.createCoffee(type);
        
                //加配料
                coffee.addMilk();
                coffee.addsugar();
        
                return coffee;
            }
        }
 *  进行使用
    
        public class Client { 
            public static void main(String[] args) { 
                //创建咖啡店类对象
                CoffeeStore store = new CoffeeStore();
                Coffee coffee = store.orderCoffee("latte");
        
                System.out.println(coffee.getName());
                //加奶
                //加糖
                //拿铁咖啡
            }
        }
 *  优点
    
     *  CoffeeStore类解除了和Coffee实现类的耦合
     *  当新增咖啡品种时，只需要修改工厂类的代码，而不用去修改CoffeeStore类的代码
        
         *  工厂类的客户端可能有很多（CoffeeStore算一个），其他还有出售咖啡的甜品店等，当咖啡品种发生变化的时候，只需要修改工厂类的代码，而无需去每个客户端中修改代码，提高效率
 *  缺点
    
     *  产生了新的耦合，CoffeeStore对象和SimpleCoffeeFactory工厂对象的耦合，工厂对象和Coffee实现类的耦合
     *  当新增咖啡品种时，需要修改工厂类的代码，违反了开闭原则

### 3. 静态工厂 ###

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

public class SimpleCoffeeFactory { 
    
        public static Coffee createCoffee(String type) { 
            //省略工厂中的方法
        }
    }

相比简单工厂模式，此方式的好处是在不同的客户端中无需创建不同的工厂对象

## 三、工厂方法模式 ##

*  工厂方法模式完全遵循开闭原则，可以解决简单工厂模式的缺陷
 *  工厂方法模式使一个产品类的实例化延迟到其工厂的子类中

### 1. 结构 ###

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

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

### 2. 实现 ###

使用工厂方法模式对上面的案例进行改进，类图如下：

![image-20210510190403721][]

*  抽象工厂类
    
        public interface CoffeeFactory { 
        
            //创建咖啡对象的方法
            Coffee createCoffee();
        }
 *  两个具体工厂类
    
        public class AmericanCoffeeFactory implements CoffeeFactory {     
        	@Override   
            public Coffee createCoffee() {         
        		return new AmericanCoffee();    
        	}
        }
    
        public class LatteCoffeeFactory implements CoffeeFactory {     
        	@Override    
        	public Coffee createCoffee() {         
          	 return new LatteCoffee();   
           }
        }
 *  咖啡店类
    
        public class CoffeeStore {     
        
        	private CoffeeFactory factory;    
        
        	//创建咖啡店类时指定具体工厂 
        	public CoffeeStore(CoffeeFactory factory) {         
          	  this.factory = factory;   
        	}    
        
        	//点咖啡功能 
         	public Coffee orderCoffee() {         
         		Coffee coffee = factory.createCoffee();        
         		//加配料 
         		coffee.addMilk();        
         		coffee.addsugar();        
         		return coffee;   
        	 }
         }
 *  进行使用
    
        public class Client {     
        	public static void main(String[] args) {         
        
        		//创建咖啡店对象，使用创建拿铁咖啡的具体工厂 
        		CoffeeStore store = new CoffeeStore(new LatteCoffeeFactory());        
        
        		//点咖啡 
        		Coffee coffee = store.orderCoffee();        
        
        		System.out.println(coffee.getName());        
          		//加奶 
        		//加糖 
                //拿铁咖啡 
           }
        }
 *  优点
    
     *  如果新添加一种咖啡，只需要创建一个咖啡工厂的子实现类即可，无需修改原有代码，降低耦合度，满足开闭原则
 *  缺点
    
     *  每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这样会增加系统的复杂度

## 四、抽象工厂模式 ##

*  前面介绍的工厂方法模式中考虑的是一类产品的生产，即具体工厂只生产对应的那一类产品，比如畜牧场工厂类只生产动物、电视生产商工厂类只生产电视机
 *  这些工厂只生产同种类产品，同种类产品称为同等级产品，也就是说，工厂方法模式只考虑生产同等级的产品
 *  抽象工厂模式采用多等级产品的生产，将同一个具体工厂所生产的位于不同等级的一组产品称为一个产品族
    
     *  华为生产的荣耀手机、小米生产的红米手机属于同等级产品
     *  华为生产的游戏本电脑、小米生产的轻薄本电脑属于同等级产品
     *  华为生产的荣耀手机和游戏本电脑称为产品族
 *  抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品
    
     *  也就是工厂类原来只能创建同等级产品，现在可以创建产品族（多个方法创建不同等级的产品）

### 1. 结构 ###

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

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

### 2. 实现 ###

咖啡店业务发生改变，不仅要生产咖啡还要生产甜点，如提拉米苏、抹茶慕斯等，要是按照工厂方法模式，需要定义提拉米苏类、抹茶慕斯类、提拉米苏工厂、抹茶慕斯工厂、甜点工厂类，很容易发生类爆炸情况。

其中拿铁咖啡、美式咖啡属于同等级产品，都是咖啡；提拉米苏、抹茶慕斯也属于同等级产品，都是甜点。

拿铁咖啡和提拉米苏是同一产品族（都属于意大利风味工厂制造），美式咖啡和抹茶慕斯是同一产品族（都属于美式风味工厂制造）。

此案例通过抽象工厂模式实现的UML类图如下：

![image-20210510212815393][]

*  抽象工厂类
    
        public interface DessertFactory {     
        	
        	Coffee createCoffee();    
          	
          	Dessert createDessert();
        }
 *  两个具体工厂
    
        //美式甜点工厂
        public class AmericanDessertFactory implements DessertFactory {     
        
        	public Coffee createCoffee() {         
        		return new AmericanCoffee();    
        	}    
        	
        	public Dessert createDessert() {         
        		return new MatchaMousse();    
        	}
        }
    
        //意大利风味甜点工厂
        public class ItalyDessertFactory implements DessertFactory {     
        	
        	public Coffee createCoffee() {         
        		return new LatteCoffee();   
        	}    
        
        	public Dessert createDessert() {         
        		return new Tiramisu();    
        	}
        }
 *  进行使用
    
        public class Client {     
        	public static void main(String[] args) {                 
        	
        		//创建的是意大利风味甜品工厂对象 
        		ItalyDessertFactory factory = new ItalyDessertFactory();                
        
        		//获取拿铁咖啡和提拉米苏甜品 
        		Coffee coffee = factory.createCoffee();        
        		Dessert dessert = factory.createDessert();    
        	}
        }
 *  优点
    
     *  相比工厂方法模式修改的类更少，代码耦合度更低
     *  适用于当需要创建的对象是一系列相互关联或相互依赖的产品族时，比如格力工厂中的电视机、洗衣机、空调等

[image-20210510181742449]: /images/20221020/fcccd1cfe31847e09b12f13fca675c1a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80OTM0MzE5MA_size_16_color_FFFFFF_t_70]: /images/20221020/0ac8a00c659140fb8b88e67bc15c268e.png
[image-20210510190403721]: /images/20221020/6411081a563d4f4981f1d1662e81555a.png
[image-20210510212815393]: /images/20221020/c34bcdefd6bc410d99845437d9eddaec.png