Scala学习教程笔记三之函数式编程、集合操作、模式匹配、类型参数、隐式转换、Actor、

1：Scala和Java的对比:

1.1:Scala中的函数是Java中完全没有的概念。因为Java是完全面向对象的编程语言，没有任何面向过程编程语言的特性，因此Java中的一等公民是类和对象，而且只有方法的概念，即寄存和依赖于类与对象中的方法。Java中的方法是绝对不可能脱离类和对象独立存在的。
1.2:Scala是一门既面向对象，又面向过程的语言。因此在Scala中有非常好的面向对象的特性，可以使用Scala来基于面向对象的思想开发大型复杂的系统和工程，而且Scala也面向过程，因此Scala中有函数的概念。在Scala中，函数和类，对象等一样，都是一等公民。Scala中的函数可以独立存在，不需要依赖于任何类与对象。
1.3:Scala的函数式编程，就是Scala面向过程的最好的佐证。也正是因为函数式编程，才让Scala具备了Java所不具备对的更强大的功能和特性。
    而之所以Scala一直没有替换Java，是因为Scala之前一直没有开发过太多知名的应用。而Java则不一样。最重要的一点在于，Java现在不只是一门编程语言，还是一个庞大的，涵盖了软件开发，甚至云计算，大数据的技术生态。其中重要框架和系统包含Spring,lucene,Hadoop,Activiti等等。

2:Scala之函数式编程:

2.1:将函数赋值给变量:
    Scala中的函数是一等公民，可以独立定义，独立存在，而且可以直接将函数作为值赋值给变量，必须在函数后面加上空格和下划线:
    class Person{

      def hello(name : String) = {
        println("hi," + name)
      }
      //将函数赋值给变量的语法,函数命令 _(1、函数名称，2、空格，3、下划线)
      val sayHello = hello _;
      sayHello("张三");
    }
    //定义一个Object来测试
    object Object {

      def main(args: Array[String]): Unit = {
        val p1 = new Person;
        p1.sayHello
      }
    }
2.2:匿名函数:
    Scala中，函数也可以不需要命名，此时函数被称为匿名函数。可以直接定义函数之后，将函数赋值给某个变量，也可以将直接定义的匿名函数传入其他函数之中。Scala定义匿名函数的语法规则就是:(参数名称:参数类型) => 函数体;这种语法必须掌握和深刻理解。
    class Person{

      val sayHello = (name : String) => println("hi,"+ name);
    }
    //定义一个Object来测试
    object Object {

      def main(args: Array[String]): Unit = {
        val p1 = new Person;
        p1.sayHello("张三");
      }
    }
2.3:高阶函数:
    Scala中，由于函数是一等公民，因此可以直接将某个函数传入其他函数，作为参数。这个功能是及其强大的，也是Java这种面向对象的编程语言所不具备的。
    接受其他函数作为参数的函数，也被称作为高阶函数(higher-order function),高阶函数的另一个功能就是将函数作为返回值:
    class Person{

      val sayHello = (name : String) => println("hi,"+ name);
      //def 函数名称(函数名称:(函数类型) => 函数返回值,参数1 :参数类型......)
      def greeting(hello:(String) => Unit, name: String): Unit ={
        hello(name);
      }
    }
    //定义一个Object来测试        
    object Object {

      def main(args: Array[String]): Unit = {
        val p1 = new Person;
        p1.greeting(p1.sayHello, "李思思");
      }
    }
    //高阶函数的另一个功能就是将函数作为返回值:
    class Person{
      //高阶函数的另一个功能就是将函数作为返回值:
      def getGreetingFunc(msg : String) = (name : String) => println(msg +", " + name);
      val greetingFunc = getGreetingFunc("hello");
      greetingFunc("张三三");
    }
    //定义一个Object来测试
    object Object {

      def main(args: Array[String]): Unit = {
        val p1 = new Person;
        p1.greetingFunc;
        println(Array(1,2,3,4,5).map((num : Int) => num * num).toBuffer)
      }
    }
