Quels sont les avantages d'utiliser des traits par rapport à des classes abstraites?

Question

Quelqu'un peut-il s'il vous plaît expliquer les traits de caractère à Scala? Quels sont les avantages des traits par rapport à l’extension d’une classe abstraite?

Answer 1

La réponse courte est que vous pouvez utiliser plusieurs traits - ils sont "empilables". De plus, les traits ne peuvent pas avoir de paramètres de constructeur.

Voici comment les traits sont empilés. Notez que la commande des traits est importante. Ils s'appelleront de droite à gauche.

class Ball {
  def properties(): List[String] = List()
  override def toString() = "It's a" +
    properties.mkString(" ", ", ", " ") +
    "ball"
}

trait Red extends Ball {
  override def properties() = super.properties ::: List("red")
}

trait Shiny extends Ball {
  override def properties() = super.properties ::: List("shiny")
}

object Balls {
  def main(args: Array[String]) {
    val myBall = new Ball with Shiny with Red
    println(myBall) // It's a shiny, red ball
  }
}

Answer 2

Ce site donne un bon exemple d'utilisation des traits. Un grand avantage des traits est que vous pouvez étendre plusieurs traits mais seulement une classe abstraite. Les traits résolvent bon nombre des problèmes liés à l'héritage multiple, mais permettent la réutilisation du code.

Si vous connaissez le rubis, les traits ressemblent à ceux d'un mélange

.

Answer 3

package ground.learning.scala.traits

/**
 * Created by Mohan on 31/08/2014.
 *
 * Stacks are layered one top of another, when moving from Left -> Right,
 * Right most will be at the top layer, and receives method call.
 */
object TraitMain {

  def main(args: Array[String]) {
    val strangers: List[NoEmotion] = List(
      new Stranger("Ray") with NoEmotion,
      new Stranger("Ray") with Bad,
      new Stranger("Ray") with Good,
      new Stranger("Ray") with Good with Bad,
      new Stranger("Ray") with Bad with Good)
    println(strangers.map(_.hi + "\n"))
  }
}

trait NoEmotion {
  def value: String

  def hi = "I am " + value
}

trait Good extends NoEmotion {
  override def hi = "I am " + value + ", It is a beautiful day!"
}

trait Bad extends NoEmotion {
  override def hi = "I am " + value + ", It is a bad day!"
}

case class Stranger(value: String) {
}

Output :

List(I am Ray
, I am Ray, It is a bad day!
, I am Ray, It is a beautiful day!
, I am Ray, It is a bad day!
, I am Ray, It is a beautiful day!
)

Answer 4

C’est le meilleur exemple que j’ai vu

Scala en pratique: Traits de composition - Style Lego: http: //gleichmann.wordpress. com / 2009/10/21 / scala-in-practice-composing-traits-lego-style /

    class Shuttle extends Spacecraft with ControlCabin with PulseEngine{

        val maxPulse = 10

        def increaseSpeed = speedUp
    }

Answer 5

Les traits sont utiles pour mélanger des fonctionnalités dans une classe. Consultez http://scalatest.org/ . Notez comment vous pouvez mélanger dans différents langages spécifiques au domaine (DSL) dans une classe de test. Consultez le guide de démarrage rapide pour consulter certaines des DSL prises en charge par Scalatest ( http://scalatest.org/quick_start)

Answer 6

Semblables aux interfaces en Java, les traits permettent de définir les types d’objet en spécifiant la signature des méthodes prises en charge.

Contrairement à Java, Scala permet d’implémenter partiellement les traits; c'est-à-dire qu'il est possible de définir des implémentations par défaut pour certaines méthodes.

Contrairement aux classes, les traits peuvent ne pas avoir de paramètres de constructeur. Les traits sont comme des classes, mais définissent une interface de fonctions et de champs dans lesquels les classes peuvent fournir des valeurs et des implémentations concrètes.

Les traits peuvent hériter d’autres traits ou de classes.

Answer 7

Je cite le site Web du livre Programmation en Scala, première édition et plus précisément la section intitulée "a Traiter, ou ne pas traiter? " du chapitre 12.

  

Chaque fois que vous implémenterez une collection de comportements réutilisable, vous devrez décider si vous souhaitez utiliser un trait ou une classe abstraite. Il n’existe aucune règle ferme, mais cette section contient quelques directives à prendre en compte.

     

Si le comportement ne sera pas réutilisé, faites-en une classe concrète. Ce n'est pas un comportement réutilisable après tout.

     

S'il peut être réutilisé dans plusieurs classes non liées, faites-en un trait. Seuls les traits peuvent être mélangés dans différentes parties de la hiérarchie des classes.

Il y a un peu plus d'informations dans le lien ci-dessus concernant les traits et je vous suggère de lire la section complète. J'espère que cela aide.