23中设计模式，以及三种常见的设计模式demo

news2024/11/17 23:42:35

常见的23种设计模式

在这里插入图片描述

Java设计模式是软件工程中常见的解决方案，用于解决在软件设计中反复出现的问题。设计模式可以分为三大类：创建型模式、结构型模式和行为型模式。这里，我将简单介绍三种常见的设计模式，并给出相应的Java代码示例。

1. 工厂方法模式（Factory Method Pattern） - 创建型模式

工厂方法模式定义了一个用于创建对象的接口，但让子类决定要实例化的类是哪一个。工厂方法让类的实例化推迟到子类中进行。

示例代码：

// 抽象产品类
interface Product {
    void use();
}

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

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

// 抽象工厂类
interface Creator {
    Product factoryMethod();
}

// 具体工厂类A
class ConcreteCreatorA implements Creator {
    @Override
    public Product factoryMethod() {
        return new ConcreteProductA();
    }
}

// 具体工厂类B
class ConcreteCreatorB implements Creator {
    @Override
    public Product factoryMethod() {
        return new ConcreteProductB();
    }
}

// 客户端代码
public class FactoryMethodDemo {
    public static void main(String[] args) {
        Creator creatorA = new ConcreteCreatorA();
        Product productA = creatorA.factoryMethod();
        productA.use();

        Creator creatorB = new ConcreteCreatorB();
        Product productB = creatorB.factoryMethod();
        productB.use();
    }
}

2. 单例模式（Singleton Pattern） - 创建型模式

单例模式确保一个类仅有一个实例，并提供一个全局访问点。

示例代码（懒汉式）：

public class Singleton {
    // 私有静态实例，懒加载
    private static Singleton instance;

    // 私有构造函数，防止外部实例化
    private Singleton() {}

    // 提供一个全局的静态方法，返回唯一实例
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }

    // 示例方法
    public void someMethod() {
        System.out.println("SomeMethod is called");
    }

    // 客户端代码
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        singleton.someMethod();
    }
}

3. 观察者模式（Observer Pattern） - 行为型模式

观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。

示例代码：

import java.util.ArrayList;
import java.util.List;

// 抽象主题类
interface Subject {
    void registerObserver(Observer o);
    void removeObserver(Observer o);
    void notifyObservers();
}

// 抽象观察者类
interface Observer {
    void update(String message);
}

// 具体主题类
class ConcreteSubject implements Subject {
    private List<Observer> observers;
    private String message;

    public ConcreteSubject() {
        observers = new ArrayList<>();
    }

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

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

    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(message);
        }
    }

    public void setMessage(String message) {
        this.message = message;
        notifyObservers();
    }
}

// 具体观察者类
class ConcreteObserver implements Observer {
    private String name;

    public ConcreteObserver(String name) {
        this.name = name;
    }

    @Override
    public void update(String message) {
        System.out.println(name + " received: " + message);
    }
}

// 客户端代码
public class ObserverDemo {
    public static void main(String[] args) {
        ConcreteSubject subject = new ConcreteSubject();

        Observer observer1 = new ConcreteObserver("Observer1");
        Observer observer2 = new ConcreteObserver("Observer2");

        subject.registerObserver(observer1);
        subject.registerObserver(observer2);

        subject.setMessage("Hello, Observers!");
    }
}