设计模式（单例模式、观察者模式、发布订阅者模式）、垃圾回收机制

最新推荐文章于 2024-05-18 16:31:13 发布

TOTO come on

最新推荐文章于 2024-05-18 16:31:13 发布

阅读量190

点赞数

文章标签：设计模式 java 数据库

本文链接：https://blog.youkuaiyun.com/qq_56756602/article/details/127038445

版权

本文探讨了设计模式中的单例模式、观察者模式和发布订阅者模式，并详细解释了各自的应用场景。同时，文章还介绍了垃圾回收机制在内存管理中的作用，包括引用计数和标记-清除两种常见算法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

设计模式

什么是设计模式

设计模式

以前程序员在开发项目过程中遇到问题解决出来的一套解决方案（特定代码编写）

设计模式

23种三类

单例模式

整个应用程序中中只有一个实例存在

三类：

创建模式：这些设计模式提供了一种在创建对象的同时隐藏创建逻辑的方式，而不是使用new运算符直接实例化对象

结构模式：这些设计模式关注类和对象的组合，继承的概念用来组合接口和定义组合对象获得新功能的方式

行为模式：这些设计模式特别关注对象之间的通信

   <script>
        class Person {
        // 创建对象之前先判断它是否存在，如果存在，直接使用，不存在去创建
     // static修饰的方法称为静态方法，直接通过类名调用与实例对象无关
           static getInstance() {
                if (this.instance == null) {//instance 实例
                    this.instance = new Person()
                }
                return this.instance
            }
            constructor() {
                this.name = 'jack'
            }
        }
        //创建对象之前判断它是否存在，如果存在，直接使用，不存在去创建
        // let p1 = new Person()
        // let p2 = new Person()

        // getInstance()因其在class类中无法被直接调用，无法被直接调用，只能在它前面加static
        let p1=Person.getInstance()
        let p2=Person.getInstance()
        console.log(p1 === p2)

    </script>

单例模式的应用

希望只有一个div实例存在，每次执行init方法都给同一个div实例对象复制

单例模式，保存整个应用程序中只有一个实例存在

    <script>
        class CreatDiv{
            static getInstance(){
                    if(this.instance==null){
                        this.instance=new CreatDiv()
                    }
                    return this.instance
                }
            constructor(){
             
                this.divEle=document.createElement('div')//创建div节点
                document.body.appendChild(this.divEle)//添加div到body节点
            }
            init(context){
                this.divEle.innerHTML=context
            }
        }
        let div1=CreatDiv.getInstance()
        // let div1=new CreaeDiv()
        div1.init('hello')
        let div2=CreatDiv.getInstance()
        // let div2=new CreateDiv()
        div2.init('world')

        // 希望只有一个div实例存在，每次执行init方法都给同一个div实例对象复制
        // 单例模式，保存整个应用程序中只有一个实例存在
    </script>

观察者模式：

研究对象与对象之间关系

当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新

 <script>
        // 明星类  被观察者-主体
        class Star{
            constructor(name){
                this.name=name
                this.list=[]//存储粉丝对象
            }
            // 添加粉丝对象的方法：实现关注功能
            add(obj){
                this.list.push(obj)  
            }
            // 更新状态
            updateState(message){//循环遍历所有的粉丝
                this.list.forEach(obj=>{
                    obj.receive(message)
                })
            }

        }
        // 粉丝类观察者
        class Observer{
            constructor(name){
                this.name=name
            }
            // J接收明星更新的状态
            receive(msg){
                console.log(this.name+'看到消息'+ msg +'很高兴')
            }
        }
        // 创建明星Sunnee，创建粉丝lucy，rose,jack
        // Sunnee宣布将要发布新专辑
        let sunnee=new Star('Sunnee')
        let lucy=new Observer('lucy')
        let rose=new Observer('rose')
        let jack=new Observer('jack')

        // 关注明星
        sunnee.add(rose)
        sunnee.add(lucy)
        // Sunnee宣布发布新专辑
        sunnee.updateState('发布新专辑')


    </script>

