Java设计模式

DevRunning 发布于

什么是设计模式？

设计模式全称 “软件设计模式”，是解决特定问题的一系列套路。是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。

设计模式是对软件设计中普遍存在的各种问题，所提出的解决方案。

七大设计原则

一、单一职责原则（SRP）

是最简单的面向对象设计原则。控制粒度划分，软件实体（模块、类、方法）应该只包含单一的职责：高内聚、低耦合。

  1. 错误示例

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    /**
     * 单一原则错误示例
     * 
     * @author _running
     * @since 2022-06-19
     */
    public class Test {

        private String name;

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

        /**
         * 进行活动
         *
         * @param what 什么活动
         */
        public void activity(String what) {
            String activityName = "";
            if ("game".equals(what)) {
                activityName = "游戏中...";
            } else if ("study".equals(what)) {
                activityName = "学习中...";
            } else {
                activityName = "不知所措中...";
            }
            System.out.println(this.name + "正在：" + activityName);
        }

    }

  2. 正确示例（下面只是较细度方法划分，可以使用类更细度划分）

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    /**
     * 单一原则正确示例
     *
     * @author _running
     * @since 2022-06-19
     */
    public class Test {

        private String name;

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

        public void study() {
            System.out.println(this.name + "正在学习中");
        }
        
        public void game() {
            System.out.println(this.name + "正在玩游戏中");
        }

    }

二、开闭原则

软件实体（模块、类、方法）应当对外扩展开放，对修改关闭。

三、里氏替换原则

对子类的特别定义，子类可以扩展父类的功能，但不能改变父类原有的功能。

  1. 子类可以增加自己特有的方法
  2. 子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法
  3. 当子类重载父类的方法时，方法的前置条件（入参）要比父类方法更为宽松
  4. 当子类实现父类的方法时，方法的后置条件（返回）要比父类方法更为严格或一致

四、依赖倒转原则

高层模块不应依赖底层模块，都应该依赖抽象。抽象不应依赖细节，细节应依赖抽象。

五、接口隔离原则

实现类不应依赖一些不需要的接口。

六、合成复用原则

优先使用对象组合，而不是通过继承来达到复用的目的。

在一个新的对象中使用一些已有的对象，使之成为新对象的一部分，新的对象通过向这些对象的委派达到复用已有功能的目的。

七、迪米特原则

又称最少知识原则，是对程序内部数据交互的限制。

每一个软件单位对其他单位都只有最少的知识，而且局限于那些与本单位密切相关的软件单位。

一个类对其他的类交互越少越好，当一个类发生改动，与其相关的类就会受到影响。

设计模式之创建型

一、简单工厂模式

如果所有的对象我们都通过new的方式去创建，那么当我们的程序中大量的使用此对象时，突然有一天这个对象的构造方法或是类名发生了修改，得去一个一个修改，根据迪米特原则，我们应该尽可能的少与其他类进行交互。我们可以封装一个工厂类，当我们需要对象时可以直接调用工厂方法来为我们生产对象。工厂方法模式替代了传统的直接new的形式。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
/**
 * 简单工厂模式
 *
 * @author _running
 * @since 2022-06-19
 */
public class SimpleFactory {

    static Map<String, Animal> MAP = new HashMap<>(2);


    public static void main(String[] args) {
        Animal cat = MAP.get("cat");
    }


    /**
     * 动物类
     */
    interface Animal {

        Animal getObj();

        void setObj();
    }

    /**
     * 猫
     */
    static class Cat implements Animal {

        @Override
        public Cat getObj() {
            return null;
        }

        @Override
        public void setObj() {
            MAP.put("cat", new Cat());
        }
    }

    /**
     * 狗
     */
    static class Dog implements Animal {

        @Override
        public Animal getObj() {
            return null;
        }

        @Override
        public void setObj() {
            MAP.put("dog", new Dog());
        }
    }

}

二、抽象工厂模式

抽象工厂模式提供了一个创建一系列相关或者相互依赖对象的接口，无需指定他们具体的类。

三、建造者模式

四、单例模式

