伴隨對象基本上提供了一個放置“類靜態”方法的地方。此外，伴隨對象或伴隨模塊具有對類成員（包括私有成員）的完全訪問權限。

伴侶對象非常適合封裝工廠方法之類的東西。而不必有，例如，Foo和FooFactory無處不在，你可以有一個伴侶對象采取在工廠責任的一類。

伴侶對象可用于存儲類的所有實例共有的狀態和方法，但它們不使用靜態方法或字段。他們使用可以通過繼承重寫的常規虛擬方法。Scala確實沒有什么靜態的。您可以使用多種方式使用此功能，但這是一個簡單的示例。

abstract class AnimalCounter

{

    var animals = 0

    def name: String

    def count()

    {

        animals += 1

        println("%d %ss created so far".format(animals, name))

    }

}

abstract class Animal

{

    def companion: AnimalCounter

    companion.count()

}

object Dog extends AnimalCounter

{

    val name = "dog"

}

class Dog extends Animal

{

    def companion = Dog

}

object Cat extends AnimalCounter

{

    val name = "cat"

}

class Cat extends Animal

{

    def companion = Cat

}

產生以下輸出：

scala> new Dog

1 dogs created so far

scala> new Cat

1 cats created so far

scala> new Dog

2 dogs created so far

scala> new Cat

2 cats created so far

...這是一個為伴隨的類存儲靜態工廠方法（不是DP）的好地方。如果您將那些重載的工廠方法命名為apply（/ ... /），則可以創建/初始化您的類

沒有“新”（不是那么重要）

具有不同的可能參數集（與Bloch在Effective Java中關于伸縮構造函數的內容進行比較）

能夠決定要創建哪個派生類，而不是抽象的（伴隨）類

示例代碼：

abstract class AbstractClass;

class RealThing(s: String) extends AbstractClass;

class AlternativeThing(i: Int) extends AbstractClass;

object AbstractClass {

  def apply(s: String) = {

    new RealThing(s)

  }

  def apply(i: Int) = {

    new AlternativeThing(i)

  }

}

// somewhere else you can

val vs = AbstractClass("asdf")  // gives you the RealThing wrapped over string

val vi = AbstractClass(123)  // gives you AlternativeThing wrapped over int

我不會調用對象/基類AbstractXxxxx，因為它看起來并不糟糕：就像創建抽象的東西一樣。給那些名字一個真實的含義?？紤]使用不可變，較少方法的案例類，并密封抽象基類。