[Java知识库]《23种设计模式（Java版）》| 工厂模式（内附源码案例）。

🎈🎈🎈🎈🎈往期推荐：
🎉《23种设计模式（Java版）》| 设计模式相关简介。

🎉《23种设计模式（Java版）》| 单例模式（内附源码案例）。

📢 专栏推荐：23种设计模式（Java版）系列专栏

2021 年 12 月 25日
百思不得小赵 🔍点击进入博客首页
—— 新时代的农民工 🙊
—— 换一种思维逻辑去看待这个世界 👀
今天是加入CSDN的第1029天。觉得有帮助麻烦👏点赞、🍀评论、??收藏啦。

💎 一、概述

工厂模式是我们最常用的实例化对象模式了，是用工厂方法代替new操作的一种模式。著名的Jive论坛 ,就大量使用了工厂模式，工厂模式在Java程序系统可以说是随处可见。因为工厂模式就相当于创建实例对象的new，我们经常要根据类Class生成实例对象，如A a=new A() 工厂模式也是用来创建实例对象的，所以以后new时就要多个心眼，是否可以考虑使用工厂模式，虽然这样做，可能多做一些工作，但会给你系统带来更大的可扩展性和尽量少的修改量---------来源于百度百科。

📕 二、工厂模式的三种方式

🏭 简单工厂

• 简单工厂模式是属于创建型模式，是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式
• 简单工厂模式：定义了一个创建对象的类，由这个类来封装实例化对象的行为(代码)
• 在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时，就会使用到工厂模式

案例代码：

//定义一个公共接口
public interface Car {
	void gotoWork();
}

public class Bus implements Car{
	@Override
	public void gotoWork() {
		// TODO Auto-generated method stub
		System.out.println("坐公交上班");
	}
}

public class Bike implements Car{
	@Override
	public void gotoWork() {
		// TODO Auto-generated method stub
		System.out.println("骑自行车上班");
	}
}

//简单工厂类
public class SimpleFactory {
	
	public enum CarType{
		Bike,Bus;
	}
	//通过不同的方式构建不同的实例
	public static Car getCar(CarType car) {
		Car simpleCar=null;
		switch(car) {
		case Bike:
			simpleCar=new Bike();
			break;
		case Bus:
			simpleCar= new Bus();
			break;
			default:
			 simpleCar=new Bike();
		}
		return simpleCar;
	}
}

🔨 工厂方法

通过一个需求案例：

看一个披萨的项目：要便于披萨种类的扩展，要便于维护
1.披萨的种类很多(比如 GreekPizz、CheesePizz 等
2.披萨的制作有 prepare，bake, cut, box
3.完成披萨店订购功能
客户在点披萨时，可以点不同口味的披萨，比如 北京的奶酪pizza、
北京的胡椒pizza 或者是伦敦的奶酪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;
	}
}

public class BJCheesePizz extends Pizza{
	@Override
	public void prepare() {
		// TODO Auto-generated method stub
		setName("北京的奶酪披萨");
		System.out.println("北京的奶酪披萨准备原材料");
	}
}

public class BJGreekPizz extends Pizza{
	@Override
	public void prepare() {
		// TODO Auto-generated method stub
		setName("北京的希腊披萨");
		System.out.println("北京的希腊披萨准备原材料");
	}
}

public class LDCheesePizz extends Pizza{
	@Override
	public void prepare() {
		// TODO Auto-generated method stub
		setName("伦敦奶酪披萨");
		System.out.println("伦敦奶酪披萨准备原材料");
	}
}

public class LDGreekPizz extends Pizza
	@Override
	public void prepare() {
		// TODO Auto-generated method stub
		setName("伦敦希腊披萨");
		System.out.println("伦敦希腊披萨准配原材料");
	}
}

public abstract class OrderPizza {

	 //定义一个抽象方法，让各个工厂子类自己实现
	 abstract Pizza creatPizza(String orderType);
	 //构造器
	 public OrderPizza() {
		Pizza pizza = null;
		// 订购披萨类型
		String orderType;
		do {
			orderType = getType();
			pizza=creatPizza(orderType);
			pizza.prepare();
			pizza.bake();
			pizza.cut();
			pizza.box();
			
		} while (true);
	}
		// 动态的获取用户希望订购的披萨
	private String getType() {
		try {
			BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
			System.out.println("input pizza type:");
			String str = strin.readLine();
			return str;
		} catch (IOException e) {
			e.printStackTrace();
			return "";
		}
	}
}

public class BJOrderPizza extends OrderPizza{
	@Override
	Pizza creatPizza(String orderType) {
		Pizza pizza=null;
		if(orderType.equals("cheese")) {
			pizza=new BJCheesePizz();
		}else if(orderType.equals("greek")) {
			pizza=new BJGreekPizz();
		}
		return pizza;
	}
}

public class LDOrderPizza extends OrderPizza{
	@Override
	Pizza creatPizza(String orderType) {
		Pizza pizza=null;
		if(orderType.equals("cheese")) {
			pizza=new LDCheesePizz();
		}else if(orderType.equals("greek")) {
			pizza=new LDGreekPizz();
		}
		return pizza;
	}
}

public class PizzaStore {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//创建北京口味的披萨
//		new BJOrderPizza();
		//创建伦敦口味的披萨
		new LDOrderPizza();
	}
}

🪓 抽象工厂

