Scala入门03

• scala的trait接口以及继承

scala中的接口以及继承接口和父类，在scala中接口是trait（特征），用关键字extends，类似于java8里面的interface，在trait中可以定义实现的方法，也可以定义未实现的方法同java8一样

接口代码JieKou.scala：

package com.lijie

//trait表示定义一个接口
trait JieKou {

  //接口的方法
  def traitMethod01(id :Int)

  def traitMethod02(id:Int)={
    println("这个是在接口中实现的方法，实现类需要重写，或者直接使用")
  }
}

实现类代码 ImplClass：

package com.lijie

//实现接口
class ImplClass(id: Int) extends SupperClass(id: Int) with JieKou {

  private var name: String = _

  def this(id: Int, name: String) {
    this(id)
    this.name = name
  }

  def traitMethod01(id: Int): Unit = {
    println("id为:" + id)
  }

  //接口以及实现的方法，实现类需要重写它，必须加上override
  override def traitMethod02(id: Int) = {
    println("接口以及实现的方法，实现类需要重写它，必须加上override,id为：" + id)
  }
}

//伴生对象
object ImplClass {
  def main(args: Array[String]): Unit = {
    val a = new ImplClass(1)
    a.traitMethod01(123)
    a.traitMethod02(123)
  }
}

父类代码SupperClass.scala：

package com.lijie

class SupperClass(var id: Int) {

}

• scala的模式匹配：

类似于java中的case，代码如下：

package com.lijie.test01

import scala.collection.immutable.Map

//样例类
case class CaseClass01(id: Int)
case class CaseClass02(name: String)
//单例的
case object CaseObject

//scala.MatchError如果没有默认的_ 没匹配到会抛异常
class CaseClass {
  //1.定义一个匹配方法,匹配内容
  def matchMethod01(str: String) = {
    str match {
      case "hello" => println("hello  01")
      case "world" => println("world 02")

      //相当于java中的default
      case _       => println("hello world")
    }
  }
  //2.匹配类型
  def matchMethod02(any: Any) = {
    any match {
      case a: Int    => println("Int," + a)
      case b: Double => println("Double," + b)
      case c: Short  => println("Short," + c)
      case d: String => print("String," + d)
      case _         => println("other")
    }
  }

  //3.arr内容匹配
  def matchMethod03(any: Any) = {
    any match {
      case Array(1, 2, 3)    => println("1,2,3")
      case Array(1, 2, 3, 4) => println("1,2,3,4")
      case Array(0, 1, 2, 3) => println("0,1,2,3")
      case Array(1, a, b)    => println("1," + a + "," + b)
      case Array(2, _*)      => println("2,*")
      case _                 => println("other")
    }
  }

  //4.list匹配
  def matchMethod04(any: Any) = {

    //第一个表示list.head
    //最后一个表示list.tail
    any match {
      case 0 :: Nil                => println("0")
      case 0 :: 1 :: Nil           => println("0,1")
      case 0 :: a                  => println(s"0,$a")
      case a :: b :: c :: d :: Nil => println(s"$a,$b,$c,$d")
      case _                       => println("other")
    }
  }

  //5.元祖匹配
  def matchMethod05(any: Any) = {
    any match {
      case (1, 2, 3) => println("1,2,3")
      case (_, 3, 3) => println("1,2,3")
      case _         => println("other")
    }
  }

  //6.class匹配（样例类）
  def matchMethod06(any: Any) {
    any match {
      case CaseClass01(id)   => println(s"CaseClass01($id)")
      case CaseClass02(name) => println(s"CaseClass02($name)")
      case CaseObject        => println("CaseObject")
      case _                 => println("other")
    }
  }

  //7.Option类型
  def matchMethod07(any: Any) {
    any match {
      case Some(a) => a
      case None    => 0
      case _       => throw new RuntimeException("错误")
    }
  }

  //8.偏函数 第一个String表示入参 第二个表示出参
  def matchMethod08: PartialFunction[String, String] = {
    case "hello" => {
      println("hello case")
      "hello case"
    }
    case "word" => "word case"
    case _      => "other"
  }
}

//伴生对象
object CaseClass {
  def main(args: Array[String]): Unit = {
    //内容匹配
    val c = new CaseClass
    c.matchMethod01("hello1")

    //类型匹配
    c.matchMethod02(1.1)

    //arr内容匹配
    c.matchMethod03(Array(2, 2, 2, 3))

    //list匹配
    c.matchMethod04(List(1, 2, 3, 4))

    //元祖匹配
    c.matchMethod05((1, 2, 3))

    //样例类匹配 可以用new 也可以不new
    c.matchMethod06(CaseClass01(1))

    //option匹配 这里和 .getOrElse("c",0)
    c.matchMethod07(Map("a" -> 1, "b" -> 2).get("b"))

    //偏函数匹配
    c.matchMethod08("hello")
  }
}