package
    目的：解决命名冲突
    使用和访问规则-外层包无法直接访问内层包
    package object 包对象--主要用于对常量和工具函数的封装
     import 包引入
            重命名、类隐藏机制

class
    class
    abstract class  抽象类
    Companion Class 伴生类 
    内部类 匿名类
    case class 样例类
    单例对象不带参数，而类可以
object
    伴生对象首先是一个单例对象，单例对象用关键字object定义。
    在Scala中，单例对象分为两种，一种是并未自动关联到特定类上的单例对象，称为独立对象 （Standalone Object）；
    另一种是关联到一个类上的单例对象，该单例对象与该类共有相同名字，则这种单例对象称为伴生对象（Companion Object），对应类称为伴生类。
    单例对象（singleton object）
    <1>object---单例对象使用object关键字声明单例对象，使用时可以不创建对象，直接通过类名.类成员名称 的方式来访问.通过JAVA语言中的单例模式和静态类成员实现。
        main函数必须定义在单例模式中，作为程序的入口。也可以通过混入trait App 实现。在App 已经定义了main函数
    <2>Companion object----伴生对象
     内部对象
trait
    通过extends 或者with关键字mix
        抽象
        自身
伴生带来的特权就是：它们可以互相访问私有成员
    sealed 关键字主要有2个作用：
        其修饰的trait，class只能在当前文件里面被继承
        用sealed修饰这样做的目的是告诉scala编译器在检查模式匹配的时候，让scala知道这些case的所有情况，
                scala就能够在编译的时候进行检查，看你写的代码是否有没有漏掉什么没case到，减少编程的错误。   
函数
    高阶函数
    匿名函数
    偏函数

关于类
    构造函数
        主构造函数  ---公有和私有，默认参数和自定义参数
        辅助构造函数

    成员变量

    局部变量

    方法

    成员访问控制

    复用类---组合和继承--父类和子类--继承，多态，重写等
    隐式转换
    泛型
        类型的上下界          
        class foo[T <% A]{...} //弱上界<%。关系较弱：T能够隐式转换为Ordered[T] 
        class foo[T <: A]{...} //上界 <:。T必须是A的子类,A是T的类型上界。 
        class foo[T >: A]{...} //下界 >:。T必须是A的父类，A是T类型的下界。

        协变和逆变 
        +T: 协变：class Queue[+T] {}。如果C<:A，则Queue[C] <: Queue[A]  
        -T: 逆变 : class Queue[-T] {}。如果C<:A,则Queue[C] >: Queue[A] 
    模式匹配
    并发---使用Actor模型为并发提供更高级的抽象--
            Actor构成--State Behavior Mailbox
关于case class
    case class，它其实就是一个普通的class。但是它又和普通的class略有区别。不可变类中的一种简单类型，内置了所有JAVA类的基本方法，比如以下中的2.3。
    提供factory method来方便构造object、class parameter隐含val prefix
    >1、初始化的时候普通类一定需要加new，case calss 可以不用new，当然你也可以加上。
    >2、toString的实现更漂亮
    >3、默认实现了equals 和hashCode
    >4、默认是可以序列化的，也就是实现了Serializable
    >5、自动从scala.Product中继承一些函数;
    >6、case class构造函数的参数是public级别的，我们可以直接访问
    >7、支持模式匹配，case class最重要的特性应该就是支持模式匹配。
集合元素的方法
用分隔符将集合元素连接成一个字符串---mkString
定义函数：
        /**
        * 产生计算维度，或者说是字段的名称
        */
      def makeKey(list: List[Any]): String = {
        list.mkString("_")
      }
使用
    makeKey(List(date, "#", "#", "name"))
