java设计模式之一工厂模式（Factory Method）

1.普通工厂模式
     字面意思理解，就是工厂生产产品，同样的是生产produce方法，但不同的厂生产出来的产品是不同的。
我们用一个简单的例子来实现：
首先创建一个共用的接口类：

/**
* @author joker 2016-06-13
* 工厂的接口类，每个工厂同有的就是生产这个方法
*/
public interface FactoryInter {
public void produce();
}

[align=left]其次，创建两个厂房实现这个接口：[/align]

public class AudiFactory implements FactoryInter{
@Override
public void produce() {
System. out.println("我生产的是奥迪车" );
}
}

public class BMWFactory implements FactoryInter{
@Override
public void produce() {
System. out.println("我生产的是宝马车" );
}
}

[align=left]然后建造工厂生产车子：[/align]

public class CarFactory {
public FactoryInter buildCar(String type){
switch (type ) {
case "BMW" :
return new BMWFactory();
case "Audi" :
return new AudiFactory();
default:
return null ;
}
}
}

[align=left]测试：[/align]

public class testFactory {
public static void main(String[] args) {
CarFactory carFactory=new CarFactory();
FactoryInter produce= carFactory.buildCar("BMW" );
produce.produce();
}
}

输出：我生产的是宝马车
总结：这是最基本的工厂模式，根据不同的传参创建不同的工厂，但是如果参数传递错误就不能进行生产，必须实现约定。

2.多个工厂方法
     只需要把刚才的传参方式的建造修改一下即可：

public class CarFactory {
//   public FactoryInter buildCar(String type){
//        switch (type) {
//        case "BMW":
//            return new BMWFactory();
//        case " Audi":
//            return new AudiFactory();
//        default:
//            return null;
//        }
//   }
public FactoryInter buildBMWCar(){
return new BMWFactory();
}

public FactoryInter buildAudiCar(){
return new AudiFactory();
}
}

[align=left]然后修改最后的测试方法：[/align]

public static void main(String[] args) {
//        CarFactory carFactory=new CarFactory();
//        FactoryInter produce=carFactory.buildCar("BMW");
//        produce.produce();

CarFactory carFactory=new CarFactory();
FactoryInter bmwCar= carFactory.buildBMWCar();
bmwCar.produce();
}

[align=left]最后输出： 我生产的是宝马车[/align]
[align=left]总结：这样即可根据不同的需求造出不同的车子了，而不用去理会那些约定。更为实用快捷。[/align]
[align=left]
[/align]
[align=left]3.静态工厂模式[/align]
[align=left]     其实就是把生产方法都设置为静态的，省去了初始化这一步了，如下修改：[/align]

public static FactoryInter buildBMWCar(){
return new BMWFactory();
}

public static FactoryInter buildAudiCar(){
return new AudiFactory();
}

[align=left]然后测试类修改成如下：[/align]

public static void main(String[] args) {
//        CarFactory carFactory=new CarFactory();
//        FactoryInter produce=carFactory.buildCar("BMW");
//        produce.produce();

//        CarFactory carFactory=new CarFactory();
//        FactoryInter bmwCar=carFactory.buildBMWCar();
//        bmwCar.produce();
FactoryInter audiCar=CarFactory. buildAudiCar();
audiCar.produce();
}

[align=left]最后输出： 我生产的是奥迪车[/align]
[align=left]    综上：就是一个工厂的演变过程，在实际项目过程中如果出现大量的产品需要创建且共用一个接口的，即可用工厂模式实现，而静态工厂类是用的最多的。[/align]