• 抽象工厂模式：定义了一个interface用于创建相关或有依赖关系的对象簇，而无需指明具体的类
• 抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。
• 从设计层面看，抽象工厂模式就是对简单工厂模式的改进(或者称为进一步的抽象)。
• 将工厂抽象成两层，AbsFactory(抽象工厂) 和具体实现的工厂子类。程序员可以根据创建对象类型使用对应的工厂子类。这样将单个的简单工厂类变成了工厂簇，更利于代码的维护和扩展。
  

?需求案例同工厂方法案例，抽象工厂对其进行进一步的优化。

案例代码：

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;
	}
}

public class BJCheesePizz extends Pizza{
	@Override
	public void prepare() {
		// TODO Auto-generated method stub
		setName("北京的奶酪披萨");
		System.out.println("北京的奶酪披萨准备原材料");
	}
}

public class BJGreekPizz extends Pizza{
	@Override
	public void prepare() {
		// TODO Auto-generated method stub
		setName("北京的希腊披萨");
		System.out.println("北京的希腊披萨准备原材料");
	}
}

public class LDCheesePizz extends Pizza{
	@Override
	public void prepare() {
		// TODO Auto-generated method stub
		setName("伦敦奶酪披萨");
		System.out.println("伦敦奶酪披萨准备原材料");
	}
}

public class LDGreekPizz extends Pizza
	@Override
	public void prepare() {
		// TODO Auto-generated method stub
		setName("伦敦希腊披萨");
		System.out.println("伦敦希腊披萨准配原材料");
	}
}

//抽象工厂模式的抽象层
public interface AbsFactory {
	//下面工厂子类自己建造
	Pizza creatPizza(String orderType);
}

public class BJFactory implements AbsFactory{
	public Pizza creatPizza(String orderType) {
		System.out.println("使用抽象工厂模式");
		// TODO Auto-generated method stub
		Pizza pizza=null;
		if(orderType.equals("cheese")) {
			pizza=new BJCheesePizz();
		}else if(orderType.equals("greek")) {
			pizza=new BJGreekPizz();
		}
		return pizza;
	}
}

public class LDFactory implements AbsFactory{
	public Pizza creatPizza(String orderType) {
		System.out.println("使用抽象工厂模式");
		// TODO Auto-generated method stub
		Pizza pizza=null;
		if(orderType.equals("cheese")) {
			pizza=new LDCheesePizz();
		}else if(orderType.equals("greek")) {
			pizza=new LDGreekPizz();
		}
		return pizza;
	}
	

public class OrderPizza {
	
	AbsFactory absFactory;
	public OrderPizza(AbsFactory absFactory) {
		setAbsFactory(absFactory);
	}

	private void setAbsFactory(AbsFactory absFactory) {
		Pizza pizza=null;
		String orderType="";
		this.absFactory = absFactory;
		do {
			
			orderType=getType();
			//absFactory 可能为北京 或者伦敦
			pizza=absFactory.creatPizza(orderType);
			if(pizza!=null) {
				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 type:");
			String str = strin.readLine();
			return str;
		} catch (IOException e) {
			e.printStackTrace();
			return "";
		}
	}
}

public class PizzaStore {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
			new OrderPizza(new BJFactory());
	}
}

📄 三、在JDK源码中的应用分析

JDK 中的Calendar类中，就使用了简单工厂模式

public abstract class Calendar implements Serializable, Cloneable, Comparable<Calendar> {

    public static Calendar getInstance(TimeZone zone,
                                       Locale aLocale){
        return createCalendar(zone, aLocale);
    }

    private static Calendar createCalendar(TimeZone zone,
                                           Locale aLocale){
        CalendarProvider provider =
            LocaleProviderAdapter.getAdapter(CalendarProvider.class, aLocale)
                                 .getCalendarProvider();
        if (provider != null) {
            try {
                return provider.getInstance(zone, aLocale);
            } catch (IllegalArgumentException iae) {
                // fall back to the default instantiation
            }
        }

        Calendar cal = null;

        if (aLocale.hasExtensions()) {
            String caltype = aLocale.getUnicodeLocaleType("ca");
            if (caltype != null) {
                switch (caltype) {
                case "buddhist":
                cal = new BuddhistCalendar(zone, aLocale);
                    break;
                case "japanese":
                    cal = new JapaneseImperialCalendar(zone, aLocale);
                    break;
                case "gregory":
                    cal = new GregorianCalendar(zone, aLocale);
                    break;
                }
            }
        }
        if (cal == null) {
            // If no known calendar type is explicitly specified,
            // perform the traditional way to create a Calendar:
            // create a BuddhistCalendar for th_TH locale,
            // a JapaneseImperialCalendar for ja_JP_JP locale, or
            // a GregorianCalendar for any other locales.
            // NOTE: The language, country and variant strings are interned.
            if (aLocale.getLanguage() == "th" && aLocale.getCountry() == "TH") {
                cal = new BuddhistCalendar(zone, aLocale);
            } else if (aLocale.getVariant() == "JP" && aLocale.getLanguage() == "ja"
                       && aLocale.getCountry() == "JP") {
                cal = new JapaneseImperialCalendar(zone, aLocale);
            } else {
                cal = new GregorianCalendar(zone, aLocale);
            }
        }
        return cal;
    }

}

📢 四、总结Tips

• 工厂模式的意义:将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的依赖关系的解耦。从而提高项目的扩展和维护性。
• 三种工厂模式 (简单工厂模式、工厂方法模式、抽象工厂模式)
• 设计模式的依赖抽象原则
• 创建对象实例时，不要直接 new 类, 而是把这个new 类的动作放在一个工厂的方法中，并返回。有的书上说，变量不要直接持有具体类的引用。
• 不要让类继承具体类，而是继承抽象类或者是实现interface(接口)、不要覆盖基类中已经实现的方法