2.4:高阶函数的类型推断:
    高阶函数可以自动推断出参数类型，而不需要写明类型，而且对于只有一个参数的函数，还可以省去其小括号。如果仅有一个参数在右侧的函数体内只使用一次，则还可以将接受参数省略，并且将参数用_来替代。
    class Person{

      //func函数名称作为参数一。name是参数二
      def greeting(func:(String) => Unit,name : String) {
        func(name)
      }
      //匿名函数
      greeting((name : String) => println("hello," + name) ,"张三");
      //高阶函数可以自动推断出参数类型，而不需要写明类型。如这里没有写name的String类型。
      greeting((name) => println("hello, "+ name) ,"李思思");
      //而且对于只有一个参数的函数，还可以省去其小括号。
      greeting(name => println("hello," + name) ,"王五五");

      //如果仅有一个参数在右侧的函数体内只使用一次，则还可以将接受参数省略，并且将参数用_来替代。
      def triple(func:(Int) =>Int) ={
        func(3)
      }

    }
    //定义一个Object来测试
    object Object {

      def main(args: Array[String]): Unit = {
        val p1 = new Person;
        println(p1.triple(10 * _))
      }
    }
2.5:Scala的常用的高阶函数:
    a、map,对传入的每个元素都进行映射，返回一个处理后的元素:
        println(Array(1,2,3,4,5).map(2 * _).toBuffer);
    b、foreach,对传入的每个元素都进行处理，但是没有返回值:
        (1 to 9).map("*" * _).foreach(println _);
    c、filter,对传入的每个元素都进行条件判断，如果对元素返回true,则保留该元素，否则过滤掉该元素:
        val a = (1 to 20).filter(_ % 2 ==0);
        println(a)
    d、reduceLeft，从左侧元素开始，进行reduce操作，即先对元素1和元素2进行处理，然后将结果与元素3处理，再将结果与元素4处理，依次类推，即为reduce：
        var a = (1 to 9).reduceLeft(_ * _);
        //此操作相当于1*2*3*4*5*6*7*8*9
        println(a)
    e、sortWith,对元素进行两两相比，进行排序:
        var arr = Array(3,2,4,1,5,7).sortWith(_ < _);
        println(arr.toBuffer)
2.6:闭包:
    a、在Java中，不支持直接将函数传入一个方法作为参数，通常来说，唯一的方法就是定义一个实现了某个接口的类的实例对象，该对象只有一个方法。而这些接口都只有单个的抽象方法，也就是single abstract method，简称为SAM;
    b、由于Scala是可以调用Java的代码的，因此当我们调用Java的某个方法的时候，可能就不得不创建SAM传递给方法，非常麻烦。但是Scala又是直接传递函数的。此时就可以使用Scala提供的，在调用Java方法的时候，使用的功能。SAM转换，即将SAM转换为Scala函数。(注意:要使用SAM转换为，需要使用Scala提供的特性，隐式转换):
    c、闭包，最简洁的解释就是函数在变量不处于其有效作用域的时候，还能够对变量进行访问，即为闭包;
        class Person{

          def getGreetingFunc(msg : String) = (name : String) => println(msg + "," + name);
          //两次调用getGreetingFunc函数，传入不同的msg,并创建不同的函数返回.
          //然而，msg只是一个局部变量，却在getGreetingFunc执行完以后，还可以继承存在创建的函数之中。
          //greetingFuncHello("张三"),调用的时候，值为"hello"的msg被保留在了函数体内部，可以反复的使用。
          //这种变量超出了其作用域，还可以使用的情况，即为闭包。

          val greetingFuncHello = getGreetingFunc("hello");
          val greetingFuncHi = getGreetingFunc("hi");
          //Scala通过为每个函数创建对象来实现闭包，实际上对于getGreetingFunc函数创建的函数。msg是作为函数对象的变量存在的。因此每个函数才可以拥有不同的msg
          //Scala编译器会确保上述闭包机制。

        }
        //定义一个Object来测试
        object Object {

          def main(args: Array[String]): Unit = {
            val p1 = new Person;
            p1.greetingFuncHello("张三三");
            p1.greetingFuncHi("李思思");
          }
        }
2.7:SAM转换(Scala函数和Java的类转换):
　　a、在Java中，不支持直接将函数传入一个方法作为参数，通常来说，唯一的方法就是定义一个实现了某个接口的类的实例对象，该对象只有一个方法。而这些接口都只有单个的抽象方法，也就是single abstract method，简称为SAM;
    b、由于Scala是可以调用Java的代码的，因此当我们调用Java的某个方法的时候，可能就不得不创建SAM传递给方法，非常麻烦。但是Scala又是直接传递函数的。此时就可以使用Scala提供的，在调用Java方法的时候，使用的功能。SAM转换，即将SAM转换为Scala函数。(注意:要使用SAM转换为，需要使用Scala提供的特性，隐式转换): 
