深入浅出Java23种设计模式（一）

最新推荐文章于 2024-06-18 09:41:29 发布
最新推荐文章于 2024-06-18 09:41:29 发布
阅读量1.1k 收藏 3
点赞数
分类专栏： Java23种设计模式 文章标签： 设计模式 java 23种设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43844418/article/details/115309120
版权
本文深入探讨了Java中的设计模式，包括六大设计原则——开闭原则、里氏代换原则、依赖倒转原则、接口隔离原则、迪米特法则和合成复用原则。此外，详细介绍了单例模式、抽象工厂模式、工厂方法模式和建造者模式四种创造型设计模式的实现和应用场景，展示了如何通过这些模式提升软件的灵活性、可维护性和扩展性。
摘要由CSDN通过智能技术生成

文章目录

关于设计模式

  在软件开发的历程中，正是无数前辈们本着追求完美的架构设计和代码设计的初心。经过无数前辈们的探索和努力，逐渐形成了一系列的设计原则和设计模式。

  对于Java语言来说，通常包含有6大设计原则和23中设计模式。这些都是前辈们对于开发思想的结晶。我们学习和理解这些设计原则和设计模式，深入掌握其实现原理和使用场景，能够更好的设计我们的系统架构。编写出具有高性能、高并发、高可用、高可扩展性和高可维护性的代码。

  在Java的常见的23种设计模式中，大体上可以分为创建型模式、结构型模式和行为型模式三大类。本系列文章就对Java中的23种设计模式进行汇总，方便记录和查阅。

六大设计原则

开闭原则(Open Close Principle)

  • 开闭原则：对扩展开放,对修改关闭
  • 程序进行扩展的时候,不能修改原有的代码, 实现一个热插拔的效果
  • 为了使程序扩展性好,易于维护和升级：需要使用接口和抽象类

里氏代换原则(Liskov Substitution Principle)

  • 里氏代换原则：任何基类可以出现的地方，子类一定可以出现
  • LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受影响时，基类才能真正被复用，衍生类也能够在基类的基础上增加新的行为
  • 里氏代换原则是对实现抽象化的具体步骤的规范：
    • 里氏代换原则是对开闭原则的补充
    • 实现开闭原则的关键步骤就是抽象化
    • 基类与子类的继承关系就是抽象化的具体实现

依赖倒转原则(Dependence Inversion Principle)

  • 依赖倒转原则：针对接口编程,依赖于抽象而不依赖于具体
  • 依赖倒转原则是开闭原则的基础

接口隔离原则(Interface Segregation Principle)

  • 接口隔离原则：使用多个隔离的接口，比使用单个接口要好，降低类之间的耦合度
  • 从接口隔离原则可以看出：设计模式就是一个软件的设计思想
  • 从大型软件架构出发,为了升级和维护方便：降低依赖,降低耦合

迪米特法则(最少知道原则)(Demeter Principle)

  • 迪米特法则：最少知道原则，一个实体应当尽量少的与其它实体发生相互作用,使得功能模块相互独立

合成复用原则(Composite Reuse Principle)

  • 合成复用原则：尽量使用合成或者聚合的方式，而不是使用继承

创造型模式

单例模式

看几个单例对象的示例代码，其中有些代码是线程安全的，有些则不是线程安全的，需要大家细细品味。

  • 例一：SingletonExample1
  • 这个类是懒汉模式，并且是线程不安全的
package com.cz.Creativemodel;

/**
 * @Author: zhang
 * @Date: 2021/3/29 - 19:48
 * @Descripetion: 懒汉模式，单例实例在第一次使用的时候进行创建，这个类是线程不安全的
 **/
public class SingletonExample1 {

    private SingletonExample1(){

    }
    private static SingletonExample1 instance = null;

    private static SingletonExample1 getInstance(){
        //多个线程同时调用，可能会创建多个对象
        if (instance == null){
            instance = new SingletonExample1();
        }
        return instance;
    }
}
  • 例二：SingletonExample2
  • 饿汉模式，单例实例在类装载的时候进行创建，是线程安全的
package com.cz.Creativemodel;

/**
 * @Author: zhang
 * @Date: 2021/3/29 - 19:52
 * @Descripetion: 饿汉模式，单例实例在类装载的时候进行创建，是线程安全的
 **/
public class SingletonExample2 {

    private SingletonExample2(){}

    private static SingletonExample2 instance = new SingletonExample2();

