Scala的面向對象

Scala的面向對象

1、類

一、概述

    1）scala中的類和java中基本相似。

    2）scala中的類一樣經過class來進行聲明。

    3）scala中的類一樣能夠具備成員變量和成員方法。

    4）scala中的類一樣能夠經過new關鍵字來建立出對象。

    5）Scala中的類的成員默認的訪問權限是public。也能夠加private或protected。

    6）當成員變量或成員方法是私有屬性時，外部將不能直接訪問，這個同java同樣。

1．建立類

    示例：

class Person() {
  //建立一個類，並定義類裏的兩個成員變量name和age。以及一個成員方法 eat()
  //須要注意的是：scala中變量(var)聲明時須要指定初始值，
  private var name = 「」
  private var age = 0
  def eat(){
    println("eat")
  }
}

2．類的構造

1>主構造器

    和java不一樣，scala中的類不須要明確聲明一個構造器，而是直接將構造參數經過構造參數列表聲明爲類的一部分。

    而直接寫在類的體中的既不是類的成員變量也不是成員函數的部分，會自動收集爲構造函數的體。

    scala聲明主構造的形式是在類右側聲明，若是不聲明，Scala也提供了默認構造器。注意：當顯示聲明主構造器以後，默認的空構造器失效。

    示例：

//scala中的類不須要明確聲明一個構造器，而是直接將構造參數經過構造參數列表聲明爲類的一部分
class Person(v1: String, v2: Int) {
  //建立一個類，並定義類裏的兩個成員變量name和age。以及一個成員方法 eat()
  //須要注意的是：scala中變量(var)聲明時須要指定初始值，
  private var name = v1
  private var age = v2
  //而直接寫在類的體中的既不是類的成員變量也不是成員函數的部分，會自動收集爲構造函數的體。
//當調用構造方法時，會打印 …… 和***
  println("…………")
  println("***")
}

2>輔助構造器

    有些時候，一個類裏須要多個構造器。scala裏除主構造器以外的構造器被稱爲輔助構造器。

    1）Scala的輔助構造器定義開始於def this()。

    2）Scala裏每一個輔助構造器的第一個動做都是調用同類的構造器。

    示例：

class Person(v1: String, v2: Int) {
  private var name = v1
  private var age = v2
  //Scala的輔助構造器定義開始於 def this() 
  //Scala裏每一個輔助構造器的第一個動做都是調用同類的構造器
  def this(v1: String) = {
    this(v1, 0)
  }
  def this(v2: Int) {
    this("", v2)
  }
  def this() {
    this("", 0)
  }
}

    一個完整的示例：

class Person(v1: String, v2: Int) {
  private var name = v1
  private var age = v2
  println("…………")
  println("***")
  def this(v1: String) = {
    this(v1, 0)
  }
  def this(v2: Int) {
    this("", v2)
  }
  def this() {
    this("", 0)
  }
  def getName() = {
    this.name
  }
  def setName(name: String) = {
    this.name = name
  }
  def getAge() = {
    this.age
  }
  def setAge(age: Int) = {
    this.age = age
  }
  def say() {
    println("say word")
  }
}

二、單例對象(object)

    1）scala中的類(class)不能定義靜態成員（或靜態方法），而代之以定義單例對象來替代。

    2）單例對象須要經過object關鍵字來聲明。

    3）一個單例對象能夠單獨存在，也能夠綁定到一個類上。

    4）單例對象當中的全部方法，均可以不須要建立對象而直接經過object單例對象的名字直接來調用，用起來感受就像一個靜態方法同樣。

    5）當一個單例對象和某個類寫在同一個源文件中且共享同一個名字時，他們就產生了一個綁定的關係。此時單例對象稱爲該類的伴生對象。類稱爲該對象的伴生類。

    6）類和他的伴生對象能夠互相訪問其私有成員。

    7）以伴生的方式爲類增長靜態成員成爲了可能。

    8）單例對象不能new，所以也沒有構造參數。

    9）能夠把單例對象看成是java中可能會用到的靜態方法工具類。

    10）做爲程序的入口main方法必須是靜態的，因此main方法必須處在一個單例對象中，而不能寫在一個類中。

    11）單例對象在第一次被訪問時纔會被初始化。

    示例：

class Person(v1: String, v2: Int) {
  //此私有變量，伴生類能夠訪問
  private var name = v1
  private var age = v2
}
//Person的單利對象，也即伴生類Person
object Person {
  def shownamespace() {
    val p = new Person
    //能夠訪問類的私有變量
    println(p.name)
  }
  def eat() {
    println("eat")
  }
}

