了解常见的软件设计模式

软件设计模式是指在软件开发过程中经过总结和归纳得出的一套解决常见问题的设计思想和方法。通过使用设计模式，可以提高代码的可复用性、可维护性和可扩展性，同时降低开发过程中的错误。

单例模式

单例模式是一种常见的设计模式，它保证一个类只有一个实例，并提供一个全局的访问点。单例模式常用于需要在系统中共享资源的情况，比如日志记录器、数据库连接池等。

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

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

工厂模式

工厂模式是一种创建对象的设计模式，它通过工厂类来创建对象，将对象的创建过程与使用过程解耦，使得系统更加灵活、可扩展和可维护。常见的工厂模式包括简单工厂模式、工厂方法模式和抽象工厂模式。

public interface Shape {
    void draw();
}

public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Draw a circle");
    }
}

public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Draw a rectangle");
    }
}

public class ShapeFactory {
    public Shape getShape(String shapeType) {
        if (shapeType == null) {
            return null;
        }
        if (shapeType.equalsIgnoreCase("CIRCLE")) {
            return new Circle();
        } else if (shapeType.equalsIgnoreCase("RECTANGLE")) {
            return new Rectangle();
        }
        return null;
    }
}

观察者模式

观察者模式定义了一种一对多的依赖关系，当一个对象的状态发生变化时，所有依赖该对象的对象都会收到通知并自动更新。观察者模式可以实现松耦合的系统设计，使得被观察者和观察者之间的依赖关系减弱，同时增加了系统的可扩展性。

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

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

public class ObserverA implements Observer {
    @Override
    public void update(String message) {
        System.out.println("ObserverA received message: " + message);
    }
}

public class ObserverB implements Observer {
    @Override
    public void update(String message) {
        System.out.println("ObserverB received message: " + message);
    }
}

public interface Subject {
    void addObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers(String message);
}

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

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

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

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

策略模式

策略模式定义了一系列算法，并将每个算法封装成独立的类，使得它们可以相互替换。通过使用策略模式，可以动态地改变对象的行为，提高代码的灵活性和可扩展性。

public interface Strategy {
    int calculate(int a, int b);
}

public class AddStrategy implements Strategy {
    @Override
    public int calculate(int a, int b) {
        return a + b;
    }
}

public class SubtractStrategy implements Strategy {
    @Override
    public int calculate(int a, int b) {
        return a - b;
    }
}

public class Context {
    private Strategy strategy;

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

    public int executeStrategy(int a, int b) {
        return strategy.calculate(a, b);
    }
}

以上只是常见的几种软件设计模式，还有许多其他模式，如建造者模式、装饰器模式、代理模式等，每种模式都有不同的应用场景和优缺点。通过了解和学习这些设计模式，可以帮助我们编写更加高效、健壮和可维护的代码。

本文来自极简博客，作者：紫色迷情，转载请注明原文链接：了解常见的软件设计模式