Scala學習之路 （六）Scala的類、對象、繼承、特質

一、類

1、類的定義

scala語言中沒有static成員存在，但是scala允許以某種方式去使用static成員
這個就是伴生機制，所謂伴生，就是在語言層面上，把static成員和非static成員用不同的表達方式，class和object，
但雙方具有相同的package和name，但是最終編譯器會把他們編譯到一起，這是純粹從語法層面上的約定。通過javap可以反編譯看到。
另外一個小魔法就是單例，單例本質上是通過伴生機制完成的，直接由編譯器生成一個class對象，這樣至少在底層能夠統一。

//在Scala中，類並不用聲明為public。
//Scala源文件中可以包含多個類，所有這些類都具有公有可見性。
class ClassDemo {
  //用val修飾的變量是只讀屬性，有getter但沒有setter
  //（相當與Java中用final修飾的變量）
  val id = 666
  //用var修飾的變量既有getter又有setter
  var name = "huangbo"
  //類私有字段,只能在類的內部使用
  var age = 24
  //對象私有字段,訪問權限更加嚴格的，ClassDemo類的方法只能訪問到當前對象的字段
  private[this] val address = "三里屯"
}

2、構造器

注意：主構造器會執行類定義中的所有語句

/**
  *每個類都有主構造器，主構造器的參數直接放置類名后面，與類交織在一起
  */
class Person(val name:String,val age:Int) {
  //主構造器會執行類定義中的所有語句
  println("Hello Spark")

  val x = 1
  if(x > 1){
    println("666")
  }else if(x < 1){
    println("哈哈。。。")
  }else{
    println("呵呵。。。")
  }

  private var address = "BJ"
  //用this關鍵字定義輔助構造器
  def this(name:String,age:Int,address:String){
    //每個輔助構造器必須以主構造器或其他的輔助構造器的調用開始
    this(name,age)
    println("執行輔助構造器")
    this.address = address
  }

}

object Person{
  def main(args: Array[String]): Unit = {
    val p = new Person("dengchao",33,"SH")

  }
}

總結：

主構造方法：

   1）與類名交織在一起

   2）主構造方法運行，導致類名后面的大括號里面的代碼都會運行

輔助構造方法：

   1）必須名字叫this

   2) 必須以調用主構造方法或者是其他輔助構造方法開始。

   3）里面的屬性不能寫修飾符

對象

單例對象

在Scala中沒有靜態方法和靜態字段，但是可以使用object這個語法結構來達到同樣的目的

1.存放工具方法和常量

2.高效共享單個不可變的實例=單例模式

import scala.collection.mutable.ArrayBuffer

object SingletonDemo {
  def main(args: Array[String]): Unit = {
    val session = SessionFactory.getSession()
    println(session)
  }
}

class Session{}

object SessionFactory{
  //該部分相當於java中的靜態塊
  var counts = 5
  val sessions = new ArrayBuffer[Session]()
  while (counts > 0){
    sessions += new Session
    counts -= 1
  }
  //在object中的方法相當於java中的靜態方法
  def getSession(): Session ={
    sessions.remove(0)
  }

}

總結：

1）object里面的方法都是靜態方法

2）Object里面的字段都是靜態字段

3）它本身就是一個單例，(因為不需要去new)

伴生對象

在同一個文件中，在Scala的類中，與類名相同的對象叫做伴生對象，類和伴生對象之間可以相互訪問私有的方法和屬性

class Dog {
  val id = 666
  private var name = "道哥"
  def printName(): Unit ={
    //在Dog類中可以訪問伴生對象Dog的私有屬性
    println(Dog.CONSTANT + name)
  }
}

/**
  * 伴生對象
  */
object Dog{
  //伴生對象中的私有屬性
  private var CONSTANT = "汪汪汪。。。"
  //主方法
  def main(args: Array[String]): Unit = {
    val dog = new Dog
    //訪問私有的字段name
    dog.name = "道哥666"
    dog.printName()

  }
}

總結：

伴生對象和伴生類可以互相訪問私有屬性和私有方法。

apply方法

通常我們會在類的伴生對象中定義apply方法，當遇到類名(參數1,...參數n)時apply方法會被調用

