Java常用设计模式

奇遇少年2024-06-30 20:20

引言

设计模式是软件工程中的一种模板，用于解决在软件设计过程中遇到的常见问题。设计模式不是代码，而是解决特定问题的策略。Java作为一种面向对象的编程语言，提供了丰富的特性来实现各种设计模式。

目录

    • 引言
    • 创建型模式
      • [1. 单例模式（Singleton）](#1. 单例模式（Singleton）)
      • [2. 工厂方法模式（Factory Method）](#2. 工厂方法模式（Factory Method）)
      • [3. 抽象工厂模式（Abstract Factory）](#3. 抽象工厂模式（Abstract Factory）)
      • [4. 建造者模式（Builder）](#4. 建造者模式（Builder）)
      • [5. 原型模式（Prototype）](#5. 原型模式（Prototype）)
    • 结构型模式
      • [1. 适配器模式（Adapter）](#1. 适配器模式（Adapter）)
      • [2. 装饰器模式（Decorator）](#2. 装饰器模式（Decorator）)
      • [3. 代理模式（Proxy）](#3. 代理模式（Proxy）)
      • [4. 外观模式（Facade）](#4. 外观模式（Facade）)
      • [5. 桥接模式（Bridge）](#5. 桥接模式（Bridge）)
    • 行为型模式
      • [1. 策略模式（Strategy）](#1. 策略模式（Strategy）)
      • [2. 模板方法模式（Template Method）](#2. 模板方法模式（Template Method）)
      • [3. 观察者模式（Observer）](#3. 观察者模式（Observer）)
      • [4. 迭代器模式（Iterator）](#4. 迭代器模式（Iterator）)
      • [5. 责任链模式（Chain of Responsibility）](#5. 责任链模式（Chain of Responsibility）)
    • 结语

创建型模式

创建型模式主要关注对象的创建过程，隐藏创建逻辑，实例化对象的代码不会依赖于具体类。Java中常见的创建型模式有：

1. 单例模式（Singleton）

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

java 复制代码 
public class Singleton {
    private static Singleton instance;
    private Singleton() {}
    
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

2. 工厂方法模式（Factory Method）

工厂方法模式定义了一个创建对象的接口，让子类决定实例化哪一个类。

java 复制代码 
interface Product { void use(); }
class ConcreteProduct implements Product { public void use() { ... } }
abstract class Creator { abstract Product factoryMethod(); }
class ConcreteCreator extends Creator {
    public Product factoryMethod() { return new ConcreteProduct(); }
}

3. 抽象工厂模式（Abstract Factory）

抽象工厂模式创建相关或依赖对象的家族，而不需明确指定具体类。

java 复制代码 
interface ProductA { void useA(); }
interface ProductB { void useB(); }
interface AbstractFactory { ProductA createProductA(); ProductB createProductB(); }
class ConcreteFactory implements AbstractFactory {
    public ProductA createProductA() { return new ProductAImpl(); }
    public ProductB createProductB() { return new ProductBImpl(); }
}

4. 建造者模式（Builder）

建造者模式用于创建一个复杂对象，同时允许用户只通过指定复杂对象的类型和内容就能构建它们。

java 复制代码 
class Product {
    public void setPart(String part) { ... }
    public static class Builder {
        private Product product = new Product();
        public Builder setPart(String part) {
            product.setPart(part);
            return this;
        }
        public Product build() { return product; }
    }
}

5. 原型模式（Prototype）

原型模式通过拷贝现有的实例创建新的实例，而不是通过新建。

java 复制代码 
class Prototype implements Cloneable {
    public void use() { ... }
    public Prototype clone() { ... }
}

结构型模式

结构型模式主要关注对象的组合，继承和成员管理，它们定义了如何将对象组合成更大的结构。

1. 适配器模式（Adapter）

适配器模式将一个类的接口转换成客户期望的另一个接口。

java 复制代码 
interface Target { void request(); }
class Adaptee { public void specificRequest() { ... } }
class Adapter implements Target {
    private Adaptee adaptee;
    public Adapter(Adaptee adaptee) { this.adaptee = adaptee; }
    public void request() { adaptee.specificRequest(); }
}

2. 装饰器模式（Decorator）

装饰器模式动态地给一个对象添加额外的职责。

java 复制代码 
interface Component { void operate(); }
abstract class Decorator implements Component {
    protected Component component;
    public Decorator(Component component) { this.component = component; }
    public void operate() { component.operate(); }
}
class ConcreteComponent implements Component { public void operate() { ... } }
class ConcreteDecoratorA extends Decorator {
    public ConcreteDecoratorA(Component component) { super(component); }
    public void operate() {
        super.operate();
        // 添加额外职责
    }
}

3. 代理模式（Proxy）

代理模式为另一个对象提供一个代替或占位符，以控制对它的访问。

java 复制代码 
interface Subject { void request(); }
class RealSubject implements Subject { public void request() { ... } }
class Proxy implements Subject {
    private RealSubject realSubject;
    public Proxy() { this.realSubject = new RealSubject(); }
    public void request() {
        // 代理职责
        realSubject.request();
    }
}

4. 外观模式（Facade）

外观模式提供了一个统一的高层接口，用来访问子系统中的一群接口。

java 复制代码 
class SubSystemOne { public void operation1() { ... } }
class SubSystemTwo { public void operation2() { ... } }
class Facade {
    private SubSystemOne one;
    private SubSystemTwo two;
    public Facade() { one = new SubSystemOne(); two = new SubSystemTwo(); }
    public void operation() {
        one.operation1();
        two.operation2();
    }
}

5. 桥接模式（Bridge）

桥接模式将抽象部分与它的实现部分分离，使它们可以独立地变化。

java 复制代码 
abstract class Abstraction {
    protected Implementor implementor;
    public Abstraction(Implementor implementor) {
        this.implementor = implementor;
    }
    public void operation() {
        implementor.operationImplementor();
    }
}
interface Implementor {
    void operationImplementor();
}
class ConcreteImplementorA implements Implementor {
    public void operationImplementor() { ... }
}

行为型模式

行为型模式主要关注对象间的通信，它们将对象的行为和算法封装起来，独立于客户端。

1. 策略模式（Strategy）

策略模式定义了一系列算法，并将每一个算法封装起来，使它们可以互换。

java 复制代码 
interface Strategy { void algorithm(); }
class ConcreteStrategyA implements Strategy { public void algorithm() { ... } }
class Context {
    private Strategy strategy;
    public Context(Strategy strategy) { this.strategy = strategy; }
    public void executeStrategy() { strategy.algorithm(); }
}

2. 模板方法模式（Template Method）

模板方法模式定义了一个算法的骨架，将一些步骤的执行延迟到子类。

java 复制代码 
abstract class AbstractClass {
    public void templateMethod() {
        baseOperation1();
        baseOperation2();
        operation();
    }
    protected abstract void operation();
    protected void baseOperation1() { ... }
    protected void baseOperation2() { ... }
}
class ConcreteClass extends AbstractClass {
    protected void operation() { ... }
}

3. 观察者模式（Observer）

观察者模式定义了对象间的一种一对多的依赖关系，当一个对象改变状态时，所有依赖于它的对象都得到通知并自动更新。

java 复制代码 
interface Observer { void update(); }
interface Subject {
    void attach(Observer o);
    void detach(Observer o);
    void notifyObservers();
}
class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<>();
    public void attach(Observer o) { observers.add(o); }
    public void detach(Observer o) { observers.remove(o); }
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }
}

4. 迭代器模式（Iterator）

迭代器模式提供一种顺序访问一个聚合对象中的各个元素，而又不暴露其内部的表示。

java 复制代码 
interface Iterator {
    boolean hasNext();
    Object next();
}
interface Aggregate {
    Iterator createIterator();
}
class ConcreteIterator implements Iterator {
    private List<Object> items;
    private int position = 0;
    public ConcreteIterator(List<Object> items) { this.items = items; }
    public boolean hasNext() { return position < items.size(); }
    public Object next() { return items.get(position++); }
}

5. 责任链模式（Chain of Responsibility）

责任链模式使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。

java 复制代码 
interface Handler {
    void handleRequest(Request request);
}
class ConcreteHandlerA extends Handler {
    private Handler next;
    public void setNext(Handler next) { this.next = next; }
    public void handleRequest(Request request) {
        if (next != null) {
            next.handleRequest(request);
        }
    }
}

结语

设计模式是软件开发过程中的宝贵财富，它们提供了解决特定问题的通用方法。掌握设计模式不仅能够帮助开发者写出更加优雅、灵活和可维护的代码，而且能够促进团队之间的沟通和代码的共享。Java作为一门广泛应用的编程语言，其对设计模式的支持非常全面，学习和应用Java设计模式对于提升编程技能至关重要。

相关推荐
hakesashou几秒前
Python中常用的函数介绍
java·网络·python
qq_459730032 分钟前
C 语言面向对象
c语言·开发语言
佚先森9 分钟前
2024ARM网络验证 支持一键云注入引流弹窗注册机 一键脱壳APP加固搭建程序源码及教程
java·html
菜鸟学Python11 分钟前
Python 数据分析核心库大全！
开发语言·python·数据挖掘·数据分析
小白不太白95013 分钟前
设计模式之 责任链模式
python·设计模式·责任链模式
一个小坑货18 分钟前
Cargo Rust 的包管理器
开发语言·后端·rust
bluebonnet2723 分钟前
【Rust练习】22.HashMap
开发语言·后端·rust
古月居GYH23 分钟前
在C++上实现反射用法
java·开发语言·c++
吾与谁归in41 分钟前
【C#设计模式(13)——代理模式(Proxy Pattern)】
设计模式·c#·代理模式
吾与谁归in42 分钟前
【C#设计模式(14)——责任链模式( Chain-of-responsibility Pattern)】
设计模式·c#·责任链模式
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO07【目标跟踪】相机运动补偿08Unity中PICO实现 隔空取物 和 接触抓取物体09RAG 实践- Ollama+RagFlow 部署本地知识库10量化方法怎么选？如何评估量化后的大模型LLM？