    public static SingletonExample2 getInstance(){
        return instance;
    }
}
  • 例三：SingletonExample3
  • 懒汉模式，单例实例在第一次使用的时候进行创建，这个类是线程安全的，但是这个写法不推荐
package com.cz.Creativemodel;

/**
 * @Author: zhang
 * @Date: 2021/3/29 - 19:54
 * @Descripetion: 懒汉模式，单例实例在第一次使用的时候进行创建，这个类是线程安全的，但是这个写 法不推荐
 **/
public class SingletonExample3 {

    private SingletonExample3(){}

    private static SingletonExample3 instance = null;

    public static synchronized SingletonExample3 getInstance(){
        if (instance == null){
            instance = new SingletonExample3();
        }
        return instance;
    }
}
  • 例四：SingletonExample4
  • 懒汉模式（双重锁同步锁单例模式），单例实例在第一次使用的时候进行创建，但是，这个类不是线程安全的！！！！！
package com.cz.Creativemodel;

/**
 * @Author: zhang
 * @Date: 2021/3/29 - 19:57
 * @Descripetion: 懒汉模式（双重锁同步锁单例模式）
 * 单例实例在第一次使用的时候进行创建，这个类不是线程安全的
 **/
public class SingletonExample4 {

    private SingletonExample4(){}

    private static SingletonExample4 instance = null;

    public static SingletonExample4 getInstance(){
        if (instance == null){
            synchronized (SingletonExample4.class){
                if (instance == null){
                    instance = new SingletonExample4();
                }
            }
        }
        return instance;
    }
}

  • 线程不安全分析如下：

  • 当执行instance = new SingletonExample4();这行代码时，CPU会执行如下指令：

    • 1.memory = allocate()分配对象的内存空间
    • 2.ctorInstance()初始化对象
    • 3.instance = memory 设置instance指向刚分配的内存

  • 单纯执行以上三步没啥问题，但是在多线程情况下，可能会发生指令重排序。

  • 指令重排序对单线程没有影响，单线程下CPU可以按照顺序执行以上三个步骤，但是在多线程下，如果发生了指令重排序，则会打乱上面的三个步骤。

  • 如果发生了JVM和CPU优化，发生重排序时，可能会按照下面的顺序执行：

    • 1.memory = allocate()分配对象的内存空间
    • 3.instance = memory设置instance指向刚分配的内存
    • 2.ctorInstance()初始化对象

  • 假设目前有两个线程A和B同时执行getInstance()方法，A线程执行到instance = new SingletonExample4();B线程刚执行到第一个if (instance == null){}处，

  • 如果按照1.3.2的顺序，假设线程A执行到3.instance = memory设置instance指向刚分配的内存，此时，线程B判断instance已经有值，就会直接return instance;

  • 而实际上，线程A还未执行2.ctorInstance()初始化对象，也就是说线程B拿到的instance对象 还未进行初始化，这个未初始化的instance对象一旦被线程B使用，就会出现问题。

  • 例五：SingletonExample5

  • 懒汉模式（双重锁同步锁单例模式）单例实例在第一次使用的时候进行创建，这个类是线程安全的，使用的是 volatile +双重检测机制来禁止指令重排达到线程安全

package com.cz.Creativemodel;

/**
 * @Author: zhang
 * @Date: 2021/3/29 - 20:06
 * @Descripetion: 懒汉模式（双重锁同步锁单例模式）
 * 单例实例在第一次使用的时候进行创建，这个类是线程安全的
 **/
public class SingletonExample5 {

    private SingletonExample5(){}

    //单例对象 volatile + 双重检测机制来禁止指令重排
    private volatile static SingletonExample5 instance = null;

    public static SingletonExample5 getInstance(){
        if (instance == null){
            synchronized (SingletonExample5.class){
                if (instance == null){
                    return instance = new SingletonExample5();
                }
            }
        }
        return instance;
    }
}
  • 例六：SingletonExample6
  • 饿汉模式，单例实例在类装载的时候（使用静态代码块）进行创建，是线程安全的
package com.cz.Creativemodel;

/**
 * @Author: zhang
 * @Date: 2021/3/29 - 20:09
 * @Descripetion: 饿汉模式，单例实例在类装载的时候进行创建，是线程安全的
 **/
public class SingletonExample6 {

    private SingletonExample6(){}

    private static SingletonExample6 instance = null;

    static {
        instance = new SingletonExample6();
    }

