Quali sono i vantaggi dell'utilizzo dei tratti rispetto alle classi astratte?

Question

Qualcuno può spiegare i tratti alla Scala? Quali sono i vantaggi dei tratti rispetto all'estensione di una classe astratta?

Answer 1

La risposta breve è che puoi usare più tratti: sono "impilabili". Inoltre, i tratti non possono avere parametri di costruzione.

Ecco come vengono impilati i tratti. Si noti che l'ordinamento dei tratti è importante. Si chiameranno l'un l'altro da destra a sinistra.

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

Questo sito offre un buon esempio di utilizzo dei tratti. Un grande vantaggio dei tratti è che puoi estendere più tratti ma solo una classe astratta. I tratti risolvono molti dei problemi con ereditarietà multipla ma consentono il riutilizzo del codice.

Se conosci il rubino, i tratti sono simili ai mix-in

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

Questo è il miglior esempio che ho visto

Scala in pratica: comporre tratti - stile Lego: http: //gleichmann.wordpress. com / 2009/10/21 / scala-in-pratica-composizione-tratti-lego-style /

    class Shuttle extends Spacecraft with ControlCabin with PulseEngine{

        val maxPulse = 10

        def increaseSpeed = speedUp
    }

Answer 5

I tratti sono utili per mescolare funzionalità in una classe. Dai un'occhiata a http://scalatest.org/ . Nota come puoi mescolare in varie lingue specifiche del dominio (DSL) in una classe di test. consulta la guida rapida per esaminare alcuni dei DSL supportati da Scalatest ( http://scalatest.org/quick_start)

Answer 6

Simile alle interfacce in Java, i tratti sono usati per definire i tipi di oggetto specificando la firma dei metodi supportati.

A differenza di Java, Scala consente di implementare parzialmente i tratti; cioè è possibile definire implementazioni predefinite per alcuni metodi.

Contrariamente alle classi, i tratti potrebbero non avere parametri di costruzione. I tratti sono come le classi, ma che definiscono un'interfaccia di funzioni e campi che le classi possono fornire valori e implementazioni concrete.

I tratti possono ereditare da altri tratti o da classi.

Answer 7

Sto citando dal sito web del libro Programmazione in Scala, Prima edizione e più specificamente la sezione chiamata " Per tratto o non tratto? " dal capitolo 12.

  

Ogni volta che implementerai una raccolta riutilizzabile di comportamenti, dovrai decidere se vuoi usare un tratto o una classe astratta. Non esiste una regola precisa, ma questa sezione contiene alcune linee guida da considerare.

     

Se il comportamento non verrà riutilizzato, renderlo una classe concreta. Dopo tutto, non è un comportamento riutilizzabile.

     

Se può essere riutilizzato in più classi non correlate, rendilo un tratto. Solo i tratti possono essere mescolati in diverse parti della gerarchia di classi.

Ci sono un po 'più di informazioni nel link sopra per quanto riguarda i tratti e ti suggerisco di leggere l'intera sezione. Spero che questo aiuti.