在Scala中拥有伴随对象的背后原理是什么？

Question

是否存在需要用于类的伴侣对象（单例）的情况？我为什么要创建一个类，说一个Foo并为其创建一个伴随对象？

Answer 1

伴随对象基本上提供了一个放置“类静态”方法的地方。此外，伴随对象或伴随模块具有对类成员（包括私有成员）的完全访问权限。

伴侣对象非常适合封装工厂方法之类的东西。而不必有，例如，Foo和FooFactory无处不在，你可以有一个伴侣对象采取在工厂责任的一类。

Answer 2

伴侣对象可用于存储类的所有实例共有的状态和方法，但它们不使用静态方法或字段。他们使用可以通过继承重写的常规虚拟方法。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

Answer 3

...这是一个为伴随的类存储静态工厂方法（不是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，因为它看起来并不糟糕：就像创建抽象的东西一样。给那些名字一个真实的含义。考虑使用不可变，较少方法的案例类，并密封抽象基类。