What is the difference between Scala s case class and class

Question

I searched in Google to find the differences between a case class and a class  Everyone mentions that when you want to do pattern matching on the class  use case class  Otherwise use classes and also mentioning some extra perks like equals and hash code overriding  But are these the only reasons why one should use a case class instead of class    I guess there should be some very important reason for this feature in Scala  What is the explanation or is there a resource to learn more about the Scala case classes from

User · Answer

Class   scala gt  class Animal name String  defined class Animal  scala gt  val an1   new Animal  Padddington   an1  Animal   Animal 748860cc  scala gt  an1 name  lt console gt  14  error  value name is not a member of Animal        an1 name                But if we use same code but use case class   scala gt  case class Animal name String  defined class Animal  scala gt  val an2   new Animal  Paddington   an2  Animal   Animal Paddington   scala gt  an2 name res12  String   Paddington   scala gt  an2    Animal  fred   res14  Boolean   false  scala gt  an2    Animal  Paddington   res15  Boolean   true   Person class   scala gt  case class Person first String last String age Int  defined class Person  scala gt  val harry   new Person  Harry   Potter  30  harry  Person   Person Harry Potter 30   scala gt  harry res16  Person   Person Harry Potter 30  scala gt  harry first    Saily   lt console gt  14  error  reassignment to val        harry first    Saily                       scala gt val saily    harry copy first  Saily   res17  Person   Person Saily Potter 30   scala gt  harry copy age   harry age 1  res18  Person   Person Harry Potter 31    Pattern Matching   scala gt  harry match          case Person  Harry    age    gt  println age         case     gt  println  no match            30  scala gt  res17 match          case Person  Harry    age    gt  println age         case     gt  println  no match            no match   object  singleton   scala gt  case class Person first  String last String age Int  defined class Person  scala gt  object Fred extends Person  Fred   Jones  22  defined object Fred

User · Answer

Case classes define a compagnon object with apply and unapply methods Case classes extends Serializable  Case classes define equals hashCode and copy methods All attributes of the constructor are val  syntactic sugar

User · Answer

Some of the key features of case classes are listed below   case classes are immutable  You can instantiate case classes without new keyword  case classes can be compared by value   Sample scala code on scala fiddle  taken from the scala docs   https   scalafiddle io sf 34XEQyE 0

User · Answer

Unlike classes  case classes are just used to hold data   Case classes are flexible for data-centric applications  which means you can define data fields in case class and define business logic in a companion object  In this way  you are separating the data from the business logic   With the copy method  you can inherit any or all required properties from the source and can change them as you like

User · Answer

I think overall all the answers have given a semantic explanation about classes and case classes  This could be very much relevant  but every newbie in scala should know what happens when you create a case class  I have written this answer  which explains case class in a nutshell    Every programmer should know that if they are using any pre-built functions  then they are writing a comparatively less code  which is enabling them by giving the power to write most optimized code  but power comes with great responsibilities  So  use prebuilt functions with very cautions   Some developers avoid writing case classes due to additional 20 methods  which you can see by disassembling class file   Please refer this link if you want to check all the methods inside a case class

User · Answer

A case class is a class that may be used with the match case statement   def isIdentityFun term  Term   Boolean   term match     case Fun x  Var y   if x    y   gt  true   case     gt  false     You see that case is followed by an instance of class Fun whose 2nd parameter is a Var  This is a very nice and powerful syntax  but it cannot work with instances of any class  therefore there are some restrictions for case classes  And if these restrictions are obeyed  it is possible to automatically define hashcode and equals   The vague phrase  a recursive decomposition mechanism via pattern matching  means just  it works with case    Indeed  the instance followed by match is compared to  matched against  the instance that follows case  Scala has to decompose them both  and has to recursively decompose what they are made of    What case classes are useful for  The Wikipedia article about Algebraic Data Types gives two good classical examples  lists and trees  Support for algebraic data types  including knowing how to compare them  is a must for any modern functional language   What case classes are not useful for  Some objects have state  the code like connection setConnectTimeout connectTimeout  is not for case classes   And now you can read A Tour of Scala  Case Classes

User · Answer

The case class construct in Scala can also be seen as a convenience to remove some boilerplate   When constructing a case class Scala gives you the following    It creates a class as well as its companion object Its companion object implements the apply method that you are able to use as a factory method  You get the syntactic sugar advantage of not having to use the new keyword       Because the class is immutable you get accessors  which are just the variables  or properties  of the class but no mutators  so no ability to change the variables   The constructor parameters are automatically available to you as public read only fields  Much nicer to use than Java bean construct     You also get hashCode  equals  and toString methods by default and the equals method compares an object structurally  A copy method is generated to be able to clone an object  with some fields having new values provided to the method      The biggest advantage as has been mentioned previously is the fact that you can pattern match on case classes  The reason for this is because you get the unapply method which lets you deconstruct a case class to extract its fields          In essence what you are getting from Scala when creating a case class  or a case object if your class takes no arguments  is a  singleton object which serves the purpose as a factory and as an extractor

User · Answer

