java中常用的6条设计模式及其设计原则

在Java中，设计模式是用于解决特定上下文中常见问题的最佳实践解决方案，广泛用于编写易于维护、扩展和理解的代码。这里我将介绍六种常用的设计模式及其对应的设计原则：

1. 单例模式 (Singleton)

设计原则: 确保一个类只有一个实例，并提供全局访问点。

应用场景: 当你需要确保系统中只有一个全局对象（如配置对象、连接池等）时使用。

示例代码:

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

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

设计原则: 定义一个用于创建对象的接口，让子类决定实例化哪一个类。

应用场景: 当创建逻辑变得复杂或者客户端代码需要与产品对象解耦时使用。

示例代码:

public interface Product {
    void use();
}

public class ConcreteProductA implements Product {
    public void use() {
        System.out.println("Product A used.");
    }
}

public class ConcreteProductB implements Product {
    public void use() {
        System.out.println("Product B used.");
    }
}

public abstract class Creator {
    public abstract Product factoryMethod();
}

public class ConcreteCreatorA extends Creator {
    @Override
    public Product factoryMethod() {
        return new ConcreteProductA();
    }
}

public class ConcreteCreatorB extends Creator {
    @Override
    public Product factoryMethod() {
        return new ConcreteProductB();
    }
}

3. 观察者模式 (Observer)

设计原则: 定义对象间的一种一对多的依赖关系，当一个对象的状态改变时，所有依赖于它的对象都会被自动通知和更新。

应用场景: 当你希望在系统中建立一个触发机制，比如用户操作触发某些响应或报告生成等。

示例代码:

import java.util.ArrayList;
import java.util.List;

public interface Observer {
    void update();
}

public class ConcreteObserver implements Observer {
    public void update() {
        System.out.println("Observer has been updated.");
    }
}

public class Subject {
    private List<Observer> observers = new ArrayList<>();

    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }
}

4. 装饰者模式 (Decorator)

设计原则: 对象应对扩展开放，但对修改关闭。动态地将责任附加到对象上。若要扩展功能，装饰者提供了比继承更有弹性的替代方案。

应用场景: 当你需要给类添加额外功能时，并希望在运行时动态地添加这些功能。

示例代码:

public interface Component {
    void operation();
}

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

public abstract class Decorator implements Component {
    protected Component wrappedComponent;

    public Decorator(Component comp) {
        this.wrappedComponent = comp;
    }

    public void operation() {
        wrappedComponent.operation();
    }
}

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

    public void operation() {
        super.operation();
        addedBehavior();
    }

    private void addedBehavior() {
        System.out.println("Concrete Decorator A behavior.");
    }
}

5. 策略模式 (Strategy)

设计原则: 定义算法家族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。

应用场景: 当你有多种类的算法或业务规则，并且这些算法需要在运行时根据不同情况动态更换时使用。

示例代码:

public interface Strategy {
    void execute();
}

public class ConcreteStrategyA implements Strategy {
    public void execute() {
        System.out.println("Executing strategy A.");
    }
}

public class ConcreteStrategyB implements Strategy {
    public void execute() {
        System.out.println("Executing strategy B.");
    }
}

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

    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }

    public void executeStrategy() {
        strategy.execute();
    }
}

使用策略模式，可以方便地更改Context类实例的行为，通过为其设置不同的Strategy实现。

6. 适配器模式 (Adapter)

设计原则: 将一个类的接口转换成客户期望的另一个接口。适配器让原本由于接口不兼容而不能一起工作的那些类可以一起工作。

应用场景: 当你希望使用一个已存在的类，但其接口并不符合你的需求时，你可以创建一个适配器类来间接地适配其接口。

示例代码:

// 目标接口
public interface Target {
    void request();
}

// 需要被适配的类
public class Adaptee {
    public void specificRequest() {
        System.out.println("Specific request.");
    }
}

// 适配器
public class Adapter implements Target {
    private Adaptee adaptee;

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

    @Override
    public void request() {
        adaptee.specificRequest();
    }
}

通过适配器模式，我们可以使原本因接口不兼容而无法一起工作的类可以一起工作。这种模式通过适配器类Adapter将Adaptee类的接口转换为目标接口Target所期望的形式。

总结

这六种设计模式是Java中常用的模式，通过应用这些模式，可以提升代码的可维护性、扩展性和灵活性。设计模式遵循的设计原则，如开闭原则（开放扩展，关闭修改）、单一职责原则、依赖倒置原则等，都是在软件工程中保持代码健康的重要指导原则。掌握并应用这些设计模式和原则，有助于成为一名更优秀的软件工程师。