java 23种设计模式

已于 2023-08-01 14:04:57 修改
阅读量3.6k 收藏 14
点赞数 6
文章标签： java 设计模式 开发语言
于 2023-06-08 12:47:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014133383/article/details/131101799
版权
本文介绍了Java中常用的设计模式，重点讲解了创建型模式，包括工厂方法、抽象工厂、建造者、原型和单例模式。这些模式主要用于对象的创建，通过不同的方式实现了对象实例化的控制，增强了代码的灵活性和可扩展性。其中，工厂方法模式和抽象工厂模式遵循开闭原则，允许在不修改原有代码的情况下扩展产品类型。单例模式则确保一个类只有一个实例，并提供全局访问点。
摘要由CSDN通过智能技术生成

作者备注：该文未全部完成，正在编辑完善中

文字结构：

第1章为类型

第2章为概念

第3章为概念和优缺点

第4章为详细或demo

第1章 Java语言中常用的设计模式有23种，它们被分为三大类：

1、创建型模式（Creational Patterns）

2、结构型模式（Structural Patterns）

3、行为型模式（Behavioral Patterns）

第2章

创建型模式（Creational Patterns）:

        1、工厂方法模式（Factory Method Pattern）

              1.1、简单工厂模式（Simple Factory Pattern）

        2、抽象工厂模式（Abstract Factory Pattern）

        3、建造者模式（Builder Pattern）

        4、原型模式（Prototype Pattern）

        5、单例模式（Singleton Pattern）

结构型模式（Structural Patterns）: 

       6、适配器模式（Adapter Pattern）

       7、桥接模式（Bridge Pattern）

       8、组合模式（Composite Pattern）

       9、装饰者模式（Decorator Pattern）

      10、外观模式（Facade Pattern）

      11、享元模式（Flyweight Pattern）

      12、代理模式（Proxy Pattern）

行为型模式（Behavioral Patterns）:

      13、 责任链模式（Chain of Responsibility Pattern）

      14、命令模式（Command Pattern）

      15、解释器模式（Interpreter Pattern）

      16、迭代器模式（Iterator Pattern）

      17、中介者模式（Mediator Pattern）

      18、备忘录模式（Memento Pattern）

      19、观察者模式（Observer Pattern）

      20、状态模式（State Pattern）

      21、策略模式（Strategy Pattern）

      22、模板方法模式（Template Method Pattern）

      23、访问者模式（Visitor Pattern）

第3章

创建型模式（Creational Patterns）:

      （1.1）、简单工厂模式：这不是一种设计模式，反而比较像是一种编程习惯。

                优点：
                        封装了创建对象的过程，可以通过参数直接获取对象。把对象的创建和业务逻辑层分开，这样以后就避免了修改客户代码，如果要实现新产品直接修改工厂类，而不需要在原代码中修改，这样就降低了客户 代码修改的可能性，更加容易扩展。
                缺点：
                       增加新产品时还是需要修改工厂类的代码，违背了 “ 开闭原则 ” 。

        1、工厂方法模式（Factory Method Pattern）

               概念：定义一个用于创建对象的接口，让子类决定实例化哪个产品类对象。工厂方法使一个产品类的实例化延 迟到其工厂的子类。

               优点： 用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程； 在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类，无须对原工厂进行任何修改， 满足开闭原则；

               缺点： 每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度。

              

        2、抽象工厂模式（Abstract Factory Pattern）

                概念：是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构

               优点： 当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

               缺点： 当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。

        3、建造者模式（Builder Pattern）

        4、原型模式（Prototype Pattern）

        5、单例模式（Singleton Pattern）

1、工厂方法模式（Factory Method Pattern）

     1.1、简单工厂模式（Simple Factory Pattern）

             简单工厂模式 是工厂方法设计模式的一种实现方式，用于封装对象的实例化过程。在该模式中，通过一个工厂类来根据客户端的 参数 请求创建不同的产品对象，从而实现对象的创建与使用代码的解耦。但是 简单工厂模式违反了开闭原则

简单工厂模式的一般结构和要点：

  1. 产品接口（Product）：定义了具体产品对象的共同方法，可以是一个抽象类或者接口。

  2. 具体产品（Concrete Product）：实现了产品接口的具体产品类。

  3. 工厂类（Factory）：负责创建具体产品对象的类。它通常包含一个静态方法，根据客户端的请求来创建相应的产品对象。

