GOF23--创建型模式

设计模式GOF23 (Group of Four)

创建型模式：单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式

结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式

行为型模式：模板方式模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式

创建型模式：以后用到最多的是单例模式、简单工厂模式、原型模式。

创建型模型是用来帮助你创建对象的

一、单例模式

核心作用：保证一个类只有一个实例，并且提供一个访问该实例的全局访问点

常见的五种单例模式实现方式：

主要：饿汉式(线程安全，调用效率高。但是不能延时加载)

懒汉式(线程安全，调用效率不高。但是可以延时加载)

其他：双重检测锁式，静态内部类式，枚举单例

饿汉式，私有化构造器，类初始化时加载对象，生成getter方法(不需要同步)

public class Demo1{
    //类初始化时，立即加载这个对象
    //由于加载类时，天然的是线程安全的
    private static Demo1 instance = new Demo1();

    private Demo1() {
    }

    //方法不需要同步synchronized，效率高
    public static Demo1 getInstance() {
        return instance;
    }
}

懒汉式，私有化构造器，类初始化时不初始化对象，需要调用时才创建对象

public class Demo1{
    private static Demo1 instance;

    private Demo1() {
    }

    //方法需要同步synchronized，效率低
    public static synchronized Demo1 getInstance() {
        //等到需要用对象的时候，才去new，延时加载!
        if (instance == null) {
            instance = new Demo1();
        }
        return instance;
    }
}

静态内部类式，兼并了并发高效调用和延迟加载的优势

public class Demo1{
    //只有真正调用了getInstace方法，才会加载静态内部类的内容
    //实现了延时加载
    private static class Demo2 {
        //令该对象是static final类型，保证了内存中只有这样一个实例存在，从而保证了线程安全性
        private static final Demo1 instance = new Demo1();
    }

    public static Demo1 getInstance() {
        return Demo2.instance;
    }

    private Demo1() {
    }
}

枚举单例，实现简单，由JVM从根本上提供保障，避免通过反射和反序列化的漏洞，缺点是没有延迟加载

public enum Demo1{
    //这个枚举元素，本身就是单例对象
    INSTANCE;

    //添加自己需要的操作
    public void singletonOperation() {

    }
}

如何选用？

占用资源少，不需要延时加载：枚举式好于饿汉式

占用资源大，需要延时加载：静态内部类式好于懒汉式

二、工厂模式

实现了创建者和调用者的分离。

详细分类：简单工厂模式、工厂方法模式、抽象工厂模式

面向对象设计的基本原则

OCP (开闭原则 Open-Closed Principle) 一个软件的实体应当对扩展开放，对修改关闭

DIP (依赖倒转原则 Dependence Inversion Principle) 要针对接口编程，不要针对实现编程

LoD (迪米特法则 Law of Demeter) 只与你直接的朋友通信，而避免和陌生人通信

核心本质：实例化对象，用工厂方法代替new操作。将选择实现类、创建对象统一管理和控制，从而将调用者跟我们的实现类解耦。

简单工厂模式，也叫静态工厂模式，由于工厂类一般是使用静态方法，对应增减新产品，不修改代码的话，就无法扩展（实际使用最多）

//Car接口
public interface Car {
    void run();
}

//Demo1类，继承Car接口
public class Demo1 implements Car{
    @Override
    public void run() {
        System.out.println("Demo1 再跑！");
    }
}

//Demo2类，继承Car接口
public class Demo2 implements Car{
    @Override
    public void run() {
        System.out.println("Demo2 再跑！");
    }
}

//CarFactory类，工厂类
public class CarFactory {
    public static Car createCar(String type) {
        if ("yth".equals(type)) {
            return new Demo1();
        }else if ("mx".equals(type)) {
            return new Demo2();
        }
        return null;
    }
}

//Test类，使用者类
public class Test {
    public static void main(String[] args) {
        Car c1 = CarFactory.createCar("yth");
        Car c2 = CarFactory.createCar("mx");

        c1.run();
        c2.run();
    }
}

工厂方法模式，相比于简单工厂模式而言，更加符合OCP原则，但是会创建更多的类

//Car接口
public interface Car {
    void run();
}

