访问修饰符

格式：private[x]或protected[x]，x指某个所属包、类或单例对象，表示被修饰的类（或方法、单例对象），在X域中公开，在x域范围内都可以访问；

private[包名]:在该包名作用域内，被修饰域都能被访问；

private[类名]:在该类的作用域，被修饰域都能被访问；

private[this]:仅能在包含了定义的同一对象中访问，用于保证同一类中不能被其它对象访问；

例子：

package tests{
    private[tests] class Test{
        private[tests] def showTest=println("start showTest Runing !")
    }
    package units{
        object unit{
            def main(args:Array[String]){
                val a = new Test
                a.showTest
            }
        }
    }
}

样本类

定义：带有case修饰符的类称为样本类（case class）；

例如：

case class Unit(name:String)

val t = Unit(“123)

scala为样本类提供的便捷特点：

1、添加了与类名相同的工厂方法，也就是说可以用Unit(“123”)替换new Unit(“123”)构造对象；

2、样本类参数列表中的所有参数隐式获得了val前缀，被当作字段维护，如：t.name;

3、编译器为类添加了方法toString、hashCode和equals的实现；

模式匹配

一个模式匹配包含了一系列备选项，以case关键字开始，每个备选项都包含了一个模式及一到多个表达式，他们在模式匹配过程中被计算，箭头符号=>隔开了模式和表达式；

格式：选择器 match {备选项}

备选项格式：case 模式 => 表达式

match与switch比较：

1、match 是scala表达式，始终以值做为结果；

2、备选项永远不会掉到下一个case执行；

3、如果没有模式匹配到，将抛出MatchError异常；

模式的种类

通配模式：能匹配任意对象，如：case _ => todo

常量模式：任何字面量、val、单例对象(Nil)都可以做为常量，仅能匹配自身,如:def fun(x:Any) = x match {case Nil => “123”;case _ => “456”}；

变量模式：类似通配符，可以匹配任意对象，与通配模式不同的是，它会把变量绑定在匹配的对象上，因此之后可以使用这个变量操作对象;

如:

scala> var p = "123456"
p: String = 123456

scala> def fun(x:Any) = x match {
     | case p => println("fun result is :"+p)
     | }
fun: (x: Any)Unit

scala> fun("hello world")
fun result is :hello world

说明：

1、scala中小写字母开始的简单名被当作是模式变量，所有其它的引用被认为是常量。

2、以反引号包住变量名表示是常量;

构造器模式

假如模式指定为一个样本类，那么这个模式就表示首先检查对象是该名称的样本类成员，然后检查对象的构造参数是否符号额外提供的模式,该模式使scala支持深度匹配;

例子:

scala> case class Unit(x:String){
     | def showUnit=println("showUnit " + x);
     | }
defined class Unit 
                 
scala> def fun(x:Any) = x match {
     | case Unit("123") => println("123456")
     | case _ => println("no match")
     | }
fun: (x: Any)Unit

scala> fun(new Unit("234"))
no match

scala> fun (new Unit("123"))
123456

序列模式

匹配List或Array这样的序列类型,同样的语法也可以指定模式内任意数量的元素;

如:

scala> def fun (x:Any)= x match{
     | case List(0,_,_) => println("123")
     | case _ => println("no match")
     | }
fun: (x: Any)Unit

scala> fun(List(1,2,3))
no match

说明：匹配一个不指定长度的序列可以 _*做为模式的最后元素,如：List(0,_*)；

元组模式

用于匹配元素，类似(a,b,c)这样的模式可以匹配任意的三元组;

如:

scala> def fun(x:Any) = x match {
     | case ("123",1,2) => println("123")
     | case _ => println("no match")
     | }
fun: (x: Any)Unit

scala> fun((1,2,3))
no match

scala> fun(("123",1,2))
123

类型模式

可把类型模式当作类型测试和类型转化的简易替代;

如:

scala> def fun(x:Any) = x match {
     | case s:String => println("String Type length is" + s.length)
     | case _ => println("no match")
     | }
fun: (x: Any)Unit

scala> fun("123456")
String Type length is6

说明：

1、与该模式功能相同的还有两个函数 isInstanceof（类型测试）与 asInstanceof（类型转换）

2、x.isInstanceof[String]检查x是否为String类型类型，是就返回true否则返回false；

3、x.asInstanceof[String]将x转换为String类型返回；

4、类型擦除:类型参数信息没有保留到运行期，因此，运行期没有办法判定给定的Map对象创建时带了两个Int参数还是其它的类型,，系统只能判定这个值是某种任意类型参数的Map,而唯一例外的数组类型Array[类型];

变量绑定模式

除了独立的变量模式外，可使用该模式对任何其它模式添加变量，格式:变量名+@+模式，这种模式的意义在于它能像通常的那要做模式匹配，并且如果匹配成功，则把变量设置成匹配的对象;

