常用设计模式一（创建型模式）

其他 2020-05-02 16:49:24 阅读次数: 0

前言

很久前就一直想总结下常用的设计模式，但是各种原因一直拖到现在，下面我尝试用自己的理解去解释常用的设计模式，旨在让自己对常用设计模式有一个直观认识，过后回来能看懂并理解这些常用设计模式，当然如果这篇文章能帮到想了解设计的同学那就更好不过了。

概念介绍

设计模式分为三大类：

  • 创建型模式(Creational Pattern)：创建型模式对类的实例化过程进行了抽象，将软件模块中对象的创建和对象的使用分离。使软件的结构更加清晰，外界对于这些对象只需要知道它们共同的接口，而不需要清楚其具体的实现细节，使整个系统的设计更加符合单一职责原则。
    创建型模式在创建什么(What)，由谁创建(Who)，何时创建(When)等方面都为软件设计者提供了尽可能大的灵活性。创建型模式隐藏了类的实例的创建细节，通过隐藏对象如何被创建和组合在一起达到使整个系统独立的目的。
    设计模式中属于创建型模式的有：
    单例模式、建造者模式、工厂方法模式、抽象工厂模式、原型模式。
    其中常用的有：

    • 单例模式：保证一个类只有一个实例，并且提供对这个实例的全局访问方式。
    • 建造者模式：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
    • 工厂方法模式：允许一个类的实例化推迟到子类中进行。
    • 抽象工厂模式：提供一个创建相关或依赖对象的接口，而不指定对象的具体类。

    这几个模式在这篇文章中都会有介绍。

  • 结构型模式(Structural Pattern)：结构型模式描述如何将类或者对象结合在一起形成更大的结构，就像搭积木，可以通过简单积木的组合形成复杂的、功能更为强大的结构。
    结构型模式可以分为类结构型模式和对象结构型模式：
    类结构型模式关心类的组合，由多个类可以组合成一个更大的系统，在类结构型模式中一般只存在继承关系和实现关系。
    对象结构型模式关心类与对象的组合，通过关联关系使得在一个类中定义另一个类的实例对象，然后通过该对象调用其方法。 根据“合成复用原则”，在系统中尽量使用关联关系来替代继承关系，因此大部分结构型模式都是对象结构型模式。
    设计模式中属于结构型模式的有：适配器模式、代理模式、享元模式、外观模式、桥接模式、组合模式、装饰器模式。
    其中常用的有：

    • 适配器模式：将一个接口转换成客户希望的另一个接口，适配器模式使接口不兼容的那些类可以一起工作，其别名为包装器(Wrapper)。适配器模式既可以作为类结构型模式，也可以作为对象结构型模式。
    • 代理模式：给某一个对象提供一个代理，并由代理对象控制对原对象的引用，它是一种对象结构型模式。
    • 享元模式：运用共享技术有效地支持大量细粒度对象的复用。系统只使用少量的对象，而这些对象都很相似，状态变化很小，可以实现对象的多次复用。由于享元模式要求能够共享的对象必须是细粒度对象，因此它又称为轻量级模式，它是一种对象结构型模式。

    这几个模式会在下篇文章中介绍。

  • 行为型模式(Behavioral Pattern)：行为型模式是对在不同的对象之间划分责任和算法的抽象化。行为型模式不仅仅关注类和对象的结构，而且重点关注它们之间的相互作用。通过行为型模式，可以更加清晰地划分类与对象的职责，并研究系统在运行时实例对象 之间的交互。在系统运行时，对象并不是孤立的，它们可以通过相互通信与协作完成某些复杂功能，一个对象在运行时也将影响到其他对象的运行。
    设计模式中属于行为型模式的有：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
    其中常用的有：

    • 策略模式：定义一系列算法，将每一个算法封装起来，并让它们可以相互替换。策略模式让算法独立于使用它的客户而变化，也称为政策模式。
    • 观察者模式：定义对象间的一种一对多依赖关系，使得每当一个对象状态发生改变时，其相关依赖对象皆得到通知并被自动更新。

单例模式

单例模式是最常用的设计模式之一，是为了保证单例对象的类只有一个实例存在，并保证整个系统只需要拥有一个全局对象。

使用场景

确保某个类在全局中只需要存在一个对象的场景。如：访问IO和数据库时，使用单例模式可以避免浪费资源。

懒汉模式

懒汉模式是声明一个静态变量，在调用对象类提供的get方法时就进行初始化，如下：

public class LazySingleton {
    private static LazySingleton mSingleton;

