option类型（用来避免空指针的遇到一次处理一次的繁琐操作）
def divide(a:Int,b:Int):Option[int] = {
if(b == 0)
None
else
Some(a/b)
}
result1 = divide(10,0)
result1 match{
case Some(x) => println()
case None => println()
}偏函数（是一个PartialFunction类的对象）（被包在花括号内，没有match的case语句）
val pf: PartialFunction[Int,String] = {
case 1 => "一"
case 2 => "二"
case 3 => "三"
case _ => "未匹配"
}
println(pf(1)) val list1 = List(1,2,3,4,5,6,7,8,9,10)
val list2 = list1.map{
case x if x>=1 && x<=3 =>"[1-3]"
case x if x>=1 && x<=3 =>"[1-3]"
case _ =>"[8-*]"
}异常处理
提取器（一个类想要支持模式匹配，必须要实现一个提取器）
要实现一个提取器，只需要在该类的伴生对象中实现一个unapply方法即可
object Student{
def apply(name:String, age:Int) = new Student(name,age)
}
def unapply(s:Student):Option[String,Int] = {
if(s != null) {
Some(s.name,s.age)
}else{
None
}
}作为值的函数
val list1 = List(1,2,3,4,5,6,7,8,9,10)
val func = (x:Int) => "*" * x
val list2 = list1.map(func)匿名函数（没有赋值给变量的函数）
val list1 = List(1,2,3,4,5,6,7,8,9,10)
val list2 = list1.map((x:Int) => "*" * x)
val list3 = list1.map("*" * _)柯里化操作（将原先只接受多个参数的方法转化为多个只有一个参数的参数列表的方法）
def merge1(s1:String,s2:String):String = s1 + s2
def merge2(s1:String,s2:String)(f1:(String,String) => String):String = f1(s1, s2)
def main(args: Array[String]): Unit = {
val str1 = merge1("abc","xyz")
val str2 = merge1("abc","xyz")(_ + _)
val str3 = merge2("abc","xyz")(_.toUpperCase() + _)
}闭包（可以访问不在当前作用域范围数据的一个函数）（柯里化就是一个闭包）
控制抽象函数
隐式转换（用implicit关键字声明的带有单个参数的方法）（是指以implicit关键字声明的带有单个参数的方法。该方法是被自动调用的，用来实现自动将某种类型的数据转换为另一种类型的数据）
隐式参数（用implicit关键字修饰的变量）（如果方法的某个参数列表使用了implicit修饰，则该参数列表就是隐式参数）（好处，调用方法的时候隐式参数不需要给值）
（该关键字在2.10版本出现）
隐式转换手动导入
//定义RichFile类用来丰富File类的功能，
class RichFile(file:File){
def read() = Source.fromFile(file).mkString
}
//定义对象ImplicitDemo，该单例对象中有一个隐式转换方法
object ImplicitDemo{
implicit def file2RichFile(file:File) = new RichFile(file)
}
//隐式转换方法file2RichFile，是用来将File对象转换成RichFile对象
def main(args: Array[String]): Unit = {
import ImplicitDemo.file2RichFile
val file = new File("./data/w.txt")
println(file.read())
}
隐式转换自动导入（当对象调用类中不存在的方法或者成员时，编译器会自动对该对象进行隐式转换。当方法中的参数类型与目标类型不一致时，编译器也会自动调入隐式转换）
object demo2{
class RichFile(file:File){
def read() = Source.fromFile(file).mkString
}
def main(): Unit = {
//用来将普通的File->RichFile，当程序需要的时候会自动调用
implicit def file2RichFile(file:File) = new RichFile(file)
val file = new File("./1.txt")
println(file.read())
}
}
隐式参数手动导入（）
object demo1{
def show(name:String)(implicit delimit:(String,String)) = delimit._1 + name + delimit._2
object ImplicitParam{
implicit val delimit_default = ("<<<",">>>") //或者"<<<" -> ">>>"
}
def main(args: Array[String]): Unit = {
import implicit ImplicitParam delimit_default
println(show("张三"))
println(show("李斯")("((","))"))
}
}隐式参数自动导入（）
object demo1{
def show(name:String)(implicit delimit:(String,String)) = delimit._1 + name + delimit._2
def main(args: Array[String]): Unit = {
implicit val delimit_default = ("<<<",">>>") //或者"<<<" -> ">>>"
println(show("张三"))
println(show("李斯")("((","))"))
}
}泛型（泛型方法，泛型类，泛型特质）
object demo1{
def getMiddleEle[T](arr.Array[T]):T = arr(arr.length/2)
def main(args:Array[String]):Unit = {
println(getMiddleEle(Array(1,2,3,4,5)))
println(getMiddleEle(Array("a","b","c")))
}
}object demo1{
class Pair[T](var a:T,var b:T)
def main(args:Array[String]): Unit = {
val p1 = new Pair[Int](10,20)
}
}object demo1{
trait Logger[T] {
val a:T
def show(b:T)
}
object ConsoleLogger extends Logger[String]{
override val a:String = "LYF"
override def show(b:String): Unit = println(b)
}
}上下界
T <: Person（T是Person或者的Person的子类）
T >: Person
协变，逆变，非变
协变（类A与类B之间是父子类关系，Pair[A]和Pair[B]之间也是父子类关系）（class Pair[+T]）
逆变（类A与类B之间是父子类关系，Pair[A]和Pair[B]之间也是子父类关系）（class Pair[-T]）
非变（类A与类B之间是父子类关系，Pair[A]和Pair[B]之间没有任何关系）（class Pair[T]()）
集合简介