24种设计模式

最新推荐文章于 2023-07-07 17:08:45 发布
最新推荐文章于 2023-07-07 17:08:45 发布
阅读量215 收藏 1
点赞数
分类专栏： 设计模式 文章标签： 设计模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53941773/article/details/129428084
版权
文章详细介绍了Java中的几种设计模式，包括单例模式的饿汉式和懒汉式实现，其中强调了线程安全问题和优化策略；工厂方法模式和抽象工厂模式的概念及优缺点；还提到了原型模式中的深克隆和浅克隆。这些模式在软件开发中用于提高代码复用性和系统扩展性。
摘要由CSDN通过智能技术生成

主要模式有： 单例模式、工厂方法模式、抽象工厂模式、代理模式、装饰器模式、观察者模式和责任链模式。

单例模式

饿汉式单例模式

**定义：**在类加载时就完成了初始化，所以类加载比较慢，但是获取对象的速度快

注意：饿汉式因为在类加载时就完成了实例化一个静态对象出来，第一次调用会很快，所以饿汉式天生就是线程安全的，可以直接用于多线程而不出现问题

package com.briup.TestSingleton;

/**
 * @Auther: pp's_husband
 * @Date: 2022/7/28---10:42
 * @Description:    饿汉式单例模式
 */
public class Singleton {
    String name=null;
    private final static Singleton INSTANCE = new Singleton();
    private Singleton(){};
    public static Singleton getInstance(){
        return INSTANCE;
    }
    public String getName() {
        return name;
    }

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

    public void printInfo(){
        System.out.println("the name is "+name);
    }
}


package com.briup.TestSingleton;

/**
 * @Auther: pp's_husband
 * @Date: 2022/7/28---10:54
 * @Description:
 */
public class Test {
    public static void main(String[] args) {
        Singleton test1 = Singleton.getInstance();
        test1.setName("lanjianbo");
        Singleton test2 = Singleton.getInstance();
        test2.setName("pp");

        test1.printInfo();
        test2.printInfo();

        if (test1==test2){
            System.out.println("创建的是同一个实例");

        }
        else{
            System.out.println("创建的不是同一个实例");
        }

    }
}

==优缺点：==这是一种比较常见的写法，在类加载的时候就完成了实例化，避免了多线程的同步问题，当然缺点也是有的，因为类加载时就实例化了，没有达到懒汉式加载的效果，如果该实例没有被使用，内存就浪费了

懒汉式单例模式

**定义：**在类加载时不被初始化，等到第一次使用时才初始化，会延迟加载，第一次调用需要初始化，需要做的工作比较多，性能上面会有些延迟，以后就是和饿汉式一样了

普通的懒汉式（线程不安全，不可用）

public class Singleton {

    private static Singleton instance = null;

    private Singleton() {
    }

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

}

这是懒汉式中最简单的一种写法，只有在方法第一次被访问时才会实例化，达到了懒加载的效果，但是这种写法有个致命的问题，就是多线程的安全问题，假设对象还没有被实例化，然后有两个线程同时访问，那么就可能出现多次实例化的结果，所以这种写法不可采用

同步方法的懒汉式（可用）

public class Singleton {

    private static Singleton instance = null;

    private Singleton() {
    }

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

}

这种写法是对getInstance()加了锁的处理，保证了同一时刻只能有一个线程访问并获得实例，但是缺点也很明显，因为synchronized是修饰整个方法，每个线程访问都要进行同步，而其实这个方法只执行一次实例化代码就够了，每次都同步方法显然效率低下，为了改进这种写法，就有了下面的双重检查懒汉式

双重检查懒汉式 (可用，推荐)

package com.briup.TestSingleton;

/**
 * @Auther: pp's_husband
 * @Date: 2022/7/28---10:42
 * @Description:    双重检查懒汉式单例模式
 */
public class LazyMode {

    String name = null;
    //创建LazyMode引用
    private static volatile LazyMode instance;

    //创建私有构造器
    private LazyMode(){}

    //双重检查  synchronized锁
    public static LazyMode getInstance(){
        if(instance == null){
            synchronized (LazyMode.class){
                if(instance == null){
                    instance = new LazyMode();
                }
            }
        }
        return instance;
    }

    public String getName() {
        return name;
    }

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

    public void printInfo(){
        System.out.println("the name is "+name);
    }
}


package com.briup.TestSingleton;

/**
 * @Auther: pp's_husband
 * @Date: 2022/7/28---10:54
 * @Description:
 */
