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
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
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
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
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
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
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
* 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 颜色标记:blueOtras extensiones