设计模式实践：Java代码复用中的常见模式

原创川长思鸟来 2024-11-08 22:03 50阅读 0赞

在Java编程中，设计模式是一套被广泛认可的最佳实践，用于解决特定问题的代码设计问题。它们可以帮助我们提高代码的可复用性、可维护性和灵活性。以下是一些在Java代码复用中常见的设计模式：

1. **工厂模式（Factory Pattern）**
-用于创建对象，而不是直接使用new关键字实例化对象。它将对象的创建和使用分离，使得代码更加模块化。
 ```java public interface Product {
 void use();
 }

public class ConcreteProduct implements Product {
 public void use() {
 System.out.println("Using ConcreteProduct");
 }
 }

public class Factory {
 public Product createProduct() {
 return new ConcreteProduct();
 }
 }
 ```2. **单例模式（Singleton Pattern）**
-确保一个类只有一个实例，并提供一个全局访问点。
 ```java public class Singleton {
 private static Singleton instance;

private Singleton() {}

public static Singleton getInstance() {
if (instance == null) {
 instance = new Singleton();
 }
 return instance;
 }
 }
 ```3. **建造者模式（Builder Pattern）**
-用于创建复杂对象，允许通过指定复杂对象的类型和内容逐步构建。
 ```java public class Product {
 private String partA;
 private String partB;

private Product(Builder builder) {
 this.partA = builder.partA;
 this.partB = builder.partB;
 }

public static class Builder {
 private String partA;
 private String partB;

public Builder partA(String partA) {
 this.partA = partA;
 return this;
 }

public Builder partB(String partB) {
 this.partB = partB;
 return this;
 }

public Product build() {
 return new Product(this);
 }
 }
 }
 ```4. **原型模式（Prototype Pattern）**
-通过复制现有的实例来创建新的实例，而不是通过新建实例。
 ```java public interface Prototype {
Prototype clone();
 }

public class ConcretePrototype implements Prototype {
 private String id;

public ConcretePrototype(String id) {
 this.id = id;
 }

public Prototype clone() {
 return new ConcretePrototype(this.id);
 }
 }
 ```5. **适配器模式（Adapter Pattern）**
-允许不兼容的接口之间可以一起工作，通常用于整合旧的代码库。
 ```java public interface Adaptee {
 void specificRequest();
 }

public class Adapter implements Target {
 private Adaptee adaptee;

public Adapter(Adaptee adaptee) {
 this.adaptee = adaptee;
 }

public void request() {
 adaptee.specificRequest();
 }
 }
 ```6. **装饰器模式（Decorator Pattern）**
-动态地给一个对象添加一些额外的职责，就增加功能来说，装饰器模式比生成子类更为灵活。
 ```java public interface Component {
 void operate();
 }

public class ConcreteComponent implements Component {
 public void operate() {
 System.out.println("ConcreteComponent operate");
 }
 }

public abstract class Decorator implements Component {
 protected Component component;

public Decorator(Component component) {
 this.component = component;
 }

public void operate() {
 component.operate();
 }
 }

public class ConcreteDecoratorA extends Decorator {
 public ConcreteDecoratorA(Component component) {
 super(component);
 }

public void operate() {
 super.operate();
// Add additional behavior System.out.println("ConcreteDecoratorA operate");
 }
 }
 ```7. **策略模式（Strategy Pattern）**
-定义一系列算法，把它们一个个封装起来，并使它们可以相互替换。
 ```java public interface Strategy {
int doOperation(int num1, int num2);
 }

public class OperationAdd implements Strategy {
 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);
 }
 }
 ```8. **观察者模式（Observer Pattern）**
-定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
 ```java public interface Observer {
 void update(String message);
 }

public interface Subject {
 void register(Observer obj);
 void unregister(Observer obj);
 void notifyObservers();
 }

public