    public static SingletonExample6 getInstance(){
        return instance;
    }
}
  • 例七：SingletonExample7
  • 枚举方式进行实例化，是线程安全的，此种方式也是线程最安全的
package com.cz.Creativemodel;

/**
 * @Author: zhang
 * @Date: 2021/3/29 - 20:11
 * @Descripetion: 枚举方式进行实例化，是线程安全的，此种方式也是线程最安全的
 **/
public class SingletonExample7 {

    private SingletonExample7(){}

    public static SingletonExample7 getInstance(){
        return Singleton.INSTANCE.getInstance();
    }

    private enum Singleton{
        INSTANCE;
        private SingletonExample7 singleton;
        //JVM保证这个方法绝对只调用一次
        Singleton(){
            singleton = new SingletonExample7();
        }
        public SingletonExample7 getInstance(){
            return singleton;
        }
    }
}

抽象工厂模式

一、概述：

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

二、为何使用

工厂模式是我们最常用的模式了，著名的Jive论坛 ，就大量使用了工厂模式，工厂模式在Java程序系统可以说是随处可见。

为什么工厂模式是如此常用？因为工厂模式就相当于创建实例对象的new，我们经常要根据类Class生成实例对象，如A a=new A()工厂模式也是用来创建实例对象的，所以以后new时就要多个心眼，是否可以考虑实用工厂模式，虽然这样做，可能多做一些工作，但会给你系统带来更大的可扩展性和尽量少的修改量

三、实用性

  • 一个系统要独立于它的产品的创建、组合和表示时。
  • 一个系统要由多个产品系列中的一个来配置时。
  • 当你要强调一系列相关的产品对象的设计以便进行联合使用时。
  • 当你提供一个产品类库，而只想显示它们的接口而不是实现时。

四、参与者

  • AbstractFactory 声明一个创建抽象产品对象的操作接口。
  • ConcreteFactory 实现创建具体产品对象的操作。
  • AbstractProduct 为一类产品对象声明一个接口。
  • ConcreteProduct定义一个将被相应的具体工厂创建的产品对象。 实现AbstractProduct接口。
  • Client 仅使用由AbstractFactory和AbstractProduct类声明的接口

五、类图

在这里插入图片描述

六、示例

  • AbstractFactory：定义抽象工程类IAnimalFactory
package com.cz.Creativemodel.abstractfactory;

/**
 * @Author: zhang
 * @Date: 2021/3/29 - 20:28
 * @Descripetion: 这个接口就是类图中标识的AbstractFactory抽象工厂
 **/
public interface IAnimalFactory {

    /**
     * 定义创建Icat接口实例的方法
     * @return
     */
    ICat createCat();

    /**
     * 定义创建IDog接口实例的方法
     * @return
     */
    IDog createDog();
}
  • ConcreteFactory：创建抽象工厂类的两个实现类，WhiteAnimalFactory和BlackAnimalFactory
package com.cz.Creativemodel.abstractfactory;

/**
 * @Author: zhang
 * @Date: 2021/3/29 - 20:31
 * @Descripetion: IAnimalFactory抽象工厂的实现类
 **/
public class WhiteAnimalFactory implements IAnimalFactory {

    @Override
    public ICat createCat() {
        return new WhiteCat();
    }

    @Override
    public IDog createDog() {
        return new WhiteDog();
    }
}


package com.cz.Creativemodel.abstractfactory;

/**
 * @Author: zhang
 * @Date: 2021/3/29 - 20:32
 * @Descripetion: IAnimalFactory抽象工厂的实现类
 **/
public class BlackAnimalFactory implements IAnimalFactory {
    @Override
    public ICat createCat() {
        return new BlackCat();
    }

    @Override
    public IDog createDog() {
        return new BlackDog();
    }
}
  • AbstractProduct：定义抽象工厂中要生产的抽象产品接口ICat和IDog
package com.cz.Creativemodel.abstractfactory;

/**
 * @Author: zhang
 * @Date: 2021/3/29 - 20:34
 * @Descripetion: 类图中定义的AbstractProduct
 * 指定工厂生产的产品
 **/
public interface ICat {
    /**
     * 定义方法
     */
    void eat();
}

package com.cz.Creativemodel.abstractfactory;

/**
 * @Author: zhang
 * @Date: 2021/3/29 - 20:36
 * @Descripetion:  类图中定义的AbstractProduct
 * 指定工厂生产的产品
 **/