2.8:Currying函数:
　　Currying函数指的是，将原来接受两个参数的一个函数，转换为两个函数，第一个函数接受原先的第一个参数，然后返回接受原先第二个参数的第二个函数。在函数调用的过程中，就变为了两个函数连续调用的形式:
    class Person{

      def sum(a: Int ,b : Int) = a + b;
      def sum2(a : Int) = (b : Int) => a+b;
      def sum3(a : Int)(b : Int) = a + b;
    }
    //定义一个Object来测试
    object Object {

      def main(args: Array[String]): Unit = {
        val p = new Person;
        println(p.sum(1,4));
        println(p.sum2(2)(2));
        println(p.sum3(3)(3));
      }
    }
2.9:return:
　　Scala中，不需要使用return来返回函数的值，函数最后一行语句的值，就是函数的返回值。在Scala中，return用于在匿名函数中返回值给包含匿名函数的带名函数，并作为带名函数的返回值。使用return的匿名函数，是必须给出返回类型的，否则无法通过编译。
    class Person{

      def greeting(name : String) ={
        def hello(name : String): String ={
           return "hello," + name;
        }
        hello(name);
      }
    }        
    //定义一个Object来测试    
    object Object {

      def main(args: Array[String]): Unit = {
        val p = new Person;
        println(p.greeting("李思思"));
      }
    }

3：Scala函数式编程之集合操作：

3.1:Scala的集合体系结构:
    Scala中的集合体系主要包括:Iterable，Seq，Set，Map。其中，Iterable是所有集合trait的跟trait。这个结构与Java的集合体系非常相似。
    Scala中的集合是分成可变和不可变的两类集合的，其中可变集合就是说，集合的元素可以动态修改。而不可变集合的元素在初始化之后，就无法修改了。分别对应scala.collection.mutable和scala.collection.immutable两个包。
    Scala中的Seq下包含了Range，ArrayBuffer，List等子trait。其中Range就代表了一个序列，通常可以使用"1 to 10"这种语法来产生一个Range。ArrayBuffer就类似于Java中的ArrayList。
    Scala的集合类的map,flatMap,reduce,reduceLeft,foreach,等这些函数就是高阶函数。可以接受其他函数作为参数。
3.2:List:
    List代表一个不可变的列表，List的创建，val list = new List(,,,);List有head和tail，head代表List的第一个元素，tail代表第一个元素以后的所有元素。list.head，list.tail;
    List有特殊的::操作符，可以用于将head和tail合并成一个List,::list;

3.3:LinkedList:
    LinkedList代表一个可变的列表，使用elem可以引用其头部，使用next可以引用其尾部。
    val l = mutable.LinkedList(,,,,,,);
    println(l.elem + " " + l.next);
3.4:Set:
    Set代表一个没有重复元素的集合。将重复元素加入Set是没有用的。而且Set是不保证插入顺序的，也就是说，Set中的元素是乱序的。LinkedHashSet会用一个链表来维护插入顺序。SortedSet会自动根据key来进行排序的。

3.5:集合的函数式编程:
    a、map案例，为List中每个元素都添加一个前缀:
        val list = List("张三","李思思","王五五").map("name is :" + _);
        println(list.toBuffer)
    b、faltMap案例，将List中的多行句子拆分成单词:
        val list = List("hello world , i am bie xiansheng").flatMap(_.split(" "));
        println(list.toBuffer)
    c、foreach案例，打印List中的每个单词:
        List("hello world , i am bie xiansheng").foreach(println(_));
    d、zip案例，对学生姓名和学生成绩进行关联:
        val list = List("张三三","李思思","王五五","赵六六").zip(List("","","",""));
        println(list)

4：Scala之模式匹配(mathch case语法，即为模式匹配):

模式匹配是Scala中非常有特色的，非常强大的一种功能。模式匹配，其实类似于Java中的swich case语法，即对一个值进行条件判断，然后针对某种条件，即针对不同的处理。但是Scala的模式匹配功能比Java的swich case语法的功能强大的多，Java的swich case语法只能对值进行匹配。但是Scala的模式匹配除了可以对值进行匹配之外，还可以对类型进行匹配，对Array和List的元素情况进行匹配，对case class进行匹配，甚至对有值或者没值进行匹配。

