设计模式之工厂模式

工厂模式属于创建型模式，作用就是创建对象。我们最熟悉也是最简单的方式就是new一个对象，然后set相关属性，但是这种方式耦合性太强，对于后期业务快速发展及代码的维护十分不友好，因此我们需要给客户端提供更加友好的创建对象的方式。

简单工厂模式

public class FoodFactory {

    public static Food makeFood(String name) {
        if (name.equals("noodle")) {
            Food noodle = new LanZhouNoodle();
            noodle.addSpicy("more");
            return noodle;
        } else if (name.equals("chicken")) {
            Food chicken = new HuangMenChicken();
            chicken.addCondiment("potato");
            return chicken;
        } else {
            return null;
        }
    }
}

简单工厂模式对对象创建管理方式最为简单，因为其仅仅简单的对不同类对象的创建进行了一层简单的封装。一个工厂类XxxFactory，里面有一个静态方法，根据不同的参数，返回不同的派生来自同一个父类(或者同一接口)的实例对象。
​

工厂方法模式

简单工厂模式很简单，之所以要进入工厂模式，是因为我们往往需要使用两个或两个以上的工厂。工厂方法模式将生成具体食物的任务分发给具体的食物工厂。

public interface FoodFactory {
    Food makeFood(String name);
}
public class ChineseFoodFactory implements FoodFactory {

    @Override
    public Food makeFood(String name) {
        if (name.equals("A")) {
            return new ChineseFoodA();
        } else if (name.equals("B")) {
            return new ChineseFoodB();
        } else {
            return null;
        }
    }
}
public class AmericanFoodFactory implements FoodFactory {

    @Override
    public Food makeFood(String name) {
        if (name.equals("A")) {
            return new AmericanFoodA();
        } else if (name.equals("B")) {
            return new AmericanFoodB();
        } else {
            return null;
        }
    }
}

client端调用

public class client {
    public static void main(String[] args) {
        // 先选择一个具体的工厂
        FoodFactory factory = new ChineseFoodFactory();
        // 由第一步的工厂产生具体的对象，不同的工厂造出不一样的对象
        Food food = factory.makeFood("A");
    }
}

抽象工厂模式

抽象工厂其实就是多个工厂方法模式。在有多个业务品种，业务分类时，通过抽象工厂模式生产需要的对象是一种非常好的解决方式。下面是抽象工厂模式的通用代码示意：

1. AbstracFactory类

下面的代码是一个抽象工厂类，它的职责是定义每个工厂要实现的功能，有n个产品族，在抽象工厂类中就应该有n个创建方法。

public abstract class AbstractFactory {
 
     //创建A产品家族
     public abstract AbstractProductA createProductA();
     //创建B产品家族
     public abstract AbstractProductB createProductB();
     
}

2. AbstractProduct类

抽象产品类，两个抽象产品类可以有关系，例如共同继承或实现一个抽象类或接口。

public abstract class AbstractProductA {

    //每个产品共有的方法
    public void shareMethod() {}
    //每个产品相同方法，不同实现
    public abstract void doSomething();

}

3. ConcreteFactory类

具体工厂实现类，如何创建一个产品是由具体的实现类来完成的。

public class ConcreteFactory1 extends AbstractFactory {

    @Override
    public AbstractProductA createProductA() {
        return new ProductA1();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ProductB1();
    }

}

4. ConcreteProduct类

public class ProductA1 extends AbstractProductA {

    @Override
    public void doSomething() {
        System.out.println("产品A1实现方法");
    }

}

public class ProductA2 extends AbstractProductA {

     @Override
     public void doSomething() {
         System.out.println("产品A2实现方法");
     }

 }

5. client端调用

在客户端中，没有任何一个方法与实现类有关系，对于一个产品来说，我们只需要知道它的工厂方法就可以直接生产一个产品对象，没必要关心它的实现类。

public class Client {

    public static void main(String[] args) {
        //定义两个工厂
        AbstractFactory factory1 = new ConcreteFactory1();
        AbstractFactory factory2 = new ConcreteFactory2();

        //产生A1对象
        AbstractProductA a1 = new ProductA1();
        //产生A2对象
        AbstractProductA a2 = new ProductA2();
        //产生B1对象
        AbstractProductB b1 = new ProductB1();
        //产生B2对象
        AbstractProductB b2 = new ProductB2();

        //....
    }

}