public class Test {
    public static void main(String[] args) {
        LazyMode test1 = LazyMode.getInstance();
        test1.setName("lanjianbo");
        LazyMode test2 = LazyMode.getInstance();
        test2.setName("pp");

        test1.printInfo();
        test2.printInfo();

        if(test1==test2){
            System.out.println("创建的是同一个实例");

        }else{
            System.out.println("创建的不是同一个实例");
        }

    }
}

这种写法用了两个if判断，也就是Double-Check，并且同步的不是方法，而是代码块，效率较高，是对第三种写法的改进。为什么要做两次判断呢？这是为了线程安全考虑，还是那个场景，对象还没实例化，两个线程A和B同时访问静态方法并同时运行到第一个if判断语句，这时线程A先进入同步代码块中实例化对象，结束之后线程B也进入同步代码块，如果没有第二个if判断语句，那么线程B也同样会执行实例化对象的操作了

静态内部类（可用，推荐）

package com.briup.TestSingleton;

/**
 * @Auther: pp's_husband
 * @Date: 2022/7/28---11:13
 * @Description:
 */
public class TestStatic {
    private String name = null;
    private TestStatic(){}
    private static class TestStaticInstance{
        private static final TestStatic INSTANCE = new TestStatic();
    }
    public static TestStatic getInstance(){
        return TestStaticInstance.INSTANCE;
    }

    public String getName() {
        return name;
    }

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

    public void printInfo(){
        System.out.println("the name is "+ name);
    }
}


package com.briup.TestSingleton;

/**
 * @Auther: pp's_husband
 * @Date: 2022/7/28---10:54
 * @Description:
 */
public class Test {
    public static void main(String[] args) {
        TestStatic test1 = TestStatic.getInstance();
        test1.setName("lanjianbo");
        TestStatic test2 = TestStatic.getInstance();
        test2.setName("pp");

        test1.printInfo();
        test2.printInfo();

        if(test1==test2){
            System.out.println("创建的是同一个实例");
        }else{
            System.out.println("创建的不是同一个实例");
        }
    }
}

这是很多开发者推荐的一种写法，这种静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SingletonInstance类，从而完成对象的实例化。

同时，因为类的静态属性只会在第一次加载类的时候初始化，也就保证了SingletonInstance中的对象只会被实例化一次，并且这个过程也是线程安全的。

枚举

public enum Single{
    INSTANCE;
    private Single(){}
    public static void main(String[] args){
        Single single1 = Single.INSTANCE;
        Single single2 = Single.INSTANCE;
        System.out.println(single1 = single2);//true
    }
}

工厂模式

概念：工厂模式将目的将创建对象的具体过程屏蔽隔离起来，从而达到更高的灵活性

简单工厂模式

  • 简单工厂模式的核心是定义一个创建对象的接口，将对象的创建和本身的业务逻辑分离 

  • 优点：
-    简单工厂模式提供专门的工厂类用于创建对象，实现了对象创建和使用的职责分离，客户端不需知道所创建的具体产品类的类名以及创建过程，只需知道具体产品类所对应的参数即可，通过引入配置文件，可以在不修改任何客户端代码的情况下更换和增加新的具体产品类，在一定程度上提高了系统的灵活性。 

  • 缺点：
-    缺点在于不符合“开闭原则”，每次添加新产品就需要修改工厂类。在产品类型较多时，有可能造成工厂逻辑过于复杂，不利于系统的扩展维护，并且工厂类集中了所有产品创建逻辑，一旦不能正常工作，整个系统都要受到影响。
  1. 工厂类角色： 该模式的核心，用来创建产品，含有一定的商业逻辑和判断逻辑
  2. 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。
  3. 具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现
package com.briup.Factory;

/**
 * @Auther: pp's_husband
 * @Date: 2022/8/7---23:52
 * @Description:	简单工厂模式
 */

//用户类
public class SimpleFactoryCustomer{
    public static void main(String[] args){
        Factory factory = new Factory();
        BWM bwm320 = factory.createBWM(320);
        BWM bwm523 = factory.createBWM(523);
    }
}

//工厂类
class Factory{
    public BWM createBWM(int type){
        switch(type){
            case 320:
                return new BWM320();
            case 523:
                return new BWM523();
            default:
                break;
        }
        return null;
    }
}

//产品类
abstract class BWM{
    public BWM(){}
}

class BWM320 extends BWM{
    public BWM320(){
        System.out.println("制造BWN320");
    }
}

