kelas Scala dan benda-benda
Kelas adalah obyek abstrak, dan objek adalah contoh spesifik dari kelas. Kelas adalah abstrak dan tidak memakan memori, dan objek adalah beton, mengambil ruang penyimpanan. Kelas adalah cetak biru untuk menciptakan sebuah objek, itu adalah template software-didefinisikan mencakup metode dan variabel dalam tipe tertentu dari objek dalam.
Kita dapat menggunakan kata kunci baru untuk membuat objek dari kelas, contoh adalah sebagai 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);
}
}
Scala di kelas tidak dideklarasikan sebagai publik, file sumber Scala dapat memiliki beberapa kelas.
Contoh kelas atas mendefinisikan dua variabelx dan y,metode: bergerak, metode tersebut tidak memiliki nilai kembali.
definisi kelas Scala dapat memiliki parameter, parameter kelas yang disebut, seperti xc di atas, yc, parameter kelas di seluruh kelas dapat mengakses.
Maka kita bisa menggunakan baru untuk instantiate metode kelas kelas dan akses dan variabel:
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);
}
}
Pelaksanaan kode di atas, output adalah:
$ scalac Test.scala $ scala Test x 的坐标点: 20 y 的坐标点: 30
scala mewarisi
Scala mewarisi kelas dasar dengan Java sangat mirip, tetapi kita perlu memperhatikan hal-hal berikut:
- 1, menulis ulang metode non-abstrak harus menggunakan pengubah override.
- 2, tersedia di masa lalu hanya konstruktor utama dari kelas dasar konstruktor menulis parameter.
- 3. Ketika diganti dalam subclass superclass abstrak, Anda tidak perlu menggunakan kata kunci override.
Mari kita lihat sebuah 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 penggunaan meluas kata kunci untuk mewarisi kelas. Contoh Lokasi kelas mewarisi kelas Point. Titik yang disebut kelas induk (kelas dasar), Lokasi disebut subclass.
menimpa val xc menulis ulang bidang kelas induk.
Semua properti dan metode mewarisi akan mewarisi kelas induk, Scala memungkinkan hanya mewarisi kelas induk.
Contohnya adalah sebagai 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);
}
}
Pelaksanaan kode di atas, output adalah:
$ scalac Test.scala $ scala Test x 的坐标点 : 20 y 的坐标点 : 30 z 的坐标点 : 20
Scala menulis ulang metode non-abstrak harus mengesampingkan pengubah.
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)
}
Pelaksanaan kode di atas, output adalah:
$ scalac Test.scala $ scala Test Employee[name=Fred][salary=50000.0]
Scala objek tunggal
Dalam Scala, hal ini tidak statis, tetapi juga menyediakan kita dengan metode untuk mencapai pola Singleton, dan itu adalah dengan menggunakan objek kunci.
Scala bila digunakan dalam model-kasus tunggal, selain definisi kelas, tetapi juga definisi dari objek target dengan nama yang sama, adalah perbedaan antara itu dan kelas, objek objek tidak dapat mengambil parameter.
Ketika Singleton objek berbagi nama yang sama dengan kelas, ia disebut benda pendamping ini kelas: objek pendamping. Anda harus menentukan kelas dan objek yang terkait dalam file sumber yang sama. Kelas ini disebut kelas objek yang menyertainya tunggal: kelas pendamping. Kelas dan objek pendamping dapat mengakses anggota pribadi mereka satu sama lain.
contoh 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);
}
}
}
Pelaksanaan kode di atas, output adalah:
$ scalac Test.scala $ scala Test x 的坐标点 : 10 y 的坐标点 : 20
Terkait contoh objek
/* 文件名：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")
}
}
Pelaksanaan kode di atas, output adalah:
$ scalac Marker.scala $ scala Marker 创建颜色标记：red 创建颜色标记：blue 创建颜色标记：green 颜色标记：red 颜色标记：blue