工厂模式是一种创建性模式,提供的就是一种创建对象的方式,解决的就是用户和产品之间的问题,隐藏生产产品的实现细节,用户只需要关心最后的结果。官方的定义是:定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。
下面利用穷举法举几个例子:
1.用户去汽车工厂买汽车,需要什么汽车买什么汽车,不用只要汽车的生产细节。
2.咱们hibernate里面配置数据库选择方言,配置什么方法就出现什么数据库，隐藏了实现细节。
3.咱们去小时买牛奶,选什么牌子买什么牌子,不用知道牛奶怎么生产的。
简单工厂
package pattern.factory;
public interface Milk {
public String getName();
}
package pattern.factory;
public class MengNiu
implements Milk {
@Override
public String getName() {
return "蒙牛"
;
}
}
package pattern.factory;
public class TeLunSu
implements Milk {
@Override
public String getName() {
return "特仑苏"
;
}
}
package pattern.factory;
public class YiLi
implements Milk {
@Override
public String getName() {
return "伊利"
;
}
}
import pattern.factory.TeLunSu;
import pattern.factory.YiLi;
public class SimpleFactory {
public Milk getMilk(String name){
Milk milk=
null;
if("特仑苏"
.equals(name)){
milk=
new TeLunSu();
}
if("蒙牛"
.equals(name)){
milk=
new MengNiu();
}
if("伊利"
.equals(name)){
milk=
new YiLi();
}
return milk;
}
}
package pattern.factory.simple;
public class SimpleFactoryTest {
public static void main(String[] args) {
//把用户的需要的产品告诉工厂
//主要是隐藏产品的创建过程,用户无需知道牛奶的创建过程
SimpleFactory simpleFactory=
new SimpleFactory();
System.out.println(simpleFactory.getMilk("特仑苏"
));
}
}
简单工厂通过代码看上去其实想一个小作坊的模式,什么产品的牛奶都有,分工不是很明确,所有的产品共用一个工厂,而且方法需要一个参数手动的输入,增加了出错的概率。
工厂方法
public class MengNiuFactory
implements Factory {
@Override
public Milk getMilk() {
return new MengNiu();
}
}
package pattern.factory.func;
import pattern.factory.Milk;
import pattern.factory.TeLunSu;
public class TeLunSuFactory
implements Factory {
@Override
public Milk getMilk() {
return new TeLunSu();
}
}
package pattern.factory.func;
import pattern.factory.Milk;
import pattern.factory.YiLi;
public class YiLiFactory
implements Factory {
@Override
public Milk getMilk() {
return new YiLi();
}
}
package pattern.factory.func;
import pattern.factory.Milk;
public interface Factory {
public Milk getMilk();
}
package pattern.factory.func;
public class FactoryTest {
public static void main(String[] args) {
Factory factory=
new MengNiuFactory();
System.out.println(factory.getMilk());
}
}
工厂方法像是工厂式的模式生产,一个产品对应一个工厂然后进行组装,这个比较规范,可以进行批量标准化规模化的生产,不过也可以看出用户选择产品有点不方便。
抽象工厂
package pattern.factory.abstr;
import pattern.factory.Milk;
public abstract class AbstractFactory {
public abstract Milk getTeLunSu();
public abstract Milk getYiLi();
public abstract Milk getMengNiu();
}
package pattern.factory.abstr;
import pattern.factory.Milk;
import pattern.factory.func.MengNiuFactory;
import pattern.factory.func.TeLunSuFactory;
import pattern.factory.func.YiLiFactory;
public class MilkFactory
extends AbstractFactory {
@Override
public Milk getTeLunSu() {
return new TeLunSuFactory().getMilk();
}
@Override
public Milk getYiLi() {
return new YiLiFactory().getMilk();
}
@Override
public Milk getMengNiu() {
return new MengNiuFactory().getMilk();
}
}
package pattern.factory.abstr;
public class AbstractFactoryTest {
public static void main(String[] args) {
AbstractFactory abstractFactory=
new MilkFactory();
abstractFactory.getMengNiu();
}
}
个人感觉抽象工厂和工厂方法其实很像,但是它在工厂方法的基础上进行了再次封装,灵活性更好,用户可以随便选取自己想要的产品,同时也体现了代码的扩展性,抽象工厂的好处也比接口要好,因为抽象类里面可以处理一下都可以用到的逻辑代码,写一些方法,看着有点像流水线的模式,一条线生产一个产品。
转载于:https://www.cnblogs.com/cleveraboy/p/9734853.html
相关资源：java设计模式精讲 Debug 方式+内存分析
