所谓的高阶函数变成，其实就是将函数当成一个类型来使用，而不是当成特定的语法结构 

object Scala13_ScalaFunction3 {

def main(args: Array[String]): Unit = {

//函数作为值

def fun1():String={

"zhangsan"

}

val a=fun1

val b=fun1 _

println(a)

println(b)

//函数作为参数

def fun2( i:Int ) : Int = {

i * 2

}

def fun22 ( f :Int => Int):Int = {

f(10)

}

println(fun22(fun2))

//函数作为返回值

def fun3 ( i:Int ):Int={

i*2

}

def fun33 ()={

fun3 _

}

println(fun33()(10))

//匿名函数

def fun4(f :Int=>Int):Int={

f(10)

}

println(fun4((x:Int)=>{x*20}))

println(fun4((x)=>{x * 20}))

println(fun4((x)=>x*20))

println(fun4(x=>x*20))

println(fun4(_ *20))

//控制抽象：可以不传参数而改为传代码，用于自定义代码逻辑

def fun5(op : => Unit)={

op

}

fun5{

println("xx")

}

//闭包,一个函数他使用了外部的变量，把这个歌变量包含在内部来使用，改变了变量的生命周期，形成了一个闭合环境

def fun6()={

val i = 20

def fun66()={

i*2

}

fun66 _

}

fun6()()

//函数柯里化，将没有联系的参数分开去传递

def fun7(a:Int)(b:Int)={

println(a+b)

}

fun7(10)(20)

//递归

// Scala要求递归函数必须明确给出返回值

// 函数内部调用自身

//一定要有跳出递归的逻辑

//调用时传递参数之间要有关系

def fun8(j:Int):Int = {

if ( j <= 1 ) {

1

} else {

j * fun8(j-1)

}

}

println(fun8(5))

//惰性函数

def fun9(): String = {

println("function...")

"zhangsan"

}

lazy val a = fun9()

println("----------")

//println(a)

}

}

六丶面向对象编程

Scala是一门完全面向对象的语言，摒弃了Java中高很多不是面向对象的语法，但其面向对象的思想和Java还是一致的

6.1基础面向对象编程

6.1.1包

基本和Java完全一致

扩展语法：

Scala中的包和类的物理路径没有关系package关键字可以嵌套声明使用同一个源码文件中的子包可以访问父包中的内容，无需导入

package com

package atguigu {

package bigdata {

class Test {

}

package scala {

object ScalaPackage {

def test(): Unit = {

new Test()

}

}

}

}

}

Scala中package也可以看做对象，并声明属性和函数

package com

package object atguigu {

val name : String = "zhangsan"

def test(): Unit = {

println(name)

}

}

package atguigu {

packafe bigdata {

package scala {

object ScalaPackage {

def test(): Unit = {

}

}

}

}

}

6.1.2导入

Scala中基本的导入也和Java完全一致

扩展语法：

Scala中导入可以再任意位置使用

object ScalaImport{

    def main(args: Array[String]): Unit = {

        import java.util.ArrayList

        new  ArrayList()   

}

}

Scala中可以只导包

object ScalaImport{

    def main(args: Array[String]): Unit = {

        import java.util

        new util.ArrayList()

    }

}

Scala可以在同一行导入相同包中的多个类

import java.util.{List, ArrayList}Scala可以给类起别名简化使用

import java.util.{ArrayList=>AList}

object ScalaImport{

    def main(args: Array[String]): Unit = {

        new AList()

    }

}

Scala中可以使用类的绝对路径而非相对路径

import _root_.java.util.ArrayListScala可以屏蔽包里的某个类

import java.util._

import java.sql.{ Date=>_, Array=>_, _ }

6.1.3 类

//声明类 ：访问权限class类名{主题内容}

class User {

//类的主题内容

}

//对象 ：new 类名（参数列表）

new User()

扩展语法：Scala 中一个源文件可以声明多个公共类

6.1.4 属性

基本语法：

class User {

var name : String = _ // 类属性其实就是类变量

var age : Int = _ // 下划线表示类的属性默认初始化

}

6.1.5 方法

Scala中类的方法就是函数，所以声明方式完全一样，但是必须通过对象调用

object Scala14_ScalaMethod {

def main(args: Array[String]): Unit = {

val user =new User

user.login("zhangsan","123456")

}

class User{

def login(name :String,password: String)={

println(name,password)

}

}

}