    public static synchronized LazySingleton getLazySingleton() {
        if (mSingleton == null) {
            mSingleton = new LazySingleton();
        }
        return mSingleton;
    }
}

懒汉模式只会在使用时才会被实例化，可以节约一定的资源，但是每次调用getLazySingleton都会进行同步，造成不必要的同步开销，这种模式一般不建议使用。

饿汉模式

饿汉模式在类加载的时候就进行了初始化，所以类加载会稍慢，但是调用类实例时由于类已经初始化所以获取速度很快。如下：

public class HungrySingleton {
    private static HungrySingleton mSingleton = new HungrySingleton();

    public static HungrySingleton getHungrySingleton() {
        return mSingleton;
    }
}

双重检查模式 （Double CheckLock）

DCL方式的优点是能保证在需要是单例才会初始化的同时保证线程安全。如下：

public class DCLSingleton {

    private static DCLSingleton mSingleton;

    public static DCLSingleton getDCLSingleton() {
        if (mSingleton == null) {
            synchronized (DCLSingleton.class) {
                if (mSingleton == null) {
                    mSingleton = new DCLSingleton();
                }
            }
        }
        return mSingleton;
    }
}

静态内部类单例模式

这种方式不仅能确保线程安全也能保证Singleton类的唯一性，这是推荐使用的静态内部类单例模式。

public class StaticSingleton {
    public static StaticSingleton getStaticSingleton() {
        return StaticSingletonHolder.singleton;
    }

    private static class StaticSingletonHolder {
        private static final StaticSingleton singleton = new StaticSingleton();
    }
}

小结

以上四种是比较常用的单例写法，单例模式在日常开发中使用很多，在Android源码中也有使用。

建造者模式

建造者模式是一步步创建复杂对象的创建型模式，这个模式可以让用户在不知道内部构建细节的情况下，控制对象的构造流程。如汽车有车轮、方向盘、座椅还有各种小零件等，将这些部件组装成一辆汽车就是一个复杂的过程。在这个事例里汽车就是一个复杂的对象，而将汽车部件组装成汽车的过程就是复杂对象的构建流程。建造者模式将复杂对象的构建过程和部件进行了良好的解耦，将耦合度降到最低。

使用场景

  • 相同方法不同执行顺序会产生不同的事件结果时。
  • 多个部件或者零件都可以装配到一个对象中，但是产生的 运行结果又不相同时。
  • 产品类是个复杂的对象，或产品类调用顺序不同就会产生不同的作用时。
  • 当初始化一个对象异常复杂时。

例子

使用建造者模式组装一台汽车，假定一辆汽车只需要有车轮、方向盘、座椅这三个部件。那么一个汽车类就有如下几个变量和组装方法：
产品类

public class Car {

    private String mWheel;//车轮
    private String mSteering;//方向盘
    private String mSeat;//座椅

    /**
     * 组装车轮
     *
     * @param mWheel
     */
    public void setmWheel(String mWheel) {
        this.mWheel = mWheel;
    }

    /**
     * 组装方向盘
     *
     * @param mSteering
     */
    public void setmSteering(String mSteering) {
        this.mSteering = mSteering;
    }

    /**
     * 组装座椅
     *
     * @param mSeat
     */
    public void setmSeat(String mSeat) {
        this.mSeat = mSeat;
    }

    @Override
    public String toString() {
        return "Car{" +
                "mWheel='" + mWheel + '\'' +
                ", mSteering='" + mSteering + '\'' +
                ", mSeat='" + mSeat + '\'' +
                '}';
    }
}

Builder类组装模板
一个良好的汽车组装流程应该有一套组装模板，模板包含各种控件的组装方法，这里的组装模板类如下

public abstract class Builder {
    public abstract void buildWheel(String wheel);

    public abstract void buildSteering(String settring);

    public abstract void buildSeat(String seat);

    public abstract Car createCar();
}

而要想组装一辆具体的车必须传承这套组装模板：

public class SixSixSixCarBuilder extends Builder {

    private Car mCar = new Car();

    @Override
    public void buildWheel(String wheel) {
        mCar.setmWheel(wheel);
    }

    @Override
    public void buildSteering(String steering) {
        mCar.setmSteering(steering);
    }

    @Override
    public void buildSeat(String seat) {
        mCar.setmSeat(seat);
    }

    @Override
    public Car createCar() {
        return mCar;
    }
}

然后还需要一个指挥者（Director ）去规范指挥组装流程：

public class Director {

    Builder mBuild = null;

    public Director(Builder build) {
        this.mBuild = build;
    }

