JAVA设计模式--工厂模式

引言

在面向对象编程中new()对象可以说是无处不见，但是如果许多地方都要生成同一个类的对象，例如许多地方都需要生成A的对象，那么你需要写很多的A a=new A（），实际上很多创建对象并不是这么简单，它是一个过程性的，很可能需要设置属性，重写方法等等...如果需求一旦发生变化，你需要去修改这个对象的创建过程，你就得修改很多地方，这对于一个大型的项目来说是很糟糕的。这时候工厂模式就出现了，工厂模式的核心思想就是将创建对象的过程封装在工厂方法中，需要创建对象时只需要调用对应的工厂方法，当需求发生变化时，只需要修改工厂方法中对象的创建过程。

优点

工厂模式优点有如下三点：

1. 工厂方法封装了对象创建的细节,将对象创建代码和其他部分脱离,减少相干性。

2. 有利于同类对象创建的统一管理和控制。

3. 你所关心的仅仅是工厂方法返回的接口方法,不必关心实现细节。

分类

工厂模式可以分为三类:
1. 简单工厂模式（Simple Factory）
2. 工厂方法模式（Factory Method）
3. 抽象工厂模式（Abstract Factory）

简单工厂模式

//抽象产品类
public abstract class Iphone{
public Iphone(){}
}
//Iphone5具体产品类
class Iphone5 extends Iphone{
public Iphone5(){
System.out.println("制造一部IPhone5");
}
}
//Iphone6具体产品类
class Iphone6 extends Iphone{
public Iphone6(){
System.out.println("制造一部IPhone6");
}
}

//工厂类
class Factory{
//工厂方法，根据传入的参数制造对应产品
public Iphone creatIphone(int type){
switch(type){
case 5:
return new Iphone5();
case 6:
return new Iphone6();
default:
return null;
}
}
}

//客户
public class Customer {
public static void main(String[] args){
Factory factory=new Factory();
factory.creatIphone(5);//获取Iphone5
factory.creatIphone(6);//获取Iphone6
}
}

从上面的代码可以看到，简单工厂方法由一个工厂类和一个抽象产品类及其数个具体产品类组成，当我们需要一个具体产品时，只需要给工厂说明传入产品型号，工厂就会去为我们制造，这样极大的降低了代码的耦合性。但是如果工厂又研发除了一个新的产品（例如Iphone7），那么我们就得修改工厂方法中的switch语句，这样就违背了开闭原则（针对扩展开放，针对修改关闭），然后就衍生出了工厂方法模式。

工厂方法模式

//抽象产品类
public abstract class Iphone{
public Iphone(){}
}
//Iphone5具体产品类
class Iphone5 extends Iphone{
public Iphone5(){
System.out.println("制造一部IPhone5");
}
}
//Iphone6具体产品类
class Iphone6 extends Iphone{
public Iphone6(){
System.out.println("制造一部IPhone6");
}
}

//抽象工厂类
public interface Factory{
public Iphone creatIphone(int type);
}
//Iphone5对应的具体工厂类
class FactoryIphone5{
public Iphone5 creatIphone(){
return new Iphone5();
}
}
//Iphone6对应的具体工厂类
class FactoryIphone6{
public Iphone6 creatIphone(){
return new Iphone6();
}
}

//客户类
public class Customer {
public static void main(String[] args){
FactoryIphone5 factoryIphone5=new FactoryIphone5();
Iphone5 iphone5=factoryIphone5.creatIphone();
FactoryIphone6 factoryIphone6=new FactoryIphone6();
Iphone6 iphone6=factoryIphone6.creatIphone();
}
}

可以看出，工厂方法模式由一个抽象产品类和数个具体产品类、一个抽象工厂类和数个具体工厂类组成。这样的话当新产品研发出来后，只需要继承抽象产品类，添加具体产品以及继承抽象工厂类，实现具体工厂类。如此就既不违反简单工厂模式的思想，又符合了开闭原则。当然我们还可以使用泛型和反射，使制造产品更加灵活。

抽象工厂模式

抽象工厂模式是工厂方法模式的进一步抽象，其英文原话"Provide an interface for creating families of related or dependent objects without specifying their concrete classes"翻译：“为创建一组相关或相互依赖的对象提供一个接口，无需指定它们的具体类”。抽象工厂模式除了拥有工厂方法模式的优点外，最主要的优点就是可以在类的内部进行产品约束。抽象工厂模式一般用于制造一族产品，并且这族产品分不同的等级，不同的具体工厂类生产不同等级的一族产品。例如电脑的硬盘，内存条...等是一族产品，对于这族产品分为AMD品牌和INTER品牌两个等级（对于产品族和产品等级的概念自行理解）。

/*
* 内存条产品抽象类
* （内存和硬盘是一族相关的产品--都是电脑配件，AMD制造和Inter制造是两个不同等级）
*/
abstract class Memory{
public Memory(){}
}
//硬盘产品抽象类
abstract class HardDisk{
public HardDisk(){}
}
//AMD内存条的具体实现类
class AmdMemory extends Memory{
public AmdMemory(){
System.out.println("制造一个AMD的内存条");
}
}
//Inter内存条的具体实现类
class InterMemory extends Memory{
public InterMemory(){
System.out.println("制造一个Inter的内存条");
}
}
//AMD硬盘的具体实现类
class AmdHardDisk extends HardDisk{
public AmdHardDisk(){
System.out.println("制造一个AMD的硬盘");
}
}
//Inter硬盘的具体实现类
class InterHardDisk extends HardDisk{
public InterHardDisk(){
System.out.println("制造一个Inter的硬盘");
}
}

//抽象工厂类
interface AbstractFactory{
public Memory creatMemory();
public HardDisk creatHardDisk();
}
//AMD工厂的具体实现类
class AmdFactory implements AbstractFactory{
public Memory creatMemory() {
return new AmdMemory();
}
public HardDisk creatHardDisk() {
return new AmdHardDisk();
}
}
//Inter工厂的具体实现类
class InterFactory implements AbstractFactory{
public Memory creatMemory() {
return new InterMemory();
}
public HardDisk creatHardDisk() {
return new InterHardDisk();
}
}

//客户
public class Customer {
public static void main(String[] args){
AmdFactory factory=new AmdFactory();
Worker worker=new Worker();
Computer computer=worker.getComputer(factory);
}
}
// 计算机类
class Computer{
public Memory memory;
public HardDisk hardDisk;
}
//组装工人
class Worker{
//创建一组相关或相互依赖的对象提供一个接口，无需指定它们的具体类
public Computer getComputer(AbstractFactory factory){
Computer computer=new Computer();
computer.memory=factory.creatMemory();
computer.hardDisk=factory.creatHardDisk();
return computer;
}
}

抽象工厂模式参考：http://blog.csdn.net/m13666368773/article/details/7677374