6.1.6 对象

Scala中对象和Java是类似的 

val user :User =new User()

6.1.7 构造方法

Scala中构造对象也需要调用类的构造方法来创建，并且一个类中可以有任意多个不相同的构造方法。这些构造方法可以分为2大类：主构造函数和辅构造函数

class User1(){//主构造函数

var username : String = _

def this(name:String){//辅助构造函数，使用this关键字声明

this()//辅助构造函数一个直接或者间接调用主构造函数

username=name

}

def this (name :String,password:String){

this(name) //构造器调用其他另外构造器，要求被调用构造器必须提前声明

}

}

6.2 高阶面向对象编程

6.2.1 继承

和Java一样，Scala中继承也是单继承，使用extends关键字，构造对象时需要考虑构造方法的执行顺序构造对象时需要考虑构造方法的执行顺序构造对象时需要考虑构造方法的执行顺序

6.2.2 封装

封装就是把抽象出的数据和对数据的操作封装到一起，数据被保护在内部，程序的其他部分只有通过被授权的操作（成员方法），才能对数据进行访问

1.将属性进行私有化

2.提供一个公共的set方法，用于对属性赋值

3.提供一个公共的get方法，用于获取属性的值

6.2.3 抽象

Scala将一个不完整的类称为抽象类

//抽象类，抽象类没办法实例化，只有子类继承，重写才能实例化

abstract class Person{

//抽象方法

def test():Unit

//抽象属性

var name : String

}

class Child extends Person {

def test(): Unit = {

}

var name: String = "zs"

}

abstract class Student(){

def test(): Unit ={

}

val age:Int = 10

}

//子类重写父类的完整方法或者完整属性时，必须添加override关键字，开发时，推荐只要重写，都添加override关键字

class ChildStudent extends Student(){

override def test(): Unit = {

}

override val age : Int = 20

}

6.2.4 特征

将多个对象中相同的特征，从对象中剥离出来，形成独立的一个结构，称之为trait（特征）

如果一个对象符合这些特征，那么可以将这个特征加入到这个对象，这个加入的过程成为混入

如果一个类只有一个特征时，采用extends进行混入

如果一个类有多个特征，这个时候，第一个特征采用extends，后续采用with

如果类存在父类的场合，并且同时具备某个特征，需要使用extends继承父类，使用with混入特征

6.2.5 反射

def main(args: Array[String]): Unit = {

val s=" a b "code>

//不可变字符串真正意义上是不可直接改变，但可使用反射调用自身进行改变

//反射就相当于镜子，调用自己

//todo:1构建反射对象

val stringClass: Class[String] = classOf[String]

val field : Field= stringClass.getDeclaredField("value")

//添加访问权限

field.setAccessible(true)

//todo:2调用反射，传入值

val obj = field.get(s)

val chars = obj.asInstanceOf[Array[Char]]

chars(2)='D'

println(s)

}

6.2.6 枚举类和应用类

<code> def main(args: Array[String]): Unit = {

//todo -集合 -数组

// 数组：严格意义上，数组不是集合，scala中给数组一个特定的类型：Array

//todo 构建

val array =new Array[String](3)

//访问

//array.update(1,"abc")

array(1)="abc"

//遍历

for (i <- array){

println(i)

}

}

数组中常用的方法：

def main(args: Array[String]): Unit = {

//多维数组

var myMatrix = Array.ofDim[Int](3,3)

// myMatrix.foreach(list=>println(list.mkString(",")))

val arr1 = Array(1,2,3,4)

val arr2 = Array(5,6,7,8)

//合并数组

val arr3 = Array.concat(arr1,arr2)

//arr3.foreach(println(_))

//创建指定范围数组

val arr4:Array[Int] = Array.range(0,3)

//arr4.foreach(println(_))

//填充

val arr5 = Array.fill(5)(-1)

arr5.foreach(println)

}

7.2.2 可变数组

基本语法：

def main(args: Array[String]): Unit = {

//可变数组

val buffer = new ArrayBuffer[String]()

//添加

buffer.append("a","b","c")

buffer.appendAll(Array("d","e","f"))

buffer.insert(1,"x")

//修改

buffer.update(0,"h")

buffer(2)="p"

//删除

buffer.remove(3)

buffer.remove(3,2)

println(buffer)

buffer.foreach(println(_))

//可变数组和不可变数组相互转换

val array = buffer.toArray

val buffer1 = array.toBuffer

//Java集合和scala集合互相转换

import scala.collection.JavaConverters._

val list=new java.util.ArrayList()

list.asScala.foreach(println(_))

val arr0 = List(1,2,3)

arr0.asJava.forEach(println)

}