//Demo1类，继承Car接口
public class Demo1 implements Car{
    @Override
    public void run() {
        System.out.println("Demo1 再跑！");
    }
}

//Demo2类，继承Car接口
public class Demo2 implements Car{
    @Override
    public void run() {
        System.out.println("Demo2 再跑！");
    }
}

//Demo3类，继承Car接口
public class Demo3 implements Car{
    @Override
    public void run() {
        System.out.println("Demo3 再跑！");
    }
}

//CarFactory接口
public interface CarFactory {
    Car createCar();
}

//Demo1Factory类，工厂类，继承CarFactory接口
public class Demo1Factory implements CarFactory{
    @Override
    public Car createCar() {
        return new Demo1();
    }
}

//Demo2Factory类，工厂类，继承CarFactory接口
public class Demo2Factory implements CarFactory{
    @Override
    public Car createCar() {
        return new Demo2();
    }
}

//Demo3Factory类，工厂类，继承CarFactory接口
public class Demo3Factory implements CarFactory{
    @Override
    public Car createCar() {
        return new Demo3();
    }
}

根据设计理论建议：工厂方法模式。但实际上，一般使用简单工厂模式。

三、抽象工厂模式 （不可以增加产品，可以增加产品族）

//Engine接口
public interface Engine {
    void run();
    void start();
}

class LuxuryEngine implements Engine {

    @Override
    public void run() {
        System.out.println("转的快！");
    }

    @Override
    public void start() {
        System.out.println("启动快！可以自动启停！");
    }
}

class LowEngine implements Engine {

    @Override
    public void run() {
        System.out.println("转的慢！");
    }

    @Override
    public void start() {
        System.out.println("启动慢！");
    }
}

//Seat接口
public interface Seat {
    void massage();
}

class LuxurySeat implements Seat {

    @Override
    public void massage() {
        System.out.println("可以自动按摩");
    }
}

class LowSeat implements Seat {

    @Override
    public void massage() {
        System.out.println("不能自动按摩");
    }
}

//Tyre接口
public interface Tyre {
    void revolve();
}

class LuxuryTyre implements Tyre {

    @Override
    public void revolve() {
        System.out.println("旋转不磨损！");
    }
}

class LowTyre implements Tyre {

    @Override
    public void revolve() {
        System.out.println("旋转磨损快！");
    }
}

//CarFactory接口
public interface CarFactory {
    Engine createEngine();
    Seat createSeat();
    Tyre createTyre();
}

//LowCarFactory类，继承了CarFactory接口
public class LowCarFactory implements CarFactory{
    @Override
    public Engine createEngine() {
        return new LowEngine();
    }

    @Override
    public Seat createSeat() {
        return new LowSeat();
    }

    @Override
    public Tyre createTyre() {
        return new LowTyre();
    }
}

//LuxuryCarFactory类，继承了CarFactory接口
public class LuxuryCarFactory implements CarFactory{
    @Override
    public Engine createEngine() {
        return new LuxuryEngine();
    }

    @Override
    public Seat createSeat() {
        return new LuxurySeat();
    }

    @Override
    public Tyre createTyre() {
        return new LuxuryTyre();
    }
}

//Client类，测试
public class Client {
    public static void main(String[] args) {
        CarFactory factory = new LowCarFactory();
        Engine e = factory.createEngine();
        e.run();
        e.start();
    }
}

四、建造者模式

本质：实现了组件的单独构造(Builder负责)和装配(Director负责)的分离，从而可以构造出复杂的对象

//AirShipBuilder接口,是我们的建造者的接口
public interface AirShipBuilder {
    Engine builderEngine();
    OrbitalModule builderOrbitalModule();
    EscapeTower builderEscapeTower();
}

//AirShipDirector接口,是我们的装配者的接口
public interface AirShipDirector {
    //组装飞船对象
    AirShip directAirShip();
}

//ythAirShipBuilder类,实现了AirShipBuilder接口
public class ythAirShipBuilder implements AirShipBuilder{

    @Override
    public Engine builderEngine() {
        System.out.println("构建尹天豪的发动机！");
        return new Engine("尹天豪牌发动机");
    }

    @Override
    public OrbitalModule builderOrbitalModule() {
        System.out.println("构建尹天豪的轨道舱模块！");
        return new OrbitalModule("尹天豪的轨道舱模块");
    }

