Java实现工厂模式、单例模式

工厂模式（Factory Pattern）

工厂模式是一种创建型设计模式，它提供了一种在不指定具体类的情况下创建对象的机制。这里我们实现一个简单的工厂模式，用于创建不同类型的汽车。

// 定义一个汽车接口
interface Car {
    void start();
}

// 实现接口的具体类
class BMW implements Car {
    @Override
    public void start() {
        System.out.println("BMW started.");
    }
}

class Audi implements Car {
    @Override
    public void start() {
        System.out.println("Audi started.");
    }
}

// 工厂类
class CarFactory {
    public static Car createCar(String type) {
        if ("BMW".equalsIgnoreCase(type)) {
            return new BMW();
        } else if ("Audi".equalsIgnoreCase(type)) {
            return new Audi();
        }
        return null; // 或者抛出异常
    }
}

// 客户端代码
public class FactoryPatternDemo {
    public static void main(String[] args) {
        Car bmw = CarFactory.createCar("BMW");
        bmw.start();

        Car audi = CarFactory.createCar("Audi");
        audi.start();
    }
}

单例模式（Singleton Pattern）

下滑查看解决方法

单例模式是一种创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点来访问这个唯一实例。这里我们实现一个线程安全的单例模式。

// 懒汉式（线程安全）
public class Singleton {
    private static volatile Singleton instance; // volatile保证多线程可见性和禁止指令重排

    private Singleton() {} // 私有构造函数，防止外部实例化

    public static Singleton getInstance() {
        if (instance == null) { // 第一次检查
            synchronized (Singleton.class) { // 同步块，确保线程安全
                if (instance == null) { // 第二次检查（双重检查锁定）
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

    // 示例方法
    public void doSomething() {
        System.out.println("Singleton is doing something.");
    }

    // 客户端代码
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        
        // 输出应该为true，因为singleton1和singleton2是同一个实例
        System.out.println(singleton1 == singleton2);
        
        singleton1.doSomething();
    }
}

注意：上面的单例模式是懒汉式（线程安全）的实现方式，它使用了双重检查锁定（double-checked locking）来确保线程安全。另一种常见的单例模式是饿汉式（饿汉式是线程安全的，因为静态变量的初始化是在类加载时完成的，而类加载是线程安全的），但它在类加载时就创建了实例，可能会浪费一些资源。你可以根据你的需求选择适合的实现方式。