Question

我不是OOP专家，而且（因为学习松散耦合）努力找到问题的答案，以什么方式实例化对象来引导用Typescript编写的应用程序。

是否可以创建“Main”类，其唯一目的是实例化，设置和传递应用程序中使用的所有对象？依赖于Foo和Bar类，这种方法是否违反了OOP原则？如果是这样，应用程序的入口点是什么样的？

即

import {Foo} from "./foo-class";
import {Bar} from "./bar-class"; 

interface IOptions {
    amountOfFooObjects: number;
}

class Main {
    private fooObjects: Foo[] = [];

    constructor(options: IOptions) {
       this.buildFoo(options);
    }

    private buildFoo(options) {
       for (let i = 0; i < options.length; i++) {
           this.fooObjects.push(new Foo(new Bar()));
       }
    }
}
let main = new Main({ amountOfFooObjects: 10 });

Answer 1

OO-wise你正在做的很好，它与java中的相似（除了静态主函数）。

然而，你可以使用typescript / javascript做一些不同的事情由于你的Main类应该是一个单例，因为我假设你只想要它的一个实例，你可以将它创建为一个对象：

let main = {
    fooObjects: [],
    init: function(options: IOptions) {
        this.buildFoo(options);
    },
    buildFoo: function(options: IOptions) {
        for (let i = 0; i < options.amountOfFooObjects; i++) {
            this.fooObjects.push(new Foo(new Bar()));
        }
    }
};
main.init({ amountOfFooObjects: 10 });

如果要强制输入类型，也可以为其设置接口：

interface Main {
    fooObjects: Foo[];
    init: (options: IOptions) => void;
    buildFoo: (options: IOptions) => void;
}

let main: Main = {
    ...
}

但是，因为你在一个模块中，你可以简单地说：

let fooObjects: Foo[] = [];
function init(options: IOptions) {
    buildFoo(options);
}

function buildFoo(options: IOptions) {
    for (let i = 0; i < options.amountOfFooObjects; i++) {
        this.fooObjects.push(new Foo(new Bar()));
    }
}

然后公开（导出）你想要的东西。

但是，如果您希望扩展此类Main类，例如为其提供不同的实现，那么请坚持使用现有的类。

在Typescript中实例化对象，尊重松散耦合

1 个答案: