Difference between using sealed trait and sealed abstract class as a base class

Question

While trying to learn Akka, I often find examples with a class hierarchy similar to this:

sealed trait Message

case class TextMessage(user: String, text: String) extends Message
case class StatusMessage(status: String) extends Message

However, in the Scala docs there's a following example:

abstract class Notification

case class Email(sourceEmail: String, title: String, body: String) extends Notification
case class SMS(sourceNumber: String, message: String) extends Notification
case class VoiceRecording(contactName: String, link: String) extends Notification

What's the difference in using a sealed trait vs. an abstract class (or sealed abstract class in this case) as a base class without constructor parameters for a class hierarchy? Are there some advantages in using one over the other?

Edit:

Specifically, if both, the trait and the abstract class are sealed, I can't extend them outside the file, right? In that case I couldn't inherit from them in Java either? If that's the case, being sealed would render most of the arguments found in the suggested duplicate useless since they refer to inheritance outside the file.

Answer 1

In this particular case there are no differences except that you can't extend multiple abstract classes but you can extend multiple traits.

You should check other answers (as mentioned in the comments) to see the actual differences between abstract classes and traits. If you are just going to use an abstract class or a trait to define the type hierarchy as in this case, then there are no differences.

E.g. you could to the following:

trait A
trait B

case class C(a: Int) extends A with B

but you can't do:

abstract class A
abstract class B

case class C(a: Int) extends A with B