面试官：项目中你都使用过哪些设计模式

引言

面试中很常见的问题，也是考验java基本功最好的方式。
也是基于上篇异步处理文件的文章，像大家简单介绍下常见的Java设计模式并提供代码示例

正文

1. 单例模式（Singleton Pattern）

单例模式确保一个类只有一个实例，并提供一个全局访问点。
示例代码

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

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

2. 工厂模式（Factory Pattern）

工厂模式提供一个接口用于创建对象，但允许子类决定实例化哪个类。
示例代码

interface Animal {
    void makeSound();
}

class Dog implements Animal {
    public void makeSound() {
        System.out.println("Woof!");
    }
}

class Cat implements Animal {
    public void makeSound() {
        System.out.println("Meow!");
    }
}

class AnimalFactory {
    public static Animal createAnimal(String type) {
        if ("dog".equals(type)) {
            return new Dog();
        } else if ("cat".equals(type)) {
            return new Cat();
        } else {
            throw new IllegalArgumentException("Invalid animal type");
        }
    }
}

// 使用工厂方法创建对象
Animal dog = AnimalFactory.createAnimal("dog");
dog.makeSound(); // 输出 "Woof!"

3. 观察者模式（Observer Pattern）

观察者模式定义了对象之间的一种一对多的依赖关系，当一个对象改变状态时，所有依赖于它的对象都会收到通知并自动更新。
示例代码

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

interface Observer {
    void update(String message);
}

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

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

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

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

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

// 使用观察者模式
ConcreteSubject subject = new ConcreteSubject();
Observer observer1 = new ConcreteObserver("Observer 1");
Observer observer2 = new ConcreteObserver("Observer 2");

subject.attach(observer1);
subject.attach(observer2);

subject.notifyObservers("Hello, world!"); // 输出 "Observer 1 received message: Hello, world!" 和 "Observer 2 received message: Hello, world!"

4. 装饰器模式（Decorator Pattern）

装饰器模式动态地给一个对象添加一些额外的职责，而不会影响从这个类中派生的其他对象。
示例代码

interface Component {
    void operation();
}

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

abstract class Decorator implements Component {
    protected Component component;

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

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

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

    public void operation() {
        super.operation();
        System.out.println("ConcreteDecoratorA operation");
    }
}

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

    public void operation() {
        super.operation();
        System.out.println("ConcreteDecoratorB operation");
    }
}

// 使用装饰器模式
Component component = new ConcreteComponent();
component = new ConcreteDecoratorA(component);
component = new ConcreteDecoratorB(component);

component.operation(); // 输出 "ConcreteComponent operation", "ConcreteDecoratorA operation", 和 "ConcreteDecoratorB operation"

总结

这只是Java设计模式的一小部分示例。每个模式都有其特定的用途和实现方法。理解和应用这些模式可以帮助你编写更灵活、可维护和可扩展的代码。
大家一定要多练习，做需求时养成下意识反应。