4.1:模式匹配的基础语法:
    a、mathch case的语法如下所示:变量 mathch {case 值 => 语法}。如果值为下划线，则代表了不满足以上所有情况下的默认情况如何处理。此外，match case中，主要一个case分支满足并处理了，就不会继续判断下一个case的分支了。(区别Java的break;)
    object Object {

      def main(args: Array[String]): Unit = {
        def judgeGeade(grade : String): Unit ={
          grade match {
            case "A" => println("A");
            case "B" => println("B");
            case "C" => println("C");
            case "D" => println("D");
            case _   => println("没有默认匹配的")
          }
        }
        judgeGeade("A");
        judgeGeade("E");
      }
    }
    b、模式匹配中使用if守卫:
        Scala的模式匹配语法，有一个特点在于，可以在case后的条件判断中，不仅仅只是提供一个值，而是可以在值的后面再加一个if守卫，进行双重过滤:
    object Object {

      def main(args: Array[String]): Unit = {
        def judgeGeade(name : String ,grade : String): Unit ={
          grade match {
            case "A" => println(name + "A");
            case "B" => println(name +" B");
            case "C" => println(name +" C");
            case "D" => println(name +" D");
            case _ if name == "张三三" => println(name + ",you are luck boy!");
            case _   => println("没有默认匹配的")
          }
        }
        judgeGeade("张三三","A");
      }
    }
    c、在模式匹配中进行变量赋值:
        Scala的模式匹配语法中，有一个特点在于，可以将模式匹配的默认情况，下划线，替换为一个变量名，此时模式匹配语法就会将要匹配的值赋值给这个变量，从而可以在后面的处理语句中使用要匹配的值:
        优点:可以显示出_grade的值;
    object Object {

      def main(args: Array[String]): Unit = {
        def judgeGeade(name : String ,grade : String): Unit ={
          grade match {
            case "A" => println(name + "A");
            case "B" => println(name +" B");
            case "C" => println(name +" C");
            case "D" => println(name +" D");
            case _grade if name == "张三三" => println(name + ",you are luck boy!" + _grade);
            case _   => println("没有默认匹配的")
          }
        }
        judgeGeade("张三三","E");
      }
    }
4.2:对类型进行模式匹配:
    Scala的模式匹配一个强大之处就在于，可以直接匹配类型，而不是值。
    object Object {

      def main(args: Array[String]): Unit = {
        def processException(e : Exception): Unit ={
          e match {
            case e1 : IllegalArgumentException => println("IllegalArgumentException" + e1);
            case e2 : FileNotFoundException => println("FileNotFoundException" + e2);
            case e3 : IndexOutOfBoundsException => println("IndexOutOfBoundsException" + e3);
            case _ : Exception => println("Exception");
          }
        }
        processException(new IllegalArgumentException());
      }
    }
4.3:对Array和List的元素进行模式匹配:
    对Array进行模式匹配，分别可以匹配带有指定元素的数组，带有指定个数元素的数组，以某元素打头的数组。
    对List进行模式匹配，与Array类似，但是需要使用List特有的::操作符;
    object Object {

      def main(args: Array[String]): Unit = {
        def greeting(arr : Array[String]): Unit ={
          arr match {
            case Array("张三三") => println("hi,张三三");
            case Array(a,b,c,d) => println("hi," + a +" ,"+ b + ", " + c + " ,"+ d);
            case Array("李思思",_*) => println("hi,李思思");
            case _ => println("hi，how are you.")
          }
        }
        greeting(Array("张三三","李思思","王五五","a","b","c","d"));
        greeting(Array("李思思"));
        greeting(Array("a","b","c","d"));
      }
    }
    //使用List来进行模式匹配;
    object Object {

      def main(args: Array[String]): Unit = {
        def greeting(list : List[String]): Unit ={
          list match {
            case "张三三" :: Nil => println("hi,张三三");
            case a :: b :: c :: d => println("hi,"+ a +" ,"+ b + ", " + c + " ,"+ d);
            case "李思思" :: tail => println("hi,李思思");
            case _ => println("hi,how are you.")
          }
        }
        greeting(List("张三三"));
        greeting(List("李思思"));
        greeting(List("王五五"));

      }
    }
