1什么是设计模式？有什么好处？

1.1背记

1.2理解

1. 可重用性：设计模式提供了经过验证的解决方案，这些方案可以在不同的软件项目中重复使用，节省了开发时间和资源。
2. 与语言无关：设计模式是一种思想，并不依赖于特定的编程语言，这意味着它们的原则和概念可以跨语言应用。
3. 描述问题的通用词汇：设计模式为开发者提供了一套共同的术语，使得在讨论软件设计时能够有更清晰的交流。
4. 系统稳定性和灵活性：在大型软件开发中，合理运用设计模式可以增强系统的稳定性，使系统易于修改和扩展。
5. 面向对象设计原则的实践：设计模式是对类的封装性、继承性、多态性以及类之间关系理解的实际应用，有助于提升软件质量。

2设计模式的7大基本原则有哪些？

2.1背记

2.2理解

1. 单一职责原则（Single Responsibility Principle，SRP）：一个类只负责一项职责。一个类应该只有一个引起它变化的原因。
2. 开放封闭原则（Open-Closed Principle，OCP）：软件实体（类、模块、函数等）应该对扩展开放，对修改关闭。通过抽象和多态来实现对软件实体的扩展，而不是通过修改已有的代码。
3. 里氏替换原则（Liskov Substitution Principle，LSP）：子类应该能够替换掉父类并且工作正常，子类必须能够完全替代父类的行为。
4. 依赖倒置原则（Dependency Inversion Principle，DIP）：高层模块不应该依赖于低层模块，它们应该依赖于抽象。抽象不应该依赖于具体实现，具体实现应该依赖于抽象。
5. 接口隔离原则（Interface Segregation Principle，ISP）：客户端不应该依赖它不需要的接口。类之间的依赖关系应该建立在最小的接口上。
6. 迪米特法则（Law of Demeter，LoD）：一个对象应该对其他对象有尽可能少的了解。只与其直接的朋友进行通信，不需要了解朋友的朋友。
7. 合成复用原则（Composite Reuse Principle，CRP）：尽量使用对象组合和聚合，而不是继承来达到复用的目的。通过组合已有的对象来实现新的功能。

3使用哪种设计模式可以提高代码可维护性？

1. 单例模式（Singleton）：确保一个类只有一个实例，并提供一个全局访问点。
2. 工厂模式（Factory）：定义一个创建对象的接口，但让子类决定实例化哪个类。
3. 观察者模式（Observer）：定义对象间的一对多依赖关系，当一个对象改变状态时，所有依赖于它的对象都会收到通知并自动更新。
4. 策略模式（Strategy）：定义一系列算法，把它们一个个封装起来，并且使它们可以互相替换。
5. 装饰器模式（Decorator）：动态地给一个对象添加一些额外的职责。
6. 适配器模式（Adapter）：将一个类的接口转换成客户希望的另一个接口，使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
7. 命令模式（Command）：将请求封装成对象，以便使用不同的请求、队列或者日志来参数化其他对象。
8. 模板方法模式（Template Method）：在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。
9. 迭代器模式（Iterator）：提供一种方法顺序访问一个聚合对象中的各个元素，而又不需要暴露该对象的内部表示。

4在23种常用设计模式中，哪些是用来提高代码复用程度的？

1. 单例模式
   • 描述：单例模式是一种创建型设计模式，它确保一个类只有一个实例，并提供全局访问点[^1^]。
   • 应用场景：适用于需要频繁创建和销毁的对象，例如数据库连接池或线程池[^1^]。
   • 优点：通过控制实例数目来减少系统内存开销，同时避免对资源的多重占用[^1^]。
2. 工厂模式
   • 描述：工厂模式是一种创建型设计模式，它提供了一种创建对象的最佳方式，通过工厂类封装对象的创建逻辑[^1^]。
   • 应用场景：适用于创建过程复杂或者创建过程容易出错的对象[^1^]。
   • 优点：客户端无需关心对象的创建细节，提高了代码的灵活性和可维护性[^1^]。
3. 观察者模式
   • 描述：观察者模式是一种行为型设计模式，定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新[^1^]。
   • 应用场景：适用于对象间存在大量依赖关系的情况，如GUI事件处理、订阅发布系统等[^1^]。
   • 优点：支持广播通信，自动通知所有依赖对象，提高了系统的扩展性和灵活性[^1^]。
