【源码分析设计模式 2】JDK中的抽象工厂模式

小灰灰 2021-08-29 18:02 328阅读 0赞

## 一、基本介绍 ##

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

2、抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品；

3、使用抽象工厂模式一般要满足以下条件：

*  系统中有多个产品族， 每个具体工厂创建同族但属于不同等级的产品；
 *  系统一次只可能消费其中某一族产品，即同族的产品一起使用。

## 二、抽象工厂模式的结构 ##

抽象工厂模式同工厂方法模式一样，也是由抽象工厂、具体工厂、抽象产品和具体产品等 4 个要素构成，但抽象工厂中方法个数不同，抽象产品的个数也不同。

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

### 1、抽象工厂 ###

提供了创建产品的接口，它包含多个创建产品的方法 newProduct()，可以创建多个不同等级的产品。

### 2、具体工厂 ###

主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。

### 3、抽象产品 ###

定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。

### 4、具体产品 ###

实现了抽象产品角色所定义的接口，由具体工厂来创建，它 同具体工厂之间是多对一的关系。

## 三、优缺点 ##

### 1、优点 ###

*  可以在类的内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类进行管理；
 *  当增加一个新的产品族时不需要修改原代码，满足开闭原则。

### 2、缺点 ###

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

## 四、**《Head First 设计模式》读后感** ##

1、抽象工厂模式提供了一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

2、工厂方法模式运用的是继承，抽象工厂模式运用的是对象的组合。

## 五、JDK源码分析 ##

package com.guor.jdk;
    
    import java.util.Calendar;
    
    public class Factory {
        public static void main(String[] args) {
            Calendar cal = Calendar.getInstance();
            // 注意月份下标从0开始，所以取月份要+1
            System.out.println("年:" + cal.get(Calendar.YEAR));
            System.out.println("月:" + (cal.get(Calendar.MONTH) + 1));
            System.out.println("日:" + cal.get(Calendar.DAY_OF_MONTH));
            System.out.println("时:" + cal.get(Calendar.HOUR_OF_DAY));
            System.out.println("分:" + cal.get(Calendar.MINUTE));
            System.out.println("秒:" + cal.get(Calendar.SECOND));
        }
    }

![2020060323583379.png][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70][]

## 六、代码实例 ##

### 1、UML类图 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 1][]

### 2、代码架构 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 2][]

### 3、具体代码 ###

（1）order包包

package com.guor.abstractFactory.order;
    
    import com.guor.abstractFactory.pizza.Pizza;
    
    //一个抽象工厂模式的抽象层(接口)
    public interface AbsFactory {
    	//让下面的工厂子类来 具体实现
    	public Pizza createPizza(String orderType);
    }

package com.guor.abstractFactory.order;
    
    import com.guor.abstractFactory.pizza.BJCheesePizza;
    import com.guor.abstractFactory.pizza.BJPepperPizza;
    import com.guor.abstractFactory.pizza.Pizza;
    
    //这是工厂子类
    public class BJFactory implements AbsFactory {
    	@Override
    	public Pizza createPizza(String orderType) {
    		System.out.println("~使用的是抽象工厂模式~");
    		Pizza pizza = null;
    		if(orderType.equals("cheese")) {
    			pizza = new BJCheesePizza();
    		} else if (orderType.equals("pepper")){
    			pizza = new BJPepperPizza();
    		}
    		return pizza;
    	}
    }

package com.guor.abstractFactory.order;
    
    import com.guor.abstractFactory.pizza.LDCheesePizza;
    import com.guor.abstractFactory.pizza.LDPepperPizza;
    import com.guor.abstractFactory.pizza.Pizza;
    
    public class LDFactory implements AbsFactory {
    	@Override
    	public Pizza createPizza(String orderType) {
    		System.out.println("~使用的是抽象工厂模式~");
    		Pizza pizza = null;
    		if (orderType.equals("cheese")) {
    			pizza = new LDCheesePizza();
    		} else if (orderType.equals("pepper")) {
    			pizza = new LDPepperPizza();
    		}
    		return pizza;
    	}
    }

package com.guor.abstractFactory.order;
    
    import com.guor.abstractFactory.pizza.Pizza;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    
    public class OrderPizza {
    	AbsFactory factory;
    	// 构造器
    	public OrderPizza(AbsFactory factory) {
    		setFactory(factory);
    	}
    
    	private void setFactory(AbsFactory factory) {
    		Pizza pizza = null;
    		String orderType = ""; // 用户输入
    		this.factory = factory;
    		do {
    			orderType = getType();
    			// factory 可能是北京的工厂子类，也可能是伦敦的工厂子类
    			pizza = factory.createPizza(orderType);
    			if (pizza != null) { // 订购ok
    				pizza.prepare();
    				pizza.bake();
    				pizza.cut();
    				pizza.box();
    			} else {
    				System.out.println("订购失败");
    				break;
    			}
    		} while (true);
    	}
    
    	// 写一个方法，可以获取客户希望订购的披萨种类
    	private String getType() {
    		try {
    			BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
    			System.out.println("input pizza 种类:");
    			String str = strin.readLine();
    			return str;
    		} catch (IOException e) {
    			e.printStackTrace();
    			return "";
    		}
    	}
    }

package com.guor.abstractFactory.order;
    
    public class PizzaStore {
    	public static void main(String[] args) {
    		new OrderPizza(new BJFactory());
    	}
    }

（2）pizza包包

package com.guor.abstractFactory.pizza;
    
    public class BJCheesePizza extends Pizza {
    	@Override
    	public void prepare() {
    		setName("北京的奶酪pizza");
    		System.out.println("北京的奶酪pizza 准备原材料");
    	}
    }

package com.guor.abstractFactory.pizza;
    
    public class BJPepperPizza extends Pizza {
    	@Override
    	public void prepare() {
    		setName("北京的胡椒pizza");
    		System.out.println(" 北京的胡椒pizza 准备原材料");
    	}
    }

package com.guor.abstractFactory.pizza;
    
    public class LDCheesePizza extends Pizza{
    	@Override
    	public void prepare() {
    		setName("伦敦的奶酪pizza");
    		System.out.println(" 伦敦的奶酪pizza 准备原材料");
    	}
    }

package com.guor.abstractFactory.pizza;
    
    public class LDPepperPizza extends Pizza{
    	@Override
    	public void prepare() {
    		setName("伦敦的胡椒pizza");
    		System.out.println(" 伦敦的胡椒pizza 准备原材料");
    	}
    }

package com.guor.abstractFactory.pizza;
    
    //将Pizza 类做成抽象
    public abstract class Pizza {
    	protected String name; //名字
    	//准备原材料, 不同的披萨不一样，因此，我们做成抽象方法
    	public abstract void prepare();
    	public void bake() {
    		System.out.println(name + " baking;");
    	}
    	public void cut() {
    		System.out.println(name + " cutting;");
    	}
    	//打包
    	public void box() {
    		System.out.println(name + " boxing;");
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    }

（3）控制台输出

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 3][]

[2020060323583379.png]: /images/20210813/902c331e5a8442eca8f0ba23f42eb65b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70]: /images/20210813/711b26b071534ae2a24cbaab7caa31ba.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 1]: /images/20210813/36109def494f4c73872fa147aa7d169b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 2]: /images/20210813/6535d52bd42d4cfa88a079cf8d7527d6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 3]: /images/20210813/843cd4793f644416a08ec2be90ae8005.png