// 产品接口
interface Product {
    void operation();
}

// 具体产品A
class ConcreteProductA implements Product {
    @Override
    public void operation() {
        System.out.println("生产了A产品");
    }
}

// 具体产品B
class ConcreteProductB implements Product {
    @Override
    public void operation() {
        System.out.println("生产了B产品");
    }
}


// 工厂类
class Factory {
    public static Product createProduct(String type) {
        if (type.equals("A")) {
            return new ConcreteProductA();
        } else if (type.equals("B")) {
            return new ConcreteProductB();
        } else {
            return null;
        }
    }
}

// 使用示例
public class Main {
    public static void main(String[] args) {
        // 使用工厂类创建产品A
        Product productA = Factory.createProduct("A");
        productA.operation();

        // 使用工厂类创建产品B
        Product productB = Factory.createProduct("B");
        productB.operation();
    }
}

小结：

       简单工厂模式，客户端通过工厂类的静态方法来创建具体产品的实例，而不需要直接实例化产品对象。客户端只需要知道产品的类型（例如"A"或"B"），工厂类根据类型创建相应的产品对象。这样可以隐藏实例化过程，使得客户端与具体产品的实现解耦。

简单工厂模式适用于以下场景：

  • 客户端只需要知道产品的类型，不需要关心具体产品的实现细节。
  • 需要集中管理对象的创建过程，避免在多个地方重复创建对象的代码。
  • 需要通过一个公共接口来创建不同类型的产品对象。

注意:

       简单工厂模式违反了开闭原则，如果需要添加新的产品类型，就需要修改工厂类的代码。如果需要更好的扩展性和灵活性，可以考虑使用工厂方法模式或抽象工厂模式。

1.2、工厂方法模式（Factory Method Pattern）

        用于创建对象的实例化过程。在该模式中，定义一个创建对象的接口，但将实际创建对象的过程延迟到子类中进行。这样，可以将对象的实例化与使用代码解耦，使得代码更具有灵活性和可扩展性。

以下是工厂方法模式的一般结构和要点：

  1. 产品接口（Product）：定义了具体产品对象的共同方法，可以是一个抽象类或者接口。

  2. 具体产品（Concrete Product）：实现了产品接口的具体产品类。

  3. 工厂接口（Creator）：声明了创建产品对象的工厂方法，可以是一个抽象类或者接口。这个方法返回一个产品对象。

  4. 具体工厂（Concrete Creator）：实现了工厂接口，负责创建具体产品对象。

// 产品接口
interface Product {
    void operation();
}

// 具体产品A
class ConcreteProductA implements Product {
    @Override
    public void operation() {
        System.out.println("生产了A产品");
    }
}

// 具体产品B
class ConcreteProductB implements Product {
    @Override
    public void operation() {
        System.out.println("生产了B产品");
    }
}

// 工厂接口
interface Factory {
    Product createProduct();
}

// 具体工厂A
class FactoryA implements Factory {
    @Override
    public Product createProduct() {
        System.out.print("由A工厂");
        return new ConcreteProductA();
    }
}

// 具体工厂B
class FactoryB implements Factory {
    @Override
    public Product createProduct() {
        System.out.print("由B工厂");
        return new ConcreteProductB();
    }
}

// 使用示例
public class Main {
    public static void main(String[] args) {
        // 创建具体工厂A
        Factory factoryA = new FactoryA();
        // 使用具体工厂A创建产品
        Product productA = factoryA.createProduct();
        productA.operation();

        // 创建具体工厂B
        Factory factoryB = new FactoryB();
        // 使用具体工厂B创建产品
        Product productB = factoryB.createProduct();
        productB.operation();
    }
}

小结：

        工厂方法模式通过引入抽象工厂类，将具体产品的创建交给子类实现，实现了对产品创建过程的解耦。当需要新增产品时，只需要新增具体产品类和对应的具体工厂类，不需要修改已有代码，符合开闭原则。

       工厂方法模式可以应对不同类型的产品创建需求，每个具体工厂类负责创建一类产品，从而提供了更大的灵活性和扩展性。

2、Java中的抽象工厂模式

        用于创建一组相关或相互依赖的对象。抽象工厂模式提供一个接口来创建一系列具有共同主题的产品，而不需要指定具体的产品类。

