Kelas dan objek skala
Kelas ialah abstraksi objek, dan objek ialah contoh konkrit bagi kelas. Kelas adalah abstrak dan tidak menduduki memori, manakala objek adalah konkrit dan menduduki ruang simpanan. Kelas ialah rangka tindakan untuk mencipta objek, templat perisian yang mentakrifkan kaedah dan pembolehubah yang disertakan dalam objek jenis tertentu.
Kita boleh menggunakan kata kunci baharu untuk mencipta objek kelas Contohnya adalah seperti berikut:
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);
}
}Kelas dalam Scala tidak diisytiharkan sebagai awam dan boleh terdapat berbilang kelas dalam satu. Fail sumber Scala.
Kelas contoh di atas mentakrifkan dua pembolehubah x dan y, dan satu kaedah: move, kaedah tidak mempunyai nilai pulangan.
Takrifan kelas Scala boleh mempunyai parameter, dipanggil parameter kelas, seperti xc, yc di atas boleh diakses di seluruh kelas.
Kemudian kita boleh menggunakan new untuk membuat instantiate kelas dan mengakses kaedah dan pembolehubah dalam kelas:
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);
}
}Laksanakan kod di atas, hasil output ialah:
$ scalac Test.scala $ scala Test x 的坐标点: 20 y 的坐标点: 30
Warisan Scala
Scala yang mewarisi kelas asas sangat serupa dengan Java, tetapi kita perlu memberi perhatian kepada beberapa perkara:
1 untuk mengatasi simbol kaedah bukan abstrak.
2. Hanya pembina utama boleh menulis parameter ke dalam pembina kelas asas.
3 Apabila mengatasi kaedah abstrak kelas super dalam subkelas, anda tidak perlu menggunakan kata kunci ganti.
Seterusnya mari kita lihat contoh:
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 menggunakan kata kunci lanjutan untuk mewarisi kelas. Dalam contoh, kelas Lokasi mewarisi kelas Point. Point dipanggil kelas induk (kelas asas), dan Lokasi dipanggil subkelas.
override val xc mengatasi medan kelas induk.
Warisan akan mewarisi semua sifat dan kaedah kelas induk Scala hanya membenarkan warisan satu kelas induk.
Contohnya adalah seperti berikut:
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);
}
}Laksanakan kod di atas, hasil output ialah:
$ scalac Test.scala $ scala Test x 的坐标点 : 20 y 的坐标点 : 30 z 的坐标点 : 20
Scala menulis semula kaedah bukan abstrak dan mesti menggunakan pengubah ganti.
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)
}Laksanakan kod di atas, hasil output ialah:
$ scalac Test.scala $ scala Test Employee[name=Fred][salary=50000.0]
Objek tunggal Scala
Dalam Scala, tiada perkara seperti statik, tetapi ia adalah juga Kami menyediakan kaedah pelaksanaan untuk corak tunggal, iaitu menggunakan objek kata kunci.
Apabila menggunakan mod tunggal dalam Scala, sebagai tambahan kepada kelas yang ditentukan, objek objek dengan nama yang sama juga mesti ditakrifkan Perbezaan antaranya dan kelas ialah objek objek tidak boleh mengambil parameter.
Apabila objek tunggal berkongsi nama yang sama dengan kelas, ia dipanggil objek pengiring kelas ini: objek pengiring. Anda mesti menentukan kelas dan objek pengiringnya dalam fail sumber yang sama. Kelas itu dipanggil kelas pengiring bagi objek tunggal ini: kelas pengiring. Kelas dan objek rakannya boleh mengakses ahli peribadi masing-masing.
Instance objek tunggal
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);
}
}
}Laksanakan kod di atas, hasil output ialah:
$ scalac Test.scala $ scala Test x 的坐标点 : 10 y 的坐标点 : 20
Instance objek pendamping
/* 文件名：Marker.scala
* author:php中文网
* url:www.php.cn
*/
// 私有构造方法
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")
}
}Laksanakan kod di atas, output hasilnya ialah:
$ scalac Marker.scala $ scala Marker 创建颜色标记：red 创建颜色标记：blue 创建颜色标记：green 颜色标记：red 颜色标记：blue
