English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
La clase es una abstracción del objeto, y el objeto es un ejemplo específico de la clase. La clase es abstracta, no ocupa memoria, mientras que el objeto es específico, ocupa espacio de almacenamiento. La clase es un plano para crear objetos, que es un modelo de software que define los métodos y variables incluidos en un tipo específico de objeto.
我们可以使用 new 关键字来创建类的对象，示例如下：
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 ("x 的坐标点: " + x);
println ("y 的坐标点: " + y);
}
}Scala 中的类不声明为 public，一个 Scala 源文件中可以有多个类。
以上示例的类定义了两个变量 x 和 y ，一个方法：move，方法没有返回值。
Scala 的类定义可以有参数，称为类参数，如上面的 xc, yc，类参数在整个类中都可以访问。
接着我们可以使用 new 来示例化类，并访问类中的方法和变量：
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 ("x 的坐标点: " + x);
println ("y 的坐标点: " + y);
}
}
objeto Test {
def main(args: Array[String]) {
val pt = new Point(10, 20);
// 移动到一个新的位置
pt.move(10, 10);
}
}Ejecutar el código anterior, el resultado de salida es:
$ scalac Test.scala $ scala Test x 的坐标点: 20 y 的坐标点: 30
Scala 继承一个基类跟 Java 很相似，但我们需要注意以下几点：
1、重写一个非抽象方法必须使用 override 修饰符。
2、只有主构造函数才可以往基类的构造函数里写参数。
3、在子类中重写超类的抽象方法时，你不需要使用 override 关键字。
接下来让我们来看个示例：
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 ("x 的坐标点: " + x);
println ("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("Punto de coordenadas de x: "); + x);
println("Punto de coordenadas de y: "); + y);
println ("z 的坐标点 : " + z);
}
}Scala 使用 extends 关键字来继承一个类。示例中 Location 类继承了 Point 类。Point 称为父类(基类)，Location 称为子类。
override val xc 为重写了父类的字段。
继承会继承父类的所有属性和方法，Scala 只允许继承一个父类。
以下示例：
import java.io._
clase 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("Punto de coordenadas de x: "); + x);
println("Punto de coordenadas de 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("Punto de coordenadas de x: "); + x);
println("Punto de coordenadas de y: "); + y);
println ("z 的坐标点 : " + z);
}
}
objeto Test {
def main(args: Array[String]) {
val loc = new Location(10, 20, 15);
// 移动到一个新的位置
loc.move(10, 10, 5);
}
}Ejecutar el código anterior, el resultado de salida es:
$ scalac Test.scala $ scala Test Punto de coordenadas de x: 20 Punto de coordenadas de y: 30 z 的坐标点 : 20
Scala 重写一个非抽象方法，必须使用 override 修饰符。
class Person {
var name = ""
override def toString = getClass.getName + "[name=" + name + "]"
}
clase Employee extends Person {
var salary = 0.0
override def toString = super.toString + "[salary=" + salary + "]"
}
objeto Test extends App {
val fred = new Employee
fred.name = "Fred"
fred.salary = 50000
println(fred)
}Ejecutar el código anterior, el resultado de salida es:
$ scalac Test.scala $ scala Test Employee[name=Fred][salary=50000.0]
En Scala, no existe la palabra clave static, pero también nos proporciona un método de implementación del patrón singleton, es decir, usar la palabra clave object.
Al usar el patrón singleton en Scala, además de definir la clase, también se debe definir un objeto con el mismo nombre, la diferencia es que el objeto no puede llevar parámetros.
Cuando un objeto singleton comparte el mismo nombre con una clase, se le llama objeto acompañante de esa clase: objeto acompañante. Debes definir tanto la clase como su objeto acompañante en el mismo archivo de origen. La clase se llama clase acompañante del objeto singleton: clase acompañante. La clase y su objeto acompañante pueden acceder a los miembros privados mutuamente.
import java.io._
clase 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
}
}
objeto Test {
def main(args: Array[String]) {
val point = new Point(10, 20)
printPoint
def printPoint{
println("Punto de coordenadas de x: "); + point.x);
println("Punto de coordenadas de y: "); + point.y);
}
}
}Ejecutar el código anterior, el resultado de salida es:
$ scalac Test.scala $ scala Test Punto de coordenadas de x: 10 Punto de coordenadas de y: 20
/* Nombre de archivo: Marker.scala
* autor:基础教程网
* url:es.oldtoolbag.com
*/
// Método constructor privado
class Marker private(val color: String) {}}
println("Crear " + this)
override def toString(): String = "Marcador de color: "+ color
}
// Objeto acompañante, con el nombre de la clase, puede acceder a las propiedades y métodos privados de la clase
object Marker{
private val markers: Map[String, Marker] = Map(
"rojo" -> new Marker("rojo"),
"azul" -> new Marker("azul"),
"verde" -> new Marker("verde")
)
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(Marcador("rojo"))
// Llamada a función singleton, se omite el símbolo de punto (.)
println(Marcador.getMarker "azul")
}
}Ejecutar el código anterior, el resultado de salida es:
$ scalac Marcador.scala Marcador $ scala Marcador Crear marcador de color: rojo Crear marcador de color: azul Crear marcador de color: verde Marcador de color: rojo Marcador de color: azul