Scala Klassen und Objekte
Eine Klasse ist eine Abstraktion von Objekten, während ein Objekt eine konkrete Instanz einer Klasse ist. Klassen sind abstrakt und belegen keinen Speicher, während Objekte konkret sind und Speicherplatz belegen. Eine Klasse ist ein Bauplan für die Erstellung von Objekten; sie ist eine Softwarevorlage, die die Methoden und Variablen definiert, die in Objekten eines bestimmten Typs enthalten sind.
Wir können das Schlüsselwort new verwenden, um ein Objekt einer Klasse zu erstellen, wie im folgenden Beispiel gezeigt:
Beispiel
var x: Int = xc
var y: Int = yc
def move(dx: Int, dy: Int) {
x = x + dx
y = y + dy
println ("x coordinate point: " + x);
println ("y coordinate point: " + y);
}
}
In Scala werden Klassen nicht als public deklariert; eine einzelne Scala-Quelldatei kann mehrere Klassen enthalten.
Die Klasse im obigen Beispiel definiert zwei Variablenxundysowie eine Methode:move; die Methode hat keinen Rückgabewert.
Scala-Klassendefinitionen können Parameter haben, die Klassenparameter genannt werden, wie xc und yc oben. Klassenparameter sind in der gesamten Klasse zugänglich.
Dann können wir new verwenden, um die Klasse zu instanziieren und auf die Methoden und Variablen in der Klasse zuzugreifen:
Beispiel
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 coordinate point: " + x);
println ("y coordinate point: " + y);
}
}
object Test {
def main(args: Array[String]) {
val pt = new Point(10, 20);
// An eine neue Position verschieben
pt.move(10, 10);
}
}
Das Ausführen des obigen Codes erzeugt die folgende Ausgabe:
$ scalac Test.scala $ scala Test x 的坐标点: 20 y 的坐标点: 30
Scala-Vererbung
Das Erben einer Basisklasse in Scala ist Java sehr ähnlich, aber wir müssen die folgenden Punkte beachten:
- 1. Beim Überschreiben einer nicht abstrakten Methode muss der override-Modifikator verwendet werden.
- 2. Nur der primäre Konstruktor kann Parameter an den Konstruktor der Basisklasse übergeben.
- 3. Wenn eine abstrakte Methode einer Oberklasse in einer Unterklasse überschrieben wird, muss das Schlüsselwort override nicht verwendet werden.
Sehen wir uns als Nächstes ein Beispiel an:
Beispiel
var x: Int = xc
var y: Int = yc
def move(dx: Int, dy: Int) {
x = x + dx
y = y + dy
println ("x coordinate point: " + x);
println ("y coordinate point: " + 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-Koordinatenpunkt : " + x);
println ("y-Koordinatenpunkt : " + y);
println ("z-Koordinatenpunkt : " + z);
}
}
Scala verwendet das Schlüsselwort extends, um eine Klasse zu erben. Im Beispiel erbt die Klasse Location von der Klasse Point. Point wird als Elternklasse (Basisklasse) bezeichnet und Location als Unterklasse.
override val xcDies dient zum Überschreiben der Felder der Elternklasse.
Vererbung übernimmt alle Eigenschaften und Methoden der Elternklasse. Scala erlaubt nur das Erben von einer Elternklasse.
Ein Beispiel ist wie folgt:
Beispiel
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-Koordinatenpunkt : " + x);
println ("y-Koordinatenpunkt : " + 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-Koordinatenpunkt : " + x);
println ("y-Koordinatenpunkt : " + y);
println ("z-Koordinatenpunkt : " + z);
}
}
object Test {
def main(args: Array[String]) {
val loc = new Location(10, 20, 15);
// An eine neue Position verschieben
loc.move(10, 10, 5);
}
}
Das Ausführen des obigen Codes erzeugt die folgende Ausgabe:
$ scalac Test.scala $ scala Test x 的坐标点 : 20 y 的坐标点 : 30 z 的坐标点 : 20
In Scala muss beim Überschreiben einer nicht abstrakten Methode der override-Modifikator verwendet werden.
Beispiel
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)
}
Das Ausführen des obigen Codes erzeugt die folgende Ausgabe:
$ scalac Test.scala $ scala Test Employee[name=Fred][salary=50000.0]
Scala Singleton-Objekte
In Scala gibt es so etwas wie static nicht, aber es bietet uns dennoch eine Möglichkeit, das Singleton-Muster zu implementieren, nämlich die Verwendung des Schlüsselworts object.
Wenn Sie das Singleton-Muster in Scala verwenden, müssen Sie zusätzlich zur definierten Klasse ein Objekt mit demselben Namen definieren. Der Unterschied zwischen ihm und einer Klasse besteht darin, dass ein Objekt keine Parameter haben kann.
Wenn ein Singleton-Objekt denselben Namen wie eine Klasse hat, wird es als Companion-Objekt dieser Klasse bezeichnet. Sie müssen die Klasse und ihr Companion-Objekt in derselben Quelldatei definieren. Die Klasse wird als Companion-Klasse des Singleton-Objekts bezeichnet. Eine Klasse und ihr Companion-Objekt können auf die privaten Member des jeweils anderen zugreifen.
Singleton-Objekt-Beispiel
Beispiel
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-Koordinatenpunkt : " + point.x);
println ("y-Koordinatenpunkt: " + point.y);
}
}
}
Das Ausführen des obigen Codes erzeugt die folgende Ausgabe:
$ scalac Test.scala $ scala Test x 的坐标点 : 10 y 的坐标点 : 20
Begleitobjekt-Beispiel
Beispiel
* Autor: Beispiel
* URL:www.example.com
*/
// Privater Konstruktor
class Marker private(val color:String) {
println("Erstellen" + this)
override def toString(): String = "Farbmarker: "+ color
}
// Begleitobjekt, mit demselben Namen wie die Klasse, kann auf die privaten Eigenschaften und Methoden der Klasse zugreifen
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"))
// Singleton-Funktionsaufruf, wobei das . (Punkt)-Symbol weggelassen wird
println(Marker getMarker "blue")
}
}
Das Ausführen des obigen Codes erzeugt die folgende Ausgabe:
$ scalac Marker.scala $ scala Marker 创建颜色标记:red 创建颜色标记:blue 创建颜色标记:green 颜色标记:red 颜色标记:blueAndere Erweiterungen