例子：

scala> case class Unit(a:Int,b:String){
     | def showUnit=println("a:"+a+",b:"+b)
     | }
defined class Unit

scala> def fun(x:Any)= x match {
     | case Unit(1,e @ "123") => println("e:"+e)
     |  case _ => println("No Match")
     | }
fun: (x: Any)Unit

scala> fun(Unit(1,"123"))
e:123

scala> fun(Unit(1,"234"))
No Match

模式守卫

scala要求模式是线性的：模式变量仅允许在模式中出现一次，不过可以使用模式守卫重新指定该匹配规则；

模式守卫接在模式之后，开始于if,守卫可以是任意的引用模式中变量的布尔表达式，如果存在模式守卫，那么只有在守卫返回true的时候匹配才成功。

例子：

scala> def fun(x:Any)=x match {
     | case i:Int if i>0 => println("i>0")
     | case s:String if s.length ==3 => println("type is String")
     | case _ => println("No Match")
     | }
fun: (x: Any)Unit

scala> fun(123)
i>0

scala> fun("123")
type is String

scala> fun(-1)
No Match

模式重叠

模式以代码编写的先后次序尝试执行，很重要的一点是，全匹配的样本要跟在具体的简化方法之后，如果写成其它次序，那么全匹配样本将比特定规则样本得到更高的优先级，这种情况下，编译器将在你做这种尝试时发出警告，因为特定规则的样本没有可能执行；

封闭类

功能：scala编译器帮助检查match表达式中遗漏的模式组合。

原理：让样本类的超类被封闭，封闭类除了类定义所在的文件外不能再添加任何新的子类，而仅需要关系所定义的子类。当使用封闭类的样本类进行模式比配时，编译器会自动检查是否存在缺失的模式组合，存在时将抛出警告；

例子：

scala> sealed abstract class Unit
defined class Unit

scala> case class U1(s:String) extends Unit
defined class U1

scala> case class U2(i:Int) extends Unit
defined class U2

scala> case class U3(b:Any) extends Unit
defined class U3

scala> def fun(x:Unit) = x match {
     | case U1(_) => println("U1")
     | case U2(_) => println("U2")
     | }
<console>:12: warning: match may not be exhaustive.
It would fail on the following input: U3(_)

使用注解去掉警告：

scala>  def fun(x:Unit) = (x: @unchecked) match {
     |  case U1(_) => println("U1")
     | case U2(_) => println("U2")
     | }
fun: (x: Unit)Unit

说明：

模式匹配的类层级，都应当使用封闭类，而封闭类的实现把关键字sealed放在最顶层类的前面即可；

Option类型

该类型为一种可选值的定义，有两种形式Some(x),其中x为实际值和None，代表缺省值。可作用于scala集合类的某些标准操作会产生可选值；

例子：

scala> val ss = Map("123"->"Hello","456"->"World")
ss: scala.collection.immutable.Map[String,String] = Map(123 -> Hello, 456 -> Wor
ld)

scala> def fun(x:Option[String])= x match {
     | case Some(s) => println(s)
     | case None => println("No Match")
     | }
fun: (x: Option[String])Unit

scala> fun(ss get "123")
Hello

scala> fun(ss get "567")
No Match

注意:Option[String]与String两种是不同的类型，不能互相赋值；

模式的应用

1、变量的定义

例1：

scala> val aa = (123,"456")
aa: (Int, String) = (123,456)

scala> val (a,b) = aa
a: Int = 123
b: String = 456

scala> println(a)
123

scala> print(b)
456

2、偏函数的样本序列

样本序列就是函数字面量，与通常的函数里子面量不同的是，样本序列可以有多个入口点，每个都有自己的参数列表，每个样本都是函数的一个入口点，参数被模式特化。而通常的函数字面量只有一个入口;

例1(样本序列)：

scala> val fun:Option[Int] => Int ={
     | case Some(x) => x
     | case None => 0
     | }
fun: Option[Int] => Int = <function1>

scala> fun(Some(10))
res2: Int = 10

scala> fun(None)
res3: Int = 0

例2(偏函数应用)：

scala> val fun:PartialFunction[List[Int],Int] = {
     | case x :: y :: _ => y
     | }
fun: PartialFunction[List[Int],Int] = <function1>

scala> fun.isDefinedAt(List(5,6,7))
res6: Boolean = true

scala> fun.isDefinedAt(List(2))
res7: Boolean = false

说明:

1、PartialFunction[List[Int],Int]表示仅包含从整数列表到整数的偏函数；

2、fun.isDefinedAt用于检查该偏函数对List(5,6,7)有定义，上例中表示函数对任何有至少两个元素的列表有定义;