Factory（工厂模式）和 Abstract Factory Pattern (抽象工厂模式)

Factory（工厂模式）

介绍

• 工厂模式：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。 是 Java 中最常用的设计模式之一，这种类型的设计模式属于创建型模式 。

优点：

• 一个调用者想创建一个对象，只要知道其名称就可以了
• 扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。
• 屏蔽产品的具体实现，调用者只关心产品的接口。

缺点：

• 每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

实现

1、创建一个接口

public interface Wearable {
    void wear();
}

2、 创建实现接口的实体类

public class Hat implements Wearable{
    @Override
    public void wear() {
        System.out.println("我带了一顶帽子.....");
    }
}

public class Jacket implements Wearable{
    @Override
    public void wear() {
        System.out.println("我穿了一件夹克.....");
    }
}

3、 创建一个工厂，生成基于给定信息的实体类的对象

public class WearFactory {
     public List<Wearable> wear(String ...classNames) {
         List<Wearable> list = new ArrayList<>();
         if (classNames!=null) {
             for (String className : classNames) {
                 if ("Hat".equals(className)) {
                     list.add(new Hat());
                 }
                 if ("Jacket".equals(className)) {
                     list.add(new Jacket());
                 }
             }
         }
         return list;
     }
}

4、 使用该工厂，通过传递类型信息来获取实体类的对象

public class FactoryMethodDemo {
    public static void main(String[] args) {
        WearFactory wearFactory = new WearFactory();
        List<Wearable> jacket = wearFactory.wear("Jacket","Hat");
        for (Wearable wearable : jacket) {
            wearable.wear();
        }
    }
}

Abstract Factory Pattern (抽象工厂模式)

介绍

• 抽象工厂模式：是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。 提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

优点：

• 当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

缺点：

• 产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 里加代码，又要在具体的里面加代码。

实现

• 抽象工厂其实有4个角色：抽象工厂、抽象产品、具体工厂、具体产品
  

1、为颜色创建一个抽象类

public abstract class ColourFactory {
    abstract void getColour();
}

2、创建继承抽象类的实体类

public class Green extends ColourFactory {
    @Override
    void getColour() {
        System.out.println("这是绿色...");
    }
}

public class Red extends ColourFactory {
    @Override
    void getColour() {
        System.out.println("这是红色...");
    }
}

3、为衣服创建一个抽象类

public abstract class ClothesFactory {
    abstract void getClothes();
}

4、 创建继承抽象类的实体类

public class Hat extends ClothesFactory {
    @Override
    void getClothes() {
        System.out.println("我戴了一顶帽子....");
    }
}

public class Jacket extends ClothesFactory {
    @Override
    void getClothes() {
        System.out.println("我穿了一件夹克.....");
    }
}

5、 为 颜色 和 衣服 对象创建抽象类来获取工厂

public abstract class AbstractFactory {
    abstract ClothesFactory getClothes(String clothe);
    abstract ColourFactory getColour(String colour);
}

6、 创建继承了 AbstractFactory 的工厂类，基于给定的信息生成实体类的对象

public class AbstractProduct extends AbstractFactory{
    @Override
    ClothesFactory getClothes(String clothe) {
        if (!"".equals(clothe) && clothe != null) {
            if ("Jacket".equals(clothe)) {
                return new Jacket();
            }
            if ("Hat".equals(clothe)) {
                return new Hat();
            }
        }
        return null;
    }

    @Override
    ColourFactory getColour(String colour) {
        if (!"".equals(colour) && colour != null) {
            if ("Red".equals(colour)) {
                return new Red();
            }
            if ("Green".equals(colour)) {
                return new Green();
            }
        }
        return null;
    }
}

7、 使用 FactoryProducer 来获取 AbstractFactory，通过传递类型信息来获取实体类的对象。

public class AbstractFactoryDemo {
    public static void main(String[] args) {
        AbstractFactory product = new AbstractProduct();
        ClothesFactory hat = product.getClothes("Hat");
        hat.getClothes();
        ColourFactory red = product.getColour("Red");
        red.getColour();
    }
}