Java面试——单例模式和工厂模式

当谈到编程设计模式时，饿汉式和懒汉式是指在创建对象实例时的不同策略。而单例模式和工厂模式是常见的两种设计模式，用于创建和管理对象的方式。

1. 饿汉式（Eager Initialization）和懒汉式（Lazy Initialization）：

   • 饿汉式：在程序启动时或类加载时就创建对象实例，并在整个生命周期内保持单一实例。这意味着对象实例在使用前已经准备好，不需要延迟加载。饿汉式的实现通常是通过静态成员变量或静态代码块来实现。
   • 懒汉式：在对象第一次使用时才创建实例。这意味着对象实例的创建被延迟到需要的时候，也可以说是按需加载。懒汉式的实现通常是在方法调用时进行实例化，可以采用线程安全的方式实现，也可以是非线程安全的。

2. 单例模式（Singleton Pattern）：
   单例模式用于确保一个类只有一个实例，并提供全局访问点以获取该实例。它常用于需要共享资源或需要全局状态的情况。单例模式的实现可以使用饿汉式或懒汉式。在实现时，需要注意线程安全性、延迟加载和对象创建的方式。

3. 工厂模式（Factory Pattern）：
   工厂模式是一种创建对象的设计模式，它将对象的创建逻辑封装到一个工厂类中，通过调用工厂类的方法来创建对象，而不是直接调用对象的构造函数。工厂模式可以根据不同的条件或参数创建不同类型的对象，隐藏了对象创建的细节，提供了更灵活和可扩展的方式来创建对象。

总结来说，饿汉式和懒汉式是对象实例化的不同策略，单例模式确保只有一个对象实例存在，而工厂模式则是通过工厂类来创建对象，提供了更灵活的对象创建方式。这些设计模式在软件开发中经常被使用，有助于提高代码的可维护性、可扩展性和可重用性。

单例模式和工厂模式是两种常见的设计模式，它们都有不同的实现方式。

单例模式的实现：

1. 懒汉式（线程不安全）：

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

2. 懒汉式（线程安全，使用双重检查锁）：

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

3. 饿汉式（线程安全）：

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

4. 静态内部类（线程安全）：

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

工厂模式的实现：

1. 简单工厂模式：

   public class SimpleFactory {
       public static Product createProduct(String type) {
           if ("A".equals(type)) {
               return new ConcreteProductA();
           } else if ("B".equals(type)) {
               return new ConcreteProductB();
           }
           return null;
       }
   }
   

2. 工厂方法模式：

   public interface Factory {
       Product createProduct();
   }
   
   public class ConcreteFactoryA implements Factory {
       @Override
       public Product createProduct() {
           return new ConcreteProductA();
       }
   }
   
   public class ConcreteFactoryB implements Factory {
       @Override
       public Product createProduct() {
           return new ConcreteProductB();
       }
   }
   

3. 抽象工厂模式：

   public interface AbstractFactory {
       ProductA createProductA();
       ProductB createProductB();
   }
   
   public class ConcreteFactory1 implements AbstractFactory {
       @Override
       public ProductA createProductA() {
           return new ConcreteProductA1();
       }
   
       @Override
       public ProductB createProductB() {
           return new ConcreteProductB1();
       }
   }
   
   public class ConcreteFactory2 implements AbstractFactory {
       @Override
       public ProductA createProductA() {
           return new ConcreteProductA2();
       }
   
       @Override
       public ProductB createProductB() {
           return new ConcreteProductB2();
       }
   }
   

这些是单例模式和工厂模式的基本实现方式。根据具体的需求和场景，可以选择合适的实现方式来设计和实现。