工厂模式能够细分为：简略工厂、工厂办法和形象工厂三种模式

应用场景

总体而言工厂模式的应用场景分为两种：

  1. 单个对象的创立过程比较复杂，如须要做简单初始化操作的对象
  2. 须要依据不同的类型创立不同的对象

针对细分的三种模式，应用场景又能够辨别：

  1. 当对象的创立逻辑简略，通常只须要new一下就能够，此时能够思考简略工厂模式
  2. 当对象的创立逻辑很简单，须要做各种初始化操作，此时能够思考应用工厂办法模式，将对象创立的简单逻辑拆分到各个工厂类中，让每个工厂类都不至于过于简单
  3. 当零碎中有多于一个产品族，而每次只应用其中某一产品族，此时应用形象工厂模式

简略工厂模式

类图

ProcuctA和ProductB继承Product抽象类，ProductFactory依据传入的type来返回不同的Product实例

代码实现

Product

public abstract class Product {    public abstract void use();}

ProductA

public class ProductA extends Product {    @Override    public void use() {        System.out.println("You are using ProductA...");    }}

ProductB

public class ProductB extends Product {    @Override    public void use() {        System.out.println("You are using ProductB...");    }}

ProductFactory

public class ProductFactory {    public Product createProduct(String type) {        Product product = null;        if ("A".equals(type)) {            product = new ProductA();        } else if ("B".equals(type)) {            product = new ProductB();        }        return product;    }}

Main

public class Main {    public static void main(String[] args) {        ProductFactory factory = new ProductFactory();        Product product;        product = factory.createProduct("A");        product.use();        product = factory.createProduct("B");        product.use();    }}

点评

当频繁的新增不同产品时，须要频繁的批改ProductFactory中的if/else逻辑

利用

JDK

java.text.DateFormat#getDateInstance()java.text.DateFormat#getDateInstance(int)java.text.DateFormat#getDateInstance(int, java.util.Locale)

加密类，获取不同加密算法的密钥生成器:

KeyGenerator keyGen=KeyGenerator.getInstance("DESede");

工厂办法模式

类图

相比简略工厂，这种形式将ProductFactory定义为抽象类，而后创立不同的具体的ProductAFactory和ProductBFactory，在应用时决定创立那种工厂和对象，防止了if/else判断

代码实现

Product

public abstract class Product {    public abstract void use();}

ProductA

public class ProductA extends Product {    @Override    public void use() {        System.out.println("You are using ProductA...");    }}

ProductB

public class ProductB extends Product {    @Override    public void use() {        System.out.println("You are using ProductB...");    }}

ProductFactory

public abstract class ProductFactory {    public abstract Product createProduct();}

ProductAFactory

public class ProductAFactory extends ProductFactory {    @Override    public Product createProduct() {        return new ProductA();    }}

ProductBFactory

public class ProductBFactory extends ProductFactory {    @Override    public Product createProduct() {        return new ProductB();    }}

Main

public class Main {    public static void main(String[] args) {        ProductFactory factory;        Product product;        factory = new ProductAFactory();        product = factory.createProduct();        product.use();        factory = new ProductBFactory();        product = factory.createProduct();        product.use();    }}

点评

这种模式更加合乎开闭准则，然而与最原始的new ProductA()和new ProductA()相比十分类似，引入工厂模式，反倒让设计变得更加简单了。

利用

JDBC

Connection conn=DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/db1","db_user","123456");Statement statement=conn.createStatement();ResultSet rs=statement.executeQuery("select * from user");

形象工厂模式

为了了解形象工厂模式，咱们要先理解两个概念：

  • 产品等级构造 ：产品等级构造即产品的继承构造，如一个抽象类是电视机，其子类有海尔电视机、海信电视机、TCL电视机，则形象电视机与具体品牌的电视机之间形成了一个产品等级构造，形象电视机是父类，而具体品牌的电视机是其子类。
  • 产品族 ：在形象工厂模式中，产品族是指由同一个工厂生产的，位于不同产品等级构造中的一组产品，如海尔电器工厂生产的海尔电视机、海尔电冰箱，海尔电视机位于电视机产品等级构造中，海尔电冰箱位于电冰箱产品等级构造中。

在工厂办法模式中具体工厂负责生产具体的产品，每一个具体工厂对应一种具体产品。个别状况下，一个具体工厂中只有一个工厂办法或者一组重载的工厂办法。然而有时候咱们须要一个工厂能够提供多个产品对象，而不是繁多的产品对象。

类图

Factory1负责创立ProductA1和ProductB1
Factory2负责创立ProductA2和ProductB2
客户端不须要晓得具体的产品，只须要晓得创立的工厂即可应用该产品

代码实现

AbstractProductA

public abstract class AbstractProductA {    public abstract void use();}

ProductA1

public class ProductA1 extends AbstractProductA {    @Override    public void use() {        System.out.println("You are using ProductA1...");    }}

ProductA2

public class ProductA2 extends AbstractProductA {    @Override    public void use() {        System.out.println("You are using ProductA2...");    }}

AbstractProductB

public abstract class AbstractProductB {    public abstract void eat();}

ProductB1

public class ProductB1 extends AbstractProductB {    @Override    public void eat() {        System.out.println("You are eating ProductB1...");    }}

ProductB2

public class ProductB2 extends AbstractProductB {    @Override    public void eat() {        System.out.println("You are eating ProductB2...");    }}

AbstractFactory

public abstract class AbstractFactory {    public abstract AbstractProductA createProductA();    public abstract AbstractProductB createProductB();}

Factory1

public class Factory1 extends AbstractFactory {    @Override    public AbstractProductA createProductA() {        return new ProductA1();    }    @Override    public AbstractProductB createProductB() {        return new ProductB1();    }}

Factory2

public class Factory2 extends AbstractFactory {    @Override    public AbstractProductA createProductA() {        return new ProductA2();    }    @Override    public AbstractProductB createProductB() {        return new ProductB2();    }}

Main

public class Main {    public static void main(String[] args) {        AbstractFactory factory;                factory = new Factory1();        use(factory);        factory = new Factory2();        use(factory);    }    public static void use(AbstractFactory factory) {        AbstractProductA productA = factory.createProductA();        productA.use();        AbstractProductB productB = factory.createProductB();        productB.eat();    }}

点评

形象工厂模式带来了泛滥类，构造绝对简单，且创立新的产品等级构造麻烦。
形象工厂模式理论工作中利用场景很少，简略关注理解下即可