Java常用设计模式
设计模式是软件开发中解决常见问题的模板或指南。Java中的23种设计模式通常被分为三大类：创建型模式（Creational Patterns）、结构型模式（Structural Patterns）和行为型模式（Behavioral Patterns）。
创建型模式
1.单例模式（Singleton Pattern）
确保一个类仅有一个实例，并提供一个全局访问点。它有助于控制共享资源的访问。
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）
定义一个用于创建对象的接口，但是让子类决定将哪一个类实例化。这种模式使得一个类的实例化延迟到其子类。
interface Product {
void use();
}
class ConcreteProductA implements Product {
@Override
public void use() {
System.out.println("Using Product A");
}
}
class ConcreteProductB implements Product {
@Override
public 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 {
@Override
public Product factoryMethod() {
return new ConcreteProductA();
}
}
class ConcreteCreatorB extends Creator {
@Override
public 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）
提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。
interface AbstractFactory {
ProductA createProductA();
ProductB createProductB();
}
class ConcreteFactory1 implements AbstractFactory {
@Override
public ProductA createProductA() {
return new ConcreteProductA1();
}
@Override
public ProductB createProductB() {
return new ConcreteProductB1();
}
}
class ConcreteFactory2 implements AbstractFactory {
@Override
public ProductA createProductA() {
return new ConcreteProductA2();
}
@Override
public ProductB createProductB() {
return new ConcreteProductB2();
}
}
interface ProductA {
void use();
}
interface ProductB {
void use();
}
class ConcreteProductA1 implements ProductA {
@Override
public void use() {
System.out.println("Using Product A1");
}
}
class ConcreteProductA2 implements ProductA {
@Override
public void use() {
System.out.println("Using Product A2");
}
}
class ConcreteProductB1 implements ProductB {
@Override
public void use() {
System.out.println("Using Product B1");
}
}
class ConcreteProductB2 implements ProductB {
@Override
public 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）
建造者模式是一种创建型设计模式，它允许逐步构建复杂对象。此模式主要用于当你需要构造一个复杂对象，并希望构造过程是独立于构成该对象的部分及其装配方式时。
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）
允许将不兼容的接口转换成兼容的形式，使得原本由于接口不匹配而不能一起工作的类可以协同工作。
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;
}
@Override
public 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）
动态地给一个对象添加一些额外的职责。就功能来说，它相比生成子类更为灵活。
interface Component {
void operation();
}
class ConcreteComponent implements Component {
@Override
public void operation() {
System.out.println("ConcreteComponent operation");
}
}
abstract class Decorator implements Component {
protected Component component;
public Decorator(Component component) {
this.component = component;
}
@Override
public void operation() {
component.operation();
}
}
class ConcreteDecoratorA extends Decorator {
public ConcreteDecoratorA(Component component) {
super(component);
}
@Override
public void operation() {
super.operation();
System.out.println("ConcreteDecoratorA operation");
}
}
class ConcreteDecoratorB extends Decorator {
public ConcreteDecoratorB(Component component) {
super(component);
}
@Override
public 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）
为其他对象提供一种代理以控制对这个对象的访问。使用代理模式可以进行权限控制、访问远程服务器等操作。
interface Subject {
void request();
}
class RealSubject implements Subject {
@Override
public void request() {
System.out.println("RealSubject request");
}
}
class Proxy implements Subject {
private RealSubject realSubject;
@Override
public 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）
定义了对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。
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;
}
@Override
public 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）
定义一系列算法，把它们一个个封装起来，并且使它们可以互相替换。本模式使得算法可以独立于使用它的客户而变化。
interface Strategy {
void execute();
}
class ConcreteStrategyA implements Strategy {
@Override
public void execute() {
System.out.println("Executing Strategy A");
}
}
class ConcreteStrategyB implements Strategy {
@Override
public 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）
将请求封装成对象，从而使您可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤销的操作。
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;
}
@Override
public void execute() {
light.on();
}
}
class LightOffCommand implements Command {
private Light light;
public LightOffCommand(Light light) {
this.light = light;
}
@Override
public 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();
}
}