4.4:case class与模式匹配:
    Scala中提供了一种特殊的类，用case class进行声明，中文也可以称做样例类。case class其实有点类似于Java中的JavaBean的概念。即只定义field，并且由Scala编译时自动提供getter和setter方法，但是没有method。case calss的主构造函数接受的参数通常不需要使用var或者val修饰，scala自动就会使用val修饰，但是如果你自己使用var修饰，name还是会按照var来。Scala自动为case class定义了伴生对象，也就是Obeject，并且定义了apply()方法，该方法接受主构造函数中相同的参数，并且返回case class对象。
    case class Student(name : String,classroom : String) extends Person{

    }
    case class Teacher(name : String,subject : String) extends  Person {

    }
    class Person{

      def judge(p : Person): Unit ={
        p match {
          case Teacher(name,subject) => println("teacher ,name is: "+ name +",subject is :" +subject)
          case Student(name,classroom) => println("student，name is: " + name +", classroot is :" + classroom);
          case _ => println("illegal access,please go out of the school")
        }
      }
    }
    //定义一个Object
    object Object {

      def main(args: Array[String]): Unit = {
        val zhangsan : Person = Teacher("张三三","语文");
        val lisisi : Person = Teacher("李思思","数学");

        val wangwu : Person = Student("王五五","一年级");
        val person = new Person;
        person.judge(zhangsan);
        person.judge(lisisi);
        person.judge(wangwu);
      }
    }

4.5:Option与模式匹配:
    Scala有一种特殊的类型，叫做Option。Option有两种值，一种是Some，表示有值，一种是None，表示没有值。Option通常会用于模式匹配中，用于判断某个变量是有值还是没有值，这比null来的更加简明。
    class Person{

      val grades = Map("张三三" -> "A" ,"李思思" -> "B","王五五" -> "C");
      def getGrade(name :String): Unit ={
        val grade = grades.get(name);
        grade match {
          case Some(grade) => println("you grade is : " + grade);
          case None => println("sorry，you grade is null")
        }
      }
    }
    //定义一个Object
    object Object {

      def main(args: Array[String]): Unit = {
        val p = new Person;
        p.getGrade("张三三");
        p.getGrade("李思思");
        p.getGrade("王五五");
        p.getGrade("赵六六");
      }
    }

5：Scala中的类型参数：

其实就是类似于Java中的泛型。也是定义一种类型参数，比如在集合，在类，在函数中，定义类型参数，然后就可以保证使用到该类型参数的地方，就肯定，也只能是这种类型。从而实现程序更好的健壮性。

5.1:泛型类:
    顾名思义，其实就是在类的声明中，定义一些泛型类型，然后在类内部，比如field或者method，就可以使用这些泛型类型。使用泛型类，通常是需要对类中的某些成员，比如某些field或者method中的参数或者变量，进行统一的类型限制，这样可以保证程序更好的健壮性和稳定性。如果不使用泛型进行统一的类型限制，那么在后期程序运行过程中，难免出现问题，比如传入了不希望的类型，导致程序出现问题。在使用类的时候，比如创建类的对象，将类型参数替换为实际的类型，即可。或者直接给使用了泛型类型的field赋值时候，Scala会自动进行类型推断。
    class Person[T](val id : T){

      def getMessage(name : T) ={
        println("id:" + id + ",name:" + name);
      }
    }
    //定义一个Object进行测试
    object Object {

      def main(args: Array[String]): Unit = {
        val p = new Person[String]("");
        p.getMessage("张三三");
      }
    }
5.2:泛型函数:
    泛型函数，与泛型类类似，可以给某个函数在声明的时候指定泛型类型，然后再函数体内，多个变量或者返回值之间，就可以使用泛型类型进行声明，从而对某个特殊的变量，或者多个变量，进行强制性的类型限制。于泛型类一样，你可以通过给使用了泛型类型的变量传递值来让Scala自动推断泛型的实际类型，也可以在调用函数时候，手动指定泛型类型。
    class Person{

      def getCard[T](content : T)={
        if(content.isInstanceOf[Int]){
          println("card：001：" + content );
        }else if(content.isInstanceOf[String]){
          println("card：002：" + content);
        }else{
          println("card：003：" + content)
        }
      }
    }
    //定义一个Object进行测试
    object Object {

      def main(args: Array[String]): Unit = {
        val p = new Person();
        p.getCard("张三三");
        p.getCard()
        p.getCard(true)
      }
    }
