Java常用的设计模式，如单例模式、工厂模式、观察者模式等

设计模式是软件工程中的一种解决方案，用于应对常见的设计问题和挑战。它们提供了一种标准化的方式来解决设计难题，使代码更加灵活、可扩展和易于维护。

单例模式（Singleton Pattern）

概述

单例模式确保一个类只有一个实例，并提供一个全局访问点来访问这个实例。这在需要全局共享资源时非常有用，例如数据库连接池、配置管理器等。

实现

在Java中，实现单例模式有多种方式，以下是最常见的几种：

饿汉式（Eager Initialization）

public class Singleton {
    private static final Singleton instance = new Singleton();

    private Singleton() {
        // 私有构造函数，防止实例化
    }

    public static Singleton getInstance() {
        return instance;
    }
}

这种方法在类加载时就创建实例，线程安全，但如果实例过大且未被使用，会浪费资源。

懒汉式（Lazy Initialization）

public class Singleton {
    private static Singleton instance;

    private Singleton() {
        // 私有构造函数，防止实例化
    }

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

这种方法在第一次调用时才创建实例，节省资源，但需要同步以确保线程安全。

双重检查锁（Double-Checked Locking）

public class Singleton {
    private static volatile Singleton instance;

    private Singleton() {
        // 私有构造函数，防止实例化
    }

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

这种方法结合了懒汉式的延迟加载和线程安全的优点。

静态内部类（Static Inner Class）

public class Singleton {
    private Singleton() {
        // 私有构造函数，防止实例化
    }

    private static class Holder {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return Holder.INSTANCE;
    }
}

这种方法利用类加载机制实现延迟加载，且线程安全。

工厂模式（Factory Pattern）

概述

工厂模式通过创建一个工厂类来处理对象的创建，提供了一种将实例化逻辑与使用逻辑分离的方式。常见的工厂模式有简单工厂模式、工厂方法模式和抽象工厂模式。

实现

简单工厂模式（Simple Factory Pattern）

public class SimpleFactory {
    public Product createProduct(String type) {
        if (type.equals("A")) {
            return new ProductA();
        } else if (type.equals("B")) {
            return new ProductB();
        }
        return null;
    }
}

这种方法通过一个工厂类创建不同类型的产品实例。

工厂方法模式（Factory Method Pattern）

public interface Product {
    void use();
}

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

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

public abstract class Factory {
    public abstract Product createProduct();
}

public class FactoryA extends Factory {
    public Product createProduct() {
        return new ProductA();
    }
}

public class FactoryB extends Factory {
    public Product createProduct() {
        return new ProductB();
    }
}

这种方法通过定义一个抽象工厂接口和具体工厂类，提供了灵活的产品创建方式。

抽象工厂模式（Abstract Factory Pattern）

public interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

public class ConcreteFactory1 implements AbstractFactory {
    public ProductA createProductA() {
        return new ProductA1();
    }

    public ProductB createProductB() {
        return new ProductB1();
    }
}

public class ConcreteFactory2 implements AbstractFactory {
    public ProductA createProductA() {
        return new ProductA2();
    }

    public ProductB createProductB() {
        return new ProductB2();
    }
}

这种方法提供了创建一系列相关或依赖对象的接口，而无需指定它们的具体类。

观察者模式（Observer Pattern）

概述

观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。当主题对象发生变化时，它会通知所有观察者，使它们能够自动更新。

实现

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

public interface Observer {
    void update(String message);
}

public class ConcreteObserver implements Observer {
    private String name;

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

    public void update(String message) {
        System.out.println(name + " received message: " + message);
    }
}

public interface Subject {
    void attach(Observer observer);
    void detach(Observer observer);
    void notifyObservers();
}

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

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

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

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

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

这种方法通过定义主题和观察者接口，确保观察者可以被通知到主题的任何变化。

其他常见设计模式

适配器模式（Adapter Pattern）

适配器模式将一个类的接口转换成客户希望的另一个接口，使原本接口不兼容的类可以一起工作。

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

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

装饰器模式（Decorator Pattern）

装饰器模式动态地给对象添加一些额外的职责。相比生成子类，更加灵活。

public interface Component {
    void operation();
}

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

public abstract class Decorator implements Component {
    protected Component component;

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

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

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

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

    private void additionalOperation() {
        System.out.println("Additional operation");
    }
}

策略模式（Strategy Pattern）

策略模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，客户端可以选择不同的算法实现。

public interface Strategy {
    void execute();
}

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

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

public class Context {
    private Strategy strategy;

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

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

外观模式（Facade Pattern）

外观模式为一组复杂的子系统提供一个更高级的统一接口，使子系统更容易使用。

public class SubsystemA {
    public void operationA() {
        System.out.println("Subsystem A operation");
    }
}

public class SubsystemB {
    public void operationB() {
        System.out.println("Subsystem B operation");
    }
}

public class Facade {
    private SubsystemA subsystemA;
    private SubsystemB subsystemB;

    public Facade() {
        subsystemA = new SubsystemA();
        subsystemB = new SubsystemB();
    }

    public void operation() {
        subsystemA.operationA();
        subsystemB.operationB();
    }
}

模板方法模式（Template Method Pattern）

模板方法模式在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中实现，使得子类可以不改变算法结构的情况下重新定义算法的某些步骤。

public abstract class AbstractClass {
    public final void templateMethod() {
        primitiveOperation1();
        primitiveOperation2();
        concreteOperation();
    }

    protected abstract void primitiveOperation1();
    protected abstract void primitiveOperation2();

    private void concreteOperation() {
        System.out.println("Concrete operation");
    }
}

public class ConcreteClass extends AbstractClass {
    protected void primitiveOperation1() {
        System.out.println("Primitive operation 1");
    }

    protected void primitiveOperation2() {
        System.out.println("Primitive operation 2");
    }
}

设计模式是软件开发中的重要工具，能够显著提高代码的可维护性、灵活性和可扩展性。掌握这些模式并灵活应用，可以帮助开发者更好地设计和构建高质量的软件系统。

黑马程序员免费预约咨询