Case Class Inheritance

Hello friends, as discussed in the previous blog we know what are case classes and what boilerplate code do they generate.

Now in this blog, we will be discussing case class inheritance, how it can be achieved as the case to case inheritance is prohibited due to the equals and hashcode method case classes generate. We will also be telling the bad side of case classes.

 scala> case class Card(id: Int)
defined class Card

scala> case class DebitCard(id:Int,name:String,cvv:Int) extends Card(id)
:13: error: case class DebitCard has case ancestor Card, but case-to-case inheritance is prohibited. To overcome this limitation, use extractors to pattern match on non-leaf nodes.

Case class inheritance breaks equivalence relation (symmetric and transitive). Any case class successor which constricts a definition area must redefine the equality because pattern matching must work exactly as equality.

Now the question arises, how inheritance can be achieved in case classes. The answer is simple: Case Class can extend another Class, trait or Abstract Class.

Using Abstract Class-

• Create an abstract class which encapsulates the common behavior used by all the classes inheriting the abstract class.

 scala> abstract class Card(id: Int) {
|
| def printCardDetails: Unit
|
| }
defined class Card

• Extend abstract class and create a case class extending the abstract class and implementing the method.

scala> case class DebitCard(id: Int, name: String, cvv: Int)  extends Card(id) {
|
| override def printCardDetails: Unit = {
| print(id + " " + name + " " + cvv)
| }
|
| }
defined class DebitCard

We don’t need to create companion object for the DebitCard case class as it will automatically provide the companion object.

• Instantiate Card object by using DebitCard case class and specifying the type of object to be that of the base type.

 scala> val debitCardObject: Card = DebitCard(1,"Aman",312)
debitCardObject: Card = DebitCard(1,Aman,312)

Now you are ready to use the DebitCard case class and can add more case classes extending abstract class Card such as CreditCard.

Using Trait –

A Case Class or Case Object can extend a Trait.

• Create a trait using trait keyword which contains methods you want the inherited classes to implement.

 scala> trait Message {
    | def id: String
    | def content: String
    | }
     defined trait Message

• Create case class which extends the trait and overrides the variables and methods defined in the trait.

 scala> case class DefaultMessage(id: String, content: String) extends Message
defined class DefaultMessage

We don’t need to override the methods as id and content parameters are defined as methods that implicitly override Message’s methods.

• Create an object of DefaultMessage which is of type Message(i.e. the trait case class is extending)

 scala> val defaultMessage: Message =    DefaultMessage("A121","Hello everyone..!!")
        defaultMessage: Message = DefaultMessage(A121,Hello everyone..!!)

Similarly, classes can also be used to implement case class inheritance.

Case classes come with few disadvantages which were not discussed earlier:

1. Scala Compiler adds some additional functionality by extending Product trait of scala. Most of the time, it is not useful.
2. Case Class equals only considers params from first parameter lists.

scala> case class Book(id : Int)(title : String)
defined class Book
scala> Book(1)("Programming In Scala") == Book(1)("Scala for Impatient")
res0: Boolean = true

Hope you found this blog helpful and interesting.

Thanks for reading!