Java中的设计模式：单例模式、观察者模式、模板方法模式

翻滚的胖子
2023-05-28 13:29:27
后端技术
Java Python

本文将为大家详细介绍Java中的三种设计模式：单例模式、观察者模式、模板方法模式，包括函数用法、参数讲解以及附带对应的代码案例。

一、单例模式

单例模式是一种常见的设计模式，它保证一个类只有一个实例，并提供了一个全局访问点。在Java中，我们可以通过以下方式实现单例模式：

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

上述代码中，我们通过私有构造函数和静态方法getInstance()实现了单例模式。getInstance()方法返回的是Singleton类的唯一实例。

1.1 单例模式的应用场景

单例模式通常应用于以下场景：

线程池
数据库连接池
日志对象
配置文件对象

1.2 单例模式的优点

单例模式具有以下优点：

保证一个类只有一个实例，避免了重复创建对象的开销
提供了一个全局访问点，方便了对唯一实例的访问

1.3 单例模式的缺点

单例模式具有以下缺点：

不适用于多线程环境下的并发访问
需要进行额外的处理才能支持序列化

二、观察者模式

观察者模式是一种常见的设计模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象，当主题对象发生变化时，它的所有观察者都会接收到通知并更新自己。

2.1 观察者模式的实现

在Java中，我们可以通过以下方式实现观察者模式：

import java.util.ArrayList;

public interface Subject {
    void addObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
}

public interface Observer {
    void update();
}

public class ConcreteSubject implements Subject {
    private ArrayList observers;
    
    public ConcreteSubject() {
        observers = new ArrayList();
    }
    
    public void addObserver(Observer observer) {
        observers.add(observer);
    }
    
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }
    
    public void notifyObservers() {
        for(Observer observer : observers) {
            observer.update();
        }
    }
}

public class ConcreteObserver implements Observer {
    public void update() {
        // 更新操作
    }
}

上述代码中，我们定义了Subject接口和Observer接口，以及它们的具体实现类ConcreteSubject和ConcreteObserver。Subject接口定义了添加、删除和通知观察者的方法，Observer接口定义了更新操作的方法。在ConcreteSubject中，我们使用ArrayList来存储观察者，并在notifyObservers()方法中遍历观察者列表，调用它们的update()方法。在ConcreteObserver中，我们实现了update()方法，用于更新操作。

2.2 观察者模式的应用场景

观察者模式通常应用于以下场景：

GUI系统中的事件处理
发布-订阅模式
消息队列系统

2.3 观察者模式的优点

观察者模式具有以下优点：

定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象
当主题对象发生变化时，它的所有观察者都会接收到通知并更新自己
主题和观察者之间是松耦合的，可以自由地增加或删除观察者

2.4 观察者模式的缺点

观察者模式具有以下缺点：

观察者之间有依赖关系，如果观察者过多，会导致系统性能降低
通知顺序不确定，可能会导致不必要的开销

三、模板方法模式

模板方法模式是一种常见的设计模式，它定义了一个操作中的算法框架，将一些步骤延迟到子类中实现，使得子类可以不改变一个算法的结构即可重新定义该算法的某些特定步骤。

3.1 模板方法模式的实现

在Java中，我们可以通过以下方式实现模板方法模式：

public abstract class AbstractClass {
    public final void templateMethod() {
        primitiveOperation1();
        primitiveOperation2();
        concreteOperation();
        hook();
    }
    
    protected abstract void primitiveOperation1();
    protected abstract void primitiveOperation2();
    
    private void concreteOperation() {
        // 具体操作
    }
    
    protected void hook() {}
}

public class ConcreteClass extends AbstractClass {
    protected void primitiveOperation1() {
        // 具体实现1
    }
    
    protected void primitiveOperation2() {
        // 具体实现2
    }
}

上述代码中，我们定义了一个抽象类AbstractClass，其中templateMethod()方法是算法的模板方法，它定义了一个算法的框架，并调用了primitiveOperation1()、primitiveOperation2()、concreteOperation()和hook()等方法。其中primitiveOperation1()和primitiveOperation2()方法是抽象方法，需要子类实现，concreteOperation()方法是具体方法，子类不能改变，hook()方法是一个空方法，子类可以选择实现或不实现。在ConcreteClass中，我们继承了AbstractClass并实现了primitiveOperation1()和primitiveOperation2()方法。