北屋教程网

专注编程知识分享，从入门到精通的编程学习平台

2025年10月08日

Java 23种设计模式Demo案例大全_java中设计模式到底是干啥的

概述

设计模式是软件开发人员在长期实践中总结出来的最佳解决方案，它们提供了可重用的设计思路，帮助我们构建更加灵活、可维护的软件系统。本文将全面介绍Java实现的23种设计模式，每个模式都配有实际案例和清晰的UML图示。

创建型模式

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;
}
}

Mermaid图表 #1:

2. 工厂方法模式 (Factory Method Pattern)

定义一个创建对象的接口，但让子类决定实例化哪个类。

代码 (java):

public interface Shape {
void draw();
}
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("Drawing a circle");
}
}
public class ShapeFactory {
public Shape getShape(String shapeType) {
if (shapeType.equalsIgnoreCase("CIRCLE")) {
return new Circle();
}
return null;
}
}

Mermaid图表 #2:

3. 抽象工厂模式 (Abstract Factory Pattern)

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

代码 (java):

public interface GUIFactory {
Button createButton();
Checkbox createCheckbox();
}
public class WinFactory implements GUIFactory {
public Button createButton() {
return new WinButton();
}
public Checkbox createCheckbox() {
return new WinCheckbox();
}
}

Mermaid图表 #3:

4. 建造者模式 (Builder Pattern)

将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。

代码 (java):

public class Computer {
private String HDD;
private String RAM;

private Computer(ComputerBuilder builder) {
this.HDD = builder.HDD;
this.RAM = builder.RAM;
}

public static class ComputerBuilder {
private String HDD;
private String RAM;

public ComputerBuilder setHDD(String HDD) {
this.HDD = HDD;
return this;
}

public ComputerBuilder setRAM(String RAM) {
this.RAM = RAM;
return this;
}

public Computer build() {
return new Computer(this);
}
}
}

Mermaid图表 #4:

5. 原型模式 (Prototype Pattern)

用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。

代码 (java):

