The Practical Difference Between Abstract Class and Trait in Scala

1. Overview

Before getting to know the difference between abstract class and trait lets understand them.

Traits are like Java interface but in a trait, we are allowed to implement its members.

Abstract Classes are constructed using abstract keyword, it supports both abstract and non-abstract methods.

2. Similarities

Once we understand similarities then only we can appreciate the differences. Let's go ahead and learn those.

A trait with a declared and implemented method and variable:

xxxxxxxxxx

trait mytrait { 

  def myMethod():Unit

  val aVal: Int 

  val myVal = 10 

  def myImpMethod = { println("I am from trait") } 

}

An abstract class with an abstract and non-abstract method and variable:

xxxxxxxxxx

abstract class abstClass { 

  def myMethod():Unit 

  val aVal: Int 

  val myVal = 10 

  def myImpMethod:Unit = { println("I am from abstClass") } 

}

In the main method, trait and abstract class both can't be instantiated.

xxxxxxxxxx

val myTObj = new mytrait //compilation error

val myAObj = new abstClass() //compilation error

Classes that are extending trait or abstract class need to implement the declared methods.

xxxxxxxxxx

class myTClass extends mytrait {

  val aVal=10 

  def myMethod ={ println("I am from myTclass") } 

} 

class myAClass extends abstClass {

  val aVal=10 

  def myMethod ={ println("I am from myAclass") } 

}

3. Differences

3.1 Constructor Parameters

xxxxxxxxxx

trait myTraitWithParam(name: String){} 

abstract class abstClassWithParam(name : String){}

name is the constructor parameter, a trait with a constructor parameter gives compilation error whereas it works fine with an abstract class.

3.2 Adding to Object Instance

xxxxxxxxxx

trait objectInstanceTrait { 

  def myObjectMethod = { println("I am from object instance trait") } 

} 

class myTClass {} 

def main(args: Array[String]):Unit={ 

  val classObjWithTrait = new myTClass with objectInstanceTrait

  classObjWithTrait.myObjectMethod 

} 

ouptput => "I am from object instance trait"

The implemented method "myObjectMethod" from the trait can be accessed by an instance of a class. Abstract class can't be added to an object instance, it leads to a compilation error.

3.3 Multiple Inheritances

In multiple inheritance, one class can have more than one superclass and inherit features from all parent classes. Scala does not support multiple inheritance with classes, but it can be achieved by traits.

xxxxxxxxxx

class myClass extends trait1 with trait2{} 

class myNewClass extends abstClass1 with abstClass2{}

When abstract class used for multiple inheritances, it results in a compilation error.

With multiple inheritance, the scala resolves the diamond problem, by trait linearization. A trait with the extreme right will get the highest priority.

xxxxxxxxxx

trait Printer { 

  def print(msg : String) = println (msg) 

 } 

trait DelimitWithHyphen extends Printer { 

  override def print(msg : String)= { println("-------------") } 

} 

trait DelimitWithStar extends Printer { 

  override def print(msg : String)= { println("*************") } 

} 

class CustomPrinter extends Printer with DelimitWithHyphen with DelimitWithStar 

new CustomPrinter().print("Hello World!") 

 output=> "*************"

3.4 Stackability

Stackable traits in Scala refers to being able to mix in multiple traits that work together to apply multiple modifications to a method. This involves invoking super.theMethod

xxxxxxxxxx

trait base{ 

  def baseMethod(s: String):Unit = println(s) 

}

trait stack1 extends base{

  override def baseMethod(s: String) = println("from stack1") 

} 

trait replace1 extends base { 

  abstract override def baseMethod(s: String) ={

    super.baseMethod(s); 

    println("from replace1")} 

}

class Stackable { 

  this : base => def apply() 

  { println( baseMethod("bottom") ) } 

} 

(new Stackable with stack1 with replace1)() 

output => 

from stack1 

from replace1

Invocation started from relace1 then it is passed to stack1 by super.baseMethod(s).

This method invocation went to stack1 because it is left side of replace1.

3.5 Interoperable with Java

Traits are interoperable with Java if they don't have any implementation, abstract classes can be directly used.

4. Conclusion

Scala traits are more flexible than abstract classes. We should use abstract classes when we want to create a base class with a constructor argument. In case of dought always go with the trait, because traits can be easily converted into an abstract class.