Java中常用的设计模式

设计模式是用于解决软件设计中常见问题的可复用解决方案。在Java中，有许多常用的设计模式可以帮助开发人员提高代码的可维护性、可读性和可重用性。本文将介绍一些常用的设计模式。

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

2. 工厂模式（Factory Pattern）

工厂模式是一种创建型设计模式，它定义了一个用于创建对象的接口，但将决定实例化哪个类的工作交给子类。工厂模式在Java中有三种实现方式：简单工厂模式、工厂方法模式和抽象工厂模式。

// 简单工厂模式
public class SimpleFactory {
    public static Product createProduct(String type) {
        if (type.equals("A")) {
            return new ProductA();
        } else if (type.equals("B")) {
            return new ProductB();
        }
        return null;
    }
}

// 工厂方法模式
public interface Factory {
    Product createProduct();
}

public class ProductAFactory implements Factory {
    @Override
    public Product createProduct() {
        return new ProductA();
    }
}

public class ProductBFactory implements Factory {
    @Override
    public Product createProduct() {
        return new ProductB();
    }
}

// 抽象工厂模式
public interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

public class ConcreteFactory implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ProductA();
    }
    
    @Override
    public ProductB createProductB() {
        return new ProductB();
    }
}

3. 观察者模式（Observer Pattern）

观察者模式是一种行为型设计模式，它定义了一对多的依赖关系，使得当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。观察者模式在Java中通过java.util.Observer和java.util.Observable接口来实现。

import java.util.Observable;
import java.util.Observer;

public class Subject extends Observable {
    private int state;
    
    public int getState() {
        return state;
    }
    
    public void setState(int state) {
        this.state = state;
        setChanged();
        notifyObservers();
    }
}

public class ObserverA implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("ObserverA received update: " + arg);
    }
}

public class ObserverB implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("ObserverB received update: " + arg);
    }
}

public static void main(String[] args) {
    Subject subject = new Subject();
    subject.addObserver(new ObserverA());
    subject.addObserver(new ObserverB());
    
    subject.setState(1);
    subject.setState(2);
}

4. 适配器模式（Adapter Pattern）

适配器模式是一种结构型设计模式，它将一个类的接口转换成客户端所期望的另一个接口。适配器模式能够解决接口不兼容的问题。

public interface Target {
    void request();
}

public class Adaptee {
    public void specificRequest() {
        System.out.println("Adaptee specific request");
    }
}

public class Adapter implements Target {
    private Adaptee adaptee;
    
    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }
    
    @Override
    public void request() {
        adaptee.specificRequest();
    }
}

public static void main(String[] args) {
    Target target = new Adapter(new Adaptee());
    target.request();
}

5. 策略模式（Strategy Pattern）

策略模式是一种行为型设计模式，它定义了一族算法，并将每个算法分别封装起来，使它们可以相互替换。策略模式能够让算法独立于使用它的客户端。

public interface Strategy {
    void doSomething();
}

public class ConcreteStrategyA implements Strategy {
    @Override
    public void doSomething() {
        System.out.println("ConcreteStrategyA do something");
    }
}

public class ConcreteStrategyB implements Strategy {
    @Override
    public void doSomething() {
        System.out.println("ConcreteStrategyB do something");
    }
}

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

public static void main(String[] args) {
    Context contextA = new Context(new ConcreteStrategyA());
    contextA.execute();
    
    Context contextB = new Context(new ConcreteStrategyB());
    contextB.execute();
}

这里只是介绍了一些常见的设计模式，还有许多其他的设计模式可以用于不同的场景。熟悉并正确使用设计模式可以让Java应用程序更易于扩展和维护。

本文来自极简博客，作者：夏日蝉鸣，转载请注明原文链接：Java中常用的设计模式