以下是抽象工厂模式的一般结构和要点：

  1. 抽象产品接口（Abstract Product）：定义了具体产品对象的共同方法，可以是一个抽象类或接口。

  2. 具体产品（Concrete Product）：实现了抽象产品接口的具体产品类。

  3. 抽象工厂接口（Abstract Factory）：定义了创建一组相关产品对象的方法。

  4. 具体工厂（Concrete Factory）：实现了抽象工厂接口，负责创建一组相关产品对象


// 抽象产品接口 Cpu
 interface Cpu {
    void operationCpu();
}

// 抽象产品接口 硬盘
 interface Disk {
    void operationDisk();
}


//具体产品 华为Cpu
 class HuaWeiCpu implements Cpu {
    @Override
    public void operationCpu() {
        System.out.println("华为Cpu");
    }
}

//具体产品 小米Cpu
 class XiaomiCpu implements Cpu {
    @Override
    public void operationCpu() {
        System.out.println("小米Cpu");
    }
}


// 具体产品 华为硬盘
 class HuaWeiDisk implements Disk {
    @Override
    public void operationDisk() {
        System.out.println("华为硬盘");
    }
}

// 具体产品 小米硬盘
 class XiaomiDisk implements Disk {
    @Override
    public void operationDisk() {
        System.out.println("小米硬盘");
    }
}

// 抽象工厂接口
 interface AbstractFactory {
    Cpu operationCpu();
    Disk operationDisk();
}

// 具体工厂 华为工厂
 class HuaWeiFactory implements AbstractFactory {
    @Override
    public Cpu operationCpu() {
        return new HuaWeiCpu();
    }

    @Override
    public Disk operationDisk() {
        return new HuaWeiDisk();
    }
}

// 具体工厂 小米工厂
class XiaomiFactory implements AbstractFactory {
    @Override
    public Cpu operationCpu() {
        return new XiaomiCpu();
    }

    @Override
    public Disk operationDisk() {
        return new XiaomiDisk();
    }
}


//客户端测试

class Test {

    public static void main(String[] args) {
        // 创建具体工厂 华为
        AbstractFactory huaweiFactory = new HuaWeiFactory();
        // 使用具体工厂 创建产品cpu和产品硬盘
        Cpu huaWeiCpu = huaweiFactory.operationCpu();
        Disk huaWeiDisk = huaweiFactory.operationDisk();
        huaWeiCpu.operationCpu();
        huaWeiDisk.operationDisk();

        // 创建具体工厂 小米
        AbstractFactory xiaomiFactory = new XiaomiFactory();
        // 使用具体工厂 创建产品cpu和产品硬盘
        Cpu xiaomiCpu = xiaomiFactory.operationCpu();
        Disk xiaomiDisk = xiaomiFactory.operationDisk();
        xiaomiCpu.operationCpu();
        xiaomiDisk.operationDisk();
    }
}

小结：

客户端只需要使用抽象工厂接口和抽象产品接口来创建和使用产品，而无需关心具体产品的实现细节。

抽象工厂模式适用于以下场景：

  • 需要创建一组相关或相互依赖的产品对象。
  • 客户端不关心具体产品的实现细节，只需要使用产品的接口。
  • 需要确保一组产品对象被一起创建，避免不一致或错误的配置。

通过抽象工厂模式，可以实现产品族的切换和扩展，同时也符合开闭原则，因为可以通过添加新的具体工厂类和具体产品类来扩展产品族，而无需修改已有的代码。

3、建造者模式（Builder Pattern）

        用于创建复杂对象。建造者模式将对象的构建过程和表示分离，使得同样的构建过程可以创建不同的表示。

以下是建造者模式的一般结构和要点：

  1. 产品类（Product）：表示被构建的复杂对象。产品类通常包含多个属性。

  2. 抽象建造者（Builder）：定义了构建产品的抽象方法，以及设置产品各个部分的方法。

  3. 具体建造者（Concrete Builder）：实现抽象建造者接口，实现具体产品的构建过程。具体建造者通常包含一个具体产品实例作为成员变量，以便在构建过程中逐步组装产品。

  4. 指挥者（Director）：负责使用具体建造者构建产品。指挥者定义了构建产品的顺序和步骤，可以通过指挥者来统一构建过程。

class Student {