7.2.3 常用方法

def main(args: Array[String]): Unit = {

//集合常用的方法

val array = Array(1,2,3)

println(array.size)

println(array.length)

println(array.isEmpty)

println(array.contains(2))//是否包含

println(array.distinct.mkString(","))//去重

println(array.reverse.mkString(","))//反转

println(array.mkString(","))

array.foreach(println)

array.iterator

println(array.toList.takeRight(2))//取后几个元素

println(array.toList.take(2))//取前几个元素

println(array.find(x => x % 2 == 0))//按条件查找

println(array.toList.drop(2))//删除前几个元素

println(array.toList.dropRight(2))//删除前几个元素

}

7.2.4多集合常用方法 

def main(args: Array[String]): Unit = {

val list = List(1,2,3,4)

val list1 = List(1,2,3,4)

val list2 = List(3,4,5,6)

// 集合头

println("head => " + list.head)

// 集合尾

println("tail => " + list.tail)

// 集合尾迭代

println("tails => " + list.tails.next())

// 集合初始值

println("init => " + list.init)

// 集合初始值迭代

println("inits => " + list.inits.hasNext)

// 集合最后元素

println("last => " + list.last)

// 集合并集

println("union => " + list.union(list1))

// 集合交集

println("intersect => " + list.intersect(list1))

// 集合差集

println("diff => " + list.diff(list1))

// 切分集合

println("splitAt => " + list.splitAt(2))

// 滑动（窗口）

println("sliding => " + list.sliding(2).next())

// 滚动（没有重复）

println("sliding => " + list.sliding(2,2).next())

// 拉链

println("zip => " + list.zip(list1))

// 数据索引拉链

println("zipWithIndex => " + list.zipWithIndex)

}

7.2.5 计算函数 

def main(args: Array[String]): Unit = {

val list = List(1,2,3,4)

val list1 = List(3,4,5,6)

// 集合最小值

println("min => " + list.min)

// 集合最大值

println("max => " + list.max)

// 集合求和

println("sum => " + list.sum)

// 集合乘积

println("product => " + list.product)

// 集合简化规约

println("reduce => " + list.reduce((x:Int,y:Int)=>{x+y}))

println("reduce => " + list.reduce((x,y)=>{x+y}))

println("reduce => " + list.reduce((x,y)=>x+y))

println("reduce => " + list.reduce(_+_))

// 集合简化规约(左)

println("reduceLeft => " + list.reduceLeft(_+_))

// 集合简化规约(右)

println("reduceRight => " + list.reduceRight(_+_))

// 集合折叠

println("fold => " + list.fold(0)(_+_))

// 集合折叠(左)

println("foldLeft => " + list.foldLeft(0)(_+_))

// 集合折叠(右)

println("foldRight => " + list.foldRight(0)(_+_))

// 集合扫描

println("scan => " + list.scan(0)(_+_))

// 集合扫描(左)

println("scanLeft => " + list.scanLeft(0)(_+_))

// 集合扫描(右)

println("scanRight => " + list.scanRight(0)(_+_))

}

7.2.6 功能函数

def main(args: Array[String]): Unit = {

val list = List(1,2,3,4)

// 集合映射

println("map => " + list.map(x=>{x*2}))

println("map => " + list.map(x=>x*2))

println("map => " + list.map(_*2))

// 集合扁平化

val list1 = List(

List(1,2),

List(3,4)

)

println("flatten =>" + list1.flatten)

// 集合扁平映射

println("flatMap =>" + list1.flatMap(list=>list))

// 集合过滤数据

println("filter =>" + list.filter(_%2 == 0))

// 集合分组数据

println("groupBy =>" + list.groupBy(_%2))

// 集合排序

println("sortBy =>" + list.sortBy(num=>num)(Ordering.Int.reverse))

println("sortWith =>" + list.sortWith((left, right) => {left < right}))

}

7.3 Seq集合

7.3.1 不可变List

