• 工厂模式：定义了一个创建对象的接口，但由子类决定要实例化的类是哪个，工厂方法让类把实例化推迟到子类。
• 所有的工厂模式都用来封装对象的创建，工厂方法模式通过让子类决定该创建的对象是什么来达到将对象创建的过程和封装的目的。
• 在简单工厂中，创建对象的是另一个类，而在工厂方法中，是由子类来创建对象。
• 简单工厂不是真正的设计模式，但是也是一种简单的方法用来将客户程序从具体类中解耦。
• 工厂方法使用继承，把对象的创建委托给子类，子类实现工厂方法来创建对象。
• 抽象工厂模式：提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。
• 抽象工厂使用对象组合，对象的创建被是现在工厂接口所暴露出来的方法中。

设计原则

依赖倒置原则:
要依赖抽象，不要依赖具体类
指导方针：

• 变量不可以持有具体类的引用
• 不要让类派生自具体类
• 不要覆盖基类中已经实现的方法
  上述这些基本方针需要我们尽量遵守，并不是一定遵守

实例

抽象工厂模式

1525915392(1).jpg

抽象工厂模式创建的是对象家族，也就是很多对象而不是一个对象，并且这些对象是相关的，也就是说必须一起创建出来。而工厂模式只是用于创建一个对象，这和抽象工厂模式有很大不同。

抽象工厂模式用到了工厂模式来创建单一对象，AbstractFactory 中的 createProductA 和 createProductB 方法都是让子类来实现，这两个方法单独来看就是在创建一个对象，这符合工厂模式的定义。

至于创建对象的家族这一概念是在 Client 体现，Client 要通过 AbstractFactory 同时调用两个方法来创建出两个对象，在这里这两个对象就有很大的相关性，Client 需要同时创建出这两个对象。

从高层次来看，抽象工厂使用了组合，即 Cilent 组合了 AbstractFactory，而工厂模式使用了继承。

public class AbstractProductA {
}
public class AbstractProductB {
}
public class ProductA1 extends AbstractProductA {
}
public class ProductA2 extends AbstractProductA {
}
public class ProductB1 extends AbstractProductB {
}
public class ProductB2 extends AbstractProductB {
}
public abstract class AbstractFactory {
    abstract AbstractProductA createProductA();
    abstract AbstractProductB createProductB();
}
public class ConcreteFactory1 extends AbstractFactory {
    AbstractProductA createProductA() {
        return new ProductA1();
    }

    AbstractProductB createProductB() {
        return new ProductB1();
    }
}
public class ConcreteFactory2 extends AbstractFactory {
    AbstractProductA createProductA() {
        return new ProductA2();
    }

    AbstractProductB createProductB() {
        return new ProductB2();
    }
}
public class Client {
    public static void main(String[] args) {
        AbstractFactory abstractFactory = new ConcreteFactory1();
        AbstractProductA productA = abstractFactory.createProductA();
        abstractFactory = new ConcreteFactory2();
        productA = abstractFactory.createProductA();
    }
}

工厂模式

1525915529(1).jpg

上图中，Factory 有一个 doSomethind() 方法，这个方法需要用到一组产品对象，这组产品对象由 factoryMethod() 方法创建。该方法是抽象的，需要由子类去实现。

public abstract class Factory {
    abstract public Product factoryMethod();
    public void doSomething() {
        Product product = factoryMethod();
        // do something with the product
    }
}
public class ConcreteFactory extends Factory {
    public Product factoryMethod() {
        return new ConcreteProduct();
    }
}
public class ConcreteFactory1 extends Factory {
    public Product factoryMethod() {
        return new ConcreteProduct1();
    }
}
public class ConcreteFactory2 extends Factory {
    public Product factoryMethod() {
        return new ConcreteProduct2();
    }
}