Java常用设计模式

设计模式是软件开发中解决常见问题的模板或指南。Java中的23种设计模式通常被分为三大类：创建型模式（Creational Patterns）、结构型模式（Structural Patterns）和行为型模式（Behavioral Patterns）。

创建型模式

1.单例模式（Singleton Pattern）

确保一个类仅有一个实例，并提供一个全局访问点。它有助于控制共享资源的访问。

java">public class Singleton {private static Singleton instance;private Singleton() {// 私有构造函数，防止外部实例化}public static Singleton getInstance() {if (instance == null) {instance = new Singleton();}return instance;}public void showMessage() {System.out.println("Hello, I am a Singleton!");}
}// 使用示例
public class SingletonDemo {public static void main(String[] args) {Singleton singleton = Singleton.getInstance();singleton.showMessage();}
}

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

定义一个用于创建对象的接口，但是让子类决定将哪一个类实例化。这种模式使得一个类的实例化延迟到其子类。

java">interface Product {void use();
}class ConcreteProductA implements Product {@Overridepublic void use() {System.out.println("Using Product A");}
}class ConcreteProductB implements Product {@Overridepublic void use() {System.out.println("Using Product B");}
}abstract class Creator {public abstract Product factoryMethod();public void anOperation() {Product product = factoryMethod();product.use();}
}class ConcreteCreatorA extends Creator {@Overridepublic Product factoryMethod() {return new ConcreteProductA();}
}class ConcreteCreatorB extends Creator {@Overridepublic Product factoryMethod() {return new ConcreteProductB();}
}// 使用示例
public class FactoryMethodDemo {public static void main(String[] args) {Creator creatorA = new ConcreteCreatorA();creatorA.anOperation();Creator creatorB = new ConcreteCreatorB();creatorB.anOperation();}
}

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

提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

java">interface AbstractFactory {ProductA createProductA();ProductB createProductB();
}class ConcreteFactory1 implements AbstractFactory {@Overridepublic ProductA createProductA() {return new ConcreteProductA1();}@Overridepublic ProductB createProductB() {return new ConcreteProductB1();}
}class ConcreteFactory2 implements AbstractFactory {@Overridepublic ProductA createProductA() {return new ConcreteProductA2();}@Overridepublic ProductB createProductB() {return new ConcreteProductB2();}
}interface ProductA {void use();
}interface ProductB {void use();
}class ConcreteProductA1 implements ProductA {@Overridepublic void use() {System.out.println("Using Product A1");}
}class ConcreteProductA2 implements ProductA {@Overridepublic void use() {System.out.println("Using Product A2");}
}class ConcreteProductB1 implements ProductB {@Overridepublic void use() {System.out.println("Using Product B1");}
}class ConcreteProductB2 implements ProductB {@Overridepublic void use() {System.out.println("Using Product B2");}
}// 使用示例
public class AbstractFactoryDemo {public static void main(String[] args) {AbstractFactory factory1 = new ConcreteFactory1();ProductA productA1 = factory1.createProductA();ProductB productB1 = factory1.createProductB();productA1.use();productB1.use();AbstractFactory factory2 = new ConcreteFactory2();ProductA productA2 = factory2.createProductA();ProductB productB2 = factory2.createProductB();productA2.use();productB2.use();}
}

区别

工厂方法：一个子类创建一个产品，子类决定实例化单一产品。
抽象工厂：一个子类创建多个相关产品，子类实例化一组相关产品。

4.建造者模式（Builder Pattern）

建造者模式是一种创建型设计模式，它允许逐步构建复杂对象。此模式主要用于当你需要构造一个复杂对象，并希望构造过程是独立于构成该对象的部分及其装配方式时。

java">class Product {private String partA;private String partB;public void setPartA(String partA) {this.partA = partA;}public void setPartB(String partB) {this.partB = partB;}
}interface Builder {void buildPartA();void buildPartB();Product getResult();
}class ConcreteBuilder implements Builder {private Product product = new Product();public void buildPartA() {product.setPartA("PartA");}public void buildPartB() {product.setPartB("PartB");}public Product getResult() {return product;}
}// 调用
Builder builder = new ConcreteBuilder();
builder.buildPartA();
builder.buildPartB();
Product product = builder.getResult();

结构型模式

1.适配器模式（Adapter Pattern）

允许将不兼容的接口转换成兼容的形式，使得原本由于接口不匹配而不能一起工作的类可以协同工作。

java">interface Target {void request();
}class Adaptee {public void specificRequest() {System.out.println("Adaptee's specific request");}
}class Adapter implements Target {private Adaptee adaptee;public Adapter(Adaptee adaptee) {this.adaptee = adaptee;}@Overridepublic void request() {adaptee.specificRequest();}
}// 使用示例
public class AdapterDemo {public static void main(String[] args) {Adaptee adaptee = new Adaptee();Target target = new Adapter(adaptee);target.request();}
}