5.3:上边界Bounds:
    在指定泛型类型的时候，有时候，我们需要对泛型类型的范围进行界定，而不是可以是任意的。比如，我们可能要求某个泛型类型，它就必须是某个类的子类，这样在程序中就可以放心的调用泛型类型继承的父类的方法，程序才能正常的使用和运行。此时就可以使用上下边界Bounds的特性。Scala的上下边界特性允许泛型类型必须是某个类的子类，或者必须是某个类的父类。
    class Person(val name : String){

      def hello = println("hi.i am " + name);
      def makeFriends(p : Person): Unit ={
        hello;
        p.hello
      }
    }
    //定义一个Student继承Person
    class Student(name : String) extends Person(name){

    }
    //定义一个类Party使用上边界
    class Party[T <: Person](p1 : T,p2 : T) {

      //def play = p1.makeFriends(p2);
      def play(): Unit ={
        p1.makeFriends(p2);
      }
    }
    //定义一个Object进行测试
    object Object {

      def main(args: Array[String]): Unit = {
        val s1 = new Student("张三三");
        val s2 = new Student("李思思");

        val p = new Party[Person](s1,s2);
        p.play()
      }
    }
5.4:下边界Bounds:
    除了指定泛型类型的上边界，还可以指定下边界，即指定泛型类型必须是某个类的父类;
    class Father(val name : String) {

    }
    class Child(name : String) extends Father(name){

    }
    //定义一个Object进行测试
    object Object {

      def getIdCard[R >: Child](person : R): Unit ={
        if(person.getClass == classOf[Child]){
          println("请告诉我你爸爸的姓名!")
        }else if(person.getClass == classOf[Father]){
          println("请拿走你孩子的身份证!")
        }else{
          println("你开心就好!")
        }
      }
      def main(args: Array[String]): Unit = {
        val c = new Child("张三三");
        getIdCard(c);
        val f = new Father("李思思");
        getIdCard(f)
      }
    }
5.5:View Bounds:
    上下边界Bounds，虽然可以让一种泛型类型，支持有父子关系的多种类型。但是，在某个类与上下边界Bounds指定的父子类型范围内的类都没有任何关系，则默认是肯定不能接受的。然而，View Bounds作为一种上下边界Bounds的加强版，支持可以对类型进行隐式转换，将指定的类型进行隐式转换后，再判断是否在边界指定的类型范围内:
    class Person(val name : String) {

    }
    class Dog(val name : String) {

      def hello(): Unit ={
        println("汪汪汪汪，i am " + name)
      }
    }
    class Patty[T <% Person](p1 :T,p2 : T) {

      def show(): Unit ={
        println("View Bounds的练习学习")
      }
    }    
    //定义一个Object进行测试
    object Object {

      implicit def dog2Person(dog : Object) : Person ={
        if(dog.isInstanceOf[Dog]){
          val _dog = dog.asInstanceOf[Dog];
          new Person(_dog.name);
        }else{
          null;
        }
      }

      def main(args: Array[String]): Unit = {
        val person = new Person("张三三");
        val dog = new Dog("小旺旺");

        val party = new Patty[Person](person,dog);
        party.show()
      }
    }
5.6:Context Bounds:
    是一种特殊的Bounds,它会根据泛型类型的声明，比如"T : 类型"要求必须存在一个类型为"类型[T]"的隐式值。其实，Context Bounds之所以叫Context，是因为它基于的是一种全局的上下文，需要使用到上下文中的隐式值以及注入。
   
5.7:Manifest Context Bounds:
    在Scala中，如果要实例化一个泛型数组，就必须使用Manifest Context Bounds。也就是说，如果数组元素类型为T的话或者函数定义[T :Manifest]泛型类型，这样才能实例化Array[T]这种泛型数组;
    class Meat(val name : String) {

    }
    class Vegetable(val name : String) {

    }    
    //定义一个Object进行测试
    object Object {

      def foodPackage[T : Manifest](food : T*) ={
        val foodPackage = new Array[T](food.length);
        for(i <- 0 until(food.length)){
          foodPackage(i) = food(i);
        }
        foodPackage;
      }
      def main(args: Array[String]): Unit = {
        val m1 = new Meat("大肉");
        val v1 = new Vegetable("胡萝卜");

        println(foodPackage(m1,v1).toBuffer);
      }
    }
