工厂模式精讲

工厂模式是一种创建性模式,提供的就是一种创建对象的方式,解决的就是用户和产品之间的问题,隐藏生产产品的实现细节,用户只需要关心最后的结果。官方的定义是:定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

下面利用穷举法举几个例子:

 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();
    }
}

个人感觉抽象工厂和工厂方法其实很像,但是它在工厂方法的基础上进行了再次封装,灵活性更好,用户可以随便选取自己想要的产品,同时也体现了代码的扩展性,抽象工厂的好处也比接口要好,因为抽象类里面可以处理一下都可以用到的逻辑代码,写一些方法,看着有点像流水线的模式,一条线生产一个产品。