Scala類 簡介 類是物件的抽象，而物件是類的具體例項。類是抽象的，不佔用記憶體，而物件是具體的，佔用儲存空間。類是用於建立物件的藍圖，它是一個定義包括在特定型別的物件中的方法和變數的軟體模板。 Scala中的類不宣告為public，一個Scala原始檔中可以有多個類。 Scala簡單例項

class Point(xc: Int, yc: Int) { var x: Int = xc var y: Int = ycdef 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);
} } ```
       Scala抽象類
       抽象類是一種不能被例項化的類，抽象類中包括了若干不能完整定義的方法，這些方法由子類去擴充套件定義自己的實現。
```abstract class Animal { //抽象欄位(域） //前面我們提到，一般類中定義欄位的話必須初始化，而抽象類中則沒有這要求 var height:Int //抽象方法 def eat:Unit }
       //Person繼承Animal，對eat方法進行了實現 //通過主構造器對height引數進行了初始化 class Person(var height:Int) extends Animal{ //對父類中的方法進行實現，注意這裡面可以不加override關鍵字 def eat()={ println("eat by mouth") }
}
       //通過擴充套件App建立程式的入口 //App其實是一種trait，它幫助我們定義了main方法。 object Person extends App{ new Person(10).eat() } ```繼承
       簡介
       重寫一個非抽象方法必須使用override修飾符。
       重寫超類的抽象方法時，不需要使用override關鍵字。
       只有主建構函式才可以往基類的建構函式裡寫引數。
       繼承會繼承父類的所有屬性和方法，Scala 只允許繼承一個父類。
       Scala簡單例項
```class Point(xc: Int, yc: Int) { var x: Int = xc var y: Int = ycdef 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 = zcoverride def move(dx: Int, dy: Int) { x = x - dx y = y - dy println ("x 的座標點: " + x) println ("y 的座標點: " + y) }
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);
loc.move(10, 10, 5);
} } ```
       Scala單例物件
       簡介
       在Scala中，是沒有static的，但是提供了單例模式的實現方法，那就是使用關鍵字object。
Scala中使用單例模式時，除了定義的類之外，還要定義一個同名的 object物件，它和類的區別是，object物件不能帶引數。
       簡單例項
       object Student { private var studentNo:Int=0; def uniqueStudentNo()={ studentNo+=1 studentNo } def main(args: Array[String]): Unit = { println(Student.uniqueStudentNo()) } }
       伴生類與伴生物件
       簡介
       當單例物件與某個類是同一個名稱時，單例物件被稱作是這個類的伴生物件，類被稱為是這個單例物件的伴生類。必須在同一個原始檔裡定義伴生類和伴生物件。它們可以互相訪問其私有成員。
簡單例項
       ```class Student(var name:String,var age:Int){ private var sex:Int=0 //直接訪問伴生物件的私有成員 def printCompanionObject()=println(Student.studentNo) }
object Student { private var studentNo:Int=0; def uniqueStudentNo()={ studentNo+=1 studentNo } def main(args: Array[String]): Unit = { println(Student.uniqueStudentNo()) val s=new Student("john",29) //直接訪問伴生類Student中的私有成員 println(s.sex) } } ```匿名類
       當某個類在程式中只使用一次時，可以將類定義為匿名類。
       ```//抽象的Person類 abstract class Person(name:String,age:Int){ def walk():Unit }
object demo{ def main(args: Array[String]): Unit = { //下面的程式碼定義了一個匿名類，並且進行了例項化 //直接new Person("john",18)，後面跟的是類的內容 //我們知道，Person是一個抽象類，它是不能被例項化的 //這裡能夠直接new操作是因為我們擴充套件了Person類，只不 //過這個類是匿名的，只能使用一次而已 val s=new Person("john",18){ override def walk()={ println("Walk like a normal Person") } } s.walk() } } ```
       多型與動態繫結
       簡介
       多型(Polymorphic)也叫動態繫結(Dynamic Binding)、遲繫結(Late Binding)，指在執行期間（而非編譯期間）判斷所引用物件的實際型別，根據其實際型別呼叫其相應的方法。子類的引用可以賦給父類。
       簡單例項
       ```//抽象Person類 abstract class Person(var name:String,var age:Int){def walk():Unit //talkTo方法，引數為Person型別 def talkTo(p:Person):Unit }
class Student(name:String,age:Int) extends Person(name,age){ private var studentNo:Int=0 def walk()=println("walk like a elegant swan") //重寫父類的talkTo方法 def talkTo(p:Person)={ println("talkTo() method in Student") println(this.name+" is talking to "+p.name) } }
class Teacher(name:String,age:Int) extends Person(name,age){ private var teacherNo:Int=0def walk()=println("walk like a elegant swan")//重寫父類的talkTo方法 def talkTo(p:Person)={ println("talkTo() method in Teacher") println(this.name+" is talking to "+p.name) } }
object demo{ def main(args: Array[String]): Unit = {//下面的兩行程式碼演示了多型的使用
       //Person類的引用可以指向Person類的任何子類
       val p1:Person=new Teacher("albert",38)
       val p2:Person=new Student("john",38)
       //下面的兩行程式碼演示了動態繫結
       //talkTo方法引數型別為Person型別
       //p1.talkTo(p2)傳入的實際型別是Student
       //p2.talkTo(p1)傳入的實際型別是Teacher
       //程式會根據實際型別呼叫對應的不同子類中的talkTo()方法p1.talkTo(p2)
       p2.talkTo(p1)
       } } ```
       文章來自：https://www.itjmd.com/news/show-3240.html