设计模式之工厂模式

Posted 2022-01-27 JKerving

工厂模式属于创建型模式，作用就是创建对象。我们最熟悉也是最简单的方式就是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();

        //....