5.8:协变和逆变:
    Scala中的协变和逆变是非常有特色的，解决了Java中的泛型的一大缺憾。比如，Java中，如果有Professional是Master的子类，那么Card[Professional]是不是Card[Master]的子类呢，答案是，肯定不是啊。因此对于发开程序造成了很多的麻烦。而Scala中，只要灵活使用了协变和逆变，就可以解决Java中泛型的问题。
    class Master {

    }
    class Professional extends Master{

    }
    class Card[+T](val name : String) {
      //+是协变
      def enterMeet(card : Card[Master]): Unit ={
        println("欢迎大师以及大师级别以下的来到会场")
      }
    }
    class Card2[-T](val name : String){

      def enterMeet2(card : Card2[Professional]): Unit ={
        println("只有专家级别的才可以进入此会场，如果是大师级别的当然更可以了")
      }
    }
    //定义一个Object进行测试
    object Object {

      def main(args: Array[String]): Unit = {
        val p = new Card[Professional]("张三三专家");
        val m = new Card[Master]("李思思大师");
        p.enterMeet(m);
        m.enterMeet(p);

        val p2 = new Card2[Professional]("张三三专家");
        val m2 = new Card2[Master]("李思思大师");
        p2.enterMeet2(p2);
        p2.enterMeet2(m2);
        m2.enterMeet2(p2);
        m2.enterMeet2(m2);
      }
    }
5.9:Existential Type:
　　在Scala里面，有一种特殊的类型参数，就是    Existential Type，即存在性类型。
    Array[T] forSome{type T}
    Array[_]

6：Scala之隐式转换与隐式参数：

　　允许手动指定，将某种类型的对象转换成其他类型的对象。最核心的就是定义隐式转换函数，即implicit conversion function。定义的隐式转换函数，只要在编写的程序内引入，就会被Scala自动使用。Scala会根据隐式转换函数的签名，在程序中使用隐式转换函数接受的参数类型定义的对象时，会自动将其传入隐式转换函数，转换为另外一种类型的对象并且返回。这就是"隐式转换";隐式转换函数的名字随便起，因为通常不会由用户手动调用，而是Scala进行调用的。但是如果要使用隐式转换，则需要对隐式转换函数进行导入。因此通常建议将隐式转换函数的名称命名为"one2one"的形式。

6.1:隐式转换:
    实现隐式转换，只要在程序可见的范围内定义隐式转换函数即可。Scala会自动使用隐式转换函数。隐式转换函数与普通函数唯一的语法区别就是，要以implicit开头，而且一定要定义函数返回类型。
    class Student(val name : String) {

    }
    class Older(val name : String) {

    }
    class SpecialPerson(val name : String) {

      var ticketNum = ;
      def buySpecialTicket(p : SpecialPerson): Unit ={
        ticketNum += ;
        println("票数:" + ticketNum);
      }
    }
    //定义一个Object来测试
    object Object {

      implicit def object2SpecialPerson(obj : Object) : SpecialPerson = {
        if(obj.getClass == classOf[Student]){
          val s = obj.asInstanceOf[Student];
          new SpecialPerson(s.name);
        }else if(obj.getClass == classOf[Older]){
          val older = obj.asInstanceOf[Older];
          new SpecialPerson(older.name);
        }else{
          null;
        }
      }

      def main(args: Array[String]): Unit = {
        val s = new Student("张三三");
        val o = new Older("李思思");
        val specialPerson = new SpecialPerson("王五五");

        specialPerson.buySpecialTicket(s);
        specialPerson.buySpecialTicket(o);
        specialPerson.buySpecialTicket(specialPerson);
      }
    }
6.2:使用隐式转换加强现有类型:
    隐式转换非常强大的一个功能，就是可以在不知不觉中加强现有类型的功能。也就是说，可以为，某个类定义一个加强版的类，并定义互相之间的隐式转换，从而让源类在使用加强版的方法时，由Scala自动进行隐式转换为加强肋，然后再调用该方法。
    class Man(val name : String) {

    }
    class SuperMan(val name : String) {

      def emitLaser = println(name + " ，变身超人");
    }
    //定义一个Object来测试
    object Object {

      implicit def man2SuperMan(man : Man):SuperMan = new SuperMan(man.name);

      def main(args: Array[String]): Unit = {
        val man = new Man("张三三");
        man.emitLaser;
      }
    }
6.3:导入隐式转换函数(隐式转换函数作用域与导入):
    Scala默认会使用两种隐式转换，一种是源类型，或者目标类型的伴生对象内的隐式转换函数；一种是当前程序作用域内的可以用唯一标识标识的隐式转换函数。如果隐式转换函数不在上述两种情况下的话，那么就必须手动使用import语法引入某个包下的隐式转换函数，比如import test._。通常建议，仅仅在需要进行隐式转换的地方，比如某个函数或者非法内，用import导入隐式转换函数，这样可以缩小隐式转换函数的作用域，避免不需要的隐式转换。

