软件设计的要点是高内聚低耦合，而工厂模式则满足了这个要求，工厂模式分为三种：简单工厂模式（静态工厂类），工厂方法模式，抽象工厂模式。先上代码
简单工厂模式
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实现接口方法
很简单的一个道理，不用工厂模式意味着我们吃饭要自己做，简单工厂模式是工厂给你做，你要做菜则调用工厂做菜方法，要做米饭调用工厂做米饭方法，工厂方法模式则是分多个工厂，做菜的工厂和做饭的工厂，调用统一的做接口。做饭和做菜两个工厂实现做的方法，要做饭则实例化做饭工厂，要做菜则实例化做菜工厂。所工厂方法模式耦合度更低。
抽象工厂模式
抽象工厂模式和工厂方法模式类似，区别在于
工厂方法模式：一个抽象产品类，可以派生出多个具体产品类。一个抽象工厂类，可以派生出多个具体工厂类。每个具体工厂类只能创建一个具体产品类的实例。
抽象工厂模式：多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。一个抽象工厂类，可以派生出多个具体工厂类。每个具体工厂类可以创建多个具体产品类的实例。