Java实现设计模式之工厂模式

工厂模式

工厂模式专门负责实例化有大量公共接口的类，包含以下形式：

1、简单工厂模式（simplefactory）

2、工厂方法（Factorymethod）

3、抽象工厂（AbstractFactory）

 

1、简单工厂模式（simplefactory）：通过多态，工厂实例化合适的对象。

简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了与具体产品的依赖。缺点是：违背了开放-封闭原则。

 

2、工厂方法（Factory method）定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到其子类。

工厂方法模式是简单工厂模式的进一步抽象和推广，既保持了简单工厂模式的优点，而且客服了简单工厂的缺点。但是工厂方法的缺点是：每增加一个产品，就需要增加一个产品工厂的类，增加了额外的开发。（用反射可以解决）

 

3、抽象工厂（AbstractFactory）提供一个创建一系列相关或互相依赖对象的接口，而无需指定它们具体的类。

1.      抽象工厂的好处：

a)      改变具体工厂即可使用不同的产品配置，使改变一个应用的具体工厂变得很容易。

b)     让具体的创建实例过程与客户端分离，客户端通过抽象接口操作实例，产品的具体类名也被具体工厂的实现分离。

2.      抽象工厂的缺点：如果要新增方法，改动极大。

3.      用简单工厂改进抽象工厂：用DataAccess类来取代具体实施类，可以达到解耦合的目的。但是在DataAccess中增加了更多的Switch，并不明智。

4.       用反射+抽象工厂：优点是去掉了switch，缺点是要更改string字段，重新部署和编译。使用反射+配置文件实现：所有使用简单工厂的地方，都可以考虑使用反射技术来去除switch和if，解除分支判断带来的耦合问题。

Java实现简单工厂模式：

/**
* 《大话设计模式》——简单工厂模式
* 应用实例：计算器
* 思想：将加减乘除都封装成子类，在客户端new对应的实例。
*/
package DaHuaSheJiMoShi;

/**
* @author LilyLee
* @Version 1.0
* @email lilylee_1213@foxmail.com
*
*/
public class SimpleFactory {

public static void main(String[] args) {
OperationFactory oper= new OperationFactory();
Operation o=oper.CreateOperate("+");
o.setNumA(1);
o.setNumB(2);
System.out.println(o.GetResult());

}

public static class OperationFactory{
public Operation CreateOperate(String op){
Operation oper=null;
switch(op){
case "+":
oper=new OperationAdd();
break;
case "*":
oper =new OperationMul();
}
return oper;
}
}

}
class Operation{
private double numA=0;
/**
* @return the numA
*/
public double getNumA() {
return numA;
}
/**
* @param numA the numA to set
*/
public void setNumA(double numA) {
this.numA = numA;
}
/**
* @return the numB
*/
public double getNumB() {
return numB;
}
/**
* @param numB the numB to set
*/
public void setNumB(double numB) {
this.numB = numB;
}
private double numB=0;

public double GetResult(){
double result=0;
return result;
}

}

class OperationAdd extends Operation{
public double GetResult(){
double result=0;
result=getNumA()+getNumB();
return result;
}
}

class OperationMul extends Operation{
public double GetResult(){
double result=0;
result=getNumA()*getNumB();
return result;
}
}



工厂模式方法Java实现：

/**
* 《大话设计模式》第八章，雷锋工厂
*
* 工厂方法：
* 把工厂类抽象出一个接口，这个接口只有一个方法，就是创建抽象产品的工厂方法。
* 所有的具体类都去实现这个接口。
* 工厂模式就变成了一个工厂抽象接口和多个具体生成对象的工厂。
*
* 工厂模式和简单工厂的区别是：
* 工厂方法把简单工厂内部逻辑判断移到了客户端来进行。
* 由于工厂方法的多态性，克服了简单工厂的不足，有良好的开放-封闭原则。
* 但是缺点是每增加一个产品，就要额外增加产品工厂类。
*/
package DaHuaSheJiMoShi;