    private String name;
    private Integer age;
    private String address;

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                '}';
    }
}

 class Builder{

    private Student student;

   public Builder(){
        student = new Student();
    }

    public Builder setName(String name){
       this.student.setName(name);
       return this;
    }

    public Builder setAge(Integer age){
        this.student.setAge(age);
        return this;
    }

    public Builder setAddress(String address){
        this.student.setAddress(address);
        return this;
    }

    public Student builder(){
        return student;
    }

}

class Test{
    public static void main(String[] args) {
       Student student =  new Builder()
                .setName("张三")
                .setAge(18)
                .setAddress("地址信息")
                .builder();

       System.out.println(student);
    }
}

4、原型模式（Prototype Pattern）

        核心思想是通过克隆（Clone）已有的原型对象来创建新的对象实例。Java中，原型模式的实现依赖于java.lang.Cloneable接口和clone()方法。

以下是原型模式的一般结构和要点：

  1. 原型接口（Prototype）：定义了克隆方法clone()，用于复制现有对象并创建新对象。

  2. 具体原型类（Concrete Prototype）：实现原型接口，实现clone()方法，完成对象的复制。

  3. 客户端（Client）：使用原型对象创建新对象的客户端代码。客户端通过调用原型对象的clone()方法来创建新对象，而不是使用构造函数或工厂方法。

class Student implements Cloneable{

    private String name;
    private Integer age;
    private String address;

    private List<String> friends;

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }




    public List<String> getFriends() {
        return friends;
    }

    public void setFriends(List<String> friends) {
        this.friends = friends;
    }

    @Override
    protected Object clone()  {
        try {
            return super.clone();
        } catch (CloneNotSupportedException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                ", friends=" + friends +
                '}';
    }
}

 class Builder{

    private Student student;

   public Builder(){
        student = new Student();
    }

    public Builder setName(String name){
       this.student.setName(name);
       return this;
    }

    public Builder setAge(Integer age){
        this.student.setAge(age);
        return this;
    }

    public Builder setAddress(String address){
        this.student.setAddress(address);
        return this;
    }

     public Builder setFriends(List<String> friends) {
         this.student.setFriends(friends);
         return this;
     }
    public Student builder(){
        return student;
    }

}

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

        List<String> friends = new ArrayList<>();
        friends.add("小明");
        friends.add("小wang");
        friends.add("小米");
        friends.add("小高");

       Student student =  new Builder()
                .setName("张三")
                .setAge(18)
                .setAddress("地址信息")
               .setFriends(friends)
                .builder();

       System.out.println(student);

        Student student2 = (Student) student.clone();
        student2.setName("李四");
        System.out.println(student2);

        System.out.println("============浅拷贝==============");

        friends.add("WWWWW");
        System.out.println(student);
        System.out.println(student2);
        System.out.println("是否是同一个："+(student ==student2));
    }
}

运行结果

小结：clone()方法是浅克隆，即只复制对象本身，而不复制其引用的对象。如果需要实现深克隆，需要在clone()方法中手动复制引用对象。

原型模式适用于以下场景：

  • 创建对象的过程比较复杂，而复制已有对象的成本较低。
  • 需要避免使用显式的构造函数来创建新对象。
  • 需要动态地创建对象的副本。

通过原型模式，可以避免重复的对象创建过程，提高性能，并且可以动态地创建新对象，使得对象的创建更加灵活和可扩展。

试试深克隆

//省略重复代码。。。。。。


@Override
    protected Object clone()  {
        try {
            //深克隆方法
             Student student = (Student) super.clone();
             List<String> _friends = new ArrayList<>(this.getFriends());
             student.setFriends(_friends);
             
             return student;
        } catch (CloneNotSupportedException e) {
            throw new RuntimeException(e);
        }
    }

运行结果

深克隆&浅克隆 的总结：

原型模式是一种通过克隆已有对象来创建新对象的设计模式。在某些情况下，我们需要进行深克隆而不仅仅是浅克隆，原因如下：

  1. 避免共享引用对象：如果原型对象和克隆对象之间共享引用对象，那么对其中一个对象的修改会影响到另一个对象。通过深克隆，可以复制引用对象，使得克隆对象拥有独立的引用对象，从而避免共享引用对象的问题。

  2. 保护数据完整性：如果对象中包含引用对象，并且这些引用对象的数据是不可变的，那么深克隆可以确保原型对象和克隆对象之间的数据完整性。如果使用浅克隆，克隆对象和原型对象会共享相同的引用对象，可能导致克隆对象在修改引用对象数据时影响到原型对象。

  3. 处理循环引用：当对象之间存在循环引用时，使用浅克隆可能会导致克隆过程无限循环。通过深克隆，可以避免循环引用的问题，每个对象只被克隆一次。