4. 享元模式
   • 描述：享元模式是一种结构型设计模式，通过共享技术有效地支持大量细粒度对象的复用[^2^][^3^]。
   • 应用场景：适用于系统中有大量相似对象的场景，如缓存实现、数据库连接管理等[^2^][^3^]。
   • 优点：显著减少了内存中对象的数量，降低了内存的使用和提高了性能[^2^][^3^]。
5. 桥接模式
   • 描述：桥接模式是一种结构型设计模式，将抽象部分与实现部分分离，使它们可以独立变化[^2^][^3^]。
   • 应用场景：适用于不希望在抽象和实现之间建立一个固定的绑定关系的场景[^2^][^3^]。
   • 优点：实现了抽象和实现的分离，提高了系统的灵活性和扩展性[^2^][^3^]。
6. 模板方法模式
   • 描述：模板方法模式是一种行为型设计模式，定义了一个操作中的算法框架，而将一些步骤延迟到子类中[^2^][^3^]。
   • 应用场景：适用于多个子类具有共同的方法但具体实现不同的情况[^2^][^3^]。
   • 优点：通过继承复用公共的方法，避免了代码重复，提高了代码的可维护性[^2^][^3^]。

5你在工作中是如何使用设计模式的？

5.1背记

5.1.1创建型设计模式

5.1.2结构型设计模式

5.1.3行为型设计模式

5.2理解

1. 单例模式：在Spring框架中，默认情况下，Bean是单例的，即在整个应用中只有一个实例。这是通过单例模式实现的，确保了资源的有效利用和性能优化。
2. 工厂模式：在Spring框架中，IoC容器通过工厂模式创建Bean实例。开发者只需要配置好相应的配置文件，Spring容器会自动创建所需的Bean实例，无需手动创建对象。
3. 模板方法模式：在Spring MVC中，Controller的处理方法通常使用模板方法模式。Controller类定义了处理请求的模板方法，具体的子类可以实现这些方法以完成具体的业务逻辑。
4. 策略模式：在Spring框架中，通过使用策略模式，可以轻松地更换算法或策略。例如，可以通过更换不同的视图解析器来改变视图的解析策略。
5. 观察者模式：在Spring中，事件发布/订阅机制使用了观察者模式。当一个事件发生时，所有注册为该事件的监听器都会自动收到通知。
6. 装饰器模式：在Spring中，通过使用装饰器模式，可以为一个对象动态添加功能。例如，通过为一个Bean添加不同的AOP切面，可以为该Bean添加额外的功能。
7. 代理模式：在MyBatis中，通过使用代理模式，可以实现对数据库操作的拦截和增强。

6Java语言可以用哪些方式实现单例模式？

6.1懒汉式

public class Singleton {
    private static Singleton instance;
    private Singleton() {}
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
} 基础版实现：存在线程安全问题

6.2懒汉式（改进版）

public class Singleton {
    private static Singleton instance;

    private Singleton() {
    }

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
} 改进版实现：在上一版的基础上解决线程安全问题

6.3饿汉式

public class Singleton {
    private static Singleton instance = new Singleton();
    private Singleton() {}
    public static Singleton getInstance() {
        return instance;
    }
}

6.4双重检查锁定

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

6.5静态内部类

• 延迟初始化：静态内部类在第一次被使用时才会被加载，因此 Singleton 实例在第一次调用 getInstance() 方法时才被创建，实现了延迟初始化。
• 线程安全：由于静态内部类的加载是由 JVM 保证线程安全的，因此 Singleton 实例的创建是线程安全的，无需额外的同步机制。
• 性能优化：相比其他单例模式实现（如饿汉式、懒汉式），静态内部类方式在保证线程安全的同时，避免了每次获取实例时的同步开销，提高了性能。

• 反射攻击：
• 问题：虽然私有构造方法可以防止外部直接实例化，但通过反射机制仍然可以调用私有构造方法，破坏单例。 解决方案：可以在构造方法中添加检查，防止多次实例化。

• 序列化问题：
• 问题：如果 Singleton 类实现了 Serializable 接口，反序列化时会创建新的实例，破坏单例。 解决方案：重写 readResolve 方法，确保反序列化时返回同一个实例。