public interface IDog {
    /**
     *定义方法
     */
    void eat();
}
  • ConcreteProduct：创建产品的实现类BlackCat、BlackDog、WhiteCat、WhiteDog
package com.cz.Creativemodel.abstractfactory;

/**
 * @Author: zhang
 * @Date: 2021/3/29 - 20:37
 * @Descripetion: ICat接口的实现类
 **/
public class BlackCat implements ICat {
    @Override
    public void eat() {
        System.out.println("The black cat is eating!");
    }
}

package com.cz.Creativemodel.abstractfactory;

/**
 * @Author: zhang
 * @Date: 2021/3/29 - 20:38
 * @Descripetion: IDog的实现类
 **/
public class BlackDog implements IDog {
    @Override
    public void eat() {
        System.out.println("The black dog is eating");
    }
}

package com.cz.Creativemodel.abstractfactory;

/**
 * @Author: zhang
 * @Date: 2021/3/29 - 20:39
 * @Descripetion: ICat的实现类
 **/
public class WhiteCat implements ICat {
    @Override
    public void eat() {
        System.out.println("The white cat is eating!");
    }
}

package com.cz.Creativemodel.abstractfactory;

/**
 * @Author: zhang
 * @Date: 2021/3/29 - 20:39
 * @Descripetion: IDog的实现类
 **/
public class WhiteDog implements IDog {
    @Override
    public void eat() {
        System.out.println("The white dog is eating!");
    }
}
  • Client：定义一个测试类Test
package com.cz.Creativemodel.abstractfactory;

/**
 * @Author: zhang
 * @Date: 2021/3/29 - 20:43
 * @Descripetion: 测试类
 **/
public class Test {
    public static void main(String[] args) {
        IAnimalFactory blackAnimalFactory = new BlackAnimalFactory();
        ICat blackCat = blackAnimalFactory.createCat();
        blackCat.eat();
        IDog blackDog = blackAnimalFactory.createDog();
        blackDog.eat();

        IAnimalFactory whiteAnimalFactory = new WhiteAnimalFactory();
        ICat whiteCat = whiteAnimalFactory.createCat();
        whiteCat.eat();
        IDog whiteDog = whiteAnimalFactory.createDog();
        whiteDog.eat();
    }
}
  • 运行结果：
    在这里插入图片描述

七、总结

由此可见，工厂方法确实为系统结构提供了非常灵活强大的动态扩展机制，只要我们更换一下具体的工厂方法，系统其他地方无需一点变换，就有可能将系统功能进行改头换面的变化

工厂方法

一、概述

定义一个用于创建对象的接口，让子类决定实例化哪一个类。FactoryMethod使一个类的实例化延迟到其子类。

二、适用性

  • 当一个类不知道它所必须创建的对象的类的时候。
  • 当一个类希望由它的子类来指定它所创建的对象的时候。
  • 当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。

三、参与者

  • Product 定义工厂方法所创建的对象的接口。
  • ConcreteProduct 实现Product接口。
  • Creator 声明工厂方法，该方法返回一个Product类型的对象。 Creator也可以定义一个工厂方法的缺省实现，它返回一个缺省的ConcreteProduct对象。 可以调用工厂方法以创建一个Product对象。
  • ConcreteCreator 重定义工厂方法以返回一个ConcreteProduct实例。

四、类图

在这里插入图片描述

五、示例

  • Product
package com.cz.Creativemodel.factorymethod;

/**
 * @Author: zhang
 * @Date: 2021/3/29 - 20:52
 * @Descripetion: 定义一个接口Wo
 **/
public interface Work {
    /**
     * 定义方法
     */
    void doWork();
}
  • ConcreteProduct
package com.cz.Creativemodel.factorymethod;

/**
 * @Author: zhang
 * @Date: 2021/3/29 - 20:52
 * @Descripetion: Work接口的具体实现类
 **/
public class TeacherWork implements Work {
    @Override
    public void doWork() {
        System.out.println("老师审批作业!");
    }
}

package com.cz.Creativemodel.factorymethod;

/**
 * @Author: zhang
 * @Date: 2021/3/29 - 20:53
 * @Descripetion:  Work接口的具体实现类
 **/
public class StudentWork implements Work {
    @Override
    public void doWork() {
        System.out.println("学生做作业!");
    }
}
  • Creator
package com.cz.Creativemodel.factorymethod;

/**
 * @Author: zhang
 * @Date: 2021/3/29 - 20:54
 * @Descripetion: 抽象工厂接口
 **/
