工厂模式

前言

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，而是通过使用一个共同的接口来指向新创建的对象。

介绍

意图

定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

优点

1、一个调用者想创建一个对象，只要知道其名称就可以了。
2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。
3、屏蔽产品的具体实现，调用者只关心产品的接口。
4.每个具体工厂类只负责创建对应的产品，符合单一职责原则。

缺点

每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。因为使用设计模式的原则之一是降低程序的耦合。

简单工厂模式（工厂模式的特例）

简单工厂模式看作为工厂方法模式的一种特例，两者归为一类。

与工厂模式不一样的是，简单工厂模式只有抽象产品类，具体产品类和一个工厂类。

    示例：创建蛋糕工厂，根据客户端传的参数实例化相应的对象。

抽象产品类

Cake.java

public abstract class Cake {abstract void produce();
}

具体产品类

AppleCake.java,
BananaCake.java,
ChocolateCake.java

---

AppleCake.java,

public class AppleCake extends Cake{void produce() {System.out.println("制作苹果蛋糕");}
}

---

BananaCake.java

public class BananaCake extends Cake{void produce() {System.out.println("制作香蕉蛋糕");}
}

---

ChocolateCake.java

public class ChocolateCake extends Cake {void produce() {System.out.println("制作巧克力蛋糕");}}

工厂类

CakeFactory.java

public class CakeFactory {public Cake getCake(String cakeName) throws Exception {if ("苹果蛋糕".equals(cakeName)) {return new AppleCake();} else if ("香蕉蛋糕".equals(cakeName)) {return new BananaCake();} else if ("巧克力蛋糕".equals(cakeName)) {return new ChocolateCake();}else {throw new Exception("输入有误，请重新输入！");}}/**利用反射机制public Cake getCake(Class obj){Cake cake = null;try {cake = (Cake) Class.forName(obj.getName()).newInstance();//实例化对象，newInstance()调用无参构造函数} catch (InstantiationException e) {e.printStackTrace();} catch (IllegalAccessException e) {e.printStackTrace();} catch (ClassNotFoundException e) {e.printStackTrace();}return cake;}*/
}

---

测试

Test.java

	public class Test {public static void main(String[] args) throws Exception {//第一种方式的测试代码String cakeName = "苹果蛋糕";CakeFactory cakeFactory = new CakeFactory();Cake cake = cakeFactory.getCake(cakeName);cake.produce();//第二种的测试代码（反射机制）
//	        CakeFactory cakeFactory = new CakeFactory();
//	        cakeFactory.getCake(DurianCake.class).produce();}
}

运行结果（第二种方式的运行结果）

工厂模式

抽象工厂(Abstract Factory)角色： 是工厂方法模式的核心，与应用程序无关。任何在模式中创建的对象的工厂类必须实现这个接口。

具体工厂(Concrete Factory)角色 ： 这是实现抽象工厂接口的具体工厂类，包含与应用程序密切相关的逻辑，并且受到应用程序调用以创建某一种产品对象。

抽象产品(Abstract Product)角色 ： 工厂方法模式所创建的对象的超类型，也就是产品对象的共同父类或共同拥有的接口。

具体产品(Concrete Product)角色 ： 这个角色实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创建，它们之间往往一一对应。

抽象工厂

AbstractFactory.java

public abstract class AbstractFactory {abstract Car getDriver();
}

---

具体工厂

HomeCarFactory类，StudentCarFactory类，ChinaCarFactory类

HomeCarFactory.java

public class HomeCarFactory extends AbstractFactory {Car getDriver() {return new HomeCar();}
}

StudentCarFactory.java

public class StudentCarFactory extends AbstractFactory {Car getDriver() {return new StudentCar();}
}

ChinaCarFactory.java

public class ChinaCarFactory extends AbstractFactory {Car getDriver() {return new ChinaCar();}
}

---

抽象产品

Car.java

public abstract class Car {abstract void driver();
}

---

具体产品

StudentCar类，HomeCar类，ChinaCar类

StudentCar.java

public class StudentCar extends Car{void driver() {System.out.println("校车出发");}
}

HomeCar.java

public class HomeCar extends Car{void driver() {System.out.println("私家车出发");}

ChinaCar.java

public class ChinaCar extends Car{void driver() {System.out.println("公车出发");}
}

测试

public class CarFactoryTest {public static void main(String[] args) {// TODO Auto-generated method stubAbstractFactory st = new StudentCarFactory();st.getDriver().driver();AbstractFactory ch = new ChinaCarFactory();ch.getDriver().driver();AbstractFactory ho = new HomeCarFactory();ho.getDriver().driver();}}