引言
设计模式是软件工程中的一套被反复使用的、大家公认的、经过分类编目的代码设计经验的总结。它们是解决特定问题的模板,可以提高代码的可重用性、可读性和可维护性。本文将介绍Java中常见的20种设计模式,并提供具体的使用场景、设计模式的解释以及示例代码。
创建型模式
单例模式(Singleton)
使用场景 :需要确保某个类只有一个实例,并且提供一个全局访问点。
解释 :单例模式确保一个类只有一个实例,并提供一个全局访问点。
示例代码:
java
public class Singleton {
private static Singleton instance;
private Singleton() {}
public static synchronized Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
工厂方法模式(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();
}
}
抽象工厂模式(Abstract Factory)
使用场景 :当需要创建多个相关或依赖对象的家族时。
解释 :提供一个创建一系列相关或相互依赖对象的接口,而不需要指定它们具体的类。
示例代码:
java
// 类似工厂方法模式,但增加了多个产品族的创建
建造者模式(Builder)
使用场景 :当创建复杂对象时,需要逐步构建。
解释 :将一个复杂对象的构建与其表示分离,使得同样的构建过程可以创建不同的表示。
示例代码:
java
class Product {
// ...
}
class Builder {
private Product product = new Product();
public Builder setPart1(String part1) {
product.setPart1(part1);
return this;
}
// ...
public Product build() {
return product;
}
}
原型模式(Prototype)
使用场景 :当创建新对象成本较高时,可以使用原型模式。
解释 :通过拷贝现有的实例来创建新的实例,而不是通过新建。
示例代码:
java
class Prototype implements Cloneable {
// ...
public Object clone() {
try {
return super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return null;
}
}
结构型模式
适配器模式(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();
}
}
装饰器模式(Decorator)
使用场景 :当需要动态地给一个对象添加额外的职责时。
解释 :在不修改对象结构的情况下,动态地给对象添加职责。
示例代码:
java
interface Component {
void operate();
}
class ConcreteComponent implements Component {
public void operate() {
// ...
}
}
abstract class Decorator implements Component {
protected Component component;
public Decorator(Component component) {
this.component = component;
}
public void operate() {
component.operate();
}
}
class ConcreteDecoratorA extends Decorator {
public ConcreteDecoratorA(Component component) {
super(component);
}
public void operate() {
super.operate();
// 添加额外职责
}
}
代理模式(Proxy)
使用场景 :当需要控制对原始对象的访问时。
解释 :为其他对象提供一个代替或占位符作为它的接口。
示例代码:
java
interface Subject {
void request();
}
class RealSubject implements Subject {
public void request() {
// ...
}
}
class Proxy implements Subject {
private RealSubject realSubject;
public Proxy() {
this.realSubject = null;
}
public void request() {
if (realSubject == null) {
realSubject = new RealSubject();
}
realSubject.request();
}
}
外观模式(Facade)
使用场景 :当需要提供一个客户端可以访问系统的复杂接口的简化接口时。
解释 :定义一个高层接口,使得子系统更容易使用。
示例代码:
java
interface SubSystem {
void operation();
}
class SubSystem0 implements SubSystem {
public void operation() {
// ...
}
}
class SubSystem1 implements SubSystem {
public void operation() {
// ...
}
}
class Facade {
private SubSystem0 subSystem0 = new SubSystem0();
private SubSystem1 subSystem1 = new SubSystem1();
public void operation() {
subSystem0.operation();
subSystem1.operation();
}
}
桥接模式(Bridge)
使用场景 :当需要将抽象部分与它的实现部分分离,使它们可以独立地变化时。
解释 :将抽象与实现解耦,让它们可以独立地变化。
示例代码:
java
abstract class Abstraction {
protected Implementor implementor;
public Abstraction(Implementor implementor) {
this.implementor = implementor;
}
public void operation() {
implementor.operationImpl();
}
}
interface Implementor {
void operationImpl();
}
class ConcreteImplementorA implements Implementor {
public void operationImpl() {
// ...
}
}
class RefinedAbstraction extends Abstraction {
public RefinedAbstraction(Implementor implementor) {
super(implementor);
}
// ...
}
组合模式(Composite)
使用场景 :当需要将对象组合成树形结构以表示"部分-整体"的层次结构时。
解释 :将对象组合成树形结构来表示"部分-整体"的层次结构。
示例代码:
java
interface Component {
void operation();
}
class Leaf implements Component {
public void operation() {
// ...
}
}
class Composite implements Component {
private List<Component> children = new ArrayList<>();
public void add(Component component) {
children.add(component);
}
public void operation() {
for (Component component : children) {
component.operation();
}
}
}
享元模式(Flyweight)
使用场景 :当需要减少创建大量相似对象时。
解释 :通过共享来高效地支持大量细粒度的对象。
示例代码:
java
class Flyweight {
private String intrinsicState;
public Flyweight(String intrinsicState) {
this.intrinsicState = intrinsicState;
}
public void operation(String extrinsicState) {
// ...
}
}
class FlyweightFactory {
private HashMap<String, Flyweight> flyweights = new HashMap<>();
public Flyweight getFlyweight(String key) {
if (!flyweights.containsKey(key)) {
flyweights.put(key, new Flyweight(key));
}
return flyweights.get(key);
}
}
行为型模式
策略模式(Strategy)
使用场景 :当需要在运行时选择算法或行为时。
解释 :定义一系列算法,把它们一个个封装起来,并使它们可互换。
示例代码:
java
interface Strategy {
void algorithmInterface();
}
class ConcreteStrategyA implements Strategy {
public void algorithmInterface() {
// ...
}
}
class Context {
private Strategy strategy;
public Context(Strategy strategy) {
this.strategy = strategy;
}
public void executeStrategy() {
strategy.algorithmInterface();
}
}
模板方法模式(Template Method)
使用场景 :当需要在方法中定义算法的框架,将一些步骤的实现延迟到子类中时。
解释 :定义算法的骨架,将一些步骤的实现延迟到子类中。
示例代码:
java
abstract class AbstractClass {
public void templateMethod() {
step1();
step2();
step3();
}
public abstract void step2();
public void step1() {
// ...
}
public void step3() {
// ...
}
}
class ConcreteClass extends AbstractClass {
public void step2(){
// ...
}
}
观察者模式(Observer)
使用场景 :当一个对象的改变需要同时改变其他对象,而不知道具体有多少对象待改变时。
解释 :对象间存在一对多关系时,则使用观察者模式。
示例代码:
java
interface Observer {
void update();
}
interface Subject {
void registerObserver(Observer o);
void removeObserver(Observer o);
void notifyObservers();
}
class ConcreteSubject implements Subject {
private List<Observer> observers = new ArrayList<>();
public void registerObserver(Observer o) {
observers.add(o);
}
public void removeObserver(Observer o) {
observers.remove(o);
}
public void notifyObservers() {
for (Observer observer : observers) {
observer.update();
}
}
}
class ConcreteObserver implements Observer {
public void update() {
// ...
}
}
迭代器模式(Iterator)
使用场景 :当需要访问一个聚合对象中的元素,而又不暴露其内部的表示时。
解释 :提供一种顺序访问一个聚合对象中的各个元素的方法,而又不暴露其内部的表示。
示例代码:
java
interface Iterator {
boolean hasNext();
Object next();
}
interface Aggregate {
Iterator createIterator();
}
class ConcreteIterator implements Iterator {
private List items;
private int position = 0;
public ConcreteIterator(List items) {
this.items = items;
}
public boolean hasNext() {
return position < items.size();
}
public Object next() {
return items.get(position++);
}
}
class ConcreteAggregate implements Aggregate {
private List items = new ArrayList();
public Iterator createIterator() {
return new ConcreteIterator(items);
}
}
中介者模式(Mediator)
使用场景 :当系统中对象之间存在复杂的引用关系时。
解释 :用一个中介对象来封装一系列对象之间的交互。
示例代码:
java
interface Mediator {
void register(String colleague, Colleague colleague);
void relay(String colleague);
}
interface Colleague {
void setMediator(Mediator mediator);
void notify(String message);
}
class ConcreteMediator implements Mediator {
private Map<String, Colleague> colleagues = new HashMap<>();
public void register(String colleague, Colleague colleague) {
colleagues.put(colleague, colleague);
}
public void relay(String colleague, String event) {
Colleague c = colleagues.get(colleague);
// ...
}
}
class ConcreteColleagueA implements Colleague {
private Mediator mediator;
public void setMediator(Mediator mediator) {
this.mediator = mediator;
}
public void notify(String message) {
mediator.relay("ColleagueA", message);
}
}
命令模式(Command)
使用场景 :当需要将请求封装为一个对象,从而使用不同的请求、队列或日志请求时。
解释 :将请求封装为一个对象,从而使你可用不同的请求、队列或日志来参数化其他对象。
示例代码:
java
interface Command {
void execute();
}
class Receiver {
public void action() {
// ...
}
}
class ConcreteCommand implements Command {
private Receiver receiver;
public ConcreteCommand(Receiver receiver) {
this.receiver = receiver;
}
public void execute() {
receiver.action();
}
}
class Invoker {
private Command command;
public void setCommand(Command command) {
this.command = command;
}
public void executeCommand() {
command.execute();
}
}
责任链模式(Chain of Responsibility)
使用场景 :当多个对象处理请求,但具体哪个对象处理该请求待运行时才能确定时。
解释 :使多个对象都有机会处理请求。从而避免请求的发送者和接收者之间的耦合关系。
示例代码:
java
interface Handler {
void handleRequest(Request request);
}
class ConcreteHandler1 extends Handler {
private Handler next;
public void setNext(Handler next) {
this.next = next;
}
public void handleRequest(Request request) {
if (next != null) {
next.handleRequest(request);
}
}
}
class Request {
// ...
}
备忘录模式(Memento)
使用场景 :当需要保存和恢复对象的内部状态时。
解释 :在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态。
示例代码:
java
class Memento {
private String state;
public Memento(String state) {
this.state = state;
}
public String getState() {
return state;
}
}
class Originator {
private String state;
public Memento saveStateToMemento() {
return new Memento(state);
}
public void getStateFromMemento(Memento memento) {
state = memento.getState();
}
}
class Caretaker {
private Memento memento;
public void setMemento(Memento memento) {
this.memento = memento;
}
public Memento getMemento() {
return memento;
}
}
状态模式(State)
使用场景 :当一个对象的行为取决于它的状态,并且它的状态值在运行时改变时。
解释 :允许对象在内部状态改变时改变它的行为。
示例代码:
java
interface State {
void handle(StateContext context);
}
class ConcreteStateA implements State {
public void handle(StateContext context) {
// ...
}
}
class StateContext {
private State state;
public StateContext(State state) {
this.state = state;
}
public void handleState() {
state.handle(this);
}
}
访问者模式(Visitor)
使用场景 :当需要对一个对象结构中的对象进行操作,而又不想让这些操作依赖于对象的类时。
解释 :为一个对象结构(比如组合结构)增加新能力。
示例代码:
java
interface Element {
void accept(Visitor visitor);
}
class ConcreteElementA implements Element {
public void accept(Visitor visitor) {
visitor.visit(this);
}
}
interface Visitor {
void visit(ConcreteElementA element);
}
class ConcreteVisitor implements Visitor {
public void visit(ConcreteElementA element) {
// ...
}
}
结语
本文介绍了Java中常见的20种设计模式,每种模式都提供了使用场景、简要的解释以及示例代码。设计模式是软件开发中的重要工具,它们帮助我们写出更加清晰、灵活且可维护的代码。希望本文能够帮助你更好地理解和应用设计模式。