当前位置： 首页 > news >正文

【软件设计_设计模式】设计模式代码笔记

news 2024/12/20 16:20:55

 设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。

设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理地运用设计模式可以完美地解决很多问题，每种模式在现实中都有相应的原理来与之对应，每种模式都描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是设计模式能被广泛应用的原因。

最佳自学课程

目录

一、观察者模式

Java

TypeScript

一、观察者模式

Java

主题

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;public class Subject {private List<Observer> observers = new LinkedList<>();private int state;public int getState() {return state;}public void setState(int state) {this.state = state;notifyAllObservers();}public void attach(Observer observer){observers.add(observer);}public void notifyAllObservers(){Iterator<Observer> iterator = observers.iterator();// 使用迭代器遍历LinkedListwhile (iterator.hasNext()) {// hasNext()方法检查是否还有下一个元素// next()方法返回序列中的下一个元素Observer element = iterator.next();element.update();}//原文链接：https://blog.csdn.net/ftm_csdn/article/details/140175119}
}

 观察者抽象类

public abstract class Observer {protected Subject subject;public abstract void update();
}

 观察者实现类

public class BinaryObserver extends Observer{public BinaryObserver(Subject subject){this.subject = subject;this.subject.attach(this);}@Overridepublic void update() {System.out.println( "Binary String: " + Integer.toBinaryString( subject.getState() ) ); }
}
public class HexaObserver extends Observer{public HexaObserver(Subject subject){this.subject = subject;this.subject.attach(this);}@Overridepublic void update() {System.out.println( "Hex String: " + Integer.toHexString( subject.getState() ).toUpperCase() ); }
}

 调用方式

public class ObserverPatternDemo {public static void main(String[] args) {Subject subject = new Subject();new HexaObserver(subject);new OctalObserver(subject);new BinaryObserver(subject);System.out.println("First state change: 15");   subject.setState(15);System.out.println("Second state change: 10");  subject.setState(10);}
}

观察者（实现者）抽象类 

/*** Created by tianming.fan on 2024/12/13.*/
//观察者是接收主题通知的对象。观察者需要实现一个更新方法，当收到主题的通知时，调用该方法进行更新操作。
public abstract class ObserverABC<T> {protected SubjectAPI subject;public abstract void update(T data);public ObserverABC(SubjectAPI subject) {this.subject = subject;}public SubjectAPI getSubject() {return subject;}
}

主题接口 


/*** Created by tianming.fan on 2024/12/13.*/
//主题（Subject）：也称为被观察者或可观察者，它是具有状态的对象，并维护着一个观察者列表。主题提供了添加、删除和通知观察者的方法。
public interface SubjectAPI {//注册void registerObserver(ObserverABC o);//注销void removeObserver(ObserverABC o);//通知void notifyAllObservers();
}

主题（命令） 实现类

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;/*** Created by tianming.fan on 2024/12/13.*/
//主题（Subject）：也称为被观察者或可观察者，它是具有状态的对象，并维护着一个观察者列表。主题提供了添加、删除和通知观察者的方法。
public class Subject implements SubjectAPI{private List<ObserverABC> observers = new LinkedList<ObserverABC>();private String data;public void setData(String data) {this.data = data;notifyAllObservers();}@Overridepublic void registerObserver(ObserverABC o) {observers.add(o);}@Overridepublic void removeObserver(ObserverABC o) {observers.remove(o);}public void notifyAllObservers(){// 获取LinkedList的迭代器Iterator<ObserverABC> iterator = observers.iterator();// 使用迭代器遍历LinkedListwhile (iterator.hasNext()) {// hasNext()方法检查是否还有下一个元素// next()方法返回序列中的下一个元素ObserverABC element = iterator.next();element.update(data);}}
}

观察者实现类 

/*** Created by tianming.fan on 2024/12/13.*/
//观察者（Observer）：观察者是接收主题通知的对象。观察者需要实现一个更新方法，当收到主题的通知时，调用该方法进行更新操作。
public class BinaryObserver extends ObserverABC<String> {public BinaryObserver(SubjectAPI subject){super(subject);getSubject().registerObserver(this);}@Overridepublic void update(String data) {System.out.println( "Binary String: " + Integer.toBinaryString(Integer.parseInt(data)) );}
}
public class HexaObserver extends ObserverABC<String> {public HexaObserver(SubjectAPI subject){super(subject);getSubject().registerObserver(this);}@Overridepublic void update(String data) {System.out.println( "Hex String: " + Integer.toHexString( Integer.parseInt(data) ).toUpperCase() );}
}
public class OctalObserver extends ObserverABC<String> {public OctalObserver(SubjectAPI subject){super(subject);getSubject().registerObserver(this);}@Overridepublic void update(String data) {System.out.println( "Octal String: " + Integer.toOctalString(Integer.parseInt(data)) );}
}

/*** 观察者模式是一种行为型设计模式，它定义了一种一对多的依赖关系，当一个对象的状态发生改变时，其所有依赖者都会收到通知并自动更新。** 当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知依赖它的对象。观察者模式属于行为型模式。*//**结构观察者模式包含以下几个核心角色：主题（Subject）：也称为被观察者或可观察者，它是具有状态的对象，并维护着一个观察者列表。主题提供了添加、删除和通知观察者的方法。观察者（Observer）：观察者是接收主题通知的对象。观察者需要实现一个更新方法，当收到主题的通知时，调用该方法进行更新操作。具体主题（Concrete Subject）：具体主题是主题的具体实现类。它维护着观察者列表，并在状态发生改变时通知观察者。具体观察者（Concrete Observer）：具体观察者是观察者的具体实现类。它实现了更新方法，定义了在收到主题通知时需要执行的具体操作。*/
public class ObserverPatternDemo {public static void main(String[] args) {Subject subject = new Subject();new HexaObserver(subject);new OctalObserver(subject);new BinaryObserver(subject);System.out.println("First state change: 15");subject.setData(String.valueOf(19));}
}

TypeScript

// 定义抽象观察者类
export abstract class AbstractObserver {public abstract update(): void;
}
import { AbstractObserver } from './AbstractObserver';
// 定义主题接口
export interface Subject {attach(observer: AbstractObserver): void;detach(observer: AbstractObserver): void;notify(): void;
}
import { AbstractObserver } from "./AbstractObserver";
import type { Subject } from "./Subject";// 实现主题
export class ConcreteSubject implements Subject {private observers: AbstractObserver[] = [];private state: number = 0;public getState(): number {return this.state;}public setState(state: number): void {this.state = state;this.notify();}public attach(observer: AbstractObserver): void {if (this.observers.indexOf(observer) === -1) {this.observers.push(observer);}}public detach(observer: AbstractObserver): void {const index = this.observers.indexOf(observer);if (index !== -1) {this.observers.splice(index, 1);}}public notify(): void {for (const observer of this.observers) {observer.update();}}
}
import { AbstractObserver } from './AbstractObserver';
import { ConcreteSubject } from './ConcreteSubject';
// 实现具体观察者
export class ConcreteObserver extends AbstractObserver {private subject: ConcreteSubject;constructor(subject: ConcreteSubject) {super();this.subject = subject;}public update(): void {console.log(`观察者收到通知：主题状态已更新为 ${this.subject.getState()}`);}
}

import { AbstractObserver } from './src/AbstractObserver';
import { ConcreteSubject } from './src/ConcreteSubject';
import { ConcreteObserver } from './src/ConcreteObserver';// 使用示例
const subject = new ConcreteSubject();
const observer1 = new ConcreteObserver(subject);
const observer2 = new ConcreteObserver(subject);subject.attach(observer1);
subject.attach(observer2);subject.setState(1); // 通知所有观察者
subject.detach(observer1); // 移除一个观察者subject.setState(2); // 再次通知所有观察者


http://www.mrgr.cn/news/80828.html

相关文章：

  • 论文笔记：是什么让多模态学习变得困难？
  • golang结构体转map
  • MLM: 掩码语言模型的预训练任务
  • 云计算赋能：TSP 问题求解与创新定价机制的全景剖析
  • C++【默认成员函数（下）】
  • xctf-WEB-新手练习区Exercise area-Writeup
  • 关于在浏览器里面获取手机方向的事件
  • Java收发邮件 Jakarta mail
  • 每日十题八股-2024年12月19日
  • el-table 多表头+跨行跨列案例
  • 使用Gradio编写大模型ollama客户端 -界面版
  • Kaggler日志--Day9
  • Docker：Dockerfile(补充四)
  • 【Rust自学】4.1. 所有权：栈内存 vs. 堆内存
  • 【Linux】NET9运行时移植到低版本GLIBC的Linux纯内核板卡上
  • 初学stm32 ——— 串口通信
  • Qt Quick：CheckBox 复选框
  • Spring Boot 配置Kafka
  • 【0371】Postgres内核 实现构建一个 WAL record
  • 【java面向对象编程】第二弹----成员方法
  • 基于DockerCompose搭建Redis主从哨兵模式
  • js分页功能
  • 【Python】使用Selenium 操作浏览器 自动化测试 记录
  • regression里面的误差来源
  • Pytorch | 从零构建AlexNet对CIFAR10进行分类
  • Linux函数栈帧