java设计模式----工厂模式

软件设计的要点是高内聚低耦合，而工厂模式则满足了这个要求，工厂模式分为三种：简单工厂模式（静态工厂类），工厂方法模式，抽象工厂模式。先上代码

简单工厂模式

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

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

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

新建一个接口：

package factory;

public interface Interface {
public void operate();

}

再建两个实现类：

package factory;

public class Impl implements Interface{

@Override
public void operate() {
System.out.println("实现接口方法");
}

}

package factory;

public class Impl1 implements Interface{

@Override
public void operate() {
System.out.println("Impl1实现接口方法");
}

}

工厂类：

package factory;

/**
* 工厂方法
* @author mercy
*
*/
public class Factory {

private Interface in;
　　　　　private Interface in1;
public Interface getInterface() {
if (in == null) {// 如果不存在则创建实例
in = new Impl();
}
return in;
}
public Interface getInterface1() {
if (in1 == null) {// 如果不存在则创建实例
in1= new Impl1();
}
return in1;
}
}

测试下：

package factory;

/**工厂模式
* @author mercy
*
*/
public class Test {
public static void main(String[] args) {
Factory f=new Factory();//创建工厂实例
Interface in=f.getInterface();//通过工厂方法获取Impl实例
in.operate();
　　　　　　　　　 Interface in1=f.getInterface();//通过工厂方法获取Impl实例
in1.operate();
}

}

结果：

实现接口方法
impl1实现接口方法

这样看工厂模式的优点是实现接口编程.而如果再新建几个接口的实现类，则如果按照正常方法，需要多新建几个对象的实例

package factory;

public class badTest{
public static void main(String[] args) {
Interface i=new Impl();
i.operate();
　　　　　　　　　 Interface i1=new Impl1();
　　　　　　　　　 i1.operate();

}

}

这样的话实现与接口直接通信，根据DIP原则，要针对接口编程，而不是针对实现编程。这样不用把具体的类暴露给客户端，客户端直接调工厂实例的方法即可。

看看工厂方法模式，只需要写一个相同的工厂类接口，再添加具体的工厂实现类

1）抽象工厂类：具体工厂类的抽象类。

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

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

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

抽象工厂类

package factory;

public interface Fac {
public Interface getInterface();

}

具体工厂类1

package factory;

public class Factory1 implements Fac{
private Interface in;
public 	Interface getInterface() {
if (in == null) {//如果不存在则创建实例
in = new Impl();
}
return in;
}
}

具体工厂类2

package factory;

public class Factory2 implements Fac{
private Interface in;
@Override
public Interface getInterface() {

if (in == null) {//如果不存在则创建实例
in = new Impl1();
}
return in;
}

}

测试下：

package factory;

/**工厂模式
* @author mercy
*
*/
public class Test {

public static void main(String[] args) {
/*简单工厂模式*/
Factory f=new Factory();//创建工厂实例
Interface in=f.getInterface();//通过工厂方法获取Impl实例
in.operate();
Interface in1=f.getInterface1();
in1.operate();
/*工厂方法模式,比简单工厂模式更降低耦合度，只需要调不同的工厂方法，保持工厂接口方法不变*/
Fac ff=new Factory1();
Interface i=ff.getInterface();//获取impl的实例
i.operate();
Fac ff1=new Factory2();
Interface i1=ff1.getInterface();//获取impl的实例
i1.operate();
}

}

结果：

Impl1实现接口方法
实现接口方法
Impl1实现接口方法

很简单的一个道理，不用工厂模式意味着我们吃饭要自己做，简单工厂模式是工厂给你做，你要做菜则调用工厂做菜方法，要做米饭调用工厂做米饭方法，工厂方法模式则是分多个工厂，做菜的工厂和做饭的工厂，调用统一的做接口。做饭和做菜两个工厂实现做的方法，要做饭则实例化做饭工厂，要做菜则实例化做菜工厂。所工厂方法模式耦合度更低。

抽象工厂模式

抽象工厂模式和工厂方法模式类似，区别在于

工厂方法模式：一个抽象产品类，可以派生出多个具体产品类。一个抽象工厂类，可以派生出多个具体工厂类。每个具体工厂类只能创建一个具体产品类的实例。

抽象工厂模式：多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。一个抽象工厂类，可以派生出多个具体工厂类。每个具体工厂类可以创建多个具体产品类的实例。