代码更优雅！开发者不能错过的五种设计模式-51CTO.COM

在软件开发中，我们常常会遇到一些常见类型的问题。

设计模式通过提供高效且经过验证的方法来处理这些问题，从而帮助开发人员创建高效且具有适应性的解决方案。

这些设计模式是后端开发的重要组成部分，它们为解决问题提供了结构化的方法，从而提高了性能。

接下来，我们简要讨论五种设计模式，这些模式在软件开发人员中非常受欢迎。

观察者设计模式 (Observer Design Pattern)

如果我们需要在对象之间建立一对多的关系，可以使用这种设计模式。

一个类负责跟踪每个观察者对象的状态，当检测到变化时，通知这些观察者对象。

这种模式可用于分布式事件处理。

它属于行为型设计模式。

代码示例：

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


interface Observer {
    void perform(String message);
}


class FirstObserver implements Observer {
    private String name;


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


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


class SecondObserver implements Observer {
    private String name;


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


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


class Tracker {
    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(String message) {
        for (Observer observer : observers) {
            observer.perform(message);
        }
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.

单例设计模式 (Singleton Design Pattern)

当我们需要一个类只有一个实例时，可以使用单例设计模式。

这通常适用于数据库管理类或缓存管理类等场景。在这些情况下，我们希望只建立一次与数据库或缓存的连接。

代码示例：

public class SingletonDesignPattern {
    private static SingletonDesignPattern instance;


    private SingletonDesignPattern() {}


    public static SingletonDesignPattern getInstance() {
        if (instance == null) {
            instance = new SingletonDesignPattern();
        }
        return instance;
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.

注意，上述getInstance()方法不是线程安全的。如果在多线程环境中使用，需要额外处理线程安全问题。

策略设计模式 (Strategy Design Pattern)

策略设计模式通过将算法与其上下文分离并在运行时动态切换算法，促进了代码的灵活性和可维护性。

它属于行为型设计模式。

这种模式允许我们在运行时动态地改变算法，从而提高了代码的可扩展性。

工厂设计模式 (Factory Design Pattern)

如果一个类有多个子类，并且我们需要根据某些输入选择具体的子类，可以使用工厂设计模式。

这种模式避免了父类和子类之间的紧耦合。

它是一种创建型设计模式，可以定义一个接口或抽象类用于创建对象，但实例化的类由子类决定。

代码示例：

interface Shape {
    void draw();
}


class Circle implements Shape {
    public void draw() {
        System.out.println("This is a circle");
    }
}


class Rectangle implements Shape {
    public void draw() {
        System.out.println("This is a rectangle");
    }
}


class ShapeFactory {
    public Shape getShape(String shapeType) {
        switch(shapeType){
            case "CIRCLE":
                return new Circle();
            case "RECTANGLE":
                return new Rectangle();
            default:
                return null;
        }
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.

构建器设计模式 (Builder Design Pattern)

构建器设计模式通过一步步构建对象，保持代码的简洁性。它将对象的构造过程与表示过程分离。

这种模式特别适合对象构造过程复杂或有多种创建方式的情况。

我们可以通过创建一个静态内部类，并赋予其与外部类相同的属性，来实现这种模式。

代码示例：

public class Order {


    private final List<Item> items;
    private final String customerName;
    private final Address deliveryAddress;


    private Order(List<Item> items, String customerName, Address deliveryAddress) {
        this.items = items;
        this.customerName = customerName;
        this.deliveryAddress = deliveryAddress;
    }


    public static class Builder {
        private List<Item> items = new ArrayList<>();
        private String customerName;
        private Address deliveryAddress;


        public Builder addItem(Item item) {
            items.add(item);
            return this;
        }


        public Builder setCustomerName(String customerName) {
            this.customerName = customerName;
            return this;
        }


        public Builder setDeliveryAddress(Address deliveryAddress) {
            this.deliveryAddress = deliveryAddress;
            return this;
        }


        public Order build() {
            return new Order(items, customerName, deliveryAddress);
        }
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.

注意，Order类的构造方法被设置为私有，并且未提供任何 setter 方法。这强制我们使用 Builder 类，增强了代码的灵活性和可维护性。

总结

以上介绍了几种在组织中广泛使用的设计模式。此外，还有装饰器模式、适配器模式、外观模式等设计模式。

掌握这些设计模式可以极大地提高软件开发效率，帮助我们更好地管理复杂性，并编写出灵活、可复用且干净的代码。