发布订阅者模式

发布者-> 消息事件中心->订阅者

不同类型->订阅者

按钮点击事件

发布者（点击按钮的人）

|

事件处理中心

|

订阅者（按钮）

三部分组成：

发布者：负责发布消息事件处理（一对多）

订阅者：订阅事件处理中心消息

事件处理中心：

处理不同类型的消息，发送给不同的订阅者

{

type(消息类型)：[消息事件1，消息事件2]

click：[执行订阅消息1，执行订阅消息2]

mousemove:[...]

}

订阅消息

向事件对象添加一条数据

发布消息

触发指定类型消息

购书

小明去书店购书，书店没有三国演义本书，小明订阅这本书，当书到达时通知我

小红去书店购书，书店没有西游记本书，小明订阅这本书，当书到达时通知我

订阅者事件处理中心发布者(出版商，书店)

购书buybook

通知订阅者书到达

<body>
    <button class="btn1">订阅者1</button>
    <button class="btn2">订阅者2</button>
    <script>
       function test(){
        const btn1=document.querySelector('.btn1')
        const btn2=document.querySelector('.btn2')
        // 订阅事件添加事件监听器
        btn1.addEventListener('click',function(){
            console.log('执行订阅的消息1')
        })
        btn2.addEventListener('click',function(){
            console.log('执行订阅的消息2')
        })


       }

    //    事件处理中心  面向对象来实现
    class EventCenter{
        constructor(){
            // {type:[执行消息处理函数1，执行消息处理函数2]}
            this.subs={}
        }
        // 订阅消息添加订阅消息
        addEvent(type,even){
            // type 为变量故用中括号
        //     if(this.subs[type]){
        //         this.subs[type]=[]
        //     }
        //     this.subs[type].push(even)
        this.subs[type]=this.subs[type]||[]
        this.subs[type].push(even)
        }
        // 发布消息
        emitEvent(type){
            if(this.subs[type]){
                this.subs[type].forEach(even=>{
                    even()
                });
            }
        }
    }

    // let eventCenter=new EventCenter()
    // // 订阅类型为click的事件
    // eventCenter.addEvent('click',function(){
    //     console.log('执行消息处理函数1');
    // })
    // eventCenter.addEvent('click',function(){
    //     console.log('执行消息处理函数2');
    // })

    // // 发布消息
    // eventCenter.emitEvent('click')

    let eventCenter = new EventCenter()
            eventCenter.addEvent('buybook',function(){
                console.log('你订阅的三国演义书已到');
            })
            eventCenter.addEvent('buybook',function(){
                console.log('你订阅的西游记书已到');
            })

            eventCenter.emitEvent('buybook')
    </script>

垃圾回收机制

回收释放不再使用的"对象"占用的内存空间

内存管理

分配内存

读写内存

回收释放内存

回收释放内存

c语言 malloc()和free() 作用回收释放内存

JavaScript语言中，“垃圾回收机制”程序自动处理回收释放内存

垃圾回收机制

垃圾回收算法

1.引用计数垃圾收集

判断当前对象有无其他对象引用，如果没有，垃圾回收机制释放它占用的内存

（垃圾回收程序定时遍历内存中所有对象）

<script>
        let obj={name:'jack',age:18}
        obj.name='rose'
        obj.age=20
        obj=null
    </script>

缺点：不能回收相互引用的对象

  <script>
      function test1(){
        let obj={name:'jack',age:18}
        obj.name='rose'
        obj.age=20
         // obj=null
      }
      let obj1={
        a:null,
      }
      let obj2={
        b:null,
      }
      obj2.b=obj1
      obj1.a=obj2
       

    </script>

2.标记-清除法

垃圾回收器将定期从根开始，找所有从根开始引用的对象，如果没有引用，则被回收