单例模式就是采取一定的方法保证在整个软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得对象实例的方法

  1. 饿汉式（静态常量）

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    /**
     * 饿汉式（静态常量）
     *
     * @author _running
     * @since 2022-06-19
     */
    public class Singleton {

        /**
         * 类加载时完成初始化对象实例
         */
        private final static Singleton INSTANCE = new Singleton();

        /**
         * 获取对象实例
         *
         * @return 对象实例
         */
        public static Singleton getInstance() {
            return INSTANCE;
        }

        private Singleton() {}
    }

  2. 饿汗式（静态代码块）

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    /**
     * 饿汉式（静态代码块）
     *
     * @author _running
     * @since 2022-06-19
     */
    public class Singleton {

        /**
         * 初始化对象实例
         */
        private static Singleton INSTANCE;

        static {
            INSTANCE = new Singleton();
        }

        /**
         * 获取对象实例
         *
         * @return 对象实例
         */
        public static Singleton getInstance() {
            return INSTANCE;
        }

        private Singleton() {

        }
    }

  3. 懒汉式（线程不安全）

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    /**
     * 懒汉式（线程不安全）
     *
     * @author _running
     * @since 2022-06-19
     */
    public class Singleton {

        /**
         * 对象实例
         */
        private static Singleton INSTANCE;

        /**
         * 获取对象实例
         *
         * @return 对象实例
         */
        public static Singleton getInstance() {
            return Optional.ofNullable(INSTANCE).orElseGet(() -> {
                // 初始化对象实例
                INSTANCE = new Singleton();
                return INSTANCE;
            });
        }

        private Singleton() {

        }
    }

  4. 懒汉式（线程安全，同步方法）

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    /**
     * 懒汉式（线程安全，同步方法）
     *
     * @author _running
     * @since 2022-06-19
     */
    public class Singleton {

        /**
         * 对象实例
         */
        private static Singleton INSTANCE;

        /**
         * 获取对象实例
         *
         * @return 对象实例
         */
        public static synchronized Singleton getInstance() {
            return Optional.ofNullable(INSTANCE).orElseGet(() -> {
                // 初始化对象实例
                INSTANCE = new Singleton();
                return INSTANCE;
            });
        }

        private Singleton() {

        }
    }

  5. 懒汉式（线程安全，同步代码块）

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    /**
     * 懒汉式（线程安全，同步代码块）
     *
     * @author _running
     * @since 2022-06-19
     */
    public class Singleton {

        /**
         * 对象实例
         */
        private static Singleton INSTANCE;


        /**
         * 获取对象实例
         *
         * @return 对象实例
         */
        public static Singleton getInstance() {
            return Optional.ofNullable(INSTANCE).orElseGet(() -> {
                synchronized (Singleton.class) {
                    // 初始化对象实例
                    INSTANCE = new Singleton();
                }
                return INSTANCE;
            });
        }

        private Singleton() {

        }
    }

  6. 饿汉式（双重检查）

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    /**
     * 饿汉式（双重检查）
     *
     * @author _running
     * @since 2022-06-19
     */
    public class Singleton {

        /**
         * 对象实例
         */
        private static volatile Singleton INSTANCE;


        /**
         * 获取对象实例
         *
         * @return 对象实例
         */
        public static Singleton getInstance() {
            if (INSTANCE == null) {
                synchronized (Singleton.class) {
                    if (INSTANCE == null) {
                        // 初始化对象实例
                        INSTANCE = new Singleton();
                    }
                }
            }
            return INSTANCE;
        }

        private Singleton() {

        }
    }

  7. 静态内部类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    /**
     * 静态内部类
     *
     * @author _running
     * @since 2022-06-19
     */
    public class Singleton {


        /**
         * 获取对象实例
         *
         * @return 对象实例
         */
        public static Singleton getInstance() {
            return StaticSingleton.INSTANCE;
        }

        private Singleton() {

        }

        private static class StaticSingleton {

            /**
             * 类加载初始化对象实例
             */
            private static volatile Singleton INSTANCE = new Singleton();

        }
    }

  8. 枚举

五、原型模式

设计模式之结构性

一、适配器模式

二、桥接模式

三、组合模式

四、装饰器模式

五、代理模式

六、外观模式

七、享元模式

设计模式之行为型

一、责任链模式

二、命令模式

三、迭代器模式

四、中介者模式

五、备忘录模式

六、观察者模式

七、状态模式

八、策略模式

九、访问者模式

十、解释器模式

十一、模版方法模式

DevRunning

DevRunning

错过便是阵阵懊恼，无意义.

37
17
38
NOTICE

你好，欢迎～

CATEGORYS
TAGS
Conda Docker Github Gradle IO模型 IP JUC Java反射 Java锁 Java集合 List MQ Map MySQL Nacos Netty Nginx PyCharm RabbitMQ Redis Set SpringBoot TCP VirtualBox Zookeeper kkFileView 二维码 优化查询 多线程 学习Kubernetes合集 学习Python合集 构建工具 架构 正则表达式 网络框架 网络爬虫案例 自动化 设计模式