需要注意的是，深克隆可能会导致性能开销较大，特别是在克隆对象的层次结构较深或对象的数据量较大时。在实际应用中，需要根据具体情况权衡使用浅克隆还是深克隆。

总而言之，通过深克隆可以确保克隆对象与原型对象之间的数据独立性，避免共享引用对象的问题，保护数据完整性，并解决循环引用的情况。这样可以更好地满足原型模式的目标，即通过复制已有对象来创建新对象，而不会对原有对象产生影响。

5、单例模式（Singleton Pattern）

用于确保一个类在全局中有且只有一个实例，并提供全局访问点来访问该实例。

单例模式有以下几种常见的实现方式：

  1. 懒汉式，线程不安全
  2. 懒汉式，线程安全
  3. 饿汉式
  4. 双重检查锁定
  5. 静态内部类

1、懒汉式，线程不安全：

public class Singleton {
    private static Singleton instance;

    private Singleton() {
    }

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

2、懒汉式，线程安全

public class Singleton {
    private static Singleton instance;

    private Singleton() {
    }

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

3、饿汉式

public class Singleton {
    private static Singleton instance = new Singleton();

    private Singleton() {
    }

    public static Singleton getInstance() {
        return instance;
    }
}

4、双重检查锁定

public class Singleton {
    private volatile static Singleton instance;

    private Singleton() {
    }

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

5、静态内部类

public class Singleton {
    private Singleton() {
    }

    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

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

小结：双重检查锁定 为什需要 使用 volatile ？

       在双重检查锁定的单例模式中，为了确保多线程环境下的线程安全性，需要对共享的实例变量添加volatile关键字。volatile关键字的作用是禁止指令重排序和线程的本地缓存，保证多线程环境下的可见性和一致性。

在没有volatile修饰的情况下，可能会发生以下情况：

  1. 线程A执行到第一次检查时，发现实例变量为null，然后线程B获取了锁并创建了实例，然后线程A获得锁进入同步块，在这里再次创建实例。