public interface IWorkFactory {
    /**
     * 定义获取Work实例对象的方法
     * @return
     */
    Work getWork();
}
  • ConcreteCreator
package com.cz.Creativemodel.factorymethod;

/**
 * @Author: zhang
 * @Date: 2021/3/29 - 20:55
 * @Descripetion: IWorkFactory工厂的实现类
 **/
public class StudentWorkFactory implements IWorkFactory {
    @Override
    public Work getWork() {
        return new StudentWork();
    }
}

package com.cz.Creativemodel.factorymethod;

/**
 * @Author: zhang
 * @Date: 2021/3/29 - 20:56
 * @Descripetion: IWorkFactory工厂的实现类
 **/
public class TeacherWorkFactory implements IWorkFactory {
    @Override
    public Work getWork() {
        return new TeacherWork();
    }
}
  • Test
package com.cz.Creativemodel.factorymethod;

/**
 * @Author: zhang
 * @Date: 2021/3/29 - 21:00
 * @Descripetion: 测试类
 **/
public class Test {
    public static void main(String[] args) {
        IWorkFactory studentWorkFactory = new StudentWorkFactory();
        studentWorkFactory.getWork().doWork();

        IWorkFactory teacherWorkFactory = new TeacherWorkFactory();
        teacherWorkFactory.getWork().doWork();
    }
}
  • 运行结果：
    在这里插入图片描述

建造者模式

一、概述

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

二、适用性

  • 当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。
  • 当构造过程必须允许被构造的对象有不同的表示时。

三、参与者

  • Builder 为创建一个Product对象的各个部件指定抽象接口。
  • ConcreteBuilder 实现Builder的接口以构造和装配该产品的各个部件。定义并明确它所创建的表示。提供一个检索产品的接口。
  • Director构造一个使用Builder接口的对象。
  • Product 表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程。包含定义组成部件的类，包括将这些部件装配成最终产品的接口。

四、类图

在这里插入图片描述

五、示例

  • Builder
package com.cz.Creativemodel.builder;

/**
 * @Author: zhang
 * @Date: 2021/3/29 - 21:09
 * @Descripetion: Person对象的构造接口
 **/
public interface PersonBuilder {

    void buildHead();
    void buildBody();
    void buildFoot();

    Person buildPerson();
}
  • ConcreteBuilder
package com.cz.Creativemodel.builder;

/**
 * @Author: zhang
 * @Date: 2021/3/29 - 21:12
 * @Descripetion: Person对象的构造器
 **/
public class ManBuilder implements PersonBuilder {

    Person person;

    public ManBuilder(){
        person = new Man();
    }

    @Override
    public void buildHead() {
        person.setHead("建造男人的头");
    }

    @Override
    public void buildBody() {
        person.setBody("建造男人的身体");
    }

    @Override
    public void buildFoot() {
        person.setFoot("建造男人的脚");
    }

    @Override
    public Person buildPerson() {
        return person;
    }
}
  • Director
package com.cz.Creativemodel.builder;

/**
 * @Author: zhang
 * @Date: 2021/3/29 - 21:15
 * @Descripetion: Person对象的整体构造器
 **/
public class PersonDirector {

    public Person constructPerson(PersonBuilder pb){
        pb.buildHead();
        pb.buildBody();
        pb.buildFoot();
        return pb.buildPerson();
    }
}
  • Product
package com.cz.Creativemodel.builder;

/**
 * @Author: zhang
 * @Date: 2021/3/29 - 21:17
 * @Descripetion: Person对象
 **/
public class Person {

    private String head;
    private String body;
    private String foot;

    public String getHead() {
        return head;
    }

    public void setHead(String head) {
        this.head = head;
    }

    public String getBody() {
        return body;
    }

    public void setBody(String body) {
        this.body = body;
    }

    public String getFoot() {
        return foot;
    }

    public void setFoot(String foot) {
        this.foot = foot;
    }
}

package com.cz.Creativemodel.builder;

/**
 * @Author: zhang
 * @Date: 2021/3/29 - 21:18
 * @Descripetion: 创建一个男人类继承Person
 **/
public class Man extends Person {
}
  • Test
package com.cz.Creativemodel.builder;


/**
 * @Author: zhang
 * @Date: 2021/3/29 - 21:19
 * @Descripetion: 描述
 **/
