Scala Clases y objetos

Una clase es una abstracción de un objeto, mientras que un objeto es una instancia concreta de una clase. La clase es abstracta y no ocupa memoria, mientras que el objeto es concreto y ocupa espacio de almacenamiento. Una clase es un modelo para crear objetos; es una plantilla de software que define los métodos y variables incluidos en los objetos de un tipo específico.

Podemos usar la palabra clave `new` para crear objetos de una clase, como en el siguiente ejemplo:

Ejemplo

class Point(xc: Int, yc: Int) {
   var x: Int = xc
   var y: Int = yc

   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
      println (Coordenada x: + x);
      println (Coordenada y: + y);
   }
}

Las clases en Scala no se declaran como `public`; un archivo fuente de Scala puede contener múltiples clases.

La clase del ejemplo anterior define dos variablesxyy, un método:move, el método no devuelve ningún valor.

Las definiciones de clase en Scala pueden tener parámetros, llamados parámetros de clase, como `xc`, `yc` de arriba, y los parámetros de clase son accesibles en toda la clase.

Luego podemos usar `new` para instanciar la clase y acceder a los métodos y variables de la clase:

Ejemplo

import java.io._

class Point(xc: Int, yc: Int) {
   var x: Int = xc
   var y: Int = yc

   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
      println (Coordenada x: + x);
      println (Coordenada y: + y);
   }
}

object Test {
   def main(args: Array[String]) {
      val pt = new Point(10, 20);

      // mover a una nueva posición
      pt.move(10, 10);
   }
}

Al ejecutar el código anterior, el resultado es:

$ scalac Test.scala 
$ scala Test
x 的坐标点: 20
y 的坐标点: 30

Scala Herencia

La herencia de una clase base en Scala es muy similar a Java, pero debemos tener en cuenta los siguientes puntos:

  • 1. Para sobrescribir un método no abstracto se debe usar el modificador `override`.
  • 2. Solo el constructor principal puede escribir parámetros en el constructor de la clase base.
  • 3. Al sobrescribir un método abstracto de la superclase en una subclase, no es necesario usar la palabra clave `override`.

A continuación veamos un ejemplo:

Ejemplo

class Point(xc: Int, yc: Int) {
   var x: Int = xc
   var y: Int = yc

   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
      println (Coordenada x: + x);
      println (Coordenada y: + y);
   }
}

class Location(override val xc: Int, override val yc: Int,
   val zc :Int) extends Point(xc, yc){
   var z: Int = zc

   def move(dx: Int, dy: Int, dz: Int) {
      x = x + dx
      y = y + dy
      z = z + dz
      println (Coordenada x : + x);
      println (Coordenada y : + y);
      println (Coordenada z : + z);
   }
}

Scala usa la palabra clave `extends` para heredar de una clase. En el ejemplo, la clase `Location` hereda de la clase `Point`. `Point` se llama clase padre (clase base), y `Location` se llama subclase.

override val xcEs para sobrescribir los campos de la clase padre.

La herencia hereda todos los atributos y métodos de la clase padre; Scala solo permite heredar de una clase padre.

El ejemplo es el siguiente:

Ejemplo

import java.io._

class Point(val xc: Int, val yc: Int) {
   var x: Int = xc
   var y: Int = yc
   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
      println (Coordenada x : + x);
      println (Coordenada y : + y);
   }
}

class Location(override val xc: Int, override val yc: Int,
   val zc :Int) extends Point(xc, yc){
   var z: Int = zc

   def move(dx: Int, dy: Int, dz: Int) {
      x = x + dx
      y = y + dy
      z = z + dz
      println (Coordenada x : + x);
      println (Coordenada y : + y);
      println (Coordenada z : + z);
   }
}

object Test {
   def main(args: Array[String]) {
      val loc = new Location(10, 20, 15);

      // mover a una nueva posición
      loc.move(10, 10, 5);
   }
}

Al ejecutar el código anterior, el resultado es:

$ scalac Test.scala 
$ scala Test
x 的坐标点 : 20
y 的坐标点 : 30
z 的坐标点 : 20

En Scala, para sobrescribir un método no abstracto, se debe usar el modificador `override`.

Ejemplo

class Person {
  var name = ""
  override def toString = getClass.getName + "[name=" + name + "]"
}

class Employee extends Person {
  var salary = 0.0
  override def toString = super.toString + "[salary=" + salary + "]"
}

object Test extends App {
  val fred = new Employee
  fred.name = "Fred"
  fred.salary = 50000
  println(fred)
}

Al ejecutar el código anterior, el resultado es:

$ scalac Test.scala 
$ scala Test
Employee[name=Fred][salary=50000.0]

Scala Objeto Singleton

En Scala no existe `static`, pero nos ofrece una forma de implementar el patrón singleton, que es usando la palabra clave `object`.

Al usar el patrón singleton en Scala, además de la clase definida, también se debe definir un objeto `object` con el mismo nombre. La diferencia con la clase es que el objeto `object` no puede llevar parámetros.

Cuando un objeto singleton comparte el mismo nombre con una clase, se denomina objeto acompañante (companion object) de esa clase. Debes definir la clase y su objeto acompañante en el mismo archivo fuente. La clase se denomina clase acompañante (companion class) de este objeto singleton. La clase y su objeto acompañante pueden acceder mutuamente a sus miembros privados.

Ejemplo de objeto singleton

Ejemplo

import java.io._

class Point(val xc: Int, val yc: Int) {
   var x: Int = xc
   var y: Int = yc
   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
   }
}

object Test {
   def main(args: Array[String]) {
      val point = new Point(10, 20)
      printPoint

      def printPoint{
         println (Coordenada x : + point.x);
         println (Coordenada y : + point.y);
      }
   }
}

Al ejecutar el código anterior, el resultado es:

$ scalac Test.scala 
$ scala Test
x 的坐标点 : 10
y 的坐标点 : 20

Ejemplo de objeto acompañante

Ejemplo

/* Nombre de archivo: Marker.scala
* author: Ejemplo
 * url:www.example.com
 */


// método constructor privado
class Marker private(val color:String) {

  println(Creando + this)
 
  override def toString(): String = Marca de color:+ color
 
}

// objeto acompañante, con el mismo nombre que la clase, puede acceder a las propiedades y métodos privados de la clase
object Marker{
 
    private val markers: Map[String, Marker] = Map(
      "red" -> new Marker("red"),
      "blue" -> new Marker("blue"),
      "green" -> new Marker("green")
    )
   
    def apply(color:String) = {
      if(markers.contains(color)) markers(color) else null
    }
 
   
    def getMarker(color:String) = {
      if(markers.contains(color)) markers(color) else null
    }
    def main(args: Array[String]) {
        println(Marker("red"))  
        // llamada a función singleton, se omite el símbolo . (punto)
                println(Marker getMarker "blue")  
    }
}

Al ejecutar el código anterior, el resultado es:

$ scalac Marker.scala 
$ scala Marker
创建颜色标记:red
创建颜色标记:blue
创建颜色标记:green
颜色标记:red
颜色标记:blue
Otras extensiones