What is a trait in Scala and how is it different from an abstract class?

In Scala, a trait is a modular, reusable unit of behavior that can be used to create composite behavior and shared between classes using mixin inheritance. It is a fundamental building block in Scala’s object model, allowing you to define interface-like contracts and also provide method implementations that can be composed into more complex classes.

An abstract class, on the other hand, is a class that cannot be instantiated but can be subclassed. Abstract classes can define abstract methods (methods that have no body) and can also provide concrete implementations for some or all of those methods.

Let’s look at the key differences between traits and abstract classes in more detail:

1. Inheritance:

- Traits: In Scala, a class can mix in multiple traits, which makes it possible to reuse behavior in a more modular way. Traits are mixed into a class using the ‘with‘ keyword.

- Abstract Classes: A class can extend only a single abstract class using the ‘extends‘ keyword. This is due to the single inheritance limitation in Scala, similar to other object-oriented programming languages like Java.

2. Constructor Parameters:

- Traits: Traits cannot have constructor parameters or any state defined with the ‘val‘ keyword in the trait definition. If you need to pass some parameters, you can use abstract ‘val‘ members or ‘def‘ methods.

- Abstract Classes: An abstract class can have constructor parameters, which can be passed when creating an instance of the concrete class that extends the abstract class.

Here’s an example to highlight the differences:

// Trait definition
trait Flyable {
  def fly(): Unit
}

trait Swimmable {
  def swim(): Unit
}

// Abstract class definition
abstract class Animal(val name: String) {
  def speak(): Unit
}

// Concrete class that uses both a trait and an abstract class
class Duck(name: String) extends Animal(name) with Flyable with Swimmable {
  def speak(): Unit = println(s"Quack, I am $name!")

  def fly(): Unit = println("I can fly!")

  def swim(): Unit = println("I can swim!")
}

val daffy = new Duck("Daffy")
daffy.speak() // Quack, I am Daffy!
daffy.fly()   // I can fly!
daffy.swim()  // I can swim!

In summary, traits in Scala provide a more modular and composable approach to defining and mixing behavior into classes compared to abstract classes. The main advantages of using traits are mixin inheritance (allowing multiple traits to be mixed into a class), whereas abstract classes are more traditional in their usage, allowing constructor parameters and single inheritance. Depending on the specific use case, you may choose traits, abstract classes, or a combination of both to design your class hierarchy and behaviors.