def main(args: Array[String]): Unit = {

//Seq集合

val list = List(1,2,3,4)

//增加数据

val list1: List[Int]=list :+ 5

println(list1)

list1.foreach(println(_))

println("_____________------------------")

val list2 : List[Int] = 0 +: list1

list2.foreach(println)

//修改数据

val list3 : List[Int] =list.updated(1,5)

println(list3)

//空集合

val list4: List[Nothing] = List()

val nil = Nil

println(list4 eq nil)

//创建集合

val list5: List[Int] = 1::2::3::Nil

println(list5)

val list6 = list1 ::: Nil

//连接集合

val list7 : List[Int] = List.concat(list1,list2)

println(list7)

//创建一个指定重复数量的元素列表

val list8: List[String]= List.fill[String](3)("a")

println(list8)

}

7.3.2 可变List

基本语法和操作

def main(args: Array[String]): Unit = {

//可变集合

val buffer = new ListBuffer[Int]()

//增加数据

buffer.append(1,2,3,4)

//修改数据

buffer.update(1,3)

//删除数据

//buffer.remove(2)

//buffer.remove(2,2)

//获取数据

println(buffer(0))

//遍历集合

buffer.foreach(println(_))

println(buffer)

println("---------------------------")

val buffer1 =ListBuffer(1,2,3,4)

val buffer2 =ListBuffer(5,6,7,8)

//增加数据

val buffer3:ListBuffer[Int] = buffer1 :+ 5

//+= 和 -=会给原来的buffer1也添加上数据

val buffer4:ListBuffer[Int] = buffer1 += 5

val buffer5:ListBuffer[Int] = buffer1 ++ buffer2

val buffer6:ListBuffer[Int] = buffer1 ++= buffer2

val buffer7:ListBuffer[Int] = buffer1 -= 1

val buffer8:ListBuffer[Int] = buffer1 - 1

println(buffer8)

}

7.3.3 可变集合和不可变集合的转换

import scala.collection.mutable

import scala.collection.mutable.ListBuffer

val buffer9 = ListBuffer(1,2,3,4)

val list = List(5,6,7,8)

//可变集合变不可变集合

val list1: List[Int] = buffer9.toList

//不可变变可变

val buffer10: mutable.Buffer[Int] = list.toBuffer

7.4Set集合

7.4.1 不可变集合

def main(args: Array[String]): Unit = {

val set1 = Set(1,2,3,4)

val set2 = Set(5,6,7,8)

// 增加数据

val set3: Set[Int] = set1 + 5 + 6

val set4: Set[Int] = set1.+(6,7,8)

println( set1 eq set3 ) // false

println( set1 eq set4 ) // false

//set4.foreach(println)

// 删除数据

val set5: Set[Int] = set1 - 2 - 3

//set5.foreach(println)

val set6: Set[Int] = set2 ++ set1

println(set6)

set6.foreach(println)

println("********")

val set7: Set[Int] = set2 ++: set1

set7.foreach(println)

println(set6 eq set7)

}

7.4.2 可变集合

def main(args: Array[String]): Unit = {

import scala.collection.mutable

val set1 = mutable.Set(1,2,3,4)

val set2 = mutable.Set(5,6,7,8)

// 增加数据

set1.add(5)

// 添加数据

set1.update(6,true)

println(set1.mkString(","))

// 删除数据

set1.update(3,false)

println(set1.mkString(","))

// 删除数据

set1.remove(2)

println(set1.mkString(","))

// 遍历数据

set1.foreach(println)

// 交集

val set3: mutable.Set[Int] = set1 & set2

println(set3.mkString(","))

// 差集

val set4: mutable.Set[Int] = set1 &~ set2

println(set4.mkString(","))

}

7.5 Map集合

Map（映射）是一种可迭代的键值对（Key/value） 结构，所有的值都可以通过键来获取。Map中的键都是唯一的

7.5.1 不可变Map

def main(args: Array[String]): Unit = {

//不可变Map

val map1 = Map( "a" -> 1, "b" -> 2, "c" -> 3 )

val map2 = Map( "d" -> 4, "e" -> 5, "f" -> 6 )

// 添加数据

val map3 = map1 + ("d" -> 4)

println(map1 eq map3) // false

println(map3)

// 删除数据

val map4 = map3 - "d"

println(map4.mkString(","))

val map5: Map[String, Int] = map1 ++ map2

println(map5 eq map1)

println(map5.mkString(","))

// 修改数据

val map7: Map[String, Int] = map1.updated("b", 5)

println(map7.mkString(","))

// 遍历数据

map1.foreach(println)

//创建空集合

val empty: Map[String,Int] = Map.empty

println(empty)

//获取指定key的值

println(map1.apply("a"))

println(map1("c"))

//获取可能存在的key的值

val maybeInt:Option[Int] = map1.get("c")

//判断key值是否存在

if (!maybeInt.isEmpty){

println(maybeInt.get)

}else{

//如果不存在，则获取默认值

println(maybeInt.getOrElse(0))

}

println(map1.getOrElse("c",0))

}