三、抽象類

    scala中一樣支持抽象類的使用，抽象類的內部能夠包含抽象方法和非抽象方法。抽象類不容許被實例化，抽象類主要是用來被繼承的。

    Scala的抽象類同java，經過abstract關鍵字來定義。抽象方法的特色：沒有｛｝方法體。

示例：

abstract class Teacher {
  //抽象方法，返回值爲Unit
  def makeNote()
  //抽象方法，返回值爲String
  def teach():String
  def compute():Int
  //實體方法
  def say(){}
}

四、特質trait

    1）能夠類比java中的接口，可是又和接口很是不同，特質至關於java中的接口，java中稱爲類實現了接口，scala中稱爲混入了特質。

    2）和java中的接口不一樣的是，scala中的特質能夠包含具備方法體的方法。

    和抽象類不一樣的地方在於，scala的類只能單繼承，可是能夠多混入，利用這種方式能夠實現相似c語言中多繼承的特性。

    3）在類中能夠經過extends或with關鍵字來讓類混入特質，若是類沒有明確繼承父類，extends關鍵字沒有被佔用就可使用extends。

    4）可是如已經使用了extends顯示的繼承了父類，再向混入特質就要用with關鍵字了。

    一個類的聲明中只能有一個extends，可是能夠有多個with。

    示例：

trait Dance {
  def Balei()
  def floor()
  //trait相似於java的接口，但能夠作具體方法的實現
  def eat(){}
}

trait Driver {
  def shache():String
  def piaoyi()
}

//scala中，只能繼承一個父類，可是能夠混入多個特質（trait)
//須要實現特質中未實現的方法
//此外，須要注意的是，若是未繼承任何類或抽象類，在混入特質時，
//好比有且僅有一個特質須要用extends來混入，而其餘特質用with混入
class ZhangTeacher extends  Dance with Driver {
  def Balei(): Unit = {
    ???
  }
  def floor(): Unit = {
    ???
  }
  def piaoyi(): Unit = {
    ???
  }
  def shache(): String = {
    ???
  }
}

五、樣例類case class

    1）只要在聲明類時，在class關鍵字前加上case關鍵字，這個類就成爲了樣例類。樣例類必需要顯式的聲明一個主構造器。

    2）當樣例類聲明一個主構造器後，會默認隱式的聲明一個空構造器。

    3）樣例類默認實現序列化接口。

    序列化的兩個做用：①數據持久化；②網絡數據傳輸。

    4）樣例類默認自動覆蓋toString、equals、hashCode方法。

    5）樣例類不須要new能夠直接生成對象。

    示例：

//須要聲明一個主構造器，主構造器能夠是一個空構造器
case class Item(v1:Int,v2:String) {
  var id=v1
  var title=v2
}

  //樣例類不須要new，而且隱式的含有空構造器
  val v1=Item(1,"phone")
//> v1  : Item = Item(1,phone)
  val v2=Item
//> v2  : Item.type = Item

六、option

    在Scala中用來表示一個結果，它可能有值，也可能沒有值，它有兩個子Option。一個是Some，一個是None。

    示例：

def f1(a:Int,b:Int)={
  	if(b!=0){
  		Some(a/b)
  	}else{
  		None
  	}
  }
  //表示若是有正確結果，返回正確結果，沒有則返回指定的默認值
  f1(4,0).getOrElse("error")

七、包的引用

    相似於java中經過import關鍵字引入包/類，scala也能夠實現這種方式引入，可是更強大一些。

    1）scala中的import能夠出如今代碼任何地方。

    2）scala中的import時能夠指的是對象和包。

    3）scala中的import能夠重命名或隱藏一些被引用的成員。

    4）scala默認會自動引入以下三個包下的全部內容。

    java.lang：java中的通用類。

    scala._：scala提供的通用類 主要是基本類型除了String。

    Predef._：提供了單例對象 以及一些經常使用方法 print println。

    示例：

import cn.tedu._
import cn.tedu.{Apple,Orange}

2、面向對象

一、重寫和重載

    1）重寫是指覆蓋父類中的方法來在子類中作其餘事項。

    格式：

    override def 父類方法名 參數列表 返回值 方法體

    2）重載是指在同一個類中提供方法名相同可是參數不一樣的方法和java中基本一致。

    示例：

二、final

    能夠用在成員變量、成員方法、類自己上，做用和java中相同。

三、多態

    示例：

object Demo13{
  def main(args: Array[String]): Unit = {
    val t1:Teacher=new TeacherChen("chen",32)
    val t2:Teacher=new TeacherLiu("liu",32)
  }
}

四、泛型

    基本和java中相同，不一樣的是，泛型是用方括號引發來的。

val arr = Array[String]();

 

上一篇：Scala中的集合類型