public abstract class Shape implements Cloneable {
private String id;
protected String type;

abstract void draw();

public String getType() {
return type;
}

public Object clone() {
Object clone = null;
try {
clone = super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return clone;
}
}

Mermaid图表 #5:

结构型模式

6. 适配器模式 (Adapter Pattern)

将一个类的接口转换成客户希望的另一个接口。

代码 (java):

public interface MediaPlayer {
void play(String audioType, String fileName);
}
public class MediaAdapter implements MediaPlayer {
AdvancedMediaPlayer advancedMusicPlayer;

public MediaAdapter(String audioType) {
if (audioType.equalsIgnoreCase("vlc")) {
advancedMusicPlayer = new VlcPlayer();
}
}

@Override
public void play(String audioType, String fileName) {
if (audioType.equalsIgnoreCase("vlc")) {
advancedMusicPlayer.playVlc(fileName);
}
}
}

Mermaid图表 #6:

7. 桥接模式 (Bridge Pattern)

将抽象部分与实现部分分离，使它们都可以独立地变化。

代码 (java):

public interface DrawAPI {
void drawCircle(int radius, int x, int y);
}
public abstract class Shape {
protected DrawAPI drawAPI;

protected Shape(DrawAPI drawAPI) {
this.drawAPI = drawAPI;
}

public abstract void draw();
}

Mermaid图表 #7:

8. 组合模式 (Composite Pattern)

将对象组合成树形结构以表示"部分-整体"的层次结构。

代码 (java):

public interface Employee {
void showEmployeeDetails();
}
public class Developer implements Employee {
private String name;

public Developer(String name) {
this.name = name;
}

@Override
public void showEmployeeDetails() {
System.out.println("Developer: " + name);
}
}
public class Manager implements Employee {
private List<Employee> employees = new ArrayList<>();

public void addEmployee(Employee emp) {
employees.add(emp);
}

@Override
public void showEmployeeDetails() {
for (Employee emp : employees) {
emp.showEmployeeDetails();
}
}
}

Mermaid图表 #8:

9. 装饰器模式 (Decorator Pattern)

动态地给一个对象添加一些额外的职责。

代码 (java):

public interface Shape {
void draw();
}
public abstract class ShapeDecorator implements Shape {
protected Shape decoratedShape;

public ShapeDecorator(Shape decoratedShape) {
this.decoratedShape = decoratedShape;
}

public void draw() {
decoratedShape.draw();
}
}
public class RedShapeDecorator extends ShapeDecorator {
public RedShapeDecorator(Shape decoratedShape) {
super(decoratedShape);
}

@Override
public void draw() {
decoratedShape.draw();
setRedBorder();
}

private void setRedBorder() {
System.out.println("Border Color: Red");
}
}

Mermaid图表 #9:

10. 外观模式 (Facade Pattern)

为子系统中的一组接口提供一个一致的界面。

代码 (java):

public class CPU {
public void freeze() { /* ... */ }
public void jump(long position) { /* ... */ }
public void execute() { /* ... */ }
}
public class ComputerFacade {
private CPU processor;

public ComputerFacade() {
this.processor = new CPU();
}

public void start() {
processor.freeze();
processor.jump(0);
processor.execute();
}
}

Mermaid图表 #10:

11. 享元模式 (Flyweight Pattern)

运用共享技术有效地支持大量细粒度的对象。

代码 (java):

public interface Shape {
void draw();
}
public class Circle implements Shape {
private String color;

public Circle(String color) {
this.color = color;
}

@Override
public void draw() {
System.out.println("Drawing a " + color + " circle");
}
}
public class ShapeFactory {
private static final HashMap<String, Shape> circleMap = new HashMap<>();

public static Shape getCircle(String color) {
Circle circle = (Circle) circleMap.get(color);

if (circle == null) {
circle = new Circle(color);
circleMap.put(color, circle);
System.out.println("Creating circle of color: " + color);
}
return circle;
}
}

Mermaid图表 #11:

12. 代理模式 (Proxy Pattern)

为其他对象提供一种代理以控制对这个对象的访问。

代码 (java):

public interface Image {
void display();
}
public class RealImage implements Image {
private String fileName;

public RealImage(String fileName) {
this.fileName = fileName;
loadFromDisk(fileName);
}

@Override
public void display() {
System.out.println("Displaying " + fileName);
}

private void loadFromDisk(String fileName) {
System.out.println("Loading " + fileName);
}
}
public class ProxyImage implements Image {
private RealImage realImage;
private String fileName;

public ProxyImage(String fileName) {
this.fileName = fileName;
}

@Override
public void display() {
if (realImage == null) {
realImage = new RealImage(fileName);
}
realImage.display();
}
}

Mermaid图表 #12:

行为型模式

13. 责任链模式 (Chain of Responsibility Pattern)

避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求。

代码 (java):

public abstract class Logger {
public static int INFO = 1;
public static int DEBUG = 2;
public static int ERROR = 3;

protected int level;
protected Logger nextLogger;

public void setNextLogger(Logger nextLogger) {
this.nextLogger = nextLogger;
}

public void logMessage(int level, String message) {
if (this.level <= level) {
write(message);
}
if (nextLogger != null) {
nextLogger.logMessage(level, message);
}
}

abstract protected void write(String message);
}
public class ConsoleLogger extends Logger {
public ConsoleLogger(int level) {
this.level = level;
}

@Override
protected void write(String message) {
System.out.println("Standard Console::Logger: " + message);
}
}

Mermaid图表 #13:

14. 命令模式 (Command Pattern)

将一个请求封装为一个对象，从而使您可以用不同的请求对客户进行参数化。

代码 (java):

public interface Order {
void execute();
}
public class BuyStock implements Order {
private Stock abcStock;

public BuyStock(Stock abcStock) {
this.abcStock = abcStock;
}

public void execute() {
abcStock.buy();
}
}
public class Broker {
private List<Order> orderList = new ArrayList<>();

public void takeOrder(Order order) {
orderList.add(order);
}

public void placeOrders() {
for (Order order : orderList) {
order.execute();
}
orderList.clear();
}
}

Mermaid图表 #14:

15. 解释器模式 (Interpreter Pattern)

给定一个语言，定义它的文法的一种表示，并定义一个解释器。

代码 (java):

public interface Expression {
boolean interpret(String context);
}
public class TerminalExpression implements Expression {
private String data;

public TerminalExpression(String data) {
this.data = data;
}

@Override
public boolean interpret(String context) {
return context.contains(data);
}
}
public class OrExpression implements Expression {
private Expression expr1;
private Expression expr2;

public OrExpression(Expression expr1, Expression expr2) {
this.expr1 = expr1;
this.expr2 = expr2;
}

@Override
public boolean interpret(String context) {
return expr1.interpret(context) || expr2.interpret(context);
}
}

Mermaid图表 #15:

16. 迭代器模式 (Iterator Pattern)

提供一种方法顺序访问一个聚合对象中各个元素，而又无须暴露该对象的内部表示。

代码 (java):

public interface Iterator {
boolean hasNext();
Object next();
}
public interface Container {
Iterator getIterator();
}
public class NameRepository implements Container {
public String names[] = {"Robert", "John", "Julie"};

@Override
public Iterator getIterator() {
return new NameIterator();
}

private class NameIterator implements Iterator {
int index;

@Override
public boolean hasNext() {
return index < names.length;
}

@Override
public Object next() {
if (this.hasNext()) {
return names[index++];
}
return null;
}
}
}

Mermaid图表 #16:

17. 中介者模式 (Mediator Pattern)

用一个中介对象来封装一系列的对象交互。

代码 (java):

public interface ChatMediator {
void sendMessage(String msg, User user);
void addUser(User user);
}
public abstract class User {
protected ChatMediator mediator;
protected String name;

public User(ChatMediator med, String name) {
this.mediator = med;
this.name = name;
}

public abstract void send(String msg);
public abstract void receive(String msg);
}
public class ChatMediatorImpl implements ChatMediator {
private List<User> users;

public ChatMediatorImpl() {
this.users = new ArrayList<>();
}

@Override
public void addUser(User user) {
this.users.add(user);
}

@Override
public void sendMessage(String msg, User user) {
for (User u : this.users) {
if (u != user) {
u.receive(msg);
}
}
}
}

Mermaid图表 #17:

18. 备忘录模式 (Memento Pattern)

在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。

代码 (java):

public class Memento {
private String state;

public Memento(String state) {
this.state = state;
}

public String getState() {
return state;
}
}
public class Originator {
private String state;

public void setState(String state) {
this.state = state;
}

public String getState() {
return state;
}

public Memento saveStateToMemento() {
return new Memento(state);
}

public void getStateFromMemento(Memento memento) {
state = memento.getState();
}
}
public class CareTaker {
private List<Memento> mementoList = new ArrayList<>();

public void add(Memento state) {
mementoList.add(state);
}

public Memento get(int index) {
return mementoList.get(index);
}
}

Mermaid图表 #18:

19. 观察者模式 (Observer Pattern)

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

代码 (java):

public interface Subject {
void registerObserver(Observer o);
void unregisterObserver(Observer o);
void notifyObservers();
}
public class ConcreteSubject implements Subject {
private List<Observer> observers;
private String message;

public ConcreteSubject() {
observers = new ArrayList<>();
}

@Override
public void registerObserver(Observer o) {
observers.add(o);
}

@Override
public void unregisterObserver(Observer o) {
observers.remove(o);
}

@Override
public void notifyObservers() {
for (Observer o : observers) {
o.update(message);
}
}

public void setMessage(String message) {
this.message = message;
notifyObservers();
}
}

Mermaid图表 #19:

20. 状态模式 (State Pattern)

允许对象在内部状态发生改变时改变它的行为。

代码 (java):

public interface State {
void doAction(Context context);
}
public class StartState implements State {
public void doAction(Context context) {
System.out.println("Player is in start state");
context.setState(this);
}

public String toString() {
return "Start State";
}
}
public class Context {
private State state;

public Context() {
state = null;
}

public void setState(State state) {
this.state = state;
}

public State getState() {
return state;
}
}

Mermaid图表 #20:

21. 策略模式 (Strategy Pattern)

定义一系列的算法，把它们一个个封装起来，并且使它们可相互替换。

代码 (java):

public interface Strategy {
int doOperation(int num1, int num2);
}
public class OperationAdd implements Strategy {
@Override
public int doOperation(int num1, int num2) {
return num1 + num2;
}
}
public class Context {
private Strategy strategy;

public Context(Strategy strategy) {
this.strategy = strategy;
}

public int executeStrategy(int num1, int num2) {
return strategy.doOperation(num1, num2);
}
}

Mermaid图表 #21:

22. 模板方法模式 (Template Method Pattern)

定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。

代码 (java):

public abstract class Game {
abstract void initialize();
abstract void startPlay();
abstract void endPlay();

// 模板方法
public final void play() {
initialize();
startPlay();
endPlay();
}
}
public class Cricket extends Game {
@Override
void initialize() {
System.out.println("Cricket Game Initialized!");
}

@Override
void startPlay() {
System.out.println("Cricket Game Started.");
}

@Override
void endPlay() {
System.out.println("Cricket Game Finished!");
}
}

Mermaid图表 #22:

23. 访问者模式 (Visitor Pattern)

主要将数据结构与数据操作分离。

代码 (java):

public interface ComputerPart {
void accept(ComputerPartVisitor computerPartVisitor);
}
public class Keyboard implements ComputerPart {
@Override
public void accept(ComputerPartVisitor computerPartVisitor) {
computerPartVisitor.visit(this);
}
}
public interface ComputerPartVisitor {
void visit(Computer computer);
void visit(Mouse mouse);
void visit(Keyboard keyboard);
}
public class ComputerPartDisplayVisitor implements ComputerPartVisitor {
@Override
public void visit(Computer computer) {
System.out.println("Displaying Computer.");
}

@Override
public void visit(Mouse mouse) {
System.out.println("Displaying Mouse.");
}

@Override
public void visit(Keyboard keyboard) {
System.out.println("Displaying Keyboard.");
}
}

Mermaid图表 #23:

总结

设计模式是软件开发中的重要概念，它们提供了经过验证的解决方案来解决常见的设计问题。通过熟练掌握这23种设计模式，您可以：

编写更加灵活、可维护的代码

提高代码复用性

使代码更易于理解和沟通

降低模块间的耦合度

每种模式都有其适用的场景，在实际开发中需要根据具体需求选择合适的设计模式。过度使用设计模式可能会导致代码变得复杂难懂，因此需要权衡利弊，合理运用。

希望本文提供的示例和图示能帮助您更好地理解和应用这些设计模式！

标签：java程序设计教程 

作者:koubeiwu , 分类:技术文章 , 浏览:6 , 评论:0

控制面板
您好，欢迎到访网站！
  查看权限
网站分类
最新留言