Java面试-设计模式

设计模式是指在软件设计过程中，经过总结和归纳的一种解决问题的经验。它是软件设计中一种普遍存在的思想模式，能够提供解决常见问题的可重用解决方案。在Java面试中，设计模式是常见的面试题之一，因为它展示了面试者对软件设计原则的理解和应用能力。

本文将介绍常见的几种设计模式，并提供相应的代码示例，帮助读者理解和掌握这些设计模式。

1. 单例模式

单例模式是指一个类只能实例化一个对象，并提供一个全局访问点。在Java中，常见的实现方式是使用私有的构造方法和静态方法来实现。

public class Singleton {
    private static Singleton instance;

    private Singleton() {
        // 私有构造方法
    }

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

2. 工厂模式

工厂模式是指将对象的创建逻辑封装到工厂类中，由工厂类负责创建对象。在Java中，常见的实现方式是使用一个工厂类和一个抽象产品类，具体产品类继承自抽象产品类。

public interface Product {
    void operate();
}

public class ConcreteProduct implements Product {
    @Override
    public void operate() {
        System.out.println("ConcreteProduct.operate()");
    }
}

public class ProductFactory {
    public static Product createProduct() {
        return new ConcreteProduct();
    }
}

3. 观察者模式

观察者模式是指在对象之间定义一种一对多的依赖关系，使得当一个对象状态发生改变时，其相关依赖对象都能够得到通知和更新。在Java中，常见的实现方式是使用java.util.Observable和java.util.Observer接口。

import java.util.Observable;
import java.util.Observer;

public class Subject extends Observable {
    private int state;

    public int getState() {
        return state;
    }

    public void setState(int state) {
        this.state = state;
        setChanged();
        notifyObservers();
    }
}

public class ObserverA implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("ObserverA.update()");
    }
}

public class ObserverB implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("ObserverB.update()");
    }
}

public class Main {
    public static void main(String[] args) {
        Subject subject = new Subject();
        Observer observerA = new ObserverA();
        Observer observerB = new ObserverB();

        subject.addObserver(observerA);
        subject.addObserver(observerB);

        subject.setState(1);
    }
}

4. 策略模式

策略模式是指定义一系列算法，封装每个算法，并使它们可以互换。在Java中，常见的实现方式是使用接口或抽象类定义算法，并在上下文类中持有一个策略对象。

public interface Strategy {
    void execute();
}

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

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

public class Context {
    private Strategy strategy;

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

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

public class Main {
    public static void main(String[] args) {
        Strategy strategyA = new ConcreteStrategyA();
        Strategy strategyB = new ConcreteStrategyB();

        Context contextA = new Context(strategyA);
        contextA.executeStrategy();

        Context contextB = new Context(strategyB);
        contextB.executeStrategy();
    }
}

总结

本文介绍了常见的几种设计模式，并提供了相应的代码示例。单例模式通过限制实例化次数和提供全局访问点，确保只有一个实例；工厂模式通过工