class BWM523 extends BWM{
    public BWM523(){
        System.out.println("制造BWM523");
    }
}

工厂方法模式

  • 优点：
    • 工厂方法模式将工厂抽象化，并定义一个创建对象的接口。每增加新产品，只需增加该产品以及对应的具体实现工厂类，由具体工厂类决定要实例化的产品是哪个，将对象的创建与实例化延迟到子类，这样工厂的设计就符合“开闭原则”了，扩展时不必去修改原来的代码。在使用时，用于只需知道产品对应的具体工厂，关注具体的创建过程，甚至不需要知道具体产品类的类名，当我们选择哪个具体工厂时，就已经决定了实际创建的产品是哪个了。
  • 缺点：
    • 但缺点在于，每增加一个产品都需要增加一个具体产品类和实现工厂类，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。
  1. 抽象工厂 AbstractFactory： 工厂方法模式的核心，是具体工厂角色必须实现的接口或者必须继承的父类，在 Java 中它由抽象类或者接口来实现。
  2. 具体工厂 Factory：被应用程序调用以创建具体产品的对象，含有和具体业务逻辑有关的代码
  3. 抽象产品 AbstractProduct：是具体产品继承的父类或实现的接口，在 Java 中一般有抽象类或者接口来实现。
  4. 具体产品 Product：具体工厂角色所创建的对象就是此角色的实例。
package com.briup.Factory;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

/**
 * @Auther: pp's_husband
 * @Date: 2022/8/8---0:08
 * @Description:    工厂方法模式
 */
public class FactoryMethodCustomer {
    public static void main(String[] args) {
        FactoryBWM320 factoryBWM320 = new FactoryBWM320();
        BWM320 bwm320 = factoryBWM320.createBWM();

        FactoryBWM523 factoryBWM523 = new FactoryBWM523();
        BWM523 bwm523 = factoryBWM523.createBWM();
    }
}

//工厂类
interface FactoryBWM{
    BWM createBWM();
}

class FactoryBWM320 implements FactoryBWM{

    @Override
    public BWM320 createBWM() {
        return new BWM320();
    }
}

class FactoryBWM523 implements FactoryBWM{

    @Override
    public BWM523 createBWM() {
        return new BWM523();
    }
}

//产品类
abstract class $BWM{
    public $BWM(){}
}

class $BWM320 extends $BWM{
    public $BWM320(){
        System.out.println("制造BWM32O");
    }
}

class $BWM523 extends $BWM{
    public $BWM523() {
        System.out.println("制造BWM523");
    }
}

抽象工厂模式

  • 优点：
    • 抽象工厂模式主要用于创建相关对象的家族。当一个产品族中需要被设计在一起工作时，通过抽象工厂模式，能够保证客户端始终只使用同一个产品族中的对象；并且通过隔离具体类的生成，使得客户端不需要明确指定具体生成类；所有的具体工厂都实现了抽象工厂中定义的公共接口，因此只需要改变具体工厂的实例，就可以在某种程度上改变整个软件系统的行为。
    • 缺点： 但该模式的缺点在于添加新的行为时比较麻烦，如果需要添加一个新产品族对象时，需要更改接口及其下所有子类，这必然会带来很大的麻烦。
  1. 抽象工厂 AbstractFactory：定义了一个接口，这个接口包含了一组方法用来生产产品，所有的具体工厂都必须实现此接口。
  2. 具体工厂 ConcreteFactory：用于生产不同产品族，要创建一个产品，用户只需使用其中一个工厂进行获取，完全不需要实例化任何产品对象。
  3. 抽象产品 AbstractProduct：这是一个产品家族，每一个具体工厂都能够生产一整组产品。
    具体产品 Product
package com.briup.Factory;

/**
 * @Auther: pp's_husband
 * @Date: 2022/8/8---0:23
 * @Description:  抽象工厂模式
 */
public class AbstractFactoryCustomer {
    public static void main(String[] args) {
        //生产宝马320系列配件
        $FactoryBWM320 $FactoryBWM320 = new $FactoryBWM320();
        $FactoryBWM320.createEngine();
        $FactoryBWM320.createAircondition();

        //生产宝马523系列配件
        $FactoryBWM523 $FactoryBWM523 = new $FactoryBWM523();
        $FactoryBWM523.createEngine();
        $FactoryBWM523.createAircondition();
    }
}

//产品类
//发动机以及型号
interface Engine{}

class EngineA implements Engine{
    public EngineA(){
        System.out.println("制造EngineA");
    }
}