2.装饰者模式（Decorator Pattern）

动态地给一个对象添加一些额外的职责。就功能来说，它相比生成子类更为灵活。

java">interface Component {void operation();
}class ConcreteComponent implements Component {@Overridepublic void operation() {System.out.println("ConcreteComponent operation");}
}abstract class Decorator implements Component {protected Component component;public Decorator(Component component) {this.component = component;}@Overridepublic void operation() {component.operation();}
}class ConcreteDecoratorA extends Decorator {public ConcreteDecoratorA(Component component) {super(component);}@Overridepublic void operation() {super.operation();System.out.println("ConcreteDecoratorA operation");}
}class ConcreteDecoratorB extends Decorator {public ConcreteDecoratorB(Component component) {super(component);}@Overridepublic void operation() {super.operation();System.out.println("ConcreteDecoratorB operation");}
}// 使用示例
public class DecoratorDemo {public static void main(String[] args) {Component component = new ConcreteComponent();Component decoratedComponentA = new ConcreteDecoratorA(component);Component decoratedComponentB = new ConcreteDecoratorB(decoratedComponentA);decoratedComponentB.operation();}
}

3.代理模式（Proxy Pattern）

为其他对象提供一种代理以控制对这个对象的访问。使用代理模式可以进行权限控制、访问远程服务器等操作。

java">interface Subject {void request();
}class RealSubject implements Subject {@Overridepublic void request() {System.out.println("RealSubject request");}
}class Proxy implements Subject {private RealSubject realSubject;@Overridepublic void request() {if (realSubject == null) {realSubject = new RealSubject();}realSubject.request();}
}// 使用示例
public class ProxyDemo {public static void main(String[] args) {Proxy proxy = new Proxy();proxy.request();}
}

行为型模式

1.观察者模式（Observer Pattern）

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

java">import java.util.ArrayList;
import java.util.List;interface Observer {void update(String message);
}class ConcreteObserver implements Observer {private String name;public ConcreteObserver(String name) {this.name = name;}@Overridepublic void update(String message) {System.out.println(name + " received message: " + message);}
}class Subject {private List<Observer> observers = new ArrayList<>();public void attach(Observer observer) {observers.add(observer);}public void detach(Observer observer) {observers.remove(observer);}public void notifyObservers(String message) {for (Observer observer : observers) {observer.update(message);}}
}// 使用示例
public class ObserverDemo {public static void main(String[] args) {Subject subject = new Subject();Observer observer1 = new ConcreteObserver("Observer 1");Observer observer2 = new ConcreteObserver("Observer 2");subject.attach(observer1);subject.attach(observer2);subject.notifyObservers("Hello Observers!");}
}

2.策略模式（Strategy Pattern）

定义一系列算法，把它们一个个封装起来，并且使它们可以互相替换。本模式使得算法可以独立于使用它的客户而变化。

java">interface Strategy {void execute();
}class ConcreteStrategyA implements Strategy {@Overridepublic void execute() {System.out.println("Executing Strategy A");}
}class ConcreteStrategyB implements Strategy {@Overridepublic void execute() {System.out.println("Executing Strategy B");}
}class Context {private Strategy strategy;public Context(Strategy strategy) {this.strategy = strategy;}public void executeStrategy() {strategy.execute();}
}// 使用示例
public class StrategyDemo {public static void main(String[] args) {Context context = new Context(new ConcreteStrategyA());context.executeStrategy();context = new Context(new ConcreteStrategyB());context.executeStrategy();}
}

3.命令模式（Command Pattern）

将请求封装成对象，从而使您可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤销的操作。

java">interface Command {void execute();
}class Light {public void on() {System.out.println("Light is on");}public void off() {System.out.println("Light is off");}
}class LightOnCommand implements Command {private Light light;public LightOnCommand(Light light) {this.light = light;}@Overridepublic void execute() {light.on();}
}class LightOffCommand implements Command {private Light light;public LightOffCommand(Light light) {this.light = light;}@Overridepublic void execute() {light.off();}
}class RemoteControl {private Command command;public void setCommand(Command command) {this.command = command;}public void pressButton() {command.execute();}
}// 使用示例
public class CommandDemo {public static void main(String[] args) {Light light = new Light();Command lightOn = new LightOnCommand(light);Command lightOff = new LightOffCommand(light);RemoteControl remote = new RemoteControl();remote.setCommand(lightOn);remote.pressButton();remote.setCommand(lightOff);remote.pressButton();}
}