💎 一、概述
工厂模式是我们最常用的实例化对象模式了，是用工厂方法代替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(接口)、不要覆盖基类中已经实现的方法
