Klasy i obiekty Scala
Klasa jest abstrakcyjną obiektu, a obiekt jest specyficzną instancją klasy. Klasa jest abstrakcyjna i nie bierze się pamięć, a obiekt jest beton, zajmują miejsca. Klasa jest plan tworzenia obiektu, to jest oprogramowanie zdefiniowane szablony obejmują metody i zmienne w poszczególnych typów obiektów w.
Możemy użyć słowa kluczowego new do tworzenia obiektów tej klasy, przykłady przedstawiają się następująco:
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 w klasie nie zostały zadeklarowane jako publiczne, plik źródłowy Scala może mieć wiele klas.
Przykłady wyżej klasy definiuje dwie zmienneX i Y,Ametoda:ruch, metoda nie ma wartości zwracanej.
Definicja klasy Scala może mieć parametry, zwane parametry klasy, takie jak wyżej xc, yc, parametry klasy w całej klasy mogą uzyskać dostęp.
Wtedy możemy użyć nowego instancję metody class i dostępu oraz zmienne:
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);
}
}
Realizacja powyższego kodu, wyjście jest:
$ scalac Test.scala $ scala Test x 的坐标点: 20 y 的坐标点: 30
Scala dziedziczyć
Scala dziedziczą klasy bazowej z Java jest bardzo podobny, ale trzeba zwrócić uwagę na następujące kwestie:
- 1, przepisać zakaz metody abstrakcyjne muszą używać modyfikatora obejścia.
- 2, jest dostępna w przeszłości tylko główny konstruktor parametrów zapisu konstruktor klasy bazowej.
- 3. Po przesłonięta w podklasie abstrakcyjne nadklasy, nie trzeba używać słowa kluczowego override.
Spójrzmy na wystąpienie:
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);
}
}
Scala użycie słowa kluczowego rozciąga dziedziczyć klasę. Instancje klasy Lokalizacja dziedziczy klasy Point. Punkt nazywa klasa dominująca (klasa podstawowa), lokalizacja jest nazywana podklasą.
przesłonić val xc przepisać pola klasy nadrzędnej.
Wszystkie właściwości i metody dziedziczą odziedziczy klasę nadrzędną, Scala umożliwia dziedziczą tylko klasę nadrzędną.
Przykłady są następujące:
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);
}
}
Realizacja powyższego kodu, wyjście jest:
$ scalac Test.scala $ scala Test x 的坐标点 : 20 y 的坐标点 : 30 z 的坐标点 : 20
Scala przepisać zakaz metody abstrakcyjne muszą być nadrzędne modyfikatora.
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)
}
Realizacja powyższego kodu, wyjście jest:
$ scalac Test.scala $ scala Test Employee[name=Fred][salary=50000.0]
Scala Singleton obiektu
W Scala, ta sprawa nie jest statyczna, ale również daje nam sposób, aby osiągnąć Singleton, a to jest użycie słowa kluczowego obiektu.
Scala gdy są stosowane w przypadku jednego wzoru, dodatkowo do definicji klasy, ale również określenie obiektu docelowego o tej samej nazwie, jest różnicą pomiędzy nim i klasy Object nie mogą przyjmować parametry.
Gdy obiekty Singleton dzielić tę samą nazwę z klasą, jest on nazywany obiektów towarzyszących tej klasy: obiektu towarzyszącego. Musisz określić klasę i związane z nią obiekty w tym samym pliku źródłowym. Klasa ta nazywana jest singleton obiektu towarzyszącego klasy: Klasa towarzyszem. Klasa i jego celem towarzysz może uzyskać dostęp do siebie nawzajem swoje prywatne członków.
instancje obiektów 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);
}
}
}
Realizacja powyższego kodu, wyjście jest:
$ scalac Test.scala $ scala Test x 的坐标点 : 10 y 的坐标点 : 20
Skojarzonej instancji obiektu
/* 文件名：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")
}
}
Realizacja powyższego kodu, wyjście jest:
$ scalac Marker.scala $ scala Marker 创建颜色标记：red 创建颜色标记：blue 创建颜色标记：green 颜色标记：red 颜色标记：blue