public class Test {
    public static void main(String[] args) {
        PersonDirector pd = new PersonDirector();
        Person person = pd.constructPerson(new ManBuilder());
        System.out.println(person.getHead());
        System.out.println(person.getBody());
        System.out.println(person.getFoot());
    }
}
  • 运行结果：
    在这里插入图片描述

原型模式

一、概述

用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

二、适用性

  • 当一个系统应该独立于它的产品创建、构成和表示时。
  • 当要实例化的类是在运行时刻指定时，例如，通过动态装载。
  • 为了避免创建一个与产品类层次平行的工厂类层次时。
  • 当一个类的实例只能有几个不同状态组合中的一种时。

建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些。

三、参与者

  • Prototype声明一个克隆自身的接口。
  • ConcretePrototype实现一个克隆自身的操作。
  • Client让一个原型克隆自身从而创建一个新的对象。

四、类图

在这里插入图片描述

五、示例

  • Prototype
package com.cz.Creativemodel.prototype;

/**
 * @Author: zhang
 * @Date: 2021/3/29 - 21:24
 * @Descripetion: 原型类，实现Cloneable接口
 **/
public class Prototype implements Cloneable {

    private String name;

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

    public String getName(){
        return this.name;
    }

    public Object clone(){
        try {
            return super.clone();
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }
    }
}
  • ConcretePrototype
package com.cz.Creativemodel.prototype;

/**
 * @Author: zhang
 * @Date: 2021/3/29 - 21:26
 * @Descripetion: 原型类的子类，用于构建原型
 **/
public class ConcretePrototype extends Prototype {

    public ConcretePrototype(String name){
        setName(name);
    }
}
  • Client
package com.cz.Creativemodel.prototype;

/**
 * @Author: zhang
 * @Date: 2021/3/29 - 21:28
 * @Descripetion: 测试类
 **/
public class Test {
    public static void main(String[] args) {
        Prototype prototype = new ConcretePrototype("prototype");
        Prototype prototype1 = (Prototype)prototype.clone();
        System.out.println(prototype.getName());
        System.out.println(prototype1.getName());
    }
}
  • 运行结果：
    在这里插入图片描述

创造型模式就讲完了；结构性模式和行为模式会在接下来的文章写

