Java 设计模式代码大全23

在软件开发中，设计模式是可重用的解决方案，用于解决常见的设计问题。它们为代码提供结构和组织，提高其可维护性、可扩展性和可读性。Java 语言提供了丰富的设计模式库，帮助开发人员创建健壮、可扩展的应用程序。

以下是一些最常用和有价值的 Java 设计模式代码示例：

单例模式```java
public class Singleton {
private static Singleton instance;
private Singleton() {
// 私有构造函数，防止外部实例化
}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
```

工厂方法模式```java
interface Shape {
void draw();
}
class Circle implements Shape {
@Override
public void draw() {
("Drawing Circle");
}
}
class Square implements Shape {
@Override
public void draw() {
("Drawing Square");
}
}
class ShapeFactory {
public Shape getShape(String shapeType) {
if (shapeType == null) {
return null;
}
if (("CIRCLE")) {
return new Circle();
} else if (("SQUARE")) {
return new Square();
}
return null;
}
}
```

外观模式```java
interface LegacyCode {
void legacyOperation1();
void legacyOperation2();
void legacyOperation3();
}
class LegacyCodeAdapter implements LegacyCode {
@Override
public void legacyOperation1() {
// 操作1的实现
}
@Override
public void legacyOperation2() {
// 操作2的实现
}
@Override
public void legacyOperation3() {
// 操作3的实现
}
}
class Client {
private LegacyCode legacyCode;
public Client(LegacyCode legacyCode) {
= legacyCode;
}
public void doSomething() {
legacyCode.legacyOperation1();
legacyCode.legacyOperation2();
legacyCode.legacyOperation3();
}
}
```

代理模式```java
interface Subject {
void request();
}
class RealSubject implements Subject {
@Override
public void request() {
// 真实的业务逻辑
}
}
class Proxy implements Subject {
private RealSubject realSubject;
public Proxy(RealSubject realSubject) {
= realSubject;
}
@Override
public void request() {
// 代理逻辑，可以添加额外的处理
();
}
}
```

观察者模式```java
interface Observer {
void update(Subject subject);
}
class Subject {
private List observers = new ArrayList();
public void addObserver(Observer observer) {
(observer);
}
public void removeObserver(Observer observer) {
(observer);
}
public void notifyObservers() {
for (Observer observer : observers) {
(this);
}
}
}
class ConcreteObserverA implements Observer {
@Override
public void update(Subject subject) {
// 观察者A对主题变化的处理
}
}
class ConcreteObserverB implements Observer {
@Override
public void update(Subject subject) {
// 观察者B对主题变化的处理
}
}
```