Java设计模式面试题

1.请列举出在JDK 中几个常用的设计模式？

单例模式（Singleton pattern）用于Runtime，Calendar 和其他的一些类中。

工厂模式（Factory pattern）被用于各种不可变的类如 Boolean，像Boolean.valueOf。

观察者模式（Observer pattern）被用于 Swing 和很多的事件监听中。

装饰器设计模式（Decorator design pattern）被用于多个 Java IO 类中。

**2.**什么是设计模式？你是否在你的代码里面使用过任何设计模式？

设计模式是世界上各种各样程序员用来解决特定设计问题的尝试和测试的方法。设计模式是代码可用性的延伸

3.Java 中什么叫单例设计模式？请用Java 写出线程安全的单例模式

​ 单例模式重点在于在整个系统上共享一些创建时较耗资源的对象。整个应用中只维护一个特定类实例，它被所有组件共同使用。Java.lang.Runtime 是单例模式的经典例子。从 Java 5 开始你可以使用枚举（enum）来实现线程安全的单例。

1. 饿汉式单例模式

饿汉式单例模式在类加载的时候就立即创建实例，实例在整个应用程序生命周期中只有一个。它的特点是线程安全但不能懒加载。

实现代码：

public class EagerSingleton {

    // 在类加载时就创建实例
    private static final EagerSingleton INSTANCE = new EagerSingleton();

    // 私有构造方法，防止外部创建实例
    private EagerSingleton() {
    }

    // 提供公共的访问方式，获取唯一实例
    public static EagerSingleton getInstance() {
        return INSTANCE;
    }

    // 其他业务方法
    public void doSomething() {
        System.out.println("EagerSingleton is doing something.");
    }

    public static void main(String[] args) {
        EagerSingleton singleton = EagerSingleton.getInstance();
        singleton.doSomething();
    }
}

2. 懒汉式单例模式

懒汉式单例模式在首次使用时才创建实例。这种方式可以实现延迟加载（即懒加载），但需要处理线程安全问题。懒汉式可以进一步分为简单实现、线程安全的实现（同步方法或者同步块）以及双重检查锁（Double-checked Locking）等形式。

2.1 简单懒汉式（线程不安全）：

public class LazySingleton {

    // 延迟创建实例
    private static LazySingleton instance;

    // 私有构造方法，防止外部创建实例
    private LazySingleton() {
    }

    // 提供公共的访问方式，获取唯一实例
    public static LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }

    public void doSomething() {
        System.out.println("LazySingleton is doing something.");
    }

    public static void main(String[] args) {
        LazySingleton singleton = LazySingleton.getInstance();
        singleton.doSomething();
    }
}

2.2 线程安全的懒汉式（同步方法）：

public class ThreadSafeLazySingleton {

    private static ThreadSafeLazySingleton instance;

    private ThreadSafeLazySingleton() {
    }

    // 使用synchronized关键字，确保线程安全
    public static synchronized ThreadSafeLazySingleton getInstance() {
        if (instance == null) {
            instance = new ThreadSafeLazySingleton();
        }
        return instance;
    }

    public void doSomething() {
        System.out.println("ThreadSafeLazySingleton is doing something.");
    }

    public static void main(String[] args) {
        ThreadSafeLazySingleton singleton = ThreadSafeLazySingleton.getInstance();
        singleton.doSomething();
    }
}

2.3 线程安全的懒汉式（双重检查锁）：

public class DoubleCheckedLockingSingleton {

    // 使用volatile关键字保证可见性和有序性
    private static volatile DoubleCheckedLockingSingleton instance;

    private DoubleCheckedLockingSingleton() {
    }

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

    public void doSomething() {
        System.out.println("DoubleCheckedLockingSingleton is doing something.");
    }

    public static void main(String[] args) {
        DoubleCheckedLockingSingleton singleton = DoubleCheckedLockingSingleton.getInstance();
        singleton.doSomething();
    }
}

**4.**在 Java 中，什么叫观察者设计模式（observer design pattern）？

​ 观察者模式是基于对象的状态变化和观察者的通讯，以便他们作出相应的操作。简单的例子就是一个天气系统，当天气变化时必须在展示给公众的视图中进行反映。这个视图对象是一个主体，而不同的视图是观察者。

**5.**使用工厂模式最主要的好处是什么？在哪里使用？

​ 工厂模式的最大好处是增加了创建对象时的封装层次。如果你使用工厂来创建对象，之后你可以使用更高级和更高性能的实现来替换原始的产品实现或类，这不需要在调用层做任何修改。

6.举一个用 Java 实现的装饰模式(decorator design pattern)？它是作用于对象层次还是类层次？

​ 装饰模式增加强了单个对象的能力。Java IO 到处都使用了装饰模式，典型例子就是 Buffered 系列类如BufferedReader 和BufferedWriter，它们增强了Reader 和Writer 对象，以实现提升性能的 Buffer 层次的读取和写入。

**7.**在 Java 中，为什么不允许从静态方法中访问非静态变量？

Java中不能从静态上下文访问非静态数据只是因为非静态变量是跟具体的对象实例关联的，而静态的却没有和任何实例关联。

**8.**设计一个 ATM 机，请说出你的设计思路？

​ 比如设计金融系统来说，必须知道它们应该在任何情况下都能够正常工作。不管是断电还是其他情况，ATM 应该保持正确的状态（事务） , 想想加锁（locking）、事务（transaction）、错误条件（error condition）、边界条件（boundary condition）等等。尽管你不能想到具体的设计，但如果你可以指出非功能性需求，提出一些问题，想到关于边界条件，这些都会是很好的。

**9.**在 Java 中，什么时候用重载，什么时候用重写？

​ 如果你看到一个类的不同实现有着不同的方式来做同一件事，那么就应该用重写（overriding），而重载（overloading）是用不同的输入做同一件事。在 Java 中，重载的方法签名不同，而重写并不是。

**10.**举例说明什么情况下会更倾向于使用抽象类而不是接口？

​ 接口和抽象类都遵循”面向接口而不是实现编码”设计原则，它可以增加代码的灵活性，可以适应不断变化的需求。下面有几个点可以帮助你回答这个问题：

在 Java 中，你只能继承一个类，但可以实现多个接口。所以一旦你继承了一个类，你就失去了继承其他类的机会了。

​ 接口通常被用来表示附属描述或行为如：Runnable、Clonable、Serializable 等等，因此当你使用抽象类来表示行为时，你的类就不能同时是Runnable 和Clonable(注：这里的意思是指如果把Runnable 等实现为抽象类的情况)，因为在 Java 中你不能继承两个类，但当你使用接口时，你的类就可以同时拥有多个不同的行为。

​ 在一些对时间要求比较高的应用中，倾向于使用抽象类，它会比接口稍快一点。并且可以更好地在同一个地方进行编码，那如果希望把一系列行为都规范在类继承层次内，那么抽象类是一个更好的选择。有时，接口和抽象类可以一起使用，接口中定义函数，而在抽象类中定义默认的实现。