Nobody mentioned that case class companion object has tupled defention  which has a type   case class Person name  String  age  Int    Person tupled is def tupled    String  Int     gt  Person   The only use case I can find is when you need to construct case class from tuple  example   val bobAsTuple     bob   14  val bob    Person apply    tupled bobAsTuple    bob  Person   Person bob 14    You can do the same  without tupled  by creating object directly  but if your datasets expressed as list of tuple with arity 20 tuple with 20 elements   may be using tupled is your choise

User · Answer

No one mentioned that case classes are also instances of Product and thus inherit these methods   def productElement n  Int   Any def productArity  Int def productIterator  Iterator Any    where the productArity returns the number of class parameters  productElement i  returns the ith parameter  and productIterator allows iterating through them

User · Answer

According to Scala s documentation       Case classes are just regular classes that are          Immutable by default   Decomposable through pattern matching   Compared by structural equality instead of by reference   Succinct to instantiate and operate on      Another feature of the case keyword is the compiler automatically generates several methods for us  including the familiar toString  equals  and hashCode methods in Java

User · Answer

Technically  there is no difference between a class and a case class -- even if the compiler does optimize some stuff when using case classes  However  a case class is used to do away with boiler plate for a specific pattern  which is implementing algebraic data types   A very simple example of such types are trees  A binary tree  for instance  can be implemented like this   sealed abstract class Tree case class Node left  Tree  right  Tree  extends Tree case class Leaf A  value  A  extends Tree case object EmptyLeaf extends Tree   That enable us to do the following      DSL-like assignment  val treeA   Node EmptyLeaf  Leaf 5   val treeB   Node Node Leaf 2   Leaf 3    Leaf 5       On Scala 2 8  modification through cloning  val treeC   treeA copy left   treeB left      Pretty printing  println  Tree A    treeA  println  Tree B    treeB  println  Tree C    treeC      Comparison  println  Tree A    Tree B   s  format  treeA    treeB  toString  println  Tree B    Tree C   s  format  treeB    treeC  toString      Pattern matching  treeA match     case Node EmptyLeaf  right    gt  println  Can be reduced to   right    case Node left  EmptyLeaf    gt  println  Can be reduced to   left    case     gt  println treeA   cannot be reduced         Pattern matches can be safely done  because the compiler warns about    non-exaustive matches  def checkTree t  Tree    t match     case Node EmptyLeaf  Node left  right     gt       case Node EmptyLeaf  Leaf el     gt    case Node Node left  right   EmptyLeaf    gt    case Node Leaf el   EmptyLeaf    gt    case Node Node l1  r1   Node l2  r2     gt    case Node Leaf e1   Leaf e2     gt    case Node Node left  right   Leaf el     gt    case Node Leaf el   Node left  right     gt       case Node EmptyLeaf  EmptyLeaf    gt    case Leaf el    gt    case EmptyLeaf   gt      Note that trees construct and deconstruct  through pattern match  with the same syntax  which is also exactly how they are printed  minus spaces    And they can also be used with hash maps or sets  since they have a valid  stable hashCode

User · Answer

Apart from what people have already said  there are some more basic differences between class and case class  1 Case Class doesn t need explicit new  while class need to be called with new  val classInst   new MyClass          For classes val classInst   MyClass              For case class   2 By Default constructors parameters are private in class   while its public in case class     For class class MyClass x Int      val classInst   new MyClass 10   classInst x      FAILURE   can t access     For caseClass case class MyClass x Int      val classInst   MyClass 10   classInst x      SUCCESS   3 case class compare themselves by value     case Class class MyClass x Int       val classInst   new MyClass 10  val classInst2   new MyClass 10   classInst    classInst2    FALSE     For Case Class case class MyClass x Int       val classInst   MyClass 10  val classInst2   MyClass 10   classInst    classInst2    TRUE

User · Answer

No one mentioned that case classes have val constructor parameters yet this is also the default for regular classes  which I think is an inconsistency in the design of Scala   Dario implied such where he noted they are  immutable    Note you can override the default by prepending the each constructor argument with var for case classes  However  making case classes mutable causes their equals and hashCode methods to be time variant   91 1   sepp2k already mentioned that case classes automatically generate equals and hashCode methods   Also no one mentioned that case classes automatically create a companion object with the same name as the class  which contains apply and unapply methods  The apply method enables constructing instances without prepending with new  The unapply extractor method enables the pattern matching that others mentioned   Also the compiler optimizes the speed of match-case pattern matching for case classes  91 2      91 1  Case Classes Are Cool    91 2  Case Classes and Extractors  pg 15

User · Answer

Case classes can be seen as plain and immutable data-holding objects that should exclusively depend on their constructor arguments   This functional concept allows us to   use a compact initialization syntax  Node 1  Leaf 2   None    decompose them using pattern matching have equality comparisons implicitly defined    In combination with inheritance  case classes are used to mimic algebraic datatypes   If an object performs stateful computations on the inside or exhibits other kinds of complex behaviour  it should be an ordinary class

User · Answer

