Java中的设计模式是一种被广泛应用于软件开发的解决方案,旨在解决常见的软件设计问题。设计模式分为三大类:创建型模式、结构型模式和行为型模式。以下是一些常见的设计模式及其原理:
1. 创建型模式
-
单例模式(Singleton Pattern)
原理:单例模式确保一个类只有一个实例,并提供一个全局访问点来获取这个实例。这通常用于需要全局唯一实例的场景,比如配置管理、数据库连接池等。
实现方式:
- 私有构造函数:防止外部直接实例化。
- 静态实例:类中持有一个私有的静态实例。
- 公共静态方法:提供一个全局访问点来获取实例,并确保线程安全(使用
synchronized
或双重检查锁定等技术)。
示例代码:
public class Singleton { private static Singleton instance; private Singleton() { // 私有构造函数,防止外部实例化 } public static synchronized Singleton getInstance() { if (instance == null) { instance = new Singleton(); // 创建实例 } return instance; } }
-
工厂方法模式(Factory Method Pattern)
原理:工厂方法模式定义一个用于创建对象的接口,但由子类决定实例化哪个类。工厂方法模式将对象的创建推迟到子类,从而实现了创建和使用的解耦。
实现方式:
- 抽象工厂类:定义一个工厂方法,返回抽象产品。
- 具体工厂类:实现工厂方法,创建具体产品。
- 抽象产品类:定义产品的公共接口。
- 具体产品类:实现产品接口。
示例代码:
// 抽象产品 interface Product { void use(); } // 具体产品 class ConcreteProductA implements Product { public void use() { System.out.println("Using Product A"); } } class ConcreteProductB implements Product { public void use() { System.out.println("Using Product B"); } } // 抽象工厂 abstract class Creator { public abstract Product factoryMethod(); } // 具体工厂 class ConcreteCreatorA extends Creator { public Product factoryMethod() { return new ConcreteProductA(); } } class ConcreteCreatorB extends Creator { public Product factoryMethod() { return new ConcreteProductB(); } }
-
抽象工厂模式(Abstract Factory Pattern)
原理:抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们的具体类。它创建多个产品对象,每个产品属于一个产品族。
实现方式:
- 抽象工厂:定义创建产品对象的接口。
- 具体工厂:实现抽象工厂接口,生成具体的产品。
- 抽象产品:定义产品的接口。
- 具体产品:实现抽象产品接口。
示例代码:
// 抽象产品A interface AbstractProductA { void operationA(); } // 具体产品A1 class ProductA1 implements AbstractProductA { public void operationA() { System.out.println("Operation A1"); } } // 具体产品A2 class ProductA2 implements AbstractProductA { public void operationA() { System.out.println("Operation A2"); } } // 抽象工厂 interface AbstractFactory { AbstractProductA createProductA(); } // 具体工厂1 class ConcreteFactory1 implements AbstractFactory { public AbstractProductA createProductA() { return new ProductA1(); } } // 具体工厂2 class ConcreteFactory2 implements AbstractFactory { public AbstractProductA createProductA() { return new ProductA2(); } }
2. 结构型模式
-
适配器模式(Adapter Pattern)
原理:适配器模式将一个类的接口转换成客户端所期望的另一种接口,使得原本因接口不匹配而不能一起工作的类可以一起工作。它通过包装一个对象,使其符合目标接口。
实现方式:
- 目标接口:客户端期望的接口。
- 适配者类:需要适配的类,具有目标接口所不具备的接口。
- 适配器类:实现目标接口,并将请求转发到适配者类。
示例代码:
// 目标接口 interface Target { void request(); } // 适配者类 class Adaptee { public void specificRequest() { System.out.println("Specific request"); } } // 适配器类 class Adapter implements Target { private Adaptee adaptee; public Adapter(Adaptee adaptee) { this.adaptee = adaptee; } public void request() { adaptee.specificRequest(); } }
-
装饰者模式(Decorator Pattern)
原理:装饰者模式动态地给一个对象添加一些额外的职责。它比生成子类更灵活,允许在运行时为对象添加功能。
实现方式:
- 组件接口:定义对象的接口。
- 具体组件:实现组件接口的类。
- 装饰者抽象类:持有一个组件对象,并实现组件接口。
- 具体装饰者:扩展装饰者抽象类,为对象添加新功能。
示例代码:
// 组件接口 interface Component { void operation(); } // 具体组件 class ConcreteComponent implements Component { public void operation() { System.out.println("Concrete Component Operation"); } } // 装饰者抽象类 abstract class Decorator implements Component { protected Component component; public Decorator(Component component) { this.component = component; } public void operation() { component.operation(); } } // 具体装饰者 class ConcreteDecorator extends Decorator { public ConcreteDecorator(Component component) { super(component); } public void operation() { super.operation(); addedBehavior(); } private void addedBehavior() { System.out.println("Added Behavior"); } }
-
代理模式(Proxy Pattern)
原理:代理模式为其他对象提供一种代理以控制对这个对象的访问。代理对象可以在客户端和真实对象之间起到中介作用,可以增加额外的功能或控制访问权限。
实现方式:
- 主题接口:定义真实对象和代理对象的共同接口。
- 真实主题:实现主题接口,定义实际的业务逻辑。
- 代理对象:实现主题接口,控制对真实主题的访问。
示例代码:
// 主题接口 interface Subject { void request(); } // 真实主题 class RealSubject implements Subject { public void request() { System.out.println("Real Subject Request"); } } // 代理对象 class Proxy implements Subject { private RealSubject realSubject; public void request() { if (realSubject == null) { realSubject = new RealSubject(); } realSubject.request(); } }
3. 行为型模式
-
策略模式(Strategy Pattern)
原理:策略模式定义一系列算法,将每一个算法封装起来,并使它们可以互换。策略模式让算法独立于使用它的客户端独立变化。
实现方式:
- 策略接口:定义所有支持的算法的共同接口。
- 具体策略:实现策略接口的具体算法。
- 上下文:使用策略对象,调用策略的方法。
示例代码:
// 策略接口 interface Strategy { void execute(); } // 具体策略A class ConcreteStrategyA implements Strategy { public void execute() { System.out.println("Strategy A"); } } // 具体策略B class ConcreteStrategyB implements Strategy { public void execute() { System.out.println("Strategy B"); } } // 上下文 class Context { private Strategy strategy; public Context(Strategy strategy) { this.strategy = strategy; } public void executeStrategy() { strategy.execute(); } }
-
**观察者模式(Observer Pattern