    @Override
    public EscapeTower builderEscapeTower() {
        System.out.println("构建尹天豪的逃逸塔！");
        return new EscapeTower("尹天豪的逃逸塔");
    }
}

//ythAirShipDirector类,实现了AirShipDirector接口
public class ythAirShipDirector implements AirShipDirector{
    private AirShipBuilder builder;

    public ythAirShipDirector(AirShipBuilder builder) {
        this.builder = builder;
    }

    @Override
    public AirShip directAirShip() {
        Engine e = builder.builderEngine();
        OrbitalModule o = builder.builderOrbitalModule();
        EscapeTower et = builder.builderEscapeTower();
        //装配飞船对象
        AirShip ship = new AirShip();
        ship.setEngine(e);
        ship.setEscapeTower(et);
        ship.setOrbitalModule(o);

        return ship;
    }
}

//AirShip类,是我们的飞船类,里边包含了发动机类,逃逸塔类,轨道舱模块类
public class AirShip {
    //轨道舱模块
    private OrbitalModule orbitalModule;
    //发动机
    private Engine engine;
    //逃逸塔
    private EscapeTower escapeTower;

    public OrbitalModule getOrbitalModule() {
        return orbitalModule;
    }

    public void setOrbitalModule(OrbitalModule orbitalModule) {
        this.orbitalModule = orbitalModule;
    }

    public Engine getEngine() {
        return engine;
    }

    public void setEngine(Engine engine) {
        this.engine = engine;
    }

    public EscapeTower getEscapeTower() {
        return escapeTower;
    }

    public void setEscapeTower(EscapeTower escapeTower) {
        this.escapeTower = escapeTower;
    }
}

class OrbitalModule {
    private String name;

    public OrbitalModule(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

class Engine {
    private String name;

    public Engine(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

class EscapeTower {
    private String name;

    public EscapeTower(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

//Client类,该类只需要用到AirShip类和ythAirShipDirector类,通过后者进行飞船的组装,通过前者进行组装好的飞船的调用即可
public class Client {
    public static void main(String[] args) {
        AirShipDirector director = new ythAirShipDirector(new ythAirShipBuilder());

        AirShip ship = director.directAirShip();

        System.out.println(ship.getEngine().getName());
        System.out.println(ship.getEscapeTower().getName());
        System.out.println(ship.getOrbitalModule().getName());
    }
}

五、原型模式 （prototype），也叫克隆模式，拷贝模式

原型模式实现：Cloneable接口和clone方法

//创建类，继承Cloneable接口，并且重写clone方法，此时是浅克隆
public class Sheep implements Cloneable{
    private String name;
    private Date birthday;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object obj = super.clone();
        return obj;
    }

    public Sheep() {
    }

    public Sheep(String name, Date birthday) {
        this.name = name;
        this.birthday = birthday;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
}

//要实现深克隆，就要把属性也克隆，修改Sheep类中重写的clone方法
protected Object clone() throws CloneNotSupportedException {
        Object obj = super.clone();
        //添加如下代码实现深克隆
        Sheep s = (Sheep) obj;
        //相当于把属性也克隆
        s.birthday = (Date) this.birthday.clone();
        return obj;
 }

//创建类去测试，可以分别测试深克隆和浅克隆。深克隆改变date前后输出不同，浅克隆相同
public class Client {
    public static void main(String[] args) throws CloneNotSupportedException {
        //浅克隆
        Date date = new Date(415469146548L);
        Sheep sheep1 = new Sheep("名趣",date);
        Sheep sheep2 = (Sheep) sheep1.clone();

        System.out.println(sheep1);
        System.out.println(sheep1.getName() + " " + sheep1.getBirthday());
        System.out.println(sheep2);
        System.out.println(sheep2.getName() + " " + sheep2.getBirthday());

        date.setTime(89487151648L);

        System.out.println(sheep1);
        System.out.println(sheep1.getName() + " " + sheep1.getBirthday());
        System.out.println(sheep2);
        System.out.println(sheep2.getName() + " " + sheep2.getBirthday());
    }
}

通过new产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式

更多推荐

GOF23--创建型模式