是否可以在scala中的多个文件中拆分对象定义？

我正在编写一个在scala中使用CreateJS库的facade，如下所示

object CreateJS
{
    sealed trait EventListener extends js.Object

    type EventHandler = js.Function

    class DisplayObject extends js.Object
    {
    }

    class Container extends DisplayObject
    {
        def addChild(item:DisplayObject):Unit = ???
        def update():Unit = ???
    }

    @JSName("createjs.Stage")
    class Stage(canvasId:String) extends Container with EventListener

    // TODO: Is enum done this way ???
    object MovieClip
    {
        @JSName("createjs.MovieClip")
        var INDEPENDENT:String = _
        @JSName("createjs.SINGLE_FRAME")
        var SINGLE_FRAME:String = _
        @JSName("createjs.SYNCHED")
        var SYNCHED:String = _
    }

    @JSName("createjs.MovieClip")
    class MovieClip(mode:js.String=MovieClip.INDEPENDENT,startPosition:js.Number=0, loop:js.Boolean=true, labels:js.Object = null) extends DisplayObject
    {

        def addEventListener(eventName:String, target:EventHandler):Unit = ???
        var timeline:TimeLine = _
        def gotoAndPlay(where:String):Unit = ???
    }

    class TimeLine extends js.Object
    {
        def addTween(tween:Tween):Unit = ???
    }

    @JSName("createjs.Shape")
    class Shape(graphics:Graphics = null) extends DisplayObject

    @JSName("createjs.Graphics")
    class Graphics extends js.Object
    {
        def beginFill(color:String):Graphics = ???
        def drawCircle(x:js.Number, y:js.Number, r:js.Number):Graphics = ???
    }

    @JSName("createjs.Ticker")
    object Ticker extends js.Object
    {
        def addEventListener(eventName:String, handler:EventHandler):Unit = ???
        def addEventListener(eventName:String, stage:Stage):Unit = ???
    }

    class Tween extends js.Object
    {
        def get(item:DisplayObject):Tween = ???
        def to(state:js.Dynamic, time:js.Number = 0):Tween = ???
    }

    @JSName("createjs.Tween")
    object Tween extends Tween


/*   Load queue */
    class Plugin extends js.Object

    @JSName("createjs.Sound")
    object Sound extends Plugin {
        def play(soundId:String):Unit = ???
    }

    @JSName("createjs.LoadQueue")
    class LoadQueue(useXHR:Boolean = true, basePath:String="", crossOrigin:String="") extends js.Object
    {
        def installPlugin(plugin:Plugin):Unit = ???

        def on(event:String, handler:EventHandler):Unit = ???

        def addEventListener(event:String, handler:EventHandler):Unit = ???

        def loadFile(params:js.Dynamic):Unit = ???

        def loadManifest(paramList:js.Array[js.Dynamic]):Unit = ???
    }


}

这个文件变成了一大堆。 在real createJS中，这些文件分为4个文件-画架、tween、声音和预加载，每个文件都扩展了基本createJS对象。我是否可以在scala中执行此文件分离，同时将所有内容保留在CreateJS命名空间中

---

（可能这样的端口已经存在？

您可以在不同的trait中拆分代码，每个trait负责一个连贯的方面（并收集相关的函数），每个trait都在一个单独的文件中，然后让公共的singleton facade对象公开所有特性

例如，使用trait

A

在文件

A.scala

中实现函数

foo

和

bar

，使用trait

B

在文件

B.scala

中实现函数

oof

和

rab

，则可以声明facade对象，就像

对象facade用B

扩展A一样

---

这样，我建议将trait声明为package private，因为它们只用于组织代码：

private[mypackage]trait A{…}

您可以将代码拆分为不同的trait，每个trait负责一个连贯的方面（并收集相关函数），每个trait都在一个单独的文件中，然后让公共单例外观对象公开所有

例如，使用trait

A

在文件

A.scala

中实现函数

foo

和

bar

，使用trait

B

在文件

B.scala

中实现函数

oof

和

rab

，则可以声明facade对象，就像

对象facade用B

扩展A一样

---

这样，我建议将trait声明为package private，因为它们只用于组织代码：

private[mypackage]trait A{…}

同意，但我不建议

private[mypackage]

。公共对象继承自traits，因此它们不应该是私有的。在我看来，这种继承甚至可以编译是一个错误。防止这些特性被误用的更好方法是使用self类型声明它们：

trait A{this:Facade.type=>…}

self类型不是必需的，除非不同的trait需要调用彼此的函数。实际上，在我的例子中不能这样做，因为扩展js的类不能在类或trait中定义Any。有什么建议吗？啊，对。但是现在我想知道为什么您首先要使用

对象

作为名称空间？为什么不简单地使用一个名为

createjs

的包呢？'因为目标是让一张脸公开所有的功能，而不是让用户必须实现/扩展的特性，即使这会像

newa{}

那样以转储方式进行。同意，但我不推荐

private[mypackage]

。公共对象继承自traits，因此它们不应该是私有的。在我看来，这种继承甚至可以编译是一个错误。防止这些特性被误用的更好方法是使用self类型声明它们：

trait A{this:Facade.type=>…}

self类型不是必需的，除非不同的trait需要调用彼此的函数。实际上，在我的例子中不能这样做，因为扩展js的类不能在类或trait中定义Any。有什么建议吗？啊，对。但是现在我想知道为什么您首先要使用

对象

作为名称空间？为什么不简单地使用一个名为

createjs

的包呢？'因为目标是让一个面公开所有的函数，而不是用户必须实现/扩展的特性，即使是以像

newa{}

这样的转储方式。