设计模式——工厂模式

面向对象设计的基本原则：

开闭原则：不断扩展，对修改关闭

依赖倒置：依赖于抽象而不依赖于实体

迪米特LoD：尽量少的依赖其他类，实现类与类之间的解耦

简单工厂

（me）用一个工厂来创建对象，用户只需知晓   所需要创建的对象    和     工厂对象 ，不需要了解所需要创建的对象是如何创建（new 的过程就是创建的方式）。工厂负责对象的创建方式（how create）。好处：当需要创建的对象很多时，用户可以不用知道这些对象的创建方法，减少联系。

例子：

场景：用户需要创建productA，productB两个产品，‘

public interface Product {
    void name();
}

public class ProductA implements Product {
    @Override
    public void name() {
        System.out.print("this is A");
    }
}

public class ProductB implements Product {
    @Override
    public void name() {
        System.out.printf("this is B");
    }
}

’工厂------调用create方法帮助创造，工厂完成产品如何new

public class ProductFactory {
    public static Product createA() {
        return new ProductA();
    }

    public static Product createB() {
        return new ProductB();
    }
}

用户------只需要知道何种产品和创建产品的工厂即可

public class Client {
    public static void main(String[] args) {
        Product product1 = ProductFactory.createA();
        Product product2 = ProductFactory.createB();
        product1.name();
        product2.name();
    }
}

工厂方法

如果新增了ProductC需要创建，但此时如果还是用简单工厂模式，则需要修改ProductFactory，不符合开闭原则。

工厂方法模式——创建对象工厂

新增ProductC

public class FactoryC implements Factory{
    @Override
    public Product create() {
        return new ProductC();
    }
}

工厂接口

public interface Factory {
    Product create();
}

工厂实现类

public class FactoryA implements Factory{
    @Override
    public Product create() {
        return new ProductA();
    }
}


public class FactoryB implements Factory{
    @Override
    public Product create() {
        return new ProductB();
    }
}


public class FactoryC implements Factory{
    @Override
    public Product create() {
        return new ProductC();
    }
}

用户实现

public class Client {
    public static void main(String[] args) {
        Factory factory;
        factory = new FactoryA();
        factory.create().name();
        factory = new FactoryB();
        factory.create().name();
        factory = new FactoryC();
        factory.create().name();
    }
}

无论加多少产品类，都不用修改原来类中的代码，而是通过增加工厂类来实现。

但是这还是有缺点的，如果产品类过多，我们就要生成很多的工厂类。假如我们要实现的产品接口不止一个，也就是有多个产品接口，不同产品接口有对应的产品族

 

抽象工厂

不可以增加产品，可以增加产品族

Add和Product是factory需要创造的两个产品

public interface Add {
    void type() ;
}

public class AddC implements Add {
    @Override
    public void type() {
        System.out.println("typec");
    }
}

public class AddD implements Add {
    @Override
    public void type() {
        System.out.println("typeD");
    }
}

/**
 * 该工厂要求productA和AddD配
 */
public class Factory1 implements Factory{
    @Override
    public Product createProduct() {
        return new ProductA();
    }

    @Override
    public Add createAdd() {
        return new AddD();
    }
}


/**
 * 该工厂要求productB和AddC配
 */
public class Factory2 implements Factory{
    @Override
    public Product createProduct() {
        return new ProductB();
    }

    @Override
    public Add createAdd() {
        return new AddC();
    }
}



public class Client {
    public static void main(String[] args) {
        Factory factory;
        factory = new Factory1();
        factory.createProduct().name();
        factory.createAdd().type();
        factory = new Factory2();
        factory.createProduct().name();
        factory.createAdd().type();
    }
}

在这里：有一个疑问，对比工厂模式和抽象工厂的代码，感觉两者之间没有什么区别，如果在工厂模式的Factory类里新建一个方法创建add对象不就和抽象工厂实现的功能一样了？

思考ing........

可能是例子举得不好。。。。。

工厂模式创建的factory只能创建product，就好比，生产周黑鸭的工厂只能产周黑鸭，不能既产周黑鸭也生产热干面

若你想要既产周黑鸭又产热干面要怎么办呢？ 那就用抽象工厂模式，开一家武汉特产工厂，里面有N条生产线，可以生产N种特产。（如上文提及的抽象工厂可以创建Product和Add）

一句话总结：工厂模式和抽象工厂看上去相似，但是Factory的等级不一样，因此不能混为一谈！