6.4:隐式转换的发生时机:
    a、调用某个函数，但是给函数传入的参数的类型，与函数定义的接受参数类型不匹配。
    b、使用某个类型的对象，调用某个方法，而这个方法并不存在与该类型中。
    c、使用某个类型的对象，调用某个方法，虽然该类型有这个方法，但是给方法传入的参数类型，与方法定义的接受参数的类型不匹配。
6.5:隐式参数:
    所谓的隐式参数，指的是在函数或者方法中，定义一个用implicit修饰的参数，此时Scala会尝试找到一个指定类型的，用implicit修饰的对象，即隐式值，并注入参数。Scala会在两个范围内查找，一种是当前作用域内可见的val或者var定义的隐式变量。一种是隐式参数类型的伴生对象内的隐式值。
    class SignPen {

      def write(context: String) = println(context);
    }
    object Object {

      implicit val signPen = new SignPen;

      def signForExam(name : String)(implicit  signPen : SignPen){
        signPen.write(name + " come to exam in time;")
      }
      def main(args: Array[String]): Unit = {
        signForExam("张三三");
      }
    }

7：Scala之Actor(多线程编程,注意,Spark中使用的分布式多线程框架，是Akka)：

　　Scala的Actor类似于Java中的多线程编程。但是不同的是，Scala的Actor提供的模型与多线程有所不同。Scala的Actor尽可能的避免锁和共享状态，从而避免多线程并发时出现资源争用的情况，进而提示多线程编程的性能。此外，Scala的Actor的这种模型还可以避免死锁等一系列传统多线程编程的问题。

7.1:Actor的创建，启动，和消息的收发:
    Scala提供了Actor trait来让我们更方便的进行Actor多线程编程，就Actor trait就类似于Java中的thread和Runnable一样，是基础的多线程基类和接口。我们只要重写Actor trait的act方法，即可实现自己的线程执行体，与Java中重写run方法类似。
    此外，使用start()方法启动actor，使用!符号，向actor发送消息。actor内部使用receive和模式匹配接受消息。
    class HelloActor extends Actor{

      def act(): Unit = {
        while(true) {
          receive{
            case name : String => println("hi," + name)
          }
        }
      }
    }
    //定义一个Object来进行测试
    object Object {

      def main(args: Array[String]): Unit = {
        val helloActor = new HelloActor;
        helloActor.start()
      }
    }
7.2:收发case class类型的消息:
    Scala的Actor模型和Java的多线程模型之间，很大的一个区别就是，Scala Actor天然支持线程之间的精确通信。即一个actor可以给其他actor直接发送消息。这个功能是非常强大和方便的。要给一个actor发送消息，需要使用"actor ! 消息"的语法。在Scala中，通常建议使用样例举，即case class来作为消息进行发送。然后在actor接受消息以后，可以使用scala强大的模式匹配功能来进行不同消息的处理。
    case class Login(name : String,passsword : String) {

    }
    case class register(name : String,password : String) {

    }
    class UserManageActor extends Actor{

      def act(): Unit = {
        while (true){
          receive{
            case Login(name,passsword) => println("name : " + name + ",password : " + passsword);
            case register(name,passsword) => println("name : " + name + ",password : " + passsword);
          }
        }
      }
    }
    //定义一个Object来进行测试
    object Object {

      def main(args: Array[String]): Unit = {
        val userManageActor = new UserManageActor;
        userManageActor.start();
        //userManageActor ! Register("张三三","123456");
        //userManageActor ! Login("张三三","123456");
      }
    }

7.3:Actor之间互相收发消息:
    如果两个Actor之间要互相收发消息，那么Scala的建议是，一个actor向另一个actor发送消息时，同时带上自己的引用。其他actor收到自己的消息时，直接通过发送消息的actor的引用，即可以给它回复消息。

7.4:同步消息和Future:
    默认情况下，消息都是异步的。但是如果希望发送的消息时同步的，即对方接受后，一定要给自己返回结果，name可以使用!?的方式发送消息。即val reply = actor !? message;如果要异步发送一个消息，但是在后续要获得消息的返回值，那么可以使用Future。即!!语法。val future = actor !! message。val reply = future();
    

待续......