object ApplyDemo {
  def main(args: Array[String]): Unit = {
    //調用Array伴生對象的apply方法
    val array = Array(1,2,3,4,5)
    println(array.toBuffer)
    //new了一個長度為9的數組，數組里面包含了9個null
    var arr = new Array(9)
    println(arr)
  }
}

繼承

Scala中，讓子類繼承父類，與Java一樣，也是使用extends關鍵字
繼承就代表，子類可以從父類繼承父類的field和method；然后子類可以在自己內部放入父類所沒有，子類特有的field和method；使用繼承可以有效復用代碼
子類可以覆蓋父類的field和method；但是如果父類用final修飾，field和method用final修飾，則該類是無法被繼承的，field和method是無法被覆蓋的

class People {
  private var name = "始皇帝"
  def getName = name
}

class Student extends People{
  private var score = 59
  def getScore = score
}

object Test{
  def main(args: Array[String]): Unit = {
    val student = new Student
    println(student.getName)
  }
}

Scala中，如果子類要覆蓋一個父類中的非抽象方法，則必須使用override關鍵字
override關鍵字可以幫助我們盡早地發現代碼里的錯誤，比如：override修飾的父類方法的方法名我們拼寫錯了；比如要覆蓋的父類方法的參數我們寫錯了；等等
此外，在子類覆蓋父類方法之后，如果我們在子類中就是要調用父類的被覆蓋的方法呢？那就可以使用super關鍵字，顯式地指定要調用父類的方法

class People {
  private var name = "始皇帝"
  def getName = name
}

class Student extends People{
  private var score = 59
  def getScore = score

  override def getName: String = super.getName + ":嬴政"
}

object Test{
  def main(args: Array[String]): Unit = {
    val student = new Student
    println(student.getName)
  }
}

抽象類

如果在父類中，有某些方法無法立即實現，而需要依賴不同的子來來覆蓋，重寫實現自己不同的方法實現。此時可以將父類中的這些方法不給出具體的實現，只有方法簽名，這種方法就是抽象方法。

而一個類中如果有一個抽象方法，那么類就必須用abstract來聲明為抽象類，此時抽象類是不可以實例化的

在子類中覆蓋抽象類的抽象方法時，不需要使用override關鍵字

abstract class AbstractDemo(name:String) {
  def sayHello:Unit
}

class StudentDemo(name:String) extends AbstractDemo(name){
  def sayHello: Unit = println("Hello " + name)
}

object StudentDemo{
  def main(args: Array[String]): Unit = {
    val li = new StudentDemo("Li")
    li.sayHello
  }
}

擴展類

在Scala中擴展類的方式和Java一樣都是使用extends關鍵字

重寫方法

在Scala中重寫一個非抽象的方法必須使用override修飾符

特質(trait)

 1、將特質作為接口使用

/**
 * // Scala中的Triat是一種特殊的概念
// 首先我們可以將Trait作為接口來使用，此時的Triat就與Java中的接口非常類似
// 在triat中可以定義抽象方法，就與抽象類中的抽象方法一樣，只要不給出方法的具體實現即可
// 類可以使用extends關鍵字繼承trait，注意，這里不是implement，而是extends，在scala中沒有implement的概念，無論繼承類還是trait，統一都是extends
// 類繼承trait后，必須實現其中的抽象方法，實現時不需要使用override關鍵字
// scala不支持對類進行多繼承，但是支持多重繼承trait，使用with關鍵字即可
 */
trait HelloTrait {
  def sayHello(name:String)
}

trait MakeFriendsTrait{
  def makeFriends(w:Worker)
}
class Worker(var name:String) extends HelloTrait with MakeFriendsTrait{
  def sayHello(name:String) = println("hello ,"+name)
  def makeFriends(w:Worker)=println("hello, my name is"+name+" you name is"+w.name)
}

object Test{
  def main(args: Array[String]) {
    val p1=new Worker("xiaoma");
    val p2=new Worker("linghuchong")
    p1.sayHello("lihuchong")
    p1.makeFriends(p2)
  }
}

 

2、在trait中定義具體方法

