介绍
工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。
工厂模式分为三种：简单工厂模式，工厂方法模式，抽象工厂模式。
简单工厂模式
简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例，是工厂模式家族中最简单实用的模式。
简单工厂模式，定义了一个创建对象的类，由这个类来封装实例化对象的行为。
在软件开发中，当我们要用到大量的创建某种，某类或者某批对象时，就会使用到工厂模式。
示例
假设我们需要制作Pizza，我们可以用一个工厂类，根据类型返回对应的Pizza实例。
package factory.simple;
public class SimpleFactoryTest{
public static void main(String[] args) {
SimpleFactory sf = new SimpleFactory();
Pizza creamPizza = sf.createPizza("cream");
}
}
class SimpleFactory {
public Pizza createPizza(String type) {
switch(type){
case "cream": return new CreamPizza();
case "fruit": return new FruitPizza();
default: return null;
}
}
}
abstract class Pizza {
}
class CreamPizza extends Pizza {
}
class FruitPizza extends Pizza {
}
简单工厂模式也叫静态工厂模式。即上面代码中，可以将createPizza方法改为静态方法，调用方也不用实例化工厂对象了。
工厂方法模式
工厂方法模式：定义一个有实例化抽象方法的抽象工厂类，由工厂子类决定具体要实例化的类。工厂方法模式将对象的实例化推迟到子类。
示例
在上面的例子中，如果又有了新种类的Pizza，就需要修改createPizza方法。随着Pizza种类不断增加，创建披萨方法会不断修改，这里其实就违背了开闭原则（对扩展开发，对修改关闭），而且现实中也不可能一个工厂生产所有种类的披萨。
下面用工厂方法模式改进一下之前的代码
package factory.method;
public class FactoryMethodTest {
public static void main(String[] args) {
Factory f = new FruitFactory();
Pizza fruitPizza = f.createPizza();
}
}
abstract class Factory {
abstract Pizza createPizza();
}
class CreamFactory extends Factory {
@Override
Pizza createPizza() {
return new CreamPizza();
}
}
class FruitFactory extends Factory {
@Override
Pizza createPizza() {
return new FruitPizza();
}
}
abstract class Pizza {
}
class CreamPizza extends Pizza {
}
class FruitPizza extends Pizza {
}
抽象工厂模式
抽象工厂模式：定义了一个interface用于创建相关或有依赖关系的对象簇，而无需指明具体的类。
抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。
从设计层面看，抽象工厂就是对简单工厂模式的改进（或者称为进一步的抽象）。
将工厂抽象为两层，抽象工厂和具体工厂子类。程序员根据要创建的对象类型使用对应的工厂子类，将单个的简单工厂变成了工厂簇，更利于代码的维护和扩展。
示例
在上面例子中，假设工厂不只生产披萨，还生产沙拉等系列产品。那么代码改进如下
package factory.abstract2;
public class AbstractFactoryTest {
public static void main(String[] args) {
Factory f = new CreamFactory();
Pizza creamPizza = f.createPizza();
Salad creamSalad = f.createSalad();
}
}
abstract class Factory {
abstract Pizza createPizza();
abstract Salad createSalad();
}
class CreamFactory extends Factory {
@Override
Pizza createPizza() {
return new CreamPizza();
}
@Override
Salad createSalad() {
return new CreamSalad();
}
}
class FruitFactory extends Factory {
@Override
Pizza createPizza() {
return new FruitPizza();
}
@Override
Salad createSalad() {
return new FruitSalad();
}
}
abstract class Pizza {
}
class CreamPizza extends Pizza {
}
class FruitPizza extends Pizza {
}
abstract class Salad {
}
class CreamSalad extends Salad {
}
class FruitSalad extends Salad {
}
JDK实例
在Calendar类中，实例化一个对象时，默认调用类的getInstance方法
public static Calendar getInstance()
{
return createCalendar(TimeZone.getDefault(), Locale.getDefault(Locale.Category.FORMAT));
}
继续跟踪createCalendar方法，可以看到里面用到了工厂模式（根据TimeZone和Locale创建对应的实例）
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;
}
小结
工厂模式的意义：将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目依赖关系解耦的目的。从而提高项目的可扩展性和维护性。
三种工厂模式：简单工厂模式，工厂方法模式，抽象工厂模式
设计模式的依赖抽象原则
- 创建对象实例时，不要直接new类，而是把这个new类的动作放在一个工厂的方法中，并返回。有的书上说，变量不要直接持有具体类的引用
- 不要让类继承具体类，而是继承抽象类或者实现接口
- 不要覆盖基类中已经实现的方法