Java设计模式之工厂模式（Factory Pattern）

  工厂模式是什么？

  Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.即定义一个用于创建对象（这些对象有一个或者多个共同的特征）的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

  Java中的设计模式分三大类：行为型模式，创建型模式，结构型模式。而工厂模式正是创建对象用的，是创建型模式中的一种。工厂模式又可以细分为三种模式：简单工厂模式（Simple Factory），工厂方法模式（Factory Method），抽象工厂模式（Abstract Factory），下面来一一介绍：

  1  简单工厂模式：

  又叫静态工厂模式，是工厂模式三中状态中结构最为简单的。主要有一个静态方法，用来接受参数，并根据参数来决定返回实现同一接口的不同类的实例。

  先看一张图：

 



下面看实现的代码：

 本次模拟的是生产电子产品的工厂，生产手机平板：

 


以上是项目的结构，下面插入代码：

package com.simple;

/**
*
* @author admin  电子产品
*
*/
public interface Product {

}

package com.simple;

/**
*
* @author admin 手机P6
*
*/
public class HuaWeiP6 implements Product{
public HuaWeiP6() {
System.out.println("大家好，我是华为P6");
}
}

package com.simple;

/**
*
* @author admin 手机P7
*
*/
public class HuaWeiP7 implements Product{
public HuaWeiP7() {
System.out.println("大家好，我是华为P7");
}
}

package com.simple;

/**
*
* @author admin 平板
*
*/
public class Tablet implements Product{
public Tablet() {
System.out.println("大家好，我是平板");
}

}

package com.simple;

/**
*
* @author admin 创建产品的工厂
*
*/
public class ProductFactory {

public static Product creatProduct(String name) {
if ("huaweip6".equals(name)) {
return new HuaWeiP6();
} else if ("huaweip7".equals(name)) {
return new HuaWeiP7();
}else if ("tablet".equals(name)) {
return new Tablet();
}else {
System.out.println("这个产品不存在的");
return null;
}
}

}

package com.simple;

public class SimpleTest {
public static void main(String[] args) {

ProductFactory.creatProduct("huaweip6");
ProductFactory.creatProduct("huaweip7");
ProductFactory.creatProduct("tablet");

ProductFactory.creatProduct("tablet33");
}
}

  由上面的代码可以看出，简单工厂的核心就是ProductFactory 一个类，他拥有必要的逻辑判断能力和所有产品的创建权利，我们只需要向把产品名字给他，就能得到我们想要的产品。这使用起来似乎非常方便。但实际上，这个ProductFacto
4000
ry有很多的局限。首先，我们每次想要增加一种新产品的时候，都必须修改ProductFactory的原代码。其次，当我们拥有很多很多产品的时候，而且产品之间又存在复杂的层次关系的时候，这个类必须拥有复杂的逻辑判断能力，其代码量也将不断地激增，这对以后的维护简直就是恐两个字...还有就是，整个系统都严重依赖ProductFactory类，只要ProductFactory类一出问题，系统就进入不能工作的状态，这也是最为致命的一点....

以上的不足将在工厂模式的另外两种状态中得到解决。

 2 工厂方法模式

、还是先看图：

  


相关的代码：

 先是和产品相关的：

package com.fmethod;

/**
*
* @author admin 对制造的产品抽象类
*
*/
public abstract class Mobile {
abstract void getCall();
abstract void takePhoto();

}

package com.fmethod;

/**
*
* @author admin  具体产品的实现类1
*
*/
public class HuaWeiP6 extends Mobile{

public HuaWeiP6() {
System.out.println("我是华为P6");
getCall();
takePhoto();
}
@Override
void getCall() {
System.out.println("P6我可以打电话");

}

@Override
void takePhoto() {
System.out.println("P6我拍照，效果一般");

}

}

package com.fmethod;

/**
*
* @author admin  具体产品的实现类2
*
*/
public class HuaWeiP7 extends Mobile{
public HuaWeiP7() {
System.out.println("我是华为P7");
getCall();
takePhoto();
}
@Override
void getCall() {
System.out.println("P7我能打电话");

}

@Override
void takePhoto() {
System.out.println("P7我拍照，效果非常好");

}

}

工厂相关：

 

package com.fmethod;

/**
*
* @author admin 工厂的抽象类
*
*/
public abstract class MobileFactory {
/**
*
* @param clazz 想要的手机
* @return      返回你要的手机
*/
abstract Mobile creatMobile();
}

package com.fmethod;

public class P6Factory extends MobileFactory{

@Override
Mobile creatMobile() {
return new HuaWeiP6();
}

}

package com.fmethod;

public class P7Factory extends MobileFactory{

@Override
Mobile creatMobile() {
return new HuaWeiP7();
}

}

