Scala Language
Operatörens överbelastning

Definiera anpassade infixoperatörer

I Scala är operatörer (som + , - , * , ++ , etc.) bara metoder. Till exempel kan 1 + 2 skrivas som 1.+(2) . Dessa typer av metoder kallas "infix-operatörer" .

Detta innebär att anpassade metoder kan definieras på dina egna typer, återanvända dessa operatörer:

class Matrix(rows: Int, cols: Int, val data: Seq[Seq[Int]]){
  def +(that: Matrix) = {
    val newData = for (r <- 0 until rows) yield
      for (c <- 0 until cols) yield this.data(r)(c) + that.data(r)(c)

    new Matrix(rows, cols, newData)
  }
}

Dessa operatörer definierade-som-metoder kan användas på så sätt:

val a = new Matrix(2, 2, Seq(Seq(1,2), Seq(3,4)))
val b = new Matrix(2, 2, Seq(Seq(1,2), Seq(3,4)))

// could also be written a.+(b)
val sum = a + b  

Observera att infixoperatörer bara kan ha ett enda argument; objektet innan operatören kommer att ringa sin egen operatör på objektet efter operatören. Alla Scala-metoder med ett enda argument kan användas som en infix-operatör.

Detta bör användas med parcimon. Det anses generellt sett som god praxis endast om din egen metod gör exakt vad man kan förvänta sig av den operatören. Om du är osäker, använd en mer konservativ namngivning, som add istället för + .

Definiera anpassade unary-operatörer

Unary-operatörer kan definieras genom att förbereda operatören med unary_ . Unary operatörer är begränsade till unary_+ , unary_- , unary_! och unary_~ :

class Matrix(rows: Int, cols: Int, val data: Seq[Seq[Int]]){
  def +(that: Matrix) = {
    val newData = for (r <- 0 until rows) yield
      for (c <- 0 until cols) yield this.data(r)(c) + that.data(r)(c)

    new Matrix(rows, cols, newData)
  }

  def unary_- = {
    val newData = for (r <- 0 until rows) yield 
      for (c <- 0 until cols) yield this.data(r)(c) * -1
   
    new Matrix(rows, cols, newData) 
  }   
}

Den unary operatören kan användas enligt följande:

val a = new Matrix(2, 2, Seq(Seq(1,2), Seq(3,4)))
val negA = -a

Detta bör användas med parcimon. Överbelastning av en unary operatör med en definition som inte är vad man kan förvänta sig kan leda till kodförvirring.