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 =
  //用var修饰的变量既有getter又有setter
  var name = "huangbo"
  //类私有字段,只能在类的内部使用
  var age =
  //对象私有字段,访问权限更加严格的，ClassDemo类的方法只能访问到当前对象的字段
  private[this] val address = "三里屯"
}

2、构造器

注意：主构造器会执行类定义中的所有语句

/**
  *每个类都有主构造器，主构造器的参数直接放置类名后面，与类交织在一起
  */
class Person(val name:String,val age:Int) {
  //主构造器会执行类定义中的所有语句
  println("Hello Spark")

  val x =
  if(x > ){
    println("")
  }else if(x < ){
    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",,"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 =
  val sessions = new ArrayBuffer[Session]()
  while (counts > ){
    sessions += new Session
    counts -=
  }
  //在object中的方法相当于java中的静态方法
  def getSession(): Session ={
    sessions.remove()
  }

}

总结：

1）object里面的方法都是静态方法

2）Object里面的字段都是静态字段

3）它本身就是一个单例，(因为不需要去new)

伴生对象

在同一个文件中，在Scala的类中，与类名相同的对象叫做伴生对象，类和伴生对象之间可以相互访问私有的方法和属性

class Dog {
  val id =
  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(,,,,)
    println(array.toBuffer)
    //new了一个长度为9的数组，数组里面包含了9个null
    var arr = new Array()
    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 =
  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 =
  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=
}
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", , 2.0, CaseDemo01)
  val v = arr(Random.nextInt())
  println(v)
  v match {
    case x: Int => println("Int " + x)
    case y: Double if(y >= ) => 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(, , )
  arr match {
    case Array(, x, y) => println(x + " " + y)
    case Array() => println("only 0")
    case Array(, _*) => println("0 ...")
    case _ => println("something else")
  }

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

  val tup = (, , )
  tup match {
    case (, x, y) => println(s"1, $x , $y")
    case (_, z, ) => 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(), SubmitTask("", "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" =>
    case "two" =>
    case _ => -
  }

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

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

总结：

偏函数就是用来做模式匹配的。