Ts实现工厂方法模式

要点：工厂类定义生产产品的接口，具体生产哪个产品由对应的工厂子类决定。

/** 工厂方法模式中的产品基类 */
export default class ProductBase {
    constructor() {}
}
/** 具体的产品A */
export class ProductA extends ProductBase {
    constructor() {
        super();
        console.log("[ProductA].constructor(): ");
    }
}
/** 具体的产品B */
export class ProductB extends ProductBase {
    constructor() {
        super();
        console.log("[ProductB].constructor(): ");
    }
}
/** 具体的产品C */
export class ProductC extends ProductBase {
    constructor() {
        super();
        console.log("[ProductC].constructor(): ");
    }
}

/** 工厂方法模式的创建者基类 */
export default abstract class CreatorBase {
    constructor() {}
    /** 生产产品的接口 */
    public abstract FactoryMethod():ProductBase;
}
/** 工厂方法模式中ProductA类的创建者 */
export class CreatorA extends CreatorBase{
    constructor() { 
        super();
        console.log("[CreatorA].constructor():");
    }

    /** 实现基类的接口 */
    public FactoryMethod(): ProductBase {
        return new ProductA();
    }
}
/** 工厂方法模式中ProductB类的创建者 */
export class CreatorB extends CreatorBase{
    constructor() { 
        super();
        console.log("[CreatorB].constructor():");
    }

    /** 实现基类的接口 */
    public FactoryMethod(): ProductBase {
        return new ProductB();
    }
}
/** 工厂方法模式中ProductC类的创建者 */
export class CreatorC extends CreatorBase{
    constructor() { 
        super();
        console.log("[CreatorC].constructor():");
    }

    /** 实现基类的接口 */
    public FactoryMethod(): ProductBase {
        return new ProductC();
    }
}

/** 工厂方法模式的泛型实现方式 */
export default class CreatorGeneric {
    constructor() {}

    /** 泛型方法 */
    public factoryMethod<T extends ProductBase>(c: { new(): T }): T {
        return new c();
    }
}

/** 单元测试类, 程序的入口 */
export default class UnitTest {
    public creator:CreatorBase;
    public product:ProductBase;
    public creatorGeneric:CreatorGeneric;
    constructor() {
        // 生产A类产品
        this.creator = new CreatorA();
        this.product = this.creator.FactoryMethod();
        
        // 生产B类产品
        this.creator = new CreatorB();
        this.product = this.creator.FactoryMethod();

        // 生产C类产品
        this.creator = new CreatorC();
        this.product = this.creator.FactoryMethod();

        // 使用泛型方式生产
        this.creatorGeneric = new CreatorGeneric();
        this.product = this.creatorGeneric.factoryMethod(CreatorA);
        this.product = this.creatorGeneric.factoryMethod(CreatorB);
        this.product = this.creatorGeneric.factoryMethod(CreatorC);
    }
}
new UnitTest();