Scala的Seq类和Java的List接口类似，都是可迭代集合，即具有确定长度并且可以根据下标查找值，并且支持排序
Scala的Map类没有提供根据内容的键或者值排序的方法，可以将Map类型转换成Scala的Seq类型进行排序

    val codeRDD = HBase_DATARDD.map(
        o => {
            val age =   Bytes.toString(o._2.getValue("info".getBytes, "age".getBytes)).toInt
            val code =   Bytes.toString(o._2.getValue("info".getBytes, "code".getBytes)).toInt
            (age,code)      
           }
        ).map(o => o._1)


        //关于Tuple1
        package scala
        case class Tuple1[ @scala.specialized +T1](val _1 : T1) extends scala.AnyRef with scala.Product1[T1] with scala.Product with scala.Serializable {
          override def toString() : java.lang.String = { /* compiled code */ }
        }
        可以通过变量名._N 的方式进行访问元组的内容，其中N表示元组中元素的索引号。即通过下标访问记录元素。
         //关于隐式类型转化
         String类没有toInt方法，而然StringOps有，编译器悄悄的将将String类的实例转换成StringOps对象实例，然后调用toInt方法
         Tuple2，表示一对--即两个，Tuple3，表示三个

    case class MatchData(lo: Int,sq: Int)
    val codeRDD = HBase_DATARDD.map(
        o => {
            val age =   Bytes.toString(o._2.getValue("info".getBytes, "age".getBytes)).toInt
            val code =   Bytes.toString(o._2.getValue("info".getBytes, "code".getBytes)).toInt
            MatchData(lo,sq)        
           }
        )

        功能：创建简单的记录类型，通过有意义的名称来访问记录的元素。

    val codeRDD = HBase_DATARDD.map(
        o => {
            val age =   Bytes.toString(o._2.getValue("info".getBytes, "age".getBytes)).toInt
            val code =   Bytes.toString(o._2.getValue("info".getBytes, "code".getBytes)).toInt
            if (column1 != null && column2 != null) {
               Some(column1.toDouble, column2.toDouble)
             }else{
               None
             }                          
           }).filter( o => o != None).map(_.get._1),//过滤后，再使用.get提取其中的一列
           //Scala中允许使用_表示匿名函数的参数map(_.get._1) 和map(o => o.get._1) 是一致的

    //在Spark中的源代码
   package scala
    case object None extends scala.Option[scala.Nothing] with scala.Product with scala.Serializable {
      def isEmpty : scala.Boolean = { /* compiled code */ }
      def get : scala.Nothing = { /* compiled code */ }
    }

   package scala
    final case class Some[+A](val x : A) extends scala.Option[A] with scala.Product with scala.Serializable {
      def isEmpty : scala.Boolean = { /* compiled code */ }
      def get : A = { /* compiled code */ }
    }

     package scala
    sealed abstract class Option[+A]() extends scala.AnyRef with scala.Product with scala.Serializable {
    object Option extends scala.AnyRef with scala.Serializable {

    //对象序列化
    //将实现了Serializable接口的对象转化成一个字节序列，并能够在以后将这个字节序列完全恢复为原来的对象--实现了轻量级持久性
    package scala
    trait Serializable extends scala.Any with java.io.Serializable {
    }
    Scala和Java互操作，Scala调用java接口。

    package scala
    trait Product extends scala.Any with scala.Equals {
      def productElement(n : scala.Int) : scala.Any
      def productArity : scala.Int
      def productIterator : scala.Iterator[scala.Any] = { /* compiled code */ }
      def productPrefix : java.lang.String = { /* compiled code */ }
    }

    package scala
    trait Equals extends scala.Any {
      def canEqual(that : scala.Any) : scala.Boolean
      def equals(that : scala.Any) : scala.Boolean
    }

    //在Scala中的源代码
    final case class Some[+A](x: A) extends Option[A] {
      def isEmpty = false
      def get = x
    }
    case object None extends Option[Nothing] {
      def isEmpty = true
      def get = throw new NoSuchElementException("None.get")
    }    
    Option类型代表任意的值，多用在集合操作中，它可以存储任意类型的值，
        Option实例就是Some或者None对象实例，Some和None都是它的子类，他们都是final类，所以不能再有派生子类了
        lastOption返回最后一个Option类型对象，lastOption方法中将通过last取到的最后一个元素转换为Some类型了
        也就是Option类型只会返回Some或None类型对象

 关于 package scala //在Spark中
   package object scala extends scala.AnyRef {
       type Iterable[+A] = scala.collection.Iterable[A]
       val Iterable : scala.collection.Iterable.type = { /* compiled code */ }
       type Iterator[+A] = scala.collection.Iterator[A]
       val Iterator : scala.collection.Iterator.type = { /* compiled code */ }
       type Seq[+A] = scala.collection.Seq[A]
       val Seq : scala.collection.Seq.type = { /* compiled code */ }
       type List[+A] = scala.collection.immutable.List[A]
       val List : scala.collection.immutable.List.type = { /* compiled code */ }
       type Vector[+A] = scala.collection.immutable.Vector[A]
       val Vector : scala.collection.immutable.Vector.type = { /* compiled code */ }
        }