/**
 // Scala中的Triat可以不是只定義抽象方法，還可以定義具體方法，此時trait更像是包含了通用工具方法的東西
// 有一個專有的名詞來形容這種情況，就是說trait的功能混入了類
// 舉例來說，trait中可以包含一些很多類都通用的功能方法，比如打印日志等等，spark中就使用了trait來定義了通用的日志打印方法
 */
trait Logger {
  def log(message:String) = println(message)
}
class Person(val name:String) extends Logger{
  def makeFridends(p:Person): Unit ={
    println("I'm"+name+" i'm glade to make friends with you"+p.name);
    log("makeFridends method invoked!!")
  }
}
object Test{
  def main(args: Array[String]) {
    val p1=new Person("linpingzhi")
    val p2=new Person("yuelingshan");
    p1.makeFridends(p2)
  }
}

 

3、在trait中定義具體字段

/**
 * // Scala中的Triat可以定義具體field，此時繼承trait的類就自動獲得了trait中定義的field
// 但是這種獲取field的方式與繼承class是不同的：如果是繼承class獲取的field，實際是定義在父類中的；
  而繼承trait獲取的field，就直接被添加到了類中
 */
trait Person {
  val eyeNum:Int=2
}
class Student(val name:String) extends Person{
  def sayHello()=println("Hi,I'm "+name +"I have "+eyeNum+"eyes !" )
}
object Test{
  def main(args: Array[String]) {
    val s=new Student("zhangsanfeng")
    s.sayHello();
  }
}

 

4、 在trait中定義抽象字段

/**
 * // Scala中的Triat可以定義抽象field，而trait中的具體方法則可以基於抽象field來編寫
// 但是繼承trait的類，則必須覆蓋抽象field，提供具體的值
 */
trait sayHello {
  val msg:String
  def sayHello(name:String)=println(msg +" , "+name)
}
class Person(val name:String) extends sayHello{
  val msg:String = "hello"
  def makeFriends(p:Person): Unit ={
    sayHello(p.name)
    println("I'm"+name +" I want to make frieds with you")
  }
}
object Test{
  def main(args: Array[String]) {
    val p1=new Person("zhangwuji")
    val p2=new Person("zhangsanfeng")
    p1.makeFriends(p2)

  }
}

 

5、為實例對象混入trait

/**
 * // 有時我們可以在創建類的對象時，指定該對象混入某個trait，這樣，就只有這個對象混入該trait的方法，而類的其他對象則沒有
 */
trait Logged {
  def log(msg:String){}

}
trait AMyLogger extends Logged{
  override def log(msg:String): Unit ={
    println("test:"+msg)
  }
}
trait BMyLogger extends Logged{
  override def log(msg:String): Unit ={
    println("log:"+msg)
  }
}
class Person(val name:String) extends AMyLogger{
  def sayHello(): Unit ={
    println("Hi ,i'm name")
    log("sayHello is invoked!")
  }
}
object  Test{
  def main(args: Array[String]) {
    val p1=new Person("liudehua")
    p1.sayHello() 


    val p2=new Person("zhangxueyou") with BMyLogger
    p2.sayHello()
  }
}

 

6、trait調用鏈

/**
 * // Scala中支持讓類繼承多個trait后，依次調用多個trait中的同一個方法，只要讓多個trait的同一個方法中，在最后都執行super.方法 即可
// 類中調用多個trait中都有的這個方法時，首先會從最右邊的trait的方法開始執行，然后依次往左執行，形成一個調用鏈條
// 這種特性非常強大，其實就相當於設計模式中的責任鏈模式的一種具體實現依賴
 */
trait Handler {
  def handler(data:String){}
}
trait DataValidHandler extends Handler{
  override def handler(data:String): Unit ={
    println("check data:"+data)
    super.handler(data)
  }
}
trait SignatureValidHandler extends Handler{
  override def handler(data:String): Unit ={
    println("check signatrue:"+data)
    super.handler(data)
  }
}
class  Person(val name:String) extends SignatureValidHandler with DataValidHandler{
  def sayHello={
    println("Hello "+name)
    handler(name)
  }
}

object Test{
  def main(args: Array[String]) {
    val p=new Person("lixiaolong");
    p.sayHello
  }
}

 

模式匹配

