classi e oggetti Scala
Class è un oggetto astratto, e l'oggetto è una specifica istanza di una classe. Class è astratta e non occupa la memoria, e l'oggetto è concreto, occupano lo spazio di archiviazione. Class è un progetto per la creazione di un oggetto, si tratta di un template definiti dal software includono i metodi e le variabili in specifici tipi di oggetti nella.
Siamo in grado di utilizzare la nuova parola chiave per creare oggetti della classe, gli esempi sono i seguenti:
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 di classe non sono dichiarati come pubblico, un file sorgente Scala può avere più classi.
Esempi di classe sopra definisce due variabilixey,unmetodo:mossa, il metodo non restituisce alcun valore.
Definizione della classe Scala possono avere parametri, detti parametri di classe, come il xc sopra, yc, parametri categoria dell'intera classe possono accedere.
Quindi possiamo usare di nuovo da istanziare i metodi e le variabili di classe di classe e di accesso:
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);
}
}
L'attuazione del codice di cui sopra, l'output è:
$ scalac Test.scala $ scala Test x 的坐标点: 20 y 的坐标点: 30
Scala Eredita
Scala ereditare una classe di base con Java è molto simile, ma abbiamo bisogno di prestare attenzione ai seguenti punti:
- 1, riscrivere un metodo non astratto deve utilizzare il modificatore override.
- 2, è disponibile in passato solo il costruttore principale dei parametri del costruttore di scrittura classe di base.
- 3. Quando sottoposto a override in una sottoclasse superclasse astratta, non occorre utilizzare la parola chiave override.
Diamo un'occhiata a un esempio:
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);
}
}
uso Scala estende parola chiave per ereditare una classe. Le istanze Luogo eredita classe Point. Punto chiamato la classe padre (classe base), la posizione è chiamato una sottoclasse.
ignorare val xc riscrivere il campo classe genitore.
Tutte le proprietà ei metodi ereditano erediteranno la classe padre, Scala permette di ereditare solo una classe genitore.
Esempi sono i seguenti:
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);
}
}
L'attuazione del codice di cui sopra, l'output è:
$ scalac Test.scala $ scala Test x 的坐标点 : 20 y 的坐标点 : 30 z 的坐标点 : 20
Scala riscrivere un metodo non-abstract deve avere la priorità modificatore.
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)
}
L'attuazione del codice di cui sopra, l'output è:
$ scalac Test.scala $ scala Test Employee[name=Fred][salary=50000.0]
Scala oggetto Singleton
In Scala, questa cosa non è statica, ma ci fornisce anche un metodo per realizzare pattern Singleton, e che è quello di utilizzare l'oggetto parola chiave.
Scala quando usato in caso singolo modello, oltre alla definizione di classe, ma anche la definizione di un oggetto target con lo stesso nome, è la differenza tra questo e la classe, oggetto oggetto non può prendere parametri.
Quando gli oggetti Singleton condividono lo stesso nome con una classe, è chiamato oggetti compagno di questa classe: oggetto associato. È necessario definire la classe e gli oggetti associati nello stesso file sorgente. Questa classe è chiamata la classe di accompagnamento oggetto Singleton: class compagno. Classe e il suo oggetto associato possono accedere vicenda i membri privati.
istanze di oggetti 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);
}
}
}
L'attuazione del codice di cui sopra, l'output è:
$ scalac Test.scala $ scala Test x 的坐标点 : 10 y 的坐标点 : 20
istanza di oggetto associato
/* 文件名：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")
}
}
L'attuazione del codice di cui sopra, l'output è:
$ scalac Marker.scala $ scala Marker 创建颜色标记：red 创建颜色标记：blue 创建颜色标记：green 颜色标记：red 颜色标记：blue