正确的答案往往取决于实际的业务需求。从一个对象扩展在某种意义上违背了该对象的目的，因为它不再是一个单一的对象。
一个可能的解决方案是将行为提取到一个抽象的特征中，然后创建扩展该特征的对象，如下所示：

trait T{
    // some behavior goes here
}

object X extends T

object Y extends T {
    // additional stuff here
}

如果要使用另一个对象方法和值，可以使用import

object X{
  def x = 5
}

object Y{
  import X._
  val y = x
}

您实际上不能扩展一个对象，因为这样会创建两个对象，而一个对象根据定义只能存在一次（编辑：但这并不完全正确，因为对象定义可以在类或方法中）。
出于您的目的，请尝试以下操作：

object X {
}

object Y {
    def a = 5
}

implicit def xToY(x: X.type) = Y

println(X.a)

它实际上并不扩展，但它允许您在其上调用比最初定义的方法更新的方法。

在两个对象之间共享代码的唯一方法是拥有一个或多个公共超类/特征。

请注意，从Scala 3开始，您也可以通过export clauses使用组合（而不是继承），export clauses允许为对象的选定成员定义别名：

object X { def f = 5 }

object Y {
  export X._
  def g = 42
  def h = f * g
}

Y.f // 5
Y.g // 42
Y.h // 210

请注意，您还可以限制要导出的成员：

object X { def f = 5; def g = 6 }
object Y { export X.f }
Y.f // 5
Y.g
^^^
value g is not a member of Y

您可以将父对象转换为类+伴随对象，然后让子对象扩展类。
在父级. scala中

class Parent {}

object Parent extends Parent {}

然后在Child. scala中

object Child extends Parent {}

是的，这与其说是解决方案，不如说是一种黑客行为。

这是一个欧文的Scala 3的答案：可以使用扩展来扩展伴随对象。

object X:
  def a = 5
end X

// Somewhere else, another file where X is visible
extension (x: X.type)
  def b = 42
end extension

// Somewhere else, another file where 
// both X and the extension are visible
@main def main =
  println(X.a)
  println(X.b)