Scala有一個十分強大的模式匹配機制，可以應用到很多場合：如switch語句、類型檢查等。

並且Scala還提供了樣例類，對模式匹配進行了優化，可以快速進行匹配

1、匹配字符串

import scala.util.Random

object CaseDemo01 extends App{
  val arr = Array("Hadoop", "HBase", "Spark")
  val name = arr(Random.nextInt(arr.length))
  name match {
    case "Hadoop" => println("哈肚普...")
    case "HBase" => println("H貝斯...")
    case _ => println("真不知道你們在說什么...")
  }
}
}

 

2、匹配類型

import scala.util.Random

object CaseDemo01 extends App{
  //val v = if(x >= 5) 1 else if(x < 2) 2.0 else "hello"
  val arr = Array("hello", 1, 2.0, CaseDemo01)
  val v = arr(Random.nextInt(4))
  println(v)
  v match {
    case x: Int => println("Int " + x)
    case y: Double if(y >= 0) => println("Double "+ y)
    case z: String => println("String " + z)
    case _ => throw new Exception("not match exception")
  }
}

注意：case y: Doubleif(y >= 0) => ...

模式匹配的時候還可以添加守衛條件。如不符合守衛條件，將掉入case _中

3、匹配數組、元組、集合

object CaseDemo03 extends App{

  val arr = Array(1, 3, 5)
  arr match {
    case Array(1, x, y) => println(x + " " + y)
    case Array(0) => println("only 0")
    case Array(0, _*) => println("0 ...")
    case _ => println("something else")
  }

  val lst = List(3, -1)
  lst match {
    case 0 :: Nil => println("only 0")
    case x :: y :: Nil => println(s"x: $x y: $y")
    case 0 :: tail => println("0 ...")
    case _ => println("something else")
  }

  val tup = (2, 3, 5)
  tup match {
    case (2, x, y) => println(s"1, $x , $y")
    case (_, z, 5) => println(z)
    case  _ => println("else")
  }
}

注意：在Scala中列表要么為空（Nil表示空列表）要么是一個head元素加上一個tail列表。

9 :: List(5, 2)  :: 操作符是將給定的頭和尾創建一個新的列表

注意：:: 操作符是右結合的，如9 :: 5 :: 2 :: Nil相當於 9 :: (5 :: (2 :: Nil))

4、樣例類

在Scala中樣例類是一中特殊的類，可用於模式匹配。case class是多例的，后面要跟構造參數，case object是單例的

import scala.util.Random

case class SubmitTask(id: String, name: String)
case class HeartBeat(time: Long)
case object CheckTimeOutTask


object CaseDemo04 extends App{
  val arr = Array(CheckTimeOutTask, HeartBeat(12333), SubmitTask("0001", "task-0001"))

  arr(Random.nextInt(arr.length)) match {
    case SubmitTask(id, name) => {
      println(s"$id, $name")
    }
    case HeartBeat(time) => {
      println(time)
    }
    case CheckTimeOutTask => {
      println("check")
    }
  }
}

 

總結 

本質上來講，class  case class用起來就是一樣的：

   最不一樣的一個東西：如果我們scala要做模式匹配，去匹配類型的話，建議使用

case case 因為scala的底層對它做了優化，匹配起來性能較好。

* 1:case class 自動生成伴生對象，自動實現了apply方法
 * 2:case class 用於做匹配，性能較好（scala的底層做過優化）
 * 3：case class 默認實現了序列化 Serializable
 * 4: case class 默認實現了toString equals等方法
 * 5：case class 主構造函數 里面沒有修飾符，默認的是val

偏函數

被包在花括號內沒有match的一組case語句是一個偏函數，它是PartialFunction[A, B]的一個實例，A代表參數類型，B代表返回類型，常用作輸入模式匹配

object PartialFuncDemo  {

  def func1: PartialFunction[String, Int] = {
    case "one" => 1
    case "two" => 2
    case _ => -1
  }

  def func2(num: String) : Int = num match {
    case "one" => 1
    case "two" => 2
    case _ => -1
  }

  def main(args: Array[String]) {
    println(func1("one"))
    println(func2("one"))
  }
}

 

總結：

偏函數就是用來做模式匹配的。