正文

Java架构设计模式：掌握经典模式，提升系统架构能力

/0 浏览量
0403

在软件开发领域，设计模式是一种在特定场景下解决问题的最佳实践。对于Java开发者来说，掌握经典的设计模式不仅能够提升代码的可读性和可维护性，还能显著提高系统架构能力。本文将详细介绍一些Java中常用的经典设计模式，帮助读者更好地理解和应用它们。

一、单例模式（Singleton）

单例模式确保一个类只有一个实例，并提供一个全局访问点。在Java中，实现单例模式通常有几种方法：

  1. 饿汉式：类加载时就创建好实例。

    public class Singleton {
   private static final Singleton INSTANCE = new Singleton();
   private Singleton() {}
   public static Singleton getInstance() {
       return INSTANCE;
   }
}

  2. 懒汉式：类加载时不创建实例，首次使用时创建实例。

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

  3. 双重校验锁：懒汉式的一种改进，减少同步块的使用。

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

二、工厂模式（Factory Method）

工厂模式定义了一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使得一个类的实例化延迟到其子类。

public interface Car {
    void run();
}

public class Audi implements Car {
    public void run() {
        System.out.println("奥迪在行驶");
    }
}

public class BMW implements Car {
    public void run() {
        System.out.println("宝马在行驶");
    }
}

public class CarFactory {
    public static Car createCar(String type) {
        if ("奥迪".equals(type)) {
            return new Audi();
        } else if ("宝马".equals(type)) {
            return new BMW();
        }
        return null;
    }
}

三、策略模式（Strategy）

策略模式定义了一系列算法，将每一个算法封装起来，并使它们可以相互替换。策略模式让算法的变化独立于使用算法的客户。

public interface Strategy {
    void execute();
}

public class ConcreteStrategyA implements Strategy {
    public void execute() {
        System.out.println("执行策略A");
    }
}

public class ConcreteStrategyB implements Strategy {
    public void execute() {
        System.out.println("执行策略B");
    }
}

public class Context {
    private Strategy strategy;

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

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

四、观察者模式（Observer）

观察者模式定义了一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并自动更新。

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

public class ConcreteObserver implements Observer {
    public void update(String message) {
        System.out.println("接收到的消息：" + message);
    }
}

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

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

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

五、总结

通过以上介绍，我们可以看到设计模式在Java开发中的应用非常广泛。掌握这些经典设计模式，不仅有助于提升代码质量，还能提高系统架构能力。希望本文能帮助你更好地理解和应用Java设计模式。

-- 展开阅读全文 --