7.5.2 可变Map

def main(args: Array[String]): Unit = {

//可变Map

val map1 = mutable.Map("a" -> 1, "b" -> 2, "c" -> 3)

val map2 = mutable.Map("d" -> 4, "e" -> 5, "f" -> 6)

// 添加数据

map1.put("d", 4)

val map3: mutable.Map[String, Int] = map1 + ("e" -> 4)

println(map1 eq map3)

val map4: mutable.Map[String, Int] = map1 += ("e" -> 5)

println(map1 eq map4)

// 修改数据

map1.update("e", 8)

map1("e") = 8

// 删除数据

map1.remove("e")

val map5: mutable.Map[String, Int] = map1 - "e"

println(map1 eq map5)

val map6: mutable.Map[String, Int] = map1 -= "e"

println(map1 eq map6)

// 清除集合

// map1.clear()

val set: Set[(String, Int)] = map1.toSet

val list: List[(String, Int)] = map1.toList

val seq: Seq[(String, Int)] = map1.toSeq

val array: Array[(String, Int)] = map1.toArray

println(set.mkString(","))

println(list.mkString(","))

println(seq.mkString(","))

println(array.mkString(","))

println(map1.get("a"))

println(map1.getOrElse("a", 0))

println(map1.keys)

println(map1.keySet)

println(map1.keysIterator)

println(map1.values)

println(map1.valuesIterator)

map1.foreach(println(_))

}

7.6 元组

在Scala语言中，我们可以将多个无关的数据封装为一个整体，这个整体我们称之为：元素组合，简称元组，有时候也可以将元组看成元素收纳的容器

def main(args: Array[String]): Unit = {

//创建元组，使用小括号

val tuple =(1,"zhangsan",30)

//根据顺序号访问元组数据

println(tuple._1)

println(tuple._2)

println(tuple._3)

//迭代器

val iterator:Iterator[Any] = tuple.productIterator

//根据索引访问元素

tuple.productElement(0)

// 如果元组的元素只有两个，那么我们称之为对偶元组，也称之为键值对

val kv: (String, Int) = ("a", 1)

val kv1: (String, Int) = "a" -> 1

println( kv eq kv1 )

}

7.7 队列

先进先出

def main(args: Array[String]): Unit = {

import scala.collection.mutable

val que = new mutable.Queue[String]()

// 添加元素

que.enqueue("a", "b", "c")

val que1: mutable.Queue[String] = que += "d"

println(que eq que1)

// 获取元素

println(que.dequeue())

println(que.dequeue())

println(que.dequeue())

println(que.dequeue())

}

八丶模式匹配

8.1 简介

Scala 中的模式匹配类似于Javg中的switch语法，但是scala从语法中补充了更多的功能，可以按照指定的规则对数据或者对象进行匹配，

8.2 基本语法

模式匹配语法中，采用match关键字声明，每个分支采用case关键字进行声明，当需要匹配时，会从第一个case分支开始，如果匹配成功，那么执行对应的逻辑代码，如果匹配不成功，继续执行下一个分支进行判断。如果所有case都不匹配，那么会执行case _分支，类似于Java中default语句。如果不存在case _分支，那么会发生错误

object ScalaMatch{

def main(args: Array[String]): Unit = {

var a: Int = 10

var b: Int = 20

var operator: Char = 'd'

var result = operator match {

case '+' => a + b

case '-' => a - b

case '*' => a * b

case '/' => a / b

case _ => "illegal"

}

println(result)

}

}

8.3 匹配规则

8.3.1匹配常量

def describe(x:Any) = x match{

case 5 => "Int five"

case "hello" => "String hello"

case true => "Boolean true"

case '+' => "Char +"

}

println(describe("hello"))

8.3.2匹配类型

