clases y objetos Scala
La clase es un objeto abstracto, y el objeto es una instancia específica de una clase. Clase es abstracta y no ocupa espacio en la memoria, y el objeto es concreto, ocupa espacio de almacenamiento. Clase es un modelo para la creación de un objeto, es una de plantillas definidas por software incluyen métodos y variables en tipos específicos de objetos en el.
Podemos utilizar la nueva palabra clave para crear objetos de la clase, los ejemplos son los siguientes:
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 de la clase no se declaran como pública, un archivo de origen Scala puede tener varias clases.
Los ejemplos de la clase anterior define dos variablesx e y,unmétodo:mover, el método no devuelve ningún valor.
definición de clase Scala puede tener parámetros, llamados parámetros de clase, como el XC anteriormente, YC, parámetros de clase en toda la clase pueden tener acceso.
Entonces podemos usar nueva para crear instancias de los métodos y variables de clase y clase de acceso:
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);
}
}
object Test {
def main(args: Array[String]) {
val pt = new Point(10, 20);
// 移到一个新的位置
pt.move(10, 10);
}
}
Aplicación del código anterior, la salida es:
$ scalac Test.scala $ scala Test x 的坐标点: 20 y 的坐标点: 30
hereda la Scala
Scala heredan de una clase base con Java es muy similar, pero hay que prestar atención a los siguientes puntos:
- 1, reescribir un método no abstracto debe utilizar el modificador override.
- 2, está disponible en el pasado sólo el constructor principal de los parámetros de escritura constructor de la clase base.
- 3. Cuando se reemplaza en una subclase de la superclase abstracta, no es necesario utilizar la palabra clave override.
Veamos un 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 ("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 ("x 的坐标点 : " + x);
println ("y 的坐标点 : " + y);
println ("z 的坐标点 : " + z);
}
}
el uso de palabras clave Scala se extiende a heredar una clase. Ubicación instancias clase hereda la clase Point. Punto llama la clase padre (clase base), la ubicación se llama una subclase.
val anular xc reescribir el campo de la clase padre.
Todas las propiedades y métodos heredan heredará la clase padre, Scala sólo permite heredar de una clase principal.
Ejemplos son los siguientes:
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 ("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 ("x 的坐标点 : " + x);
println ("y 的坐标点 : " + y);
println ("z 的坐标点 : " + z);
}
}
object Test {
def main(args: Array[String]) {
val loc = new Location(10, 20, 15);
// 移到一个新的位置
loc.move(10, 10, 5);
}
}
Aplicación del código anterior, la salida es:
$ scalac Test.scala $ scala Test x 的坐标点 : 20 y 的坐标点 : 30 z 的坐标点 : 20
Scala reescribir un método no abstracto tendrá prioridad modificador.
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)
}
Aplicación del código anterior, la salida es:
$ scalac Test.scala $ scala Test Employee[name=Fred][salary=50000.0]
Scala objeto único
En Scala, esto no es estática, sino que también nos proporciona un método para obtener el patrón Singleton, y que consiste en utilizar el objeto de palabras clave.
Scala cuando se utiliza en el modelo de un solo caso, además de la definición de clase, sino también la definición de un objeto de destino con el mismo nombre, es la diferencia entre ella y la clase, objeto objeto no puede tener parámetros.
Cuando los objetos Singleton comparten el mismo nombre con una clase, se le llama objetos compañero de esta clase: objeto acompañante. Debe definir la clase y sus objetos asociados en el mismo archivo de origen. Esta clase se llama la clase de acompañamiento objeto único: la clase de compañía. Clase y su objeto acompañante pueden acceder a sus miembros entre sí privadas.
instancias de objetos Singleton
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 ("x 的坐标点 : " + point.x);
println ("y 的坐标点 : " + point.y);
}
}
}
Aplicación del código anterior, la salida es:
$ scalac Test.scala $ scala Test x 的坐标点 : 10 y 的坐标点 : 20
instancia de objeto asociado
/* 文件名：Marker.scala
* author:本教程
* url:www.w3big.com
*/
// 私有构造方法
class Marker private(val color:String) {
println("创建" + this)
override def toString(): String = "颜色标记："+ color
}
// 伴生对象，与类共享名字，可以访问类的私有属性和方法
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"))
// 单例函数调用，省略了.(点)符号
println(Marker getMarker "blue")
}
}
Aplicación del código anterior, la salida es:
$ scalac Marker.scala $ scala Marker 创建颜色标记：red 创建颜色标记：blue 创建颜色标记：green 颜色标记：red 颜色标记：blue