工厂模式（简单工厂+工厂方法+抽象工厂）

通过多态实现，抽象类可以是

1、接口interface implements，

2、抽象类abstract extends

具体工厂类new具体产品的方法，

1、可以使用静态方法，由工厂类名字调用.静态方法（）返回new出来的具体产品，

2、也可以new工厂对象，调用对应的方法new出来具体产品

一、工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。

工厂模式在《Java与模式》中分为三类：

1）简单工厂模式（Simple Factory）：不利于产生系列产品；

2）工厂方法模式（Factory Method）：又称为多形性工厂；

3）抽象工厂模式（Abstract Factory）：又称为工具箱，产生产品族，但不利于产生新的产品；

这三种模式从上到下逐步抽象，并且更具一般性。

二、简单工厂模式

只有一个具体工厂

一个具体工厂生产new多个具体产品，根据不同的条件new和return

简单工厂模式又称静态工厂方法模式。重命名上就可以看出这个模式一定很简单。它存在的目的很简单：定义一个用于创建对象的接口。

在简单工厂模式中,一个工厂类处于对产品类实例化调用的中心位置上,它决定那一个产品类应当被实例化, 如同一个交通警察站在来往的车辆流中,决定放行那一个方向的车辆向那一个方向流动一样。

先来看看它的组成：

1)
具体工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑。在java中它往往由一个具体类实现。

2)
抽象产品角色：它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽象类来实现。

3)
具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。

//抽象产品（一个）
public interface Car{

public
void drive();

}

//具体产品（多个）