• 类加载器依赖：
• 问题：不同的类加载器可能会加载同一个类的多个实例，导致多个单例对象。 解决方案：确保在同一个类加载器下加载 Singleton 类。

public class Singleton {
    private Singleton() {}
    private static class SingletonHolder {
        private static final Singleton instance = new Singleton();
    }
    public static Singleton getInstance() {
        return SingletonHolder.instance;
    }
}

6.6枚举

public enum Singleton {
    INSTANCE;

    // 可以在这里添加其他方法
    public void someMethod() {
        // 实现具体逻辑
    }
}
 代码实现思路：

public class Main {
    public static void main(String[] args) {
        Singleton singleton = Singleton.INSTANCE;
        singleton.someMethod();
    }
}
 应用举例

7如何破坏单例模式？

7.1背记

7.2理解

1. 反射破坏：通过反射机制，可以访问私有构造函数并创建多个实例。可以构造函数中添加逻辑来防止反射破坏单例模式。
2. 序列化与反序列化破坏：当一个单例类被序列化后，再次反序列化会创建一个新的实例。可以通过在单例类中添加 readResolve() 方法，返回已有的实例，从而避免破坏。
3. 多线程环境下的破坏：在多线程环境下，如果没有合适的同步机制，可能会创建多个实例。可以使用双重检查锁定或者静态内部类等线程安全的方式来防止破坏。
4. 克隆破坏：如果单例类实现了 Cloneable 接口并重写了 clone() 方法，可以通过克隆对象创建多个实例。可以在 clone() 方法中抛出 CloneNotSupportedException 异常，阻止克隆破坏。

8为什么说枚举是实现单例最好的方式？

8.1背记

1. 线程安全性：枚举实例的创建是由JVM在加载枚举类的时候保证的，因此在多线程环境下也能保证单例的唯一性。枚举的实例创建是线程安全的，无需担心并发访问导致的多实例问题。
2. 反射安全性：枚举类的实例是在枚举类加载的时候被创建的，而且枚举类不支持通过反射来创建实例。即使使用反射强制访问枚举类的私有构造函数，也无法创建新的实例，因为枚举类的构造函数默认是私有的。
3. 序列化安全性：枚举类默认实现了 java.io.Serializable 接口，因此可以安全地进行序列化和反序列化。枚举实例在序列化和反序列化过程中保持单例的状态，不会创建新的实 例。
4. 简洁性和可读性：使用枚举实现单例模式非常简洁，只需定义一个枚举类型，枚举值即为单例实例。同时，使用枚举实现的单例模式也更易于理解和维护。

8.2理解

8.2.1定义枚举单例模式

public enum Singleton {
    INSTANCE;
    public void businessMethod() {
        System.out.println("我是一个单例！");
    }
}

8.2.2使用枚举单例模式

public class MainClass {
    public static void main(String[] args) {
        Singleton s1 = Singleton.INSTANCE;
        Singleton s2 = Singleton.INSTANCE;
        System.out.println(s1==s2);
    }
}

9不使用锁如何实现线程安全的单例？

9.1背记

• 静态变量饿汉式
• 静态内部类懒汉式
• 枚举方式

9.2理解

9.2.1饿汉式

public class Singleton {
    private static Singleton instance = new Singleton();
    private Singleton() {}
    public static Singleton getInstance() {
        return instance;
    }
}

9.2.2静态内部类

public class Singleton {
    private Singleton() {}
    private static class SingletonHolder {
        private static final Singleton instance = new Singleton();
    }
    public static Singleton getInstance() {
        return SingletonHolder.instance;
    }
}

10什么是享元模式，有哪些具体应用？

1. 文字编辑器：在文字编辑器中，每个字符都是一个对象，但是字符的属性（如字体、颜色等）可以作为内部状态进行共享，而文字的位置等属性可以作为外部状态进行传递。
2. 线程池：在线程池中，每个线程对象可以看作是一个享元对象，线程的内部状态（如线程ID、状态标识等）是可以共享的，而外部状态（如任务）是不同的，通过外部传入。
3. 资源池：在数据库连接池中，可以使用享元模式来共享和复用资源对象，提高资源的利用率。
4. 游戏中的角色：在游戏中，角色的外观、动作等可以作为内部状态进行共享，而角色的位置、血量等信息可以作为外部状态。