测试类：

 

package com.fmethod;

public class MobileTest {
public static void main(String[] args) {
P6Factory p6Factory = new P6Factory();
Mobile p6 = p6Factory.creatMobile();

P7Factory p7Factory = new P7Factory();
Mobile p7 = p7Factory.creatMobile();
}
}

结果：

 


  从上面创建产品对象的代码可以看出，工厂方法和简单工厂的主要区别是，简单工厂是把创建产品的职能都放在一个类里面，而工厂方法则把不同的产品放在实现了工厂接口的不同工厂类里面，这样就算其中一个工厂类出了问题，其他工厂类也能正常工作，互相不受影响，以后增加新产品，也只需要新增一个实现工厂接口工厂类，就能达到，不用改已有的代码。但工厂方法也有他局限的地方，那就是当面对的产品有复杂的等级结构的时候，例如，工厂除了生产手机外产品，还生产手机套产品，这样一来手机套和手机就是两大产品家族了，这两大家族下面包含了数量众多的产品，每个产品又有多个型号，这样就形成了一个复杂的产品树了。如果用工厂方法来设计这个产品家族系统，就必须为每个型号的产品创建一个对应的工厂类，当有数百种甚至上千种产品的时候，也必须要有对应的上百成千个工厂类，这就出现了传说的类爆炸，对于以后的维护来说，简直就是一场灾难.....

3 抽象工厂模式

先看图：

 



抽象工厂模式目的：意图在于创建一系列互相关联或互相依赖的对象。

产品接口：

package com.fabstract;

/**
*
* @author admin 对制造的产品抽象类
*
*/
public abstract class Mobile {
abstract void getCall();
abstract void takePhoto();

}

package com.fabstract;

/**
*
* @author admin  手机套的抽象
*
*/
public abstract class MobileSocket {
abstract void creatSocket();
}

产品的实现类：

package com.fabstract;

/**
*
* @author admin  具体产品的实现类1
*
*/
public class HuaWeiP6 extends Mobile{

public HuaWeiP6() {
System.out.println("我是华为P6");
getCall();
takePhoto();
}
@Override
void getCall() {
System.out.println("P6我可以打电话");

}

@Override
void takePhoto() {
System.out.println("P6我拍照，效果一般");

}

}

package com.fabstract;

/**
*
* @author admin  具体产品的实现类2
*
*/
public class HuaWeiP7 extends Mobile{
public HuaWeiP7() {
System.out.println("我是华为P7");
getCall();
takePhoto();
}
@Override
void getCall() {
System.out.println("P7我能打电话");

}

@Override
void takePhoto() {
System.out.println("P7我拍照，效果非常好");

}

}
package com.fabstract;

/**
*
* @author admin  手机套产品的实现类1
*
*/
public class P6Socket extends MobileSocket{

public P6Socket() {
creatSocket();
}
@Override
void creatSocket() {
System.out.println("我是华为P6的手机套");

}

}

package com.fabstract;

/**
*
* @author admin  手机套产品的实现类2
*
*/
public class P7Socket extends MobileSocket {
public P7Socket() {
creatSocket();
}

@Override
void creatSocket() {
System.out.println("我是华为P7的手机套");

}

}

抽象工厂和实现：

package com.fabstract;

/**
*
* @author admin  手机套产品的实现类2
*
*/
public class P7Socket extends MobileSocket {
public P7Socket() {
creatSocket();
}

@Override
void creatSocket() {
System.out.println("我是华为P7的手机套");

}

}
package com.fabstract;

/**
*
* @author admin  专门生产P6的工厂
*
*/
public class FactoryP6 implements ProductFactory{

@Override
public Mobile creatMobile() {
return new HuaWeiP6();
}

@Override
public MobileSocket creatMobileSocket() {
return new P6Socket();
}

}
package com.fabstract;

/**
*
* @author admin  专门生产P7的工厂
*
*/
public class FactoryP7 implements ProductFactory{

@Override
public Mobile creatMobile() {

return new HuaWeiP7();
}

@Override
public MobileSocket creatMobileSocket() {

return new P7Socket();
}

}

测试类和运行结果：

 

package com.fabstract;

public class AbstractTest {
public static void main(String[] args) {
FactoryP6 factoryP6 = new FactoryP6();
factoryP6.creatMobile();
factoryP6.creatMobileSocket();
}
}

  好了，到此已经结束了，最后再说一句，之所以用工厂模式创建对象，关键在于这些对象都有一个相同的属性，比如p6和p7都是手机，p6的手机套和p7的手机套都是手机套，这样的对象用工厂模式来创建才方便，三种不同的创建方法在应用的时候需要结合到当前的情形，没有最好的，只有最适合你的。