La palabra clave con en Scala

Este artículo demostrará cómo usar la palabra clave with en Scala.

Utilice la palabra clave con en Scala

Esta palabra clave generalmente se usa cuando se trata de composiciones de clase con mixins. Los mixins son rasgos que se utilizan para componer una clase.

Esto es algo similar a una clase de Java que puede implementar una interfaz.

Veamos un ejemplo para entender mejor la palabra clave con:

abstract class vehicle {
  val message: String
}
class Car extends vehicle {
  val message = "I'm an instance of class vehicle"
}
trait sportsCar extends vehicle {
  def ourMessage = message.toUpperCase()
}
class temp extends Car with sportsCar

val obj = new temp
println(obj.message)  // I'm an instance of class vehicle
println(obj.ourMessage)  // I'M AN INSTANCE OF CLASS VEHICLE

En el código anterior, la clase temp tiene la superclase Car y la mezcla sportsCar. Una clase puede extender solo una superclase pero muchos mixins usando la palabra clave with; una superclase y mixins pueden tener el mismo supertipo.

Veamos otro ejemplo. Primero, creemos una clase abstracta con un tipo T y algunos métodos de iteración estándar.

abstract class ourIterator {
  type T
  def hasNext: Boolean
  def next(): T
}

Ahora, vamos a crear una clase concreta donde estén presentes todas las implementaciones de T de los miembros abstractos, que son hasNext y next.

class StringIterator(str: String) extends ourIterator {
  type T = Char
  private var i = 0
  def hasNext = i < str.length
  def next() =
  {
    val ch = str.charAt(i)
    i += 1
    ch
  }
}

Vamos a crear un rasgo que también amplíe la clase ourIterator.

trait anotherIterator extends ourIterator {
  def foreach(X: T => Unit): Unit = while (hasNext) X(next())
}

El rasgo anotherIterator implementa el método foreach() llamando a la función X: T => Unit continuamente en el siguiente elemento next() siempre que haya más elementos while(hasNext).

Dado que otroIterador es un rasgo, no necesita implementar ningún miembro abstracto de la clase nuestroIterador. Ahora podemos combinar las funcionalidades de anotherIterator y StringIterator en una sola clase, como se muestra a continuación:

class temp extends StringIterator("Tony") with anotherIterator
val obj = new temp
obj.foreach(println)

Código de trabajo completo:

abstract class ourIterator {
  type T
  def hasNext: Boolean
  def next(): T
}

class StringIterator(str: String) extends ourIterator {
  type T = Char
  private var i = 0
  def hasNext = i < str.length
  def next() =
  {
    val ch = str.charAt(i)
    i += 1
    ch
  }
}

trait anotherIterator extends ourIterator {
  def foreach(X: T => Unit): Unit = while (hasNext) X(next())
}

class temp extends StringIterator("Tony") with anotherIterator
val obj = new temp
obj.foreach(println)

Producción :

T
o
n
y

En el código anterior, la nueva clase temp tiene StringIterator como superclase y anotherIterator como mezcla. Solo con herencia única, no será posible lograr este nivel de flexibilidad.