单例模式与工厂模式

class Singleton {
    private static instance: Singleton;
    
    private constructor() {
        // 初始化代码
    }
    
    public static getInstance(): Singleton {
        if (!Singleton.instance) {
            Singleton.instance = new Singleton();
        }
        return Singleton.instance;
    }
    
    public someBusinessLogic() {
        // 业务逻辑
    }
}

// 使用
const instance1 = Singleton.getInstance();
const instance2 = Singleton.getInstance();

console.log(instance1 === instance2); // 输出: true

interface Product {
    operation(): string;
}

class ConcreteProductA implements Product {
    operation(): string {
        return 'ConcreteProductA operation';
    }
}

class ConcreteProductB implements Product {
    operation(): string {
        return 'ConcreteProductB operation';
    }
}

abstract class Creator {
    public abstract factoryMethod(): Product;
    
    public someOperation(): string {
        const product = this.factoryMethod();
        return `Creator: ${product.operation()}`;
    }
}

class ConcreteCreatorA extends Creator {
    public factoryMethod(): Product {
        return new ConcreteProductA();
    }
}

class ConcreteCreatorB extends Creator {
    public factoryMethod(): Product {
        return new ConcreteProductB();
    }
}

// 使用
function clientCode(creator: Creator) {
    console.log(creator.someOperation());
}

clientCode(new ConcreteCreatorA()); // 输出: Creator: ConcreteProductA operation
clientCode(new ConcreteCreatorB()); // 输出: Creator: ConcreteProductB operation