To have the ultimate understanding of what is a case class   let s assume the following case class definition   case class Foo foo String  bar  Int    and then do the following in the terminal     scalac -print src main scala Foo scala   Scala 2 12 8 will output       case class Foo extends Object with Product with Serializable       lt caseaccessor gt   lt paramaccessor gt  private this  val foo  String          lt stable gt   lt caseaccessor gt   lt accessor gt   lt paramaccessor gt  def foo    String   Foo this foo      lt caseaccessor gt   lt paramaccessor gt  private this  val bar  Int          lt stable gt   lt caseaccessor gt   lt accessor gt   lt paramaccessor gt  def bar    Int   Foo this bar      lt synthetic gt  def copy foo  String  bar  Int   Foo   new Foo foo  bar       lt synthetic gt  def copy default 1    String   Foo this foo        lt synthetic gt  def copy default 2    Int   Foo this bar       override  lt synthetic gt  def productPrefix    String    Foo       lt synthetic gt  def productArity    Int   2      lt synthetic gt  def productElement x 1  Int   Object         case  lt synthetic gt  val x1  Int   x 1           x1  Int  match               case 0   gt  Foo this foo               case 1   gt  scala Int box Foo this bar                case     gt  throw new IndexOutOfBoundsException scala Int box x 1  toString                      override  lt synthetic gt  def productIterator    Iterator   scala runtime ScalaRunTime typedProductIterator Foo this       lt synthetic gt  def canEqual x 1  Object   Boolean   x 1  isInstanceOf Foo        override  lt synthetic gt  def hashCode    Int           lt synthetic gt  var acc  Int   -889275714       acc   scala runtime Statics mix acc  scala runtime Statics anyHash Foo this foo           acc   scala runtime Statics mix acc  Foo this bar          scala runtime Statics finalizeHash acc  2          override  lt synthetic gt  def toString    String   scala runtime ScalaRunTime  toString Foo this      override  lt synthetic gt  def equals x 1  Object   Boolean   Foo this eq x 1             case  lt synthetic gt  val x1  Object   x 1          case5              if  x1  isInstanceOf Foo                 matchEnd4 true            else             case6                      case6              matchEnd4 false                     matchEnd4 x  Boolean             x                  amp  amp           lt synthetic gt  val Foo 1  Foo   x 1  asInstanceOf Foo           Foo this foo      Foo 1 foo     amp  amp  Foo this bar      Foo 1 bar      amp  amp  Foo 1 canEqual Foo this             def  lt init gt  foo  String  bar  Int   Foo         Foo this foo   foo      Foo this bar   bar      Foo super  lt init gt         Foo super   Product   init                     lt synthetic gt  object Foo extends scala runtime AbstractFunction2 with Serializable      final override  lt synthetic gt  def toString    String    Foo      case  lt synthetic gt  def apply foo  String  bar  Int   Foo   new Foo foo  bar      case  lt synthetic gt  def unapply x 0  Foo   Option        if  x 0    null           scala None      else         new Some new Tuple2 x 0 foo    scala Int box x 0 bar           lt synthetic gt  private def readResolve    Object   Foo     case  lt synthetic gt   lt bridge gt   lt artifact gt  def apply v1  Object  v2  Object   Object   Foo this apply v1  asInstanceOf String     scala Int unbox v2       def  lt init gt     Foo type         Foo super  lt init gt                        As we can see Scala compiler produces a regular class Foo and companion-object Foo    Let s go through the compiled class and comment on what we have got    the internal state of the Foo class  immutable    val foo  String val bar  Int    getters    def foo    String def bar    Int    copy methods    def copy foo  String  bar  Int   Foo def copy default 1    String def copy default 2    Int    implementing scala Product trait     override def productPrefix    String def productArity    Int def productElement x 1  Int   Object override def productIterator    Iterator    implementing scala Equals trait for make case class instances comparable for equality by       def canEqual x 1  Object   Boolean override def equals x 1  Object   Boolean    overriding java lang Object hashCode for obeying the equals-hashcode contract    override  lt synthetic gt  def hashCode    Int    overriding java lang Object toString      override def toString    String    constructor for instantiation by new keyword    def  lt init gt  foo  String  bar  Int   Foo    Object Foo   - method apply for instantiation without new keyword   case  lt synthetic gt  def apply foo  String  bar  Int   Foo   new Foo foo  bar      extractor method unupply for using case class Foo in pattern matching    case  lt synthetic gt  def unapply x 0  Foo   Option    method to protect object as singleton from deserialization for not letting produce one more instance     lt synthetic gt  private def readResolve    Object   Foo     object Foo extends scala runtime AbstractFunction2 for doing such trick    scala gt  case class Foo foo String  bar  Int  defined class Foo  scala gt  Foo tupled res1    String  Int     gt  Foo   scala Function2  Lambda 224 1935637221 9ab310b   tupled from object returns a funtion to create a new Foo by applying a tuple of 2 elements    So case class is just syntactic sugar

User · Answer

Case classes can be pattern matched Case classes automatically define hashcode and equals Case classes automatically define getter methods for the constructor arguments     You already mentioned all but the last one    Those are the only differences to regular classes

[scala] What is the difference between Scala's case class and class?

Examples related to scala

Examples related to functional-programming

Examples related to case-class