设计模式——工厂模式

一、介绍

工厂模式属于创建型模式，它是为创建对象提供接口的，提供了一种创建对象的最佳方式，在创建对象时不会对客户端暴露创建逻辑，并且通过使用一个共同的接口来指向新创建的对象。

二、工厂模式的分类

    1：简单工厂模式

      简单工厂模式又叫静态工厂方法模式，通过专门定义一个类来负责创建其他类的实例。

      在该模式中有三个角色：

            工厂角色：该角色是简单工厂模式的核心，它负责创建的逻辑，可以直接被外部调用。

            抽象角色：所要创建对象的父类，是实例的共有接口。

            具体产品角色：所创建的实例

        我们以牛奶举例，代码如下：

/**
 * 抽象角色
 */
public interface Milk {

}

/**
 * 具体产品角色
 */
public class Mengniu implements Milk {

}

/**
 * 具体产品角色
 */
public class Telunsu implements Milk {

}

/**
 * 具体产品角色
 */
public class Telunsu implements Milk {

}

/**
 * 工厂角色
 */
public class SimpleFactory {
    public Milk getMilk(String name){
        if("蒙牛".equals(name)){
            return new Mengniu();
        }else if("伊利".equals(name)){
            return new Yili();
        }else if("特仑苏".equals(name)){
            return new Telunsu();
        }else{
            return null;
        }
    }
}

/**
 * 测试
 */
public class MilkTest {
    @Test
    public void SimpleFactoryTest(){
        SimpleFactory simpleFactory = new SimpleFactory();
        Milk milk = simpleFactory.getMilk("伊利");
        System.out.println(milk);
    }
}

这就是简单工厂模式了，当以后有新的的牛奶需要生产时直接添加新类，修改工厂角色的逻辑即可，但是这样做并不好，因为工厂角色违反了开闭原则（扩展开放，修改关闭），每添加一个新产品，工厂角色都需要修改逻辑，所以就有了工厂方法模式。

 

    2：工厂方法模式

工厂方法模式又被称为多态工厂模式，通过定义一个创建产品对象的接口，将实际的创建工作在它的子类中完成，核心工厂不在负责产检产品，这样当添加新产品时不必修改核心工厂，只需要添加子工厂即可完成。

在该模式中它有四个角色：

抽象工厂角色：该角色是工厂方法模式的核心，所有的工厂类都必须实现该工厂。

具体工厂角色：该角色是抽象工厂的实现类，负责实例化产品对象。

 

抽象角色：所要创建对象的父类，是实例的共有接口。

        具体产品角色：所创建的实例。

同样以牛奶举例，代码如下（抽象角色和具体产品角色是一样的所以就不再贴出代码）：

/**
 * 抽象工厂
 */
public interface MilkFactory {
    public Milk getMilk();
}

 

/**
 * 具体工厂角色
 */
public class MengniuFactory implements MilkFactory{
    @Override
    public Milk getMilk() {
        return new Mengniu();
    }
}

/**
 * 具体工厂角色
 */
public class MengniuFactory implements MilkFactory{
    @Override
    public Milk getMilk() {
        return new Mengniu();
    }
}

/**
 * 具体工厂角色
 */
public class MengniuFactory implements MilkFactory{
    @Override
    public Milk getMilk() {
        return new Mengniu();
    }
}

    /**
     * 测试
     */
    @Test
    public void FactoryMethodTest(){
        MilkFactory milkFactory = new MengniuFactory();
        Milk milk = milkFactory.getMilk();
        System.out.println(milk);
    }

 

这就是工厂方法模式了，需要什么产品就调用哪个产品的工厂，当添加新产品时只需要添加该产品和该产品的工厂类即可。

 

    3：抽象工厂模式

抽象工厂模式通过像客户端提供一个接口，使得客户端不必在指定产品的具体类型，就可以创建多个产品。

它和工厂方法模式一样，拥有相同的四个角色。

同样以牛奶举例（抽象产品角色，具体产品角色的代码一样就不再贴出代码）：

/**
 * 抽象工厂
 */
public interface AbstractFactory {
    public Milk getMengniu();
    public Milk getYili();
    public Milk getTelunsu();
}

/**
 * 具体工厂
 */
public class abstractFactoryImpl implements AbstractFactory {
    @Override
    public Milk getMengniu() {
        MengniuFactory mengniuFactory = new MengniuFactory();
        Milk milk = mengniuFactory.getMilk();
        return milk;
    }

    @Override
    public Milk getYili() {
        YiliFactory yiliFactory = new YiliFactory();
        Milk milk = yiliFactory.getMilk();
        return milk;
    }

    @Override
    public Milk getTelunsu() {
        TelunsuFactory telunsuFactory = new TelunsuFactory();
        Milk milk = telunsuFactory.getMilk();
        return milk;
    }
}

    /**
     * 测试
     */
    @Test
    public void abstractFactoryTest(){
        AbstractFactory abstractFactory = new abstractFactoryImpl();
        Milk milk = abstractFactory.getTelunsu();
        System.out.println(milk);
    }

这就是抽象工厂模式了，用户不需要指定类型，就可以创建多个产品。

 

三、总结

无论是简单工厂模式、工厂方法模式还是抽象工厂模式它们都是工厂模式，他们最终的目的都是为了解耦，所以在使用时不必在意属于哪一类，只需要在意的是解耦的目的达到即可。