    public Car createCar(String wheel, String steering, String seat) {
        this.mBuild.buildWheel(wheel);
        this.mBuild.buildSteering(steering);
        this.mBuild.buildSeat(seat);
        return mBuild.createCar();
    }

}

这时候谁要造汽车只需要找到这个指挥者即可，测试如下

public class Test{
    public static void main(string[] args){

        Builder builder=new SixSixSixCarBuilder();
        Director director=new Director(builder);
        director.createCar("米其林三星轮胎","真皮方向盘","真皮座椅");

        System.out.println("汽车信息："+builder.createCar().toString());
    }
}

小结

从上面例子得出建造者模式主要有以下几个结构构成：
- Product: 产品类。
- Builder：抽象Builder类，规范产品的组建，子类会继承这个类实现具体的建造流程。
- ConcreteBulider: 上面Builder的实现类，实现抽象Builder类定义的所有方法，并且返回一个组建好的对象。
- Director: 指挥者类，用于统一组装流程。

实际开发中Director类经常是忽略的，直接用Builder来对对象进行组装，如下：

public class Test{
    public static void main(string[] args){

        Builder builder=new SixSixSixCarBuilder();
        builder.buildWheel("米其林三星轮胎");
        builder.buildSteering("真皮方向盘");
        builder.buildSeat("真皮座椅");

        System.out.println("汽车信息："+builder.createCar().toString());
    }
}

这个Builder一般写成链式调用，这时Builder类的setter方法需要返回自身，如下：

public abstract class Builder {
    public abstract Builder buildWheel(String wheel);

    public abstract Builder buildSteering(String steering);

    public abstract Builder buildSeat(String seat);

    public abstract Car createCar();
}
public class SixSixSixCarBuilder extends Builder {

    private Car mCar = new Car();

    @Override
    public SixSixSixCarBuilder buildWheel(String wheel) {
        mCar.setmWheel(wheel);
        return this;
    }

    @Override
    public SixSixSixCarBuilder buildSteering(String steering) {
        mCar.setmSteering(steering);
        return this;
    }

    @Override
    public SixSixSixCarBuilder buildSeat(String seat) {
        mCar.setmSeat(seat);
        return this;
    }

    @Override
    public Car createCar() {
        return mCar;
    }
}

调用时：

public class Test{
    public static void main(string[] args){

        Builder builder=new SixSixSixCarBuilder();
        builder.buildWheel("米其林三星轮胎")
                .buildSteering("真皮方向盘")
                .buildSeat("真皮座椅") 
                .createCar();

        System.out.println("汽车信息：" + builder.createCar().toString());
    }
}

工厂方法模式

工厂方法模式是应用最广泛的模式，它定义一个用于创建对象的接口，让子类决定实例化哪个类。

使用场景

任何需要生成复杂对象的地方都可以使用工厂方法模式。

例子

还是组装汽车，具体组装k3、k5属于同一车型的两款车。由于是同一车型所以一条生产线足够。

先明确汽车需要的功能，即汽车抽象基类：

public abstract class QiYaCar {

    public abstract void drive();//汽车可以开

    public abstract void speedUp();//汽车可以加速
}

创建抽象生产线定义类：

public abstract class QiYaFactory {

    /**
     * 
     * @param clzz 具体汽车型号
     * @return 具体的汽车
     */
    public abstract <T extends QiYaCar> T createQiYaCar(Class clzz);
}

创建具体的生产线：

public class QiYaCreateFactory extends QiYaFactory{
    @Override
    public <T extends QiYaCar> T createQiYaCar(Class clzz) {
        QiYaCar car= null;
        try {
            car = (QiYaCar) Class.forName(clzz.getName()).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return (T) car;
    }
}

生产具体车型：

public class QiYaK3Car extends QiYaCar{
    @Override
    public void drive() {
        System.out.println("k3启动");
    }

    @Override
    public void speedUp() {
        System.out.println("k3加速");
    }
}
public class QiYaK5Car extends QiYaCar{
    @Override
    public void drive() {
        System.out.println("k5启动");
    }