public class Benz implements Car{

public
void drive() {

System.out.println("Driving
Benz ");

}

}

public class Bmw implements Car{

public
void drive() {

System.out.println("Driving
Bmw ");

}

}

。。。（奥迪我就不写了:P）

//具体工厂类（一个）

public class Driver{

//工厂方法.注意
返回类型为抽象产品角色

public
static Car driverCar(String s)throws Exception{

//判断逻辑，返回具体的产品角色给Client

if(s.equalsIgnoreCase("Benz"))

return
new Benz();

else
if(s.equalsIgnoreCase("Bmw"))

return
new Bmw();

......

else
throw new Exception();

。。。

//测试类 ， 欢迎暴发户出场......

public class Magnate{

public
static void main(String[] args){

try{

//告诉司机我今天坐奔驰

Car
car = Driver.driverCar("benz");

//下命令：开车

car.drive();

。。。

三、工厂方法模式

有多个具体工厂

一个具体产品对应一个具体工厂类

具体工厂new对应的具体产品，并return

工厂方法模式是简单工厂模式的进一步抽象化和推广，工厂方法模式里不再只由一个工厂类决定那一个产品类应当被实例化,这个决定被交给抽象工厂的子类去做。

　　来看下它的组成：

1)抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。

2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。

3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。

4)具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。

工厂方法模式使用继承自抽象工厂角色的多个子类来代替简单工厂模式中的“上帝类”。正如上面所说，这样便分担了对象承受的压力；而且这样使得结构变得灵活
起来——当有新的产品（即暴发户的汽车）产生时，只要按照抽象产品角色、抽象工厂角色提供的合同来生成，那么就可以被客户使用，而不必去修改任何已有的代 码。可以看出工厂角色的结构也是符合开闭原则的！

代码：
//抽象产品（一个）

public interface Moveable {

void run();

}

//具体产品（多个）

public class Plane implements Moveable {

@Override

public void run() {

System.out.println("plane....");

}

}

public class Broom implements Moveable {

@Override

public void run() {

System.out.println("broom.....");

}

}

//抽象工厂（一个）

public abstract class VehicleFactory {

abstract Moveable create();

}
//具体工厂（多个）

public class PlaneFactory extends VehicleFactory{

public Moveable create() {

return new Plane();

}

}
public class BroomFactory extends VehicleFactory{

public Moveable create() {

return new Broom();

}

}
//测试类

public class Test {

public static void main(String[] args) {

VehicleFactory factory = new BroomFactory();

Moveable m = factory.create();

m.run();

}

}

可以看出工厂方法的加入，使得对象的数量成倍增长。当产品种类非常多时，会出现大量的与之对应的工厂对象，这不是我们所希望的。因为如果不能避免这种情 况，可以考虑使用简单工厂模式与工厂方法模式相结合的方式来减少工厂类：即对于产品树上类似的种类（一般是树的叶子中互为兄弟的）使用简单工厂模式来实 现。

四、简单工厂和工厂方法模式的比较

工厂方法模式和简单工厂模式在定义上的不同是很明显的。工厂方法模式的核心是一个抽象工厂类,而不像简单工厂模式, 把核心放在一个实类上。工厂方法模式可以允许很多实的工厂类从抽象工厂类继承下来, 从而可以在实际上成为多个简单工厂模式的综合,从而推广了简单工厂模式。

反过来讲,简单工厂模式是由工厂方法模式退化而来。设想如果我们非常确定一个系统只需要一个实的工厂类, 那么就不妨把抽象工厂类合并到实的工厂类中去。而这样一来,我们就退化到简单工厂模式了。

五、抽象工厂模式

代码：

//抽象工厂

public abstract class AbstractFactory {

public abstract Vehicle createVehicle();

public abstract Weapon createWeapon();

public abstract Food createFood();

}

//具体工厂，其中Food,Vehicle，Weapon是抽象类，

public class DefaultFactory extends AbstractFactory{

@Override

public Food createFood() {

return new Apple();

}

@Override

public Vehicle createVehicle() {

return new Car();

}

@Override

public Weapon createWeapon() {

return new AK47();

}

}

//测试类

public class Test {

public static void main(String[] args) {

AbstractFactory f = new DefaultFactory();

Vehicle v = f.createVehicle();

v.run();

Weapon w = f.createWeapon();

w.shoot();

Food a = f.createFood();

a.printName();

}

}

在抽象工厂模式中，抽象产品 (AbstractProduct) 可能是一个或多个，从而构成一个或多个产品族(Product Family)。 在只有一个产品族的情况下，抽象工厂模式实际上退化到工厂方法模式。

先来认识下什么是产品族：
位于不同产品等级结构中，功能相关联的产品组成的家族。还是让我们用一个例子来形象地说明一下吧。

回到抽象工厂模式的话题上。

可以说，抽象工厂模式和工厂方法模式的区别就在于需要创建对象的复杂程度上。而且抽象工厂模式是三个里面最为抽象、最具一般性的。

抽象工厂模式的用意为：给客户端提供一个接口，可以创建多个产品族中的产品对象

而且使用抽象工厂模式还要满足一下条件：

1)系统中有多个产品族，而系统一次只可能消费其中一族产品。

2)同属于同一个产品族的产品以其使用。

来看看抽象工厂模式的各个角色（和工厂方法的如出一辙）：

1)抽象工厂角色：
这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。

2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。在java中它由具体的类来实现。

3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。

4)具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。

看过了前两个模式，对这个模式各个角色之间的协调情况应该心里有个数了，我就不举具体的例子了。只是一定要注意满足使用抽象工厂模式的条件哦。

//

工厂方法模式：

一个抽象产品类，可以派生出多个具体产品类。

一个抽象工厂类，可以派生出多个具体工厂类。

每个具体工厂类只能创建一个具体产品类的实例。

抽象工厂模式：

多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。

一个抽象工厂类，可以派生出多个具体工厂类。

每个具体工厂类可以创建多个具体产品类的实例。

//

Java 之工厂方法和抽象工厂模式

1. 概念
工厂方法：一抽象产品类派生出多个具体产品类；一抽象工厂类派生出多个具体工厂类；每个具体工厂类只能创建一个具体产品类的实例。
即定义一个创建对象的接口（即抽象工厂类），让其子类（具体工厂类）决定实例化哪一个类（具体产品类）。“一对一”的关系。

抽象工厂：多个抽象产品类派生出多个具体产品类；一个抽象工厂类派生出多个具体工厂类；每个具体工厂类可创建多个具体产品类的实例。
即提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们的具体的类。“一对多”的关系。

3. 代码

工厂方法模式：

//一个抽象产品类

public interface Product
{
}
//一个抽象工厂类
public interface Creator
{
public Product factory();
}
//多个具体产品类
public class ConcreteProduct1 implements Product
{
public ConcreteProduct1()
{
System.out.println("ConcreteProduct1被创建");
}
}

public class ConcreteProduct2 implements Product
{
public ConcreteProduct2()
{
System.out.println("ConcreteProduct2被创建");
}

}
//多个具体工厂类
public class ConcreteCreator1 implements Creator
{
public Product factory()
{
return new ConcreteProduct1();
}
}

public class ConcreteCreator2 implements Creator
{
public Product factory()
{
return new ConcreteProduct2();
}
}

public class Client
{
private static Creator creator1, creator2;
private static Product prod1, prod2;

public static void main(String[] args)
{
creator1 = new ConcreteCreator1();
prod1 = creator1.factory();
System.out.println("----------------------------");
creator2 = new ConcreteCreator2();
prod2 = creator2.factory();
}
}

抽象工厂模式：

//定义不同的产品之间的一定具备的标准，用interface实现
//其中的method()方法可看作提取出不同产品的共性，如手机都有类似的功能

//多个抽象产品
interface IProductA{
public void method();
}

interface IProductB{
public void method();
}

//实现了产品标准实现的一系列具体产品
//由于已经设计好A1由厂商1生产，故以下输出代码有“厂商x”

//多个具体产品
class ProductA1 implements IProductA{
public void method() {
System.out.println("厂商1    生产ProductA1 ...");
}
}

class ProductA2 implements IProductA{
public void method() {
System.out.println("厂商2    生产ProductA2 ...");
}
}

class ProductB1 implements IProductB{
public void method() {
System.out.println("厂商1    生产ProductB1 ...");
}
}

class ProductB2 implements IProductB{
public void method() {
System.out.println("厂商2    生产ProductB2 ...");
}
}

//每一种牌子的产品生产工厂，即不同的厂商负责自己牌子产品的生产

//多个抽象工厂
abstract class Factory1{
abstract IProductA getProductA1();
abstract IProductB getProductB1();
}

abstract class Factory2{
abstract IProductA getProductA2();
abstract IProductB getProductB2();
}

//具体的工厂用来生产相关的产品

//多个具体工厂
class ConcreteFactory1 extends Factory1{
public IProductA getProductA1() {
return new ProductA1();
}
public IProductB getProductB1() {
return new ProductB1();
}
}

class ConcreteFactoryB extends Factory2{
public IProductA getProductA2() {
return new ProductA2();
}
public IProductB getProductB2() {
return new ProductB2();
}
}

//测试类
public class Client {
public static void main(String[] args) {
//厂商1负责生产产品A1、B1
Factory1 factory1 = new ConcreteFactory1();
IProductA productA1 = factory1.getProductA1();
IProductB productB1 = factory1.getProductB1();

productA1.method();
productB1.method();

//厂商2负责生产产品A2、B2
Factory2 factory2 = new ConcreteFactoryB();
IProductA productA2 = factory2.getProductA2();
IProductB productB2 = factory2.getProductB2();

productA2.method();
productB2.method();
}
}

4. 应用场景

工厂方法：

在以下情况下，适用于工厂方法模式：

(1) 当一个类不知道它所必须创建的对象的类的时候。

(2) 当一个类希望由它的子类来指定它所创建的对象的时候。

(3) 当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。

抽象工厂：

(1) 一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有形态的工厂模式都是重要的。

(2) 这个系统有多于一个的产品族，而系统只消费其中某一产品族。

(3) 同属于同一个产品族的产品是在一起使用的，这一约束必须在系统的设计中体现出来。

(4) 系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于实现。