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

已于 2025-01-02 17:25:58 修改
阅读量406 收藏
点赞数 2
分类专栏： java TypeScript 文章标签： 设计模式 笔记 java
于 2024-12-16 14:58:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/ftm_csdn/article/details/144508668
版权

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

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

最佳自学课程

目录

一、观察者模式

Java

TypeScript

二、建造者模式

关联文章

请问Java8进阶水平中，常用的设计模式有哪些？

一、观察者模式

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 registerObserver(Observer o) {
        observers.add(o);
    }

    //注销
    public void removeObserver(Observer o) {
        observers.remove(o);
    }

    public void notifyAllObservers(){
        Iterator<Observer> iterator = observers.iterator();
        // 使用迭代器遍历LinkedList
        while (iterator.hasNext()) {
            // hasNext()方法检查是否还有下一个元素
            // next()方法返回序列中的下一个元素
            Observer element = iterator.next();
            element.update();
        }
        //原文链接：https://blog.youkuaiyun.com/ftm_csdn/article/details/140175119
    }
}

 观察者抽象类

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

    public Observer(Subject subject) {
        this.subject = subject;
    }

    public Subject getSubject() {
        return subject;
    }
}

 观察者实现类

public class BinaryObserver extends Observer {

    public BinaryObserver(Subject subject){
        super(subject);
        getSubject().registerObserver(this);
    }

    @Override
    public void update() {
        System.out.println( "Binary String: " + Integer.toBinaryString(getSubject().getState()) );
    }
}
public class HexaObserver extends Observer {

    public HexaObserver(Subject subject){
        super(subject);
        getSubject().registerObserver(this);
    }

    @Override
    public void update() {
        System.out.println( "Hex String: " + Integer.toHexString(getSubject().getState()).toUpperCase() );
    }
}
public class OctalObserver extends Observer {

    public OctalObserver(Subject subject){
        super(subject);
        getSubject().registerObserver(this);
    }

    @Override
    public void update() {
        System.out.println( "Octal String: " + Integer.toOctalString(getSubject().getState()) );
    }
}

  调用方式

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();
    }

    @Override
    public void registerObserver(ObserverABC o) {
        observers.add(o);
    }

    @Override
    public void removeObserver(ObserverABC o) {
        observers.remove(o);
    }

    public void notifyAllObservers(){
        // 获取LinkedList的迭代器
        Iterator<ObserverABC> iterator = observers.iterator();

        // 使用迭代器遍历LinkedList
        while (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);
    }

    @Override
    public 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);
    }

    @Override
    public 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);
    }

    @Override
    public 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); // 再次通知所有观察者

二、建造者模式

// 产品类：汽车
public class Car {
    private String engine;
    private String wheels;
    private String color;

    // 声明建造者
    private CarBuilder builder;

    // 构造函数私有化
    private Car(CarBuilder builder) {
        this.builder = builder;
    }

    // 外部获取建造者对象
    public static CarBuilder builder() {
        return new CarBuilder();
    }

    // 建造者设置部件
    public CarBuilder setEngine(String engine) {
        this.engine = engine;
        return builder;
    }

    public CarBuilder setWheels(String wheels) {
        this.wheels = wheels;
        return builder;
    }

    public CarBuilder setColor(String color) {
        this.color = color;
        return builder;
    }

    // 建造方法，返回汽车对象
    public Car build() {
        return this;
    }

    @Override
    public String toString() {
        return "Car{" +
                "engine='" + engine + '\'' +
                ", wheels='" + wheels + '\'' +
                ", color='" + color + '\'' +
                '}';
    }
}

// 建造者类
public class CarBuilder {
    private Car car;

    public CarBuilder() {
        car = new Car(this);
    }

    public CarBuilder setEngine(String engine) {
        car.setEngine(engine);
        return this;
    }

    public CarBuilder setWheels(String wheels) {
        car.setWheels(wheels);
        return this;
    }

    public CarBuilder setColor(String color) {
        car.setColor(color);
        return this;
    }

    public Car build() {
        return car.build();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Car car = Car.builder()
                .setEngine("V8")
                .setWheels("Aluminum Wheels")
                .setColor("Red")
                .build();

        System.out.println(car);
    }
}


 

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值