/**
* @author LilyLee
* @date 2017年6月11日
* @time 下午7:12:47
* @Version 1.0
* @email lilylee_1213@foxmail.com
*
*/
public class FactoryMethod {

public static void main(String[] args) {
// TODO Auto-generated method stub
IFactory factory=new student();
LeiFeng student=factory.CreateLeiFeng();
student.Sweep();
student.Wash();
IFactory factory2=new Volunteer();
LeiFeng volunteer2=factory2.CreateLeiFeng();
volunteer2.Sweep();
volunteer2.Wash();
}
}

class LeiFeng{
public void Sweep(){
System.out.println(this.getClass()+"扫地");
}
public void Wash(){
System.out.println(this.getClass()+"清洗");
}
}

interface IFactory{
LeiFeng CreateLeiFeng();
}

class student extends LeiFeng implements IFactory{

@Override
public LeiFeng CreateLeiFeng() {
return new student();
}

}

class Volunteer extends LeiFeng implements IFactory{
@Override
public LeiFeng CreateLeiFeng() {
return new Volunteer();
}
}



抽象工厂模式，Java实现：

/**
* 《大话设计模式》第十五章——抽象工厂模式
*
* 抽象工厂模式：提供一个创建一系列相关或互相依赖对象的接口，而无需指定它们具体的类。
* IFactory是一个抽象工厂接口，它包含所有的产品创建的抽象方法。
* 而ConcreteFactory是具体的工厂。可以有很多。
*
* 抽象工厂模式：为了创建不同的产品对象，客户端使用不同的具体工厂。
*
* 应用示例：原文的是用.Net写的，比较杂乱，有点儿看不太懂。所以找了一个更好懂的例子。
* 【http://lavasoft.blog.51cto.com/62575/11674/】
* 背景：园丁要在庄园里种植热带和亚热带的水果和蔬菜。
* 园丁是抽象接口，只有种植蔬菜和水果的区别。
* 而水果和蔬菜又分别有热带和亚热带之分。
*/
package DaHuaSheJiMoShi;

/**
* @author LilyLee
* @date 2017年6月11日
* @time 下午8:10:22
* @Version 1.0
* @email lilylee_1213@foxmail.com
*
*/

interface Fruit{}
interface Veggie{}

interface Gardener{
public Fruit createFruit(String name);
public Veggie createVeggie(String name);
}

public class AbstractFactoryTest {

public static void main(String[] args) {
Fruit f1,f2;
Veggie v1,v2;
RdGardener rdg=new RdGardener();
YRdGardener yrdf=new YRdGardener();
f1=rdg.createFruit(" 芒果");
f2=yrdf.createFruit(" 荔枝");
v1=rdg.createVeggie(" 秋葵");
v2=yrdf.createVeggie(" 辣椒");
}

//热带工厂
public static class RdGardener implements Gardener{
@Override
public Fruit createFruit(String name){
return new RdFruit(name);
}

@Override
public Veggie createVeggie(String name) {
return new RdVeggie(name);
}
}
//亚热带工厂
public static class YRdGardener implements Gardener{
@Override
public Fruit createFruit(String name){
return new YRdFruit(name);
}

@Override
public Veggie createVeggie(String name) {
return new YRdVeggie(name);
}
}

//热带水果
public static class RdFruit implements Fruit{
private String name;
/**
* @return the name
*/
public String getName() {
return name;
}
/**
* @param name the name to set
*/
public void setName(String name) {
this.name = name;
}
public RdFruit(String name){
System.out.println("种植热带水果"+name);
}
}

//热带蔬菜
public static class RdVeggie implements Veggie{
private String name;

/**
* @return the name
*/
public String getName() {
return name;
}

/**
* @param name the name to set
*/
public void setName(String name) {
this.name = name;
}
public RdVeggie(String name){
System.out.println("种植热带蔬菜"+name);
}

}

//亚热带水果
public static class YRdFruit implements Fruit{
private String name;
/**
* @return the name
*/
public String getName() {
return name;
}
/**
* @param name the name to set
*/
public void setName(String name) {
this.name = name;
}
public YRdFruit(String name){
System.out.println("种植热带水果"+name);
}
}

//亚热带蔬菜
public static class YRdVeggie implements Veggie{
private String name;

/**
* @return the name
*/
public String getName() {
return name;
}

/**
* @param name the name to set
*/
public void setName(String name) {
this.name = name;
}
public YRdVeggie(String name){
System.out.println("种植热带蔬菜"+name);
}

}

}