从头开始学Java架构之设计模式1：工厂模式详解

工厂模式-就是把创建过程隐藏起来，只把产品展示给客户使用的模式。

主要分为1.简单工厂模式 、2.工厂模式和3.抽象工厂模式，随着简单工厂到抽象工厂，复杂度越来越高，分工越来越细致，到最后的抽象工厂模式，就不再需要客户传递参数，只给他们选择权，减少出错，符合开闭原则。

一.简单工厂模式：

需要用户传递一个参数，简单工厂再根据这个参数来返回对应的对象！

代码案例：

定义一个抽象产品角色(以牛奶为例)：

public interface Milk {
    public String getName();

}

再定义几个具体的产品角色去实现上面定义的接口(特仑苏、蒙牛和伊利产品)：

public class Telunsu implements Milk{
    public String getName(){
        return "特仑苏";
    }

}

public class Mengniu implements Milk{
    public String getName(){
        return "蒙牛";
    }

}

public class Yili implements Milk{
    public String getName(){
        return "伊利";
    }

}

定义一个简单工厂类，里面进行逻辑判断：

public class SimpleFactory {
    public Milk getMilk(String name){
        if("特仑苏".equals(name)){
            return new Telunsu();
        }
        return null;
    }

}

这样，我们就能通过new一个简单工厂的对象，来传递一个参数(比如“特仑苏”)，来获得Telunsu的一个对象了：

public class Test {
    public static void main(String[] args){
        SimpleFactory factory = new SimpleFactory();
        System.out.println(factory.getMilk("特仑苏"));
    }

}

以上就是简单工厂模式的一个简单实现。

 

二.工厂模式：

工厂模式比简单工厂更进一步，它不再需要用户给它传入参数了，但是，要根据不同的牛奶品牌去建立不同的工厂！

代码案例：

先建立一个抽象工厂接口：

public interface Factory {
    Milk getMilk();

}

 

建立一个“特仑苏”工厂，去实现上面的接口：

public class TelunsuFactory implements Factory{
    public Milk getMilk(){
        return new Telunsu();
    }

}

同理，依次建立“蒙牛”工厂和“伊利”工厂：

public class MengniuFactory implements Factory{
    public Milk getMilk(){
        return new Mengniu();
    }

}

public class YiliFactory implements Factory{
    public Milk getMilk(){
        return new Yili();
    }

}

那么，在调用的时候，只需要new一个相关产品工厂的对象，再通过这个对象调用对应 类里的方法就可以获得对应的产品对象了(以MengniuFactory为例)：

public class FactoryTest {
    public static void main(String[] args){
        Factory factory = new MengniuFactory();
        System.out.println(factory.getMilk());
    }

}

以上就是工厂模式的一个简单实现。

 

三.抽象工厂模式：

工厂模式每次增加一个品牌，就要建立对应的工厂，这样会增加代码的复杂度，不利于代码的课重用性，而抽象类工厂则比工厂模式更近一步，它直接创建一个总的MilkFactory，里面可以生产所有牛奶品牌的对象，这样就避免了每次都有单独创建一个工厂了。

代码案例：

先创建一个抽象类工厂，里面定义了几个抽象方法：

public abstract class AbstractFactory {
    public abstract Milk getMengniu();
    public abstract Milk getYili();
    public abstract Milk getTelunsu();

}

再定义一个MilkFactory去实现这个抽象工厂，并实现里面的抽象方法：

public class MilkFactory extends AbstractFactory{
    Factory mengniu = new MengniuFactory();
    Factory yili = new YiliFactory();
    Factory telunsu = new TelunsuFactory();
    
    public Milk getMengniu(){
        return mengniu.getMilk();
    }
    
    public Milk getYili(){
        return yili.getMilk();
    }
    
    public Milk getTelunsu(){
        return telunsu.getMilk();
    }

}

这样，在调用的时候，直接New一个MilkFactory的对象，调用里面的方法，就能返回用户想要的对象了(以蒙牛为例)：

public class AbstractFactoryTest{
    public static void main(String[] args){
        MilkFactory factory = new MilkFactory();
        System.out.println(factory.getMengniu());
    }

}

这样，通过抽象类工厂，在修改逻辑的时候，用户就不用修改自己的代码了。