  2. 当线程A退出同步块并返回实例时，由于指令重排序，可能会先执行写入实例变量的操作，然后再执行实例初始化的操作。这样，线程B在获取到实例时，可能会得到一个未完全初始化的实例。

通过使用volatile关键字，可以解决上述问题。volatile关键字保证了在一个线程中对共享变量的修改对其他线程可见，并且禁止了指令重排序。因此，当一个线程修改了实例变量并将其写回主存时，其他线程能够立即看到这个更新的值。

修饰实例变量的目的是为了确保多线程环境下的可见性和一致性，保证线程安全地获取单例实例。

需要注意的是，使用volatile关键字并不能解决所有线程安全性问题。在双重检查锁定的单例模式中，volatile关键字仅仅保证了实例变量的可见性和一致性，但并不能保证实例本身的线程安全性。因此，在单例模式的实现中，还需要考虑其他线程安全性的问题，例如对初始化过程的同步处理等。

未完，待补充。。。。。

Lambert_lin0
关注
  • 6
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
Java 中的 23 种设计模式详解
微笑听雨
05-06 1万+
项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
java23种设计模式详解
IT-HotBoy的博客
03-15 201
 特别声明：小哥所有设计模式的相关文章都有借鉴于百度百科和其他博主的博客，也感谢这些技术人员 设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。一、设计模式可以分为三大类：1.创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。2.结构型模式，共七种：适配器模式、装饰器模式、代理...
java中23种设计模式详解
最新发布
weixin_49025285的博客
07-08 3637
封装了对象的创建过程：通过工厂模式，可以将对象的创建过程封装在一个工厂类中，客户端无需直接实例化具体的对象，只需要通过工厂类提供的接口获取对象即可。这样可以隐藏对象的具体实现，提高代码的可维护性和可扩展性。总的来说，工厂模式适用于对象的创建过程比较复杂，需要隐藏具体实现，降低客户端与具体对象的耦合，提高代码的可维护性和可扩展性的场景。可以根据需要返回不同的对象：工厂模式可以根据客户端的需求返回不同的对象，满足不同的业务需求。增加了系统的复杂度：引入工厂模式会增加系统中的类和对象的个数，增加了系统的复杂度。
Java设计模式（疯狂Java联盟版）
chuck_sun的专栏
09-08 2666
1. 设计模式........................................................................................................................ 3 1.1 创建型模式
23种设计模式介绍以及在Java中的实现
热门推荐
anxpp的博客
04-24 4万+
文本详细总结了23种设计模式以及他们如何应用到java中，并提供了大量的示例代码。 文章中的示例源码在github上：https://github.com/anxpp/JavaDesignPattern。 如果本文对您有所帮助，请帮忙点个赞扩散一下，谢谢！
【超详细】JAVA设计模式总结之23种设计模式详解（附示例代码）
qq_44082755的博客
05-11 2826
单例模式是一种创建型设计模式，确保一个类只有一个实例，并提供全局访问点来访问该实例。这意味着无论何时请求该类的实例，都将返回相同的实例。单一实例： 一个类只能有一个实例。全局访问点： 提供一个全局的访问点，使得其他对象可以轻松地访问到这个实例。延迟实例化： 实例化过程被延迟到第一次请求该实例时。节省资源： 由于只有一个实例，节省了内存和系统资源。易于控制： 由于单例模式限制了实例化过程，因此易于对实例化过程进行控制。易于扩展： 对单例类的访问点是全局的，因此易于对其功能进行扩展和修改。
Java的23种设计模式
初心不忘、始终方得
09-01 5575
大话java23种设计模式，通俗易懂
java设计模式总结
聚娃科技开发者博客
09-09 149
设计模式按照"四人帮"的分类一共分为三种。 创建型模式 东西(类)是怎么创建出来的。 Abstract Factory Bulider Factory Method Prototype Singleton 结构型模式 主要是类与类之间的结构。 Adapter Bridge Composite Decorator Facade Flyweight Proxy 行为型模式 主要是类的动作。 C...
java 23种设计模式.zip
11-19
设计模式主要分为三大类： 1.创建型模式：工厂模式、抽象工厂模式、单例模式、建造者模式、原型模式。 2.结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。 4.行为型模式：...
Java 23种设计模式全归纳
05-16
### Java 23种设计模式全归纳 #### 资源概述 本资源包汇总了Java中23种经典设计模式的详细介绍和使用示例，旨在帮助开发者系统性地学习和掌握设计模式在软件开发中的应用。这些设计模式分为三大类：创建型模式、...
java23种设计模式
10-17
java23种设计模式，每一种模式都有详细的讲解，很全面，如果你想深入了解一下java23种设计模式，这会非常适合你的哦！上传乃为百度云连接，失效请留言。 内容： 001策略模式! N. B8 ~' D! f9 j+ g0 I 002观察者模式 ...
Java 23种设计模式详解
03-16
Java 全部23种设计模式全面详解 设计模式的六大原则 1、开闭原则（Open Close Principle） 2、里氏代换原则（Liskov Substitution Principle） 3、依赖倒转原则（Dependence Inversion Principle） 4、接口隔离原则...
Java23种设计模式
楊帥
01-07 764
了解设计模式之前先了解：设计模式的六大原则 定义：设计模式（Design Pattern）是一套反复使用、多数人知晓的、经过分类编目的代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 23种设计模式分类： 单例模式 单例模式 单例模式 单例模式 单例模式 单例模式 单例模式 单例模式 单例模式 单例模式 单例模式 单例模式 单例模式 单例模式 单例...
java的23种设计模式
海的博客
04-27 1万+
java的23种设计模式 设计模式可以分为3大类： 创建型模式（5种）：工厂方法模式、抽象工厂模式、单列模式、建造者模式、原型模式。 结构型模式（7种）：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为模式（11种）：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、访问者模式、中介者模式、解释器模式。 创建者模式 工厂模式、抽象工厂模式、单例模式、建造者模式、原型模式. 1.工厂模式 1.1 简单工厂模式
Java 23种设计模式
刘程云的博客
11-25 215
代理模式：为其他对象提供一种代理用于控制对这个对象的访问。在某些场景下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介作用抽象角色：通过接口或抽象类声明真实角色实现的业务方法代理角色：实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作真实角色：实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调用。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值