RE|GoF的23种设计模式-2

时间 2019-12-13

标签 gof 设计模式繁體版

原文原文链接

工厂模式

1. 简单工厂模式

定义：简单工厂模式（Simple Factory Pattern）是指由一个工厂对象决定建立出哪种产品类的实例，但它不属于 GOF，23 种设计模式。java

场景：简单工厂适用于工厂类负责建立的对象较少的场景，且客户端只须要传入工厂类的参数，对于如何创建对象的逻辑不须要关心。设计模式

举个例子：bash

/** * 图书的接口类 */
public interface IBook {
    public void see();
}

public static class BookA implements IBook {

    @Override
    public void see() {
        System.out.println("观看书~~~~ BookA");
    }
}

public static class BookB implements IBook {

    @Override
    public void see() {
        System.out.println("观看书~~~~ BookB");
    }
}

/** * 简单工厂 */
public static class SimpleFactory {
    public static IBook create(String name) {
        switch (name) {
            case "A":
                return new BookA();
            case "B":
                return new BookB();
            default:
                throw new NullPointerException();
        }
    }
}

public static void main(String[] args) {
    // 建立IBook对象解耦--不关注如何建立的
    SimpleFactory.create("A").see();
    SimpleFactory.create("B").see();
}

// 上面的简单工厂在每次新增图书后都须要手动修改代码。不符合开闭原则。
// 咱们对上面的代码进行升级，使用className加载

public static IBook create(String className) {
    try {
        return (IBook) Class.forName(className).newInstance();
    } catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
        e.printStackTrace();
    }
    throw new NullPointerException();
}

public static void main(String[] args) {
    // 建立IBook对象解耦--不关注如何建立的
    // 我测试的时候使用的是内部类所以为 $
    SimpleFactory.create("com.reape.design.pattern.factory.SimpleFactoryPattern$BookA").see();
    SimpleFactory.create("com.reape.design.pattern.factory.SimpleFactoryPattern$BookB").see();
}

// 使用className加载，传入的字符串很长，且还须要强制转换还能够提高
// 使用 Class 加载

public static IBook create(Class<? extends IBook> clazz) {
    try {
        return clazz.newInstance();
    } catch (InstantiationException | IllegalAccessException e) {
        e.printStackTrace();
    }
    throw new NullPointerException();
}

public static void main(String[] args) {
    // 建立IBook对象解耦--不关注如何建立的
    SimpleFactory.create(BookA.class).see();
    SimpleFactory.create(BookB.class).see();
}

复制代码

简单工厂的优势：解耦使用者和对个实例对象。ide

简单工厂的缺点：工厂类的职责相对太重，不易于扩展过于复杂的产品结构。测试

2. 工厂方法模式

定义：工厂方法模式（Fatory Method Pattern）是指定义一个建立对象的接口，但让实现这个接口的类来决定实例化哪一个类，工厂方法让类的实例化推迟到子类中进行。在工厂方法模式中用户只须要关心所需产品对应的工厂，无须关心建立细节，并且加入新的产品符合开闭原则。ui

场景：工厂方法适用于如下场景：spa

建立对象须要大量重复的代码。
客户端（应用层）不依赖于产品类实例如何被建立、实现等细节。
一个类经过其子类来指定建立哪一个对象。

/** * 图书的接口类 */
public interface IBook {
    public void see();
}

public static class BookA implements IBook {

    @Override
    public void see() {
        System.out.println("观看书~~~~ BookA");
    }
}

public static class BookB implements IBook {

    @Override
    public void see() {
        System.out.println("观看书~~~~ BookB");
    }
}

public interface IFactory {
    public IBook create();
}

/** * 简单工厂 */
public static class AFactory implements IFactory {
    @Override
    public IBook create() {
        return new BookA();
    }
}

public static class BFactory implements IFactory {
    @Override
    public IBook create() {
        return new BookB();
    }
}

public static void main(String[] args) {
    // 建立IBook对象解耦--不关注如何建立的
    new AFactory().create().see();
    new BFactory().create().see();
}

复制代码

工厂方法的优势：解耦使用者和对个实例对象。设计

工厂方法的缺点：一、类的个数容易过多，增长复杂度。二、增长了系统的抽象性和理解难度。code

3. 抽象工厂模式

定义：抽象工厂模式（Abstract Factory Pattern）是指提供一个建立一系列相关或相互依赖对象的接口，无须指定他们具体的类。客户端（应用层）不依赖于产品类实例如何被建立、实现等细节，强调的是一系列相关的产品对象（属于同一产品族）一块儿使用建立对象须要大量重复的代码。须要提供一个产品类的库，全部的产品以一样的接口出现，从而使客户端不依赖于具体实现。对象

场景：抽象工厂模式适用于如下场景：建立对象须要同时建立其余有关的对象。

举个例子：

public interface IBook {
    public void see();
}

public interface INote {
    public void see();
}

public static class ABook implements IBook {

    @Override
    public void see() {
        System.out.println("阅读了 A 书");
    }
}

public static class BBook implements IBook {

    @Override
    public void see() {
        System.out.println("阅读了 B 书");
    }
}

public static class ANote implements INote {

    @Override
    public void see() {
        System.out.println("阅读了 A 笔记");
    }
}

public static class BNote implements INote {

    @Override
    public void see() {
        System.out.println("阅读了 B 笔记");
    }
}


public interface IAbstractFactory {
    IBook createBook();
    INote createNote();
}

public static class AAbstractFactory implements IAbstractFactory {

    @Override
    public IBook createBook() {
        return new ABook();
    }

    @Override
    public INote createNote() {
        return new ANote();
    }
}

public static class BAbstractFactory implements IAbstractFactory {

    @Override
    public IBook createBook() {
        return new BBook();
    }

    @Override
    public INote createNote() {
        return new BNote();
    }
}


public static void main(String[] args) {
    // 建立IBook对象解耦--不关注如何建立的
    IAbstractFactory abstractFactory = new AAbstractFactory();
    abstractFactory.createBook().see();
    abstractFactory.createNote().see();
    abstractFactory = new BAbstractFactory();
    abstractFactory.createBook().see();
    abstractFactory.createNote().see();
}
复制代码

抽象工厂很是完美清晰地描述这样一层复杂的关系。可是，若是咱们再继续扩展产品等级，将练习题 也加入到A课程中，那么咱们的代码从抽象工厂，到具体工厂要所有调整，很显然不符合开闭原则。

所以抽象工厂也是有缺点的：

规定了全部可能被建立的产品集合，产品族中扩展新的产品困难，须要修改抽象工厂的接口。
增长了系统的抽象性和理解难度。

设计模式 ---> 工厂实战

待续...