CODEWITHSUNDEEP
scala
jerome
jerome

Reputation: 2089

Case class and companion object

I have problems understanding correctly the use of class and their companion object.

When defining a case class there is its companion object that comes with it, but what is the result of defining an object having the same name as the case class? Does it override the companion object? And how to access case class parameters?

For example in TestCaseClass.scala file I define the following :

case class TestCaseClass(att1: String, att2: Int, att4s: List[String])

object TestCaseClass {

  def iWantDoSomethingWithMyParams: String = {
    att1 + " " + att2
  }

  // Other functions
}

object AnotherTestCaseClass {

  def iWantDoSomethingWithTestCaseClassParams: String = {
  // How to access TestCaseClass.att1
    TestCaseClass.att1 + " " + TestCaseClass.att2
  }

  def iWantGetAllAttr4: List[String] = {
     // ???
  }
}

Upvotes: 14

Views: 18616

Answers (2)

Ricardo
Ricardo

Reputation: 4298

I would kindly like to add one piece of information to the accepted answer that wasn't clear to me after reading it a couple of times; it's from the Scala Book (all credits to mlachkar, 0x54321 and alvinj):

A companion object in Scala is an object that’s declared in the same file as a class, and has the same name as the class. For instance, when the following code is saved in a file named Pizza.scala, the Pizza object is considered to be a companion object to the Pizza class:

class Pizza {
}

object Pizza {
}

Upvotes: 1

Chris Martin
Chris Martin

Reputation: 30736

To some extent, giving an object the same name as a class (or trait) is just a matter of convention. But it also has a bit of special meaning.

The companion object is a singleton class just like any other object. If you want a method in the companion object to interact with an instance of the class, you have to pass it an instance of the class just like in any other situation. So, to fix your first example:

case class TestCaseClass(att1: String, att2: Int, att4s: List[String])

object TestCaseClass {    
  def iWantDoSomethingWithMyParams(x: TestCaseClass): String =
    x.att1 + " " + x.att2
}

The class and the object do not "override" or step on each other's toes in any way because classes and objects belong to different namespaces. Class names are used at the type level (and also in constructor calls), and object names are used at the term level.

There are a few relationships between a class and its companion:

  • It does affect how implicits are resolved - Any implicts defined in a class's companion object are automatically brought into scope.

  • private members of the class are visible to the object, and vice versa.

  • Case classes are a little bit different, because case class is actually a shorthand which, in addition to defining a class, also adds apply and unapply methods to its companion object.

Upvotes: 21

Related Questions