class EngineB implements Engine{
    public EngineB(){
        System.out.println("制造EngineB");
    }
}

//空调以及型号
interface Aircondtion{}

class AirconditionA implements Aircondtion{
    public AirconditionA(){
        System.out.println("制造AirconditionA");
        System.out.println("------------------");
    }
}

class AirconditionB implements Aircondtion{
    public AirconditionB(){
        System.out.println("制造AirconditionB");
    }
}


//创建工厂类
interface AbstractFactory{
    //制造发动机
    public Engine createEngine();

    //制造空调
    public Aircondtion createAircondition();
}

//为宝马320系列生产配件
class $FactoryBWM320 implements AbstractFactory{

    @Override
    public Engine createEngine() {
        return new EngineA();
    }

    @Override
    public Aircondtion createAircondition() {
        return new AirconditionA();
    }
}

//为宝马523系列生产配件
class $FactoryBWM523 implements AbstractFactory{

    @Override
    public Engine createEngine() {
        return new EngineB();
    }

    @Override
    public Aircondtion createAircondition() {
        return new AirconditionB();
    }
}

原型模式

深克隆

浅克隆

潘潘她老公
关注
专栏目录
设计模式大杂烩（24种设计模式的总结以及学习设计模式的几点建议）
Java's paradise
08-14 5737
作者：zuoxiaolong8810（左潇龙），转载请注明出处。                 迄今为止，LZ已经将24种设计模式介绍完了，其中包括GOF23种设计模式以及简单工厂模式，这些设计模式之间并不是完全独立的，而是互相之间，会有一些相同的影子，下面LZ分几个方式去对比和总结下这些设计模式。 类型分类： 1、创建型设计模式：
24种设计模式（一）
zjltju1203的博客
04-30 7378
24种设计模式 第1章　简单工厂 第2章　外观模式 第3章　适配器模式 第4章　单例模式 第5章　工厂方法模式 第6章　抽象工厂模式 第7章　生成器模式 第8章　原型模式 第9章　中介者模式 第10章　代理模式 第11章　观察者模式 第12章　命令模式 第13章　迭代器模式 第14章　组合模式 第15章　模版方法模式 第16章　策略模式 第17章　状态模式 第18章　备忘录模式 第19章　享元模式...
设计模式 24种设计模式总览 单例模式基础使用
m0_45877477的博客
06-07 1138
单例模式UML 成员:静态的实例 方法:私有构造,静态的获取实例方法 创建的时机分类: 饿汉式:在类加载时创建 懒汉式:在使用时做判断,如果需要再创建
24种设计模式（三）
zjltju1203的博客
04-30 532
24种设计模式 第20章　解释器模式 第21章　装饰模式 第22章　责任链模式 第23章　桥接模式 第24章　访问者模式 第20章　解释器模式（Interpreter） 1．解释器模式的定义 给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。 这里的文法，简单点说就是我们俗称的“语法规则”。 2.　解释器模式的结构和说明 ■　AbstractEx...
简单介绍24种设计模式
解决bug的路上
05-25 1604
设计模式是一种经过多年实践证明可用的通用解决方案，它们可以帮助我们在软件开发中更容易地解决一些常见的问题。设计模式分为23种基础模式和一种扩展模式
JAVA 24种设计模式介绍与6大设计原则.pdf
04-12
JAVA 24种设计模式主要分为三类：创建型模式、结构型模式和行为型模式。创建型模式关注对象创建机制，为对象实例化提供指导，包括单例模式、抽象工厂模式、建造者模式、工厂方法模式、原型模式和生成器模式等。结构...
24种设计模式介绍与24种设计模式.pdf
06-21
24种设计模式介绍与24种设计模式.pdf..............................................................................................
24种设计模式介绍与6大设计原则-PDF版 查阅方便
12-22
这个PDF文档“24种设计模式介绍与6大设计原则”旨在帮助开发者理解和应用这些模式，提高代码的可维护性和可扩展性。以下是其中的主要内容： 一、设计原则 1. 单一职责原则：一个类或模块应只有一个引起其变化的原因...
24种设计模式介绍与6大设计原则
11-08
24种设计模式介绍与6大设计原则希望这本书的阅读者具备最基本的代码编写能力，您是一个初级的 coder,可以从中领会到怎么设计 一段优秀的代码；您是一个高级程序员，可以从中全面了解到设计模式以及 Java 的边角技术...
android 24种设计模式介绍与6大设计原则
08-11
以下是关于"Android 24种设计模式介绍与6大设计原则"的详细阐述： 一、六大设计原则 1. **单一职责原则（Single Responsibility Principle, SRP）**：一个类或模块应该只有一个引起它变化的原因。这意味着每个类应...
二十四种设计模式全实现_含图解
12-09
二十四设计模式在暑假空余时间的全实现，附带图解材料阅读。
Java 设计模式 和七大设计原则
dianbu4103的博客
11-09 192
创建型模式 抽象工厂模式(Abstract factory pattern): 提供一个接口, 用于创建相关或依赖对象的家族, 而不需要指定具体类. 生成器模式(Builder pattern): 使用生成器模式封装一个产品的构造过程, 并允许按步骤构造. 将一个复杂对象的构建与它的表示分离, 使得同样的构建过程可以创建不同的表示. 工厂模式(factory method pa...
设计模式概述篇
doufuplus
11-20 878
软件设计模式（Software Design Pattern），又称设计模式（Design Pattern），是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。它描述了在软件设计过程中的一些不断重复发生的问题，以及该问题的解决方案。也就是说，它是解决特定问题的一系列套路，是前辈们的代码设计经验的总结，具有一定的普遍性，可以反复使用。其目的是为了提高代码的可重用性、代码的可读性和代码的可靠性。
24大设计模式总结
最新发布
流华追梦的专栏
07-07 1777
设计模式（Design Pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。在软件开发中，前人对软件系统的设计和开发总结了一些原则和模式， 不管用什么语言做开发，都将对我们系统设计和开发提供指导意义。本文主要将对24种设计模式进行总结和阐述具体意义。创建型（6种）、行为型（11种）、结构型（7种）。
二十四种设计模式：适配器模式(Adapter Pattern)
weixin_34279061的博客
12-15 69
适配器模式(Adapter Pattern) 介绍将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。示例有一个Message实体类，某个类对它的操作有Insert()和Get()方法。现在需要把这个类转到另一个接口，分别对应Add()和Select()方法。 　　MessageModel using System;...
二十四种设计模式（1）-概述
renfujun2012的博客
09-21 1399
前言 设计模式每个开发者都会或多或少的接触过，使用过，设计模式的目的很简单，就是一些解决问题的方案，经过时间的检验，这种方案是最优的，这就形成了一套设计模式。很多的架构都是基于多种设计模式开发的，学习设计模式有利于我们更好的理解源码，提高学习水平。 我们最常听说的设计模式有23种，也有人说是24种，本系列文章默认为24种。设计模式很多，但是在真正的开发过程中，我们用到的也就是我们熟悉的几种，本系列文章就是挑选一部分常用的设计模式，在开发中熟练使用即可。下面会根据设计模式的分类进行讲解。 不管是什么设计模式，
二十四种设计模式和六种设计原则
先学再说
09-11 2377
转载自我的公众号：艳福不深，文末有二维码，欢迎关注 终于把这本买了一年的书浏览了一遍，《大话设计模式》，入门级好书，墙 裂 推荐 这回，对本书的精华之处做了总结 我是一条分割线 六大设计原则 单一职责原则 就一个类而言，应该仅有一个
二十四种设计模式、七大原则
折戟
01-14 2950
转自：http://www.taidous.com/thread-41942-1-3.html 程序： 1.可维护性 2.可复用性   3.可扩展性  4.灵活性好  通过封装、继承、多态把程序的耦合度降低 简单工厂模式: 用一个独立的类来做这个创造实例的过程 聚合表示一种弱的"拥有关系"，体现的是A对象可以包含B对象，但B对象不是A对象的一部分。 合成表示一种强的"拥有
设计模式（24） - 中介者模式
程序人生
08-01 305
问题描述 在一个系统中存在多个实体对象，这些实体对象之间存在交互关系。例如：实体A状态更新会导致实体B自动得到更新，并依据实体A的变化采取相应的动作。把实体对象之间的交互关心设计到每个实体对象中，会引入实体类之间的依赖关系，从而限制了实体类的可重用性。中介者模式引入一个单独的中介者对象来管理实体对象之间的交互关系。每个实体对象只和中介者对象交互，这保证了实体对象之间的独立性。 中介者模式
精通24种设计模式：Java开发者必备
"这是一本关于24种设计模式的书籍，主要针对Java开发者，适合不同级别的程序员学习。书中涵盖了从初级到高级的各种设计模式，包括策略模式、代理模式、单例模式、多例模式等，旨在提升代码设计能力和解决实际问题的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

潘潘她老公

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值