    @Override
    public void speedUp() {
        System.out.println("k5加速");
    }
}

把上面各个类组装起来就可以形成一条完整的流水线：

public class Client{
    public static void main(string[] args){

        QiYaFactory factory = new QiYaCreateFactory();

        QiYaK3Car k3Car = factory.createQiYaCar(QiYaK3Car.class);
        k3Car.drive();
        k3Car.speedUp();

        QiYaK5Car k5Car = factory.createQiYaCar(QiYaK5Car.class);
        k5Car.drive();
        k5Car.speedUp();
    }
}

小结

工厂方法模式是一个很好的设计模式，但是从上面例子也可以看出，工厂方法模式也有一定的缺点，比如当添加新的产品时就要编写一个新的产品类，同时还要引用抽象层，导致类的结构复杂化。是否使用工厂方法模式需要根据实际需求决定。

抽象工厂模式

抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。抽象工厂模式又称为Kit模式，属于对象创建型模式。

使用场景

一个对象族有相同约束时可以使用抽象工厂模式，如Android、ios都有拨号软件，这个软件属于软件的范畴，但是所在的操作系统不一样，这时候开业考虑使用抽象工厂模式来设计拨号软件。

例子

起亚和现代有两条生成线，一个中型车，一个SUV。抽象工厂模式来进行实现这两条生产线。

首先是抽象产品类：

public abstract class BetweenCar{
  public abstract void drive();//汽车可以开

  public abstract void speedUp();//汽车加速

}
public abstract class SUVCar{
   public abstract void drive();//汽车可以开

   public abstract void speedUp();//汽车加速
}

生产具体产品

public class QiYaBetweenCar extends BetweenCar{
    @Override
    public void drive() {
        System.out.println("起亚中型车启动");
    }

    @Override
    public void speedUp() {
        System.out.println("起亚中型车加速");
    }
}
public class XianDaiBetweenCar extends BetweenCar{
    @Override
    public void drive() {
        System.out.println("现代中型车启动");
    }

    @Override
    public void speedUp() {
        System.out.println("现代中型车加速");
    }
}
public class QiYaSUVCar extends SUVCar {
    @Override
    public void drive() {
        System.out.println("起亚SUV启动");
    }

    @Override
    public void speedUp() {
        System.out.println("起亚SUV加速");
    }
}
public class XianDaiSUVCar extends SUVCar {
    @Override
    public void drive() {
        System.out.println("现代SUV启动");
    }

    @Override
    public void speedUp() {
        System.out.println("现代SUV加速");
    }
}

创建生产汽车的抽象工厂里面有两条生产线，即生产中型车和SUV

public abstract class CarFactory {

    public abstract BetweenCar createBetweenCar();

    public abstract SUVCar createSUVCar();

}

定义具体的工厂

public class QiYaCarFactory extends CarFactory{

    @Override
    public BetweenCar createBetweenCar() {
        return new QiYaBetweenCar();
    }

    @Override
    public SUVCar createSUVCar() {
        return new QiYaSUVCar();
    }
}
public class XianDaiCarFactory extends CarFactory {
    @Override
    public BetweenCar createBetweenCar() {
        return new XianDaiBetweenCar();
    }

    @Override
    public SUVCar createSUVCar() {
        return new XianDaiSUVCar();
    }
}

最后客户端调用

public class Client{
    public static void main(string[] args){

        CarFactory qiYaCarFactory = new QiYaCarFactory();

        qiYaCarFactory.createBetweenCar().drive();
        qiYaCarFactory.createBetweenCar().speedUp();

        qiYaCarFactory.createSUVCar().drive();
        qiYaCarFactory.createSUVCar().speedUp();

        CarFactory xianDaiCarFactory = new XianDaiCarFactory();

        xianDaiCarFactory.createBetweenCar().drive();
        xianDaiCarFactory.createBetweenCar().speedUp();

        xianDaiCarFactory.createSUVCar().drive();
        xianDaiCarFactory.createSUVCar().speedUp();
    }
}

小结

抽象工厂模式一个显著的优点是分离接口与实现，客户端使用抽象工厂来创建需要的对象，而客户端不需要知道具体实现是谁，客户端只是面向产品的接口编程，使其从具体的产品视线中解耦，在切换产品类时更加灵活。当然抽象工厂模式不容易扩展新的产品类，因为增加一个产品类就需要修改抽象工厂，则所有具体工厂类都要修改。

准备下雨了
原创文章 17 获赞 14 访问量 3万+
关注 私信

猜你喜欢

转载自blog.csdn.net/lxzmmd/article/details/76178641
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
周排行
循环神经网络（rnn）讲解
Tigao教程四：单独的关节运动
金蝶K3WISE15.0-注册套打教程
如何在Mac上配置Kubernetes
Android应用结束自身进程的方法
SpringMVC学习 十三 拦截器栈
中国驻洛杉矶总领馆举行新春招待会
HttpClient get post 发送
11 - three.js 笔记 - 绘制三维字体模型
Mysql递归获取某个父节点下面的所有子节点和子节点上的所有父节点
每日归档
更多
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022