Accepted answer

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.


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 {

Related Query

More Query from same tag