深入浅出java设计模式（高清中文PDF）
04-05
文件类型为PDF文件，此文档对20多种java设计模式进行了详细讲解，在中文讲解的过程中还附有代码示例给学习者进行参考，使学习者通过实践更容易理解设计模式的原理。 本文档目录： 1.工厂模式 2.单例模式 3.建造模式 4.原型模式 5.适配器模式 6.桥梁模式 7.组合模式 8.装饰模式 9.门面模式 10.享元模式 11.代理模式 12.责任链模式 13.命令模式 14.解释器模式 15.迭代器模式 16.调停者模式 17.备忘录模式 18.观察者模式 19.策略模式 20.状态模式 21.模板模式 22.访问者模式 最后，还附带一个关于“分派”的章节！为了读者对访问者模式有更好的理解。
深入浅出Java 23种设计模式.rar
03-20
本资料"深入浅出Java 23种设计模式"旨在帮助开发者理解和应用这23种经典设计模式。 首先，我们要了解设计模式的三大类别：创建型模式、结构型模式和行为型模式。创建型模式关注对象的创建过程，如单例模式...
java 23种设计模式 深入理解
wrk的博客
12-20 701
以下是学习过程中查询的资料,别人总结的资料,比较容易理解(站在各位巨人的肩膀上,望博主勿究) 创建型 抽象工厂模式 http://www.cnblogs.com/java-my-life/archive/2012/03/28/2418836.html 工厂方法 http://www.cnblogs.com/java-my-life/archive/2012/03/25/2416227.h
深入浅出面向对象设计模式（Java）
CERTAINTY的博客
12-29 991
深入浅出面向对象设计模式（Java）
惊艳！美团T4手码578页设计模式高阶笔记，会是你追求的完美架构设计和代码设计吗？
weixin_50205273的博客
11-29 216
站在巨人的肩膀上学习是我们一直在做的事情，在软件开发的历程中，正是无数前辈们本着追求完美的架构设计和代码设计的初心。经过无数前辈们的探索和努力，逐渐形成了一系列的设计原则和设计模式。今天这篇文章就与大家聊一聊Java的6大设计原则和23种设计模式。 对于Java语言来说，通常包含有6大设计原则和23种设计模式，这些都是前辈们对于开发思想的结晶。我们学习和理解这些设计原则和设计模式，深入掌握其实现原理和使用场景，能够更好的设计我们的系统架构。编写出具有高性能、高并发、高可用、高可扩展性和高可维护性的代码。
深入浅出Java 23种设计模式，最全PDF版本终于开放下载了！！面试必备！！（文末有福利）...
冰河的专栏
07-18 1223
点击上方蓝色“冰河技术”，关注并选择“设为星标”持之以恒，贵在坚持，每天进步一点点！作者个人研发的在高并发场景下，提供的简单、稳定、可扩展的延迟消息队列框架，具有精准的定时任务和延迟队列...
深入浅出Java23种设计模式（二）
chongzi的博客
03-30 925
文章目录结构型模式适配器模式一、概述二、适用性三、参与者四、类图五、示例装饰模式一、概述二、适用性三、参与者四、类图五、示例外观模式一、概述二、适用性三、参与者四、类图五、示例代理模式一、概述二、适用性三、参与者四、类图五、示例桥接模式一、概述二、适用性三、参与者四、类图五、示例组合模式一、概述二、适用性三、参与者四、类图五、示例享元模式一、概述二、适用性三、参与者四、类图五、示例 结构型模式 适配器模式 一、概述 将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一
深入浅出Java23种设计模式（三）
chongzi的博客
04-02 1445
行为模式 责任链模式 一、概述 使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链， 并沿着这条链传递该请求，直到有一个对象处理它为止。 这一模式的想法是，给多个对象处理一个请求的机会，从而解耦发送者和接受者。 二、适用性 有多个的对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定。 在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。 可处理一个请求的对象集合应被动态指定。 三、参与者 Handler定义一个处理请求的接口。 （可选）实现后继链
Java23种设计模式（一）
最新发布
苏叶的专栏
06-18 959
这2个月来，重新出发，从java开发需要的数据库、查询日志工具、开发工具等的安装、环境配置，再到后面的基础学习、数据库学习、扩展学习（maven、mq、设计模式、spring 系列等等），边学边记录，基本上都已经完成，此篇是找工作之前的最后一篇了，主要以内容为主。无论你是几岁，也无论你目前所处的境况有多糟，只要立定目标、一步一步往前走，人生随时都有翻盘的可能性，祝各位一帆风顺，前途坦荡，愿自己能找到心仪的工作，不负未来。
java23种设计模式（一）
小蒋的博客
01-06 331
设计模式（Design Patterns）                                   ——可复用面向对象软件的基础 设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真
深入浅出java
11-14
深入浅出java、中文版，很简单，很生动
[Java] 深入浅出Java
YANG_sena的博客
05-16 458
该栏目由笔者学习Java过程中有用的知识，希望能帮助到大家
java深入浅出
06-20
本书适合于java初学者学习；书中详细了介绍了java相关概念以及如何去学习java这门语言
深入浅出设计模式(C#/Java版)
百里鹤的专栏
04-26 1472
GRASP模式:General Responsibility Assignment Software Patterns：通用责任分配软件模式 里面重要的概念是责任，责任是类间的一种合约或是义务，可以细分为两部分，用公式表示如下： 责任 = 知道责任 + 行为责任（这里面似乎存在概念的循环定义） 注：用通俗的话来讲，责任就是一个类知道要做什么，并且能够做什么。 分为：
深入浅出设计模式C#Java版
09-16
本资源"深入浅出设计模式C#Java版"是针对这两种主流编程语言介绍设计模式的经典著作，旨在帮助开发者理解和应用这些模式。 1. **单例模式**：确保一个类只有一个实例，并提供全局访问点。在C#中，可以使用`密封`和`...
深入浅出Java开发中的23种设计模式详解
u011153869的专栏
09-02 414
http://zz563143188.iteye.com/blog/1847029
深入浅出学java_《深入浅出学JAVA开发初级》
weixin_39797686的博客
02-21 241
整体说明：Java私塾的这一套视频是完全真实课堂录制，实际上课时间为十一天，主要内容包括：1：系统完整的学习Java的基础知识2：深入剖析重点知识点的理论3：超多的编程题目和程序讲解4：最后以一个模拟的银行系统来综合实战所学的知识下面分章节简要描述一下每天视频的内容：第一天1：Java的一些学习方法、在Java私塾学习的内容、项目等，非常重要。2：Java入门：Java是什么、有什么、能干什么、J...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值
>