def describe2(x: Any) = x match {

case i: Int => "Int"

case s: String => "String hello"

case m: List[_] => "List"

case c: Array[Int] => "Array[Int]"

case someThing => "something else " + someThing

}

println(describe2(List(1,2,3)))

8.3.3匹配数组

for (arr <- Array(Array(0), Array(1, 0), Array(0, 1, 0), Array(1, 1, 0), Array(1, 1, 0, 1), Array("hello", 90))) { // 对一个数组集合进行遍历

val result = arr match {

case Array(0) => "0" //匹配Array(0) 这个数组

case Array(x, y) => x + "," + y //匹配有两个元素的数组，然后将将元素值赋给对应的x,y

case Array(0, _*) => "以0开头的数组" //匹配以0开头和数组

case _ => "something else"

}

println("result = " + result)

}

8.3.4匹配列表

for (list <- Array(List(0), List(1, 0), List(0, 0, 0), List(1, 0, 0), List(88))) {

val result = list match {

case List(0) => "0" //匹配List(0)

case List(x, y) => x + "," + y //匹配有两个元素的List

case List(0, _*) => "0 ..."

case _ => "something else"

}

println(result)

}

val list: List[Int] = List(1, 2, 5, 6, 7)

list match {

case first :: second :: rest => println(first + "-" + second + "-" + rest)

case _ => println("something else")

}

8.3.5 匹配元组

def main(args: Array[String]): Unit = {

for (tuple <- Array((0, 1), (1, 0), (1, 1),(1, 2), (1, 0, 2))) {

val result = tuple match {

case (0, _) => "0 ..." //是第一个元素是0的元组

case (y, 0) => "" + y + "0" // 匹配后一个元素是0的对偶元组

case (a, b) => "" + a + " " + b

case _ => "something else" //默认

}

println(result)

}

}

8.3.6 匹配对象

def main(args: Array[String]): Unit = {

class User (val name:String , val age: Int)

object User{

def apply(name: String,age: Int):User =new User(name, age)

def unapply(user: User): Option[(String, Int)]={

if (user == null)

None

else

Some(user.name,user.age)

}

}

val user = User("zhangsan",11)

user match{

case User("zhangsan",11)=> println("yes")

case _ => println("no")

}

}

8.3.6 匹配对象（样例类）

def main(args: Array[String]): Unit = {

//如果在类前面增加case关键字，这个类钻用于模式匹配，被称为样例类

//在编译时，会生成大量的方法

//1.样例类会自动实现可序列化接口

//2.样例类 构造参数直接能够作为属性使用，但是不能修改，如果想修改，需要将参数使用var声明

//3.增加和重写了大量方法

//4.样例类自动生成伴生对象，而且其中自动声明了apply，unapply

case class User (var name:String , var age: Int)

/*object User{

def apply(name: String,age: Int):User =new User(name, age)

def unapply(user: User): Option[(String, Int)]={

if (user == null)

None

else

Some(user.name,user.age)

}

}*/

val user = User("zhangsan",11)

user match{

case User("zhangsan",11)=> println("yes")

case _ => println("no")

}

}

8.3.7 全量函数

def main(args: Array[String]): Unit = {

//todo-01 偏函数：以偏概全，函数处理事只需对满足条件的数据进行处理

//todo-02 全量韩秘书：函数进行处理时必须对所有数据进行处理

//将数字加一，并去掉字符串

val list :List[Any] =List(1,2,3,4,5,6,"test")

val list1=list.map {

case i: Int => i + 1

case str: String => str

}.filter(_.isInstanceOf[Int])

println(list1)

}

8.3.8 偏函数

def main(args: Array[String]): Unit = {

//todo-01 偏函数：以偏概全，函数处理事只需对满足条件的数据进行处理

//todo-02 全量函数：函数进行处理时必须对所有数据进行处理

//将所有的数字加一，并去掉字符串

val list :List[Any] =List(1,2,3,4,5,6,"test")

val list1=list.collect {

case i: Int => i + 1

}

println(list1)

}

九丶异常

 Scala异常原理和Java基本相同，但是捕捉异常的方法不同

def main(args: Array[String]): Unit = {

try {

var n= 10 / 0

} catch {

// 发生算术异常

case ex: ArithmeticException=> println("发生算术异常")

// 对异常处理

case ex: Exception=> println("发生了异常1")

} finally {

println("finally")

}

}

十丶隐式转换

10.1简介

在之前的类型学习中，我们已经学习了自动类型转换，精度小的类型可以自动转换为精度大的类型，这个转换过程无需开发人员参与，有编译器自动完成，这个转换我们称之为隐式转换

在其他的场合，隐式转换也起到了非常重要的作用。如Scala在程序编译错误时，可以通过隐式转换中类型转换机制尝试进行二次编译，将本身错误无法编译通过的代码通过类型转换后编译通过。

10.2 隐式函数 

def main(args: Array[String]): Unit = {

implicit def transform(d :Double): Int = {

d.toInt

}

var d : Double =2.0

val i : Int = d

println(i)

}

10.3 隐式参数

def main(args: Array[String]): Unit = {

def transform( implicit d : Double)={

d.toInt

}

implicit val d : Double =2.0

println(transform)

}

10.4 隐式类

在Scala2.10后提供了隐式类，可以使用implicit声明类，隐式类非常强大，同样可以扩展类的功能，在集合的数据处理中，隐式类发挥了重要的作用。

其所带的构造参数有且只能有一个隐式类必须被定义在“类”或“伴生对象”或“包对象”里，即隐式类不能是顶级的。

def main(args: Array[String]): Unit = {

val emp = new Emp()

emp.insertUser()

}

class Emp {

}

implicit class User( emp : Emp) {

def insertUser(): Unit = {

println("insert user...")

}

}

10.5 隐式机制

所谓的隐式机制，就是一旦出现编译错误时，编译器会从哪些地方查找对应的隐式转换规则，

当前代码作用域当前代码上级作用域当前类所在的包对象当前类（对象）的父类（父类）或特质（父特质）

其实最直接的方式就是直接导入。

十一丶泛型

Scala泛型和Java泛型表达的含义都是一样的，对处理的数据类型进行约束但是Scala提供，了更强大的功能

Scala的泛型可以根据功能进行改变

泛型不可变

def main(args: Array[String]): Unit = {

val test : Test[User] = new Test [User]

val test1 : Test[Parent]= new Test[Parent]

//val test1 : Test[User]= new Test[Parent] Error

//val test2 : Test[User]= new Test[SubUser] Error

class Test[T]{

}

class Parent{

}

class User extends Parent{

}

class SubUser extends User{

}

}

泛型协变

val test : Test[User] = new Test[SubUser]

class Test[+T]{

}

class SubUser extends User{

}

泛型逆变

val test : Test[User] = new Test[Parent]

class Test[-T] {

}

class Parent {

}

class User extends Parent{

}

泛型边界

def main(args: Array[String]): Unit = {

val parent : Parent = new Parent()

val user : User = new User()

val subuser : SubUser = new SubUser()

test[User](parent) // Error

test[User](user) // OK

test[User](subuser) // OK

}

def test[A]( a : A ): Unit = {

println(a)

}

class Parent {

}

class User extends Parent{

}

class SubUser extends User {

}

 泛型上限（父类被限制）

def main(args: Array[String]): Unit = {

val parent : Parent = new Parent()

val user : User = new User()

val subuser : SubUser = new SubUser()

test[Parent](parent) // Error

test[User](user) // OK

test[SubUser](subuser) // OK

}

def test[A<:User]( a : A ): Unit = {

println(a)

}

class Parent {

}

class User extends Parent{

}

class SubUser extends User {

}

泛型下限（子类被限制）

def main(args: Array[String]): Unit = {

val parent : Parent = new Parent()

val user : User = new User()

val subuser : SubUser = new SubUser()

test[Parent](parent) // OK

test[User](user) // OK

test[SubUser](subuser) // Error

}

def test[A>:User]( a : A ): Unit = {

println(a)

}

class Parent {

}

class User extends Parent{

}

class SubUser extends User {

}

上下文限定

上下文限定是将泛型和隐式转换结合的产物，以下两者功能相同使用上下文限定[A : Ordering]之后，方法内无法使用隐式参数名调用隐式参数，需要通过implicitly[Ordering[A]]获取隐式变量，如果此时无法查找到对应类型的隐式变量，会发生出错误。

def main(args: Array[String]): Unit = {

def f[A : Test](a: A) = println(a)

implicit val test : Test[User] = new Test[User]

f( new User() )

}

class Test[T] {

}

class Parent {

}

class User extends Parent{

}

class SubUser extends User {

}

十二丶正则表达式

基本语法