暴走女 發表於 2023-11-1 11:22:03

Scala基础语法总结

<h2>一、变量</h2>
<div class="jb51code"><pre class="brush:scala;">val/var 变量名称:变量类型 = 初始值</pre></div>
<p>注意：</p>
<ul><li><p><code>val</code>定义的是<strong>不可重新赋值</strong>的变量(值不可修改)</p></li><li><p><code>var</code>定义的是<strong>可重新赋值</strong>的变量(值可以修改)</p></li></ul>
<ul><li><p>scala中声明变量是变量名称在前，变量类型在后，跟java是正好相反</p></li><li><p>scala的语句最后不需要添加分号、、</p></li></ul>
<p>&nbsp;惰性变量</p>
<ul><li><p>Scala中使用==关键字lazy==来定义惰性变量，实现延迟加载(懒加载)。</p></li><li><p>惰性变量只能是不可变变量，并且只有在调用惰性变量时，才会去实例化这个变量。</p></li><li><p>语法格式</p></li></ul>
<div class="jb51code"><pre class="brush:scala;">lazy val 变量名 = 表达式</pre></div>
<h2>&nbsp;二、数据类型</h2>
<table><tbody><tr><th>基础类型</th><th>类型说明</th></tr><tr><td>Byte</td><td>8位带符号整数</td></tr><tr><td>Short</td><td>16位带符号整数</td></tr><tr><td><strong>Int</strong></td><td>32位带符号整数</td></tr><tr><td>Long</td><td>64位带符号整数</td></tr><tr><td>Char</td><td>16位无符号Unicode字符</td></tr><tr><td>String</td><td>Char类型的序列（字符串）</td></tr><tr><td>Float</td><td>32位单精度浮点数</td></tr><tr><td>Double</td><td>64位双精度浮点数</td></tr><tr><td>Boolean</td><td>true或false</td></tr></tbody></table>
<p>1. scala中所有的类型都使用大写字母开头，说明是它是&ldquo;类&rdquo;<br />2. 整形使用Int而不是Integer<br />3. scala中定义变量可以不写类型，让scala编译器自动推断&nbsp;</p>
<h2>三、scala中的条件表达式</h2>
<p><strong>1、if表达式</strong></p>
<p>这个和java差不多，可以加括号，或者不加括号</p>
<div class="jb51code"><pre class="brush:scala;">def main(args: Array): Unit = {
   val x:Int=2
   if (x&amp;gt;10) println(x)
   else println(x+x)
}</pre></div>
<p>打印为2</p>
<p><strong>2、块表达式</strong></p>
<p>定义变量时用 {} 包含一系列表达式，其中块的最后一个表达式的值就是块的值</p>
<div class="jb51code"><pre class="brush:scala;">def main(args: Array): Unit = {

    val x = 0
    val result = {
      val y = x + 10
      val z = y + "-hello"
      val m = z + "-kaikeba"
      "over"
    }
    println(result)
}</pre></div>
<p>打印结果</p>
<div class="jb51code"><pre class="brush:scala;">over

Process finished with exit code 0</pre></div>
<p>返回值就是m了&nbsp;</p>
<div class="jb51code"><pre class="brush:scala;">def main(args: Array): Unit = {
    val x = 0
    val result = {
      val y = x + 10
      val z = y + "-hello"
      val m = z + "-kaikeba"
      m
    }
    println(result)
}</pre></div>
<p>打印结果</p>
<div class="jb51code"><pre class="brush:scala;">10-hello-kaikeba</pre></div>
<h2>四、循环</h2>
<p>在scala中，可以使用for和while，但一般推荐使用for表达式，因为for表达式语法更简洁</p>
<div class="jb51code"><pre class="brush:scala;">for (i &amp;lt;- 表达式/数组/集合){
    //表达式
}</pre></div>
<p><strong>1、简单for循环</strong></p>
<div class="jb51code"><pre class="brush:scala;">def main(args: Array): Unit = {
    var nums=1 to 10
    //for循环
    for(i &amp;lt;- nums) println(i)
}</pre></div>
<p><strong>2、双层for循环</strong></p>
<div class="jb51code"><pre class="brush:scala;">def main(args: Array): Unit = {

    //双层for循环
    for (i &amp;lt;- 1 to 3; j &amp;lt;- 1 to 3)
      println(i * 10 + j)
}</pre></div>
<p>打印的值为</p>
<div class="jb51code"><pre class="brush:scala;">11
12
13
21
22
23
31
32
33</pre></div>
<p><strong>3、守卫</strong>：在for表达式中可以添加if判断语句，这个if判断称为守卫</p>
<div class="jb51code"><pre class="brush:scala;"> def main(args: Array): Unit = {
//    守卫
    var nums = 1 to 10
    for (i &amp;lt;- nums if i&amp;gt;5 ) println(i)
}</pre></div>
<p>打印的值为：&nbsp;</p>
<div class="jb51code"><pre class="brush:scala;">6
7
8
9
10</pre></div>
<p><strong>4、yield表达式&nbsp;</strong></p>
<p>在for循环体中，以yield表达式开始，这类循环能构建出一个新的集合，我们把这类循环称为推导式</p>
<div class="jb51code"><pre class="brush:scala;">def main(args: Array): Unit = {

    // for推导式：for表达式中以yield开始，该for表达式会构建出一个集合
    val v = for(i &amp;lt;- 1 to 5) yield i * 10
    //打印集合v的第一个元素
    println(v(0))
}</pre></div>
<p>打印的值为</p>
<div class="jb51code"><pre class="brush:scala;">10</pre></div>
<h2>五、while循环</h2>
<div class="jb51code"><pre class="brush:scala;">while(返回值为布尔类型的表达式){
    //表达式
}</pre></div>
<h2>六、方法</h2>
<div class="jb51code"><pre class="brush:scala;">def methodName (参数名:参数类型, 参数名:参数类型) : = {
    // 方法体：一系列的代码
}</pre></div>
<ul><li><p>参数列表的参数类型不能省略</p></li><li><p>返回值类型可以省略，由scala编译器自动推断</p></li><li><p>返回值可以不写return，默认就是{}块表达式的值 &nbsp;</p></li><li><p>注意：</p></li><li><p>如果定义递归方法，必须指定返回值类型</p></li><li><p>示例：（方法三）</p></li><li><p>定义递归方法（求阶乘）</p></li><li><p>10 * 9 * 8 * 7 * 6 * ... * 1</p></li></ul>
<div class="jb51code"><pre class="brush:scala;">//方法一
def yy(i: Int = 10, u: Int = 8): Int = {
    return i + u;
}

//方法二
def tt(i: Int) = i * i


/**
   * 递归必须添加返回值参数
   *
   * @param x
   * @return
   */
//方法三
def m1(x: Int): Int = {
    if (x == 1) 1
    else x * m1(x - 1)
}

/**
   * 参数值加*，可以传递多个参数
   *
   * @param num
   * @return
   */
//    方法四
def add(num: Int*) = num.sum

def main(args: Array): Unit = {
   
      println(yy(1))
      println(tt(8))
      println(m1(10))
      println(add(1,2,3))
}</pre></div>
<p>打印的值为</p>
<div class="jb51code"><pre class="brush:scala;">9
64
3628800
6</pre></div>
<h2>6、函数</h2>
<ul><li><p>函数在scala中属于头等公民</p>
<ul><li><p>数字能做的事，函数也可以</p></li><li><p>数字可以作为参数，所以函数也可以作为其他方法或函数的参数</p></li><li><p>数字可以作为返回值，所以函数也可以作为其他方法或函数的返回值</p></li><li><p>数字可以赋值给一个变量，所以函数也可以赋值给一个变量</p></li></ul></li><li><p>scala支持函数式编程，将来编写Spark/Flink程序中，会大量使用到函数</p></li><li><p>语法</p></li></ul>
<div class="jb51code"><pre class="brush:scala;">val 函数变量名 = (参数名:参数类型, 参数名:参数类型....) =&amp;gt; 函数体</pre></div>
<p><strong>注意</strong></p>
<ul><li><p>函数是一个对象（变量）</p></li><li><p>类似于方法，函数也有输入参数和返回值</p></li><li><p>函数定义不需要使用def定义</p></li><li><p>无需指定返回值类型</p></li></ul>
<div class="jb51code"><pre class="brush:scala;"> val add2 = (x: Int, y: Int) =&amp;gt; x * y
def main(args: Array): Unit = {
      println(add2(2,4))
}</pre></div>
<p>&nbsp;打印的值为</p>
<div class="jb51code"><pre class="brush:scala;">8</pre></div>
<p><strong>方法和函数的区别</strong></p>
<ul><li><p>方法是隶属于类或者对象的，在运行时，它是加载到JVM的==方法区==中</p></li><li><p>可以将函数对象赋值给一个变量，在运行时，它是加载到JVM的==堆内存==中</p></li><li><p>函数是一个对象，继承自FunctionN，函数对象有apply，curried，toString，tupled这些方法，而方法则没有</p></li></ul>
<p><strong>方法转换为函数</strong></p>
<ul><li><p>有时候需要将方法转换为函数，作为变量传递，就需要将方法转换为函数</p></li><li><p>使用&nbsp;<code>_&nbsp;</code>即可将方法转换为函数（记得空格）</p></li><li><div class="jb51code"><pre class="brush:scala;"> //方法三
def m1(x: Int): Int = {
    if (x == 1) 1
    else x * m1(x - 1)
}
val hanshu=m1 _;
def main(args: Array): Unit = {

    println(hanshu(10))
}</pre></div>
<p>打印的结果&nbsp;</p></li><li><div class="jb51code"><pre class="brush:scala;">3628800</pre></div>
<h2>7、数组</h2></li><li><p>scala中数组的概念是和Java类似，可以用数组来存放同类型的一组数据</p></li><li><p>scala中，有两种数组，一种是<strong>定长数组</strong>，另一种是<strong>变长数组&nbsp;</strong></p></li></ul>
<h3>（1）、定长数组</h3>
<ul><li><p>定长数组指的是数组的<strong>长度</strong>是<strong>不允许改变</strong>的</p></li><li><p>数组的<strong>元素</strong>是<strong>可以改变</strong>的</p></li></ul>
<p>demo如下&nbsp;</p>
<div class="jb51code"><pre class="brush:scala;">def main(args: Array): Unit = {
    val a = new Array(10)
    println(a)
    a(0)=98
    println(a(0))
    println(a(1))
    println(a.length)
}</pre></div>
<p>&nbsp;打印的值为：</p>
<div class="jb51code"><pre class="brush:scala;">[I@ea4a92b
98
0
10</pre></div>
<h3>（2）、变长数组</h3>
<ul><li><p>变长数组指的是数组的长度是可变的，可以往数组中添加、删除元素</p></li><li><p>创建变长数组，需要提前导入ArrayBuffer类</p></li></ul>
<div class="jb51code"><pre class="brush:scala;">import scala.collection.mutable.ArrayBuffer</pre></div>
<p></p>
<p>语法</p>
<ul><li><p>创建空的ArrayBuffer变长数组</p></li><li><div class="jb51code"><pre class="brush:scala;">val/var a = ArrayBuffer[元素类型]()</pre></div>
<p>创建带有初始元素的ArrayBuffer</p></li><li><div class="jb51code"><pre class="brush:scala;">val/var a = ArrayBuffer(元素1，元素2，元素3....)</pre></div>
<p><strong>变长数组的增删改操作</strong></p></li><li><p>使用<code>+=</code>添加元素</p></li><li><p>使用<code>-=</code>删除元素</p></li><li><p>使用<code>++=</code>追加一个数组到变长数组</p></li></ul>
<p>demo如下&nbsp;</p>
<div class="jb51code"><pre class="brush:scala;">def main(args: Array): Unit = {
    //变长数组
    val a = ArrayBuffer();
    a+=("test")
    a+=("张三")
    a++=Array("妞儿","所以算是")
    println(a(3))
    println(a.size)
}
}
</pre></div>
<p>打印的值为</p>
<div class="jb51code"><pre class="brush:scala;">所以算是
4</pre></div>
<h3>（3）、遍历数组</h3>
<p>可以使用以下两种方式来遍历数组：</p>
<ul><li><p>使用==for表达式== 直接遍历数组中的元素</p></li><li><p>使用 ==索引== 获得数组中的元素</p></li></ul>
<p></p>
<div class="jb51code"><pre class="brush:scala;">for(i &amp;lt;- a) println(i)</pre></div>
<div class="jb51code"><pre class="brush:scala;">/0 to n    ——包含0，也包含n
for(i &amp;lt;- 0 to a.length -1 ) println(a(i))</pre></div>
<div class="jb51code"><pre class="brush:scala;">//0 until n ——生成一系列的数字，包含0，不包含n
for(i &amp;lt;- 0 until a.length) println(a(i))</pre></div>
<h3>（4）、数组常用操作</h3>
<p>scala中的数组封装了丰富的计算操作，将来在对数据处理的时候，不需要我们自己再重新实现。</p>
<ul><li><p>求和&mdash;&mdash;sum方法</p></li><li><p>求最大值&mdash;&mdash;max方法</p></li><li><p>求最小值&mdash;&mdash;min方法</p></li><li><p>排序&mdash;&mdash;sorted方法</p></li></ul>
<div class="jb51code"><pre class="brush:scala;"> def main(args: Array): Unit = {

    val array = Array(1,3,4,2,5)
    println("求和："+array.sum)
    println("最大值："+array.max)
    println("最小值："+array.min)
    println("排序(获取一个新数组，并翻转)："+array.sorted.reverse(0))

}</pre></div>
<p>&nbsp;打印如下</p>
<div class="jb51code"><pre class="brush:scala;">求和：15
最大值：5
最小值：1
排序(获取一个新数组，并翻转)：5</pre></div>
<h2>8、元组&nbsp;</h2>
<p>元组可以用来包含一组<strong>不同类型</strong>的值。例如：姓名，年龄，性别，出生年月。</p>
<p><strong>元组的元素是不可变的。</strong></p>
<p><strong>1、定义元组</strong></p>
<p>使用括号来定义元组</p>
<div class="jb51code"><pre class="brush:scala;">val/var 元组变量名称 = (元素1, 元素2, 元素3....)</pre></div>
<p>使用箭头来定义元素（元组只有两个元素 )</p>
<div class="jb51code"><pre class="brush:scala;">val/var 元组 = 元素1 -&amp;gt; 元素2</pre></div>
<p><strong>2、访问元组</strong></p>
<ul><li><p>使用&nbsp;<code>_1、_2、_3....</code>来访问元组中的元素</p></li><li><p>元组的index从<strong>1开始，_1表示访问第一个元素，依次类</strong>推</p></li><li><p></p></li></ul>
<div class="jb51code"><pre class="brush:scala;">
def main(args: Array): Unit = {
    val a = (1, "张三", 20, "北京市")
    val b = 1 -&amp;gt; 2
    println(a._1)
    println(a._4)
    println(b._1)
}</pre></div>
<p>&nbsp;打印的值为</p>
<div class="jb51code"><pre class="brush:scala;">1
北京市
1</pre></div>
<h2>9、映射Map</h2>
<ul><li><p>Map可以称之为映射。它是由键值对组成的集合。scala当中的Map集合与java当中的Map类似，也是key，value对形式的。</p></li><li><p>在scala中，Map也分为不可变Map和可变 Map。</p></li></ul>
<h3>（1）、不可变map</h3>
<p>&nbsp; 定义语法</p>
<div class="jb51code"><pre class="brush:scala;">val/var map = Map(键-&amp;gt;值, 键-&amp;gt;值, 键-&amp;gt;值...)    // 推荐这种写法，可读性更好
val/var map = Map((键, 值), (键, 值), (键, 值), (键, 值)...)</pre></div>
<div class="jb51code"><pre class="brush:scala;">def main(args: Array): Unit = {
    val map1 = Map("zhangsan"-&amp;gt;30, "lisi"-&amp;gt;40)
    val map2 = Map(("zhangsan", 30), ("lisi", 30))
    println(map1("lisi"))
    println(map2("zhangsan"))
}</pre></div>
<p>打印的值为</p>
<div class="jb51code"><pre class="brush:scala;">40
30</pre></div>
<h3>（2）、可变Map</h3>
<p><strong>1、导包</strong></p>
<div class="jb51code"><pre class="brush:scala;">import scala.collection.mutable.Map</pre></div>
<div class="jb51code"><pre class="brush:scala;">def main(args: Array): Unit = {

    val map3 = Map("zhangsan" -&amp;gt; 30, "lisi" -&amp;gt; 40)
    //修改一个
    map3("zhangsan") = 50
    println("修改的" + map3)
    //添加一个
    map3 += ("yy" -&amp;gt; 22)
    println("添加的" + map3)
    //删去一个
    map3 -= "yy"
    println("删除的" + map3)
    //拿取到map所有key
    println("拿取到map所有key:" + map3.keys)
    println("拿取到map所有key:" + map3.keySet)
    //获取所有的value
    println("获取所有的value:" + map3.values)
}</pre></div>
<p>打印的值为：&nbsp;</p>
<div class="jb51code"><pre class="brush:scala;">修改的Map(lisi -&amp;gt; 40, zhangsan -&amp;gt; 50)
添加的Map(yy -&amp;gt; 22, lisi -&amp;gt; 40, zhangsan -&amp;gt; 50)
删除的Map(lisi -&amp;gt; 40, zhangsan -&amp;gt; 50)
拿取到map所有key:Set(lisi, zhangsan)
拿取到map所有key:Set(lisi, zhangsan)
获取所有的value:HashMap(40, 50)</pre></div>
<h3>（3)、遍历Map</h3>
<div class="jb51code"><pre class="brush:scala;">   val map3 = Map("zhangsan" -&amp;gt; 30, "lisi" -&amp;gt; 40)
    //方法一。通过遍历key拿取到值
    for (i &amp;lt;- map3.keys) println(i + "-&amp;gt;" + map3(i))
    //方法二，通过元组的方法拿取到值
    for (i &amp;lt;- map3) println(i._1 + "-&amp;gt;" + i._2)
    //方法三
    for((k, v) &amp;lt;- map3) println(k + " -&amp;gt; " + v)</pre></div>
<div class="jb51code"><pre class="brush:scala;">lisi-&amp;gt;40
zhangsan-&amp;gt;30
lisi-&amp;gt;40
zhangsan-&amp;gt;30
lisi -&amp;gt; 40
zhangsan -&amp;gt; 30</pre></div>
<h2>10、Set集合</h2>
<ul><li><p>Set是代表没有重复元素的集合。</p></li><li><p>Set具备以下性质：</p>
<ul><li><p>1、元素不重复</p></li><li><p>2、不保证插入顺序</p></li></ul></li><li><p>scala中的set集合也分为两种，一种是不可变集合，另一种是可变集合。</p></li></ul>
<p><strong>不可变set集合&nbsp;</strong></p>
<div class="jb51code"><pre class="brush:scala;">//创建一个空的不可变集
val/var 变量名 = Set[类型]()

//给定元素来创建一个不可变集
val/var 变量名 = Set[类型](元素1, 元素2, 元素3...)
</pre></div>
<div class="jb51code"><pre class="brush:scala;"> def main(args: Array): Unit = {
    val a = Set(1, 1, 2, 3, 4, 5)
    println("a的长度大小"+a.size)
    for(i&amp;lt;-a)println(i)
    println("添加一个元素的新set:",a + 6)
    println("删除一个元素的新set:",a -1)
    println("删除多个元素的新set:",a -- Set(2,3) )
    println("添加多个元素的新set:",a ++ Set(6,7,8))
    println("多个Set集合交集的新set:",a &amp;amp; Set(3,4,5,6))
    println(a)
}</pre></div>
<p>打印如下：</p>
<div class="jb51code"><pre class="brush:scala;">a的长度大小5
5
1
2
3
4
(添加一个元素的新set:,Set(5, 1, 6, 2, 3, 4))
(删除一个元素的新set:,Set(5, 2, 3, 4))
(删除多个元素的新set:,Set(5, 1, 4))
(添加多个元素的新set:,Set(5, 1, 6, 2, 7, 3, 8, 4))
(多个Set集合交集的新set:,Set(5, 3, 4))
Set(5, 1, 2, 3, 4)</pre></div>
<p>注意：这里对不可变的set集合进行添加删除等操作，对于该集合来说是没有发生任何变化，这里是生成了新的集合，新的集合相比于原来的集合来说发生了变化</p>
<p><strong>可变Set集合</strong></p>
<p>要使用可变集，必须要手动导入：</p>
<div class="jb51code"><pre class="brush:scala;">import scala.collection.mutable.Set</pre></div>
<h2>11、列表 List</h2>
<ul><li><p>List是scala中最重要的、也是最常用的数据结构。</p></li><li><p>List具备以下性质：</p>
<ul><li><p>1、可以保存重复的值</p></li><li><p>2、有先后顺序</p></li></ul></li><li><p>在scala中，也有两种列表，一种是不可变列表、另一种是可变列表</p></li><li><p>不可变列表就是列表的元素、长度都是不可变的</p></li><li><p>语法</p>
<h3>不可变列表</h3></li><li>使用 List(元素1, 元素2, 元素3, ...) 来创建一个不可变列表，语法格式</li></ul>
<div class="jb51code"><pre class="brush:scala;">val/var 变量名 = List(元素1, 元素2, 元素3...)

//使用 Nil 创建一个不可变的空列表
val/var 变量名 = Nil

//使用 :: 方法创建一个不可变列表
val/var 变量名 = 元素1 :: 元素2 :: Nil</pre></div>
<div class="jb51code"><pre class="brush:scala;"> def main(args: Array): Unit = {
    val list1 = List(1, 2, 3, 4)
    val list2 = Nil
    val list3= 1::2::3::Nil
    println(list1(0))
    println(list3)
}</pre></div>
<p>&nbsp;打印的值为</p>
<div class="jb51code"><pre class="brush:scala;">1
List(1, 2, 3)
</pre></div>
<h3>可变列表</h3>
<p>1、使用ListBuffer元素类型&nbsp;创建空的可变列表，语法结构</p>
<div class="jb51code"><pre class="brush:scala;">val/var 变量名 = ListBuffer()</pre></div>
<p>2、使用ListBuffer(元素1, 元素2, 元素3...)创建可变列表，语法结构</p>
<div class="jb51code"><pre class="brush:scala;">val/var 变量名 = ListBuffer(元素1，元素2，元素3...)</pre></div>
<div class="jb51code"><pre class="brush:scala;">    val a = ListBuffer()
    val b = ListBuffer(1, 2, 3, 4)
    println(b(0))
    println("list数组首部:", b.head)
    println("获取除了第一个元素外其他元素组成的列表", b.tail)
    b += 5
    println("添加应元素", b)
    b ++= List(6, 7)
    println("添加一个不可变列表", b)
    b ++= ListBuffer(8, 9)
    println("添加一个可变列表", b)
    b -= 9
    println("删除单个元素", b)
    b --= List(7,8)
    println("删除一个不可变的列表存在的元素", b)
    b --= ListBuffer(5,6)
    println("删除一个可变的列表存在的元素", b)
    println("toList根据可变的列表生成一个不可变列表",b.toList)
    println("toList根据可变的列表生成一个不可变列表，原列表不变",b)

    println("toArray根据可变的列表生成一个新的不可变数组",b.toArray)
    println("toArray根据可变的列表生成一个新的不可变数组，原列表不变",b)</pre></div>
<p>打印如下</p>
<div class="jb51code"><pre class="brush:scala;">1
(list数组首部:,1)
(获取除了第一个元素外其他元素组成的列表,ListBuffer(2, 3, 4))
(添加应元素,ListBuffer(1, 2, 3, 4, 5))
(添加一个不可变列表,ListBuffer(1, 2, 3, 4, 5, 6, 7))
(添加一个可变列表,ListBuffer(1, 2, 3, 4, 5, 6, 7, 8, 9))
(删除单个元素,ListBuffer(1, 2, 3, 4, 5, 6, 7, 8))
(删除一个不可变的列表存在的元素,ListBuffer(1, 2, 3, 4, 5, 6))
(删除一个可变的列表存在的元素,ListBuffer(1, 2, 3, 4))
(toList根据可变的列表生成一个不可变列表,List(1, 2, 3, 4))
(toList根据可变的列表生成一个不可变列表，原列表不变,ListBuffer(1, 2, 3, 4))
(toArray根据可变的列表生成一个新的不可变数组,[I@3567135c)
(toArray根据可变的列表生成一个新的不可变数组，原列表不变,ListBuffer(1, 2, 3, 4))</pre></div>
<h2>12、函数式编程</h2>
<ul><li><p>我们将来使用Spark/Flink的大量业务代码都会使用到函数式编程。</p></li><li><p>下面的这些操作是学习的重点，先来感受下如何进行函数式编程以及它的强大</p></li></ul>
<h3>（1）、遍历 - foreach</h3>
<p>方法描述</p>
<div class="jb51code"><pre class="brush:scala;">foreach(f: (A) ⇒ Unit): Unit</pre></div>
<table><tbody><tr><th>foreach</th><th>API</th><th>说明</th></tr><tr><td>参数</td><td>f: (A) &rArr; Unit</td><td>接收一个函数对象作为参数 函数的输入参数为集合的元素 返回值为空</td></tr><tr><td>返回值</td><td>Unit</td><td>空</td></tr></tbody></table>
<div class="jb51code"><pre class="brush:scala;">def main(args: Array): Unit = {
    val list = List(1, 2, 3, 4)
    //定义一个匿名函数传入到foreach方法中
    list.foreach((u: Int) =&amp;gt; println(u))
    //匿名函数的输入参数类型可以省略，由编译器自动推断
    list.foreach(u =&amp;gt; println(u))
    //当函数参数，只在函数体中出现一次，而且函数体没有嵌套调用时，可以使用下划线来简化函数定义
    list.foreach(println(_))
    //最简单直接
    list.foreach(println)
}</pre></div>
<h3>（2）、映射 - map</h3>
<ul><li><p>集合的映射操作是将来在编写Spark/Flink用得最多的操作，是我们必须要掌握。</p></li><li><p>方法描述</p></li></ul>
<div class="jb51code"><pre class="brush:scala;">def map(f: (A) ⇒ B): TraversableOnce</pre></div>
<ul><li><p>方法说明</p></li></ul>
<table><tbody><tr><th>ap方法</th><th>API</th><th>说明</th></tr><tr><td>泛型</td><td></td><td>指定map方法最终返回的集合泛型</td></tr><tr><td>参数</td><td>f: (A) &rArr; B</td><td>传入一个函数对象作为参数 该函数接收一个类型A（要转换的集合的元素类型） 返回值为类型B</td></tr><tr><td>返回值</td><td>TraversableOnce</td><td>B类型的集合</td></tr></tbody></table>
<p></p>
<div class="jb51code"><pre class="brush:scala;">    val list = List(1, 2, 3, 4)
    //定义一个匿名函数
    val b=list.map((i:Int)=&amp;gt;i*10)
    println(b)
    //省略匿名函数参数类型
    val c=list.map(i=&amp;gt;i*10)
    println(c)
    //最简单用下划线的方法
    val d=list.map(_ * 10)
    println(d)</pre></div>
<p>打印结果如下</p>
<div class="jb51code"><pre class="brush:scala;">List(10, 20, 30, 40)
List(10, 20, 30, 40)
List(10, 20, 30, 40)</pre></div>
<h3>（3）、扁平化映射 - flatmap</h3>
<ul><li><p>映射扁平化也是将来用得非常多的操作，也是必须要掌握的。</p></li><li><p>方法描述</p></li></ul>
<div class="jb51code"><pre class="brush:scala;">def flatMap(f: (A) ⇒ GenTraversableOnce): TraversableOnce</pre></div>
<p>方法说明 &nbsp;</p>
<table><tbody><tr><th>flatmap方法</th><th>API</th><th>说明</th></tr><tr><td>泛型</td><td></td><td>最终要转换的集合元素类型</td></tr><tr><td>参数</td><td>f: (A) &rArr; GenTraversableOnce</td><td>传入一个函数对象作为参数 函数的参数是集合的元素 函数的返回值是一个集合</td></tr><tr><td>返回值</td><td>TraversableOnce</td><td>B类型的集合</td></tr></tbody></table>
<p></p>
<div class="jb51code"><pre class="brush:scala;">def main(args: Array): Unit = {
    val list = List("hadoop hive spark flink", "hbase spark")
    val tt = list.flatMap(x =&amp;gt; x.split(" "));
    println(tt)
    //简写
    val t2 = list.flatMap(_.split(" "))
    println(t2)
    //flatMap该方法其本质是先进行了map 然后又调用了flatten
    val t3 = list.map(_.split(" ")).flatten
    println(t3)
}</pre></div>
<p>打印结果如下</p>
<div class="jb51code"><pre class="brush:scala;">List(hadoop, hive, spark, flink, hbase, spark)
List(hadoop, hive, spark, flink, hbase, spark)
List(hadoop, hive, spark, flink, hbase, spark)</pre></div>
<h3>（4）、过滤 - filter</h3>
<ul><li><p>过滤符合一定条件的元素</p></li><li><p>方法描述</p></li></ul>
<div class="jb51code"><pre class="brush:scala;">def filter(p: (A) ⇒ Boolean): TraversableOnce</pre></div>
<p>&nbsp;方法说明</p>
<table><tbody><tr><th>filter方法</th><th>API</th><th>说明</th></tr><tr><td>参数</td><td>p: (A) &rArr; Boolean</td><td>传入一个函数对象作为参数 函数的参数是集合中的元素 此函数返回布尔类型，满足条件返回true, 不满足返回false</td></tr><tr><td>返回值</td><td>TraversableOnce</td><td>列表</td></tr></tbody></table>
<p>&nbsp;demo展示</p>
<div class="jb51code"><pre class="brush:scala;">def main(args: Array): Unit = {
    val list = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    ///过滤出集合中大于5的元素
    val tt=list.filter(x=&amp;gt;x&amp;gt;5)
    println(tt)
    //把集合中大于5的元素取出来乘以10生成一个新的list集合
    val t3=list.filter(x=&amp;gt;x&amp;gt;5).map(u=&amp;gt;u*10)
    println(t3)
}</pre></div>
<p>&nbsp;打印的值为：</p>
<div class="jb51code"><pre class="brush:scala;">List(6, 7, 8, 9, 10)
List(60, 70, 80, 90, 100)</pre></div>
<h3>（5） 、分组 - groupBy</h3>
<ul><li><p>首先集合的元素得是kv对的；</p></li><li><p>如果要将数据按照某值分组来进行统计分析，就需要使用到分组方法</p></li><li><p>groupBy表示按照函数将列表分成不同的组</p></li><li><p>方法描述</p></li></ul>
<blockquote><p>def groupBy(f: (A) &rArr; K): Map]&nbsp;</p></blockquote>
<ul><li><p>方法说明</p></li></ul>
<table><tbody><tr><th>groupBy方法</th><th>API</th><th>说明</th></tr><tr><td>泛型</td><td></td><td>分组字段的类型</td></tr><tr><td>参数</td><td>f: (A) &rArr; K</td><td>传入一个函数对象 接收集合元素类型的参数 返回一个K类型的key，这个key会用来进行分组，相同的key放在一组中</td></tr><tr><td>返回值</td><td>Map]</td><td>返回一个映射，K为分组字段，List为这个分组字段对应的一组数据</td></tr></tbody></table>
<blockquote><p>scala&gt; val a = List(&quot;张三&quot;-&gt;&quot;男&quot;, &quot;李四&quot;-&gt;&quot;女&quot;, &quot;王五&quot;-&gt;&quot;男&quot;)<br />a: List[(String, String)] = List((张三,男), (李四,女), (王五,男))</p>
<p>// 按照性别分组<br />scala&gt; a.groupBy(_._2)<br />res0: scala.collection.immutable.Map] = Map(男 -&gt; List((张三,男), (王五,男)),<br />女 -&gt; List((李四,女)))</p>
<p>// 将分组后的映射转换为性别/人数元组列表<br />scala&gt; res0.map(x =&gt; x._1 -&gt; x._2.size)<br />res3: scala.collection.immutable.Map = Map(男 -&gt; 2, 女 -&gt; 1)</p>
<p>//根据这个例子，思考下，作业中如何使用scala编程，实现词频统计？<br />&nbsp;</p>
<p>//求每个省份有多少人？<br />val b = List(&quot;张三&quot;-&gt;(&quot;男&quot;, &quot;北京&quot;), &quot;李四&quot;-&gt;(&quot;女&quot;, &quot;河北&quot;), &quot;王五&quot;-&gt;(&quot;男&quot;, &quot;北京&quot;))</p>
<p>scala&gt; b.groupBy(_._2._2).map(x =&gt; (x._1, x._2.size))<br />res14: scala.collection.immutable.Map = Map(北京 -&gt; 2, 河北 -&gt; 1)</p>
<p></p></blockquote>
<blockquote><div class="jb51code"><pre class="brush:scala;">object yyy {
def main(args: Array): Unit = {
   val a = List("张三"-&amp;gt;"男", "李四"-&amp;gt;"女", "王五"-&amp;gt;"男")
    println(a.groupBy(_._2))

    val list2 =List("a,b,c","y,c,a,e,a,c,a")
    var map=list2.flatMap(x=&amp;gt;x.split(",")).groupBy(x=&amp;gt;x).map(y=&amp;gt;(y._1,y._2.size));
    println(map)
    println("a的个数是:"+map("a"))
}
}</pre></div></blockquote>
<p>打印的值为&nbsp;</p>
<blockquote><p>Map(男 -&gt; List((张三,男), (王五,男)), 女 -&gt; List((李四,女)))<br />Map(e -&gt; 1, y -&gt; 1, a -&gt; 4, b -&gt; 1, c -&gt; 3)<br />a的个数是:4</p></blockquote>
<h3>（6）、排序 - sort</h3>
<p>在scala集合中，可以使用以下几种方式来进行排序</p>
<ul><li><p>sorted默认排序</p></li><li><p>sortBy指定字段排序</p></li><li><p>sortWith自定义排序</p></li></ul>
<p><strong>sorted默认排序</strong></p>
<div class="jb51code"><pre class="brush:scala;"> def main(args: Array): Unit = {
    val list = List(5, 1, 2, 4, 3)
    println(list.sorted)
}
</pre></div>
<div class="jb51code"><pre class="brush:scala;">List(1, 2, 3, 4, 5)</pre></div>
<p><strong>sortBy指定字段排序</strong></p>
<div class="jb51code"><pre class="brush:scala;">def sortBy(f: (A) ⇒ B): List</pre></div>
<table><tbody><tr><th>sortBy方法</th><th>API</th><th>说明</th></tr><tr><td>泛型</td><td></td><td>按照什么类型来进行排序</td></tr><tr><td>参数</td><td>f: (A) &rArr; B</td><td>传入函数对象作为参数 函数接收一个集合类型的元素为参数 返回B类型的元素进行排序</td></tr><tr><td>返回值</td><td>List</td><td>返回排序后的列表</td></tr></tbody></table>
<p>结果如下：&nbsp;</p>
<div class="jb51code"><pre class="brush:scala;"> val list2 = List("1 hadoop", "2 spark", "3 flink")
    println(list2.sortBy(x=&amp;gt;x.split(" ")(0)))</pre></div>
<p>打印的结果如下：&nbsp;</p>
<div class="jb51code"><pre class="brush:scala;">List(1 hadoop, 2 spark, 3 flink)</pre></div>
<p><strong>sortWith自定义排序 &nbsp;</strong></p>
<ul><li><p>自定义排序，根据一个函数来进行自定义排序</p></li><li><p>方法描述</p></li></ul>
<div class="jb51code"><pre class="brush:scala;">def sortWith(lt: (A, A) ⇒ Boolean): List</pre></div>
<table><tbody><tr><th>sortWith方法</th><th>API</th><th>说明</th></tr><tr><td>参数</td><td>lt: (A, A) &rArr; Boolean</td><td>传入一个比较大小的函数对象作为参数 函数接收两个集合类型的元素作为参数 返回两个元素大小，小于返回true，大于返回false</td></tr><tr><td>返回值</td><td>List</td><td>返回排序后的列表</td></tr></tbody></table>
<div class="jb51code"><pre class="brush:scala;">   val list3 = List(2, 3, 1, 6, 4, 5)
    //降序
    var tt = list3.sortWith((x, y) =&amp;gt; x &amp;gt; y)
    println(tt)
    //升序
    var tt2 = list3.sortWith((x, y) =&amp;gt; x &amp;lt; y)
    println(tt2)
    //简写
    var tt3 =list3.sortWith(_ &amp;gt; _)
    println(tt3)</pre></div>
<p>&nbsp;打印的结果：</p>
<div class="jb51code"><pre class="brush:scala;">List(6, 5, 4, 3, 2, 1)
List(1, 2, 3, 4, 5, 6)
List(6, 5, 4, 3, 2, 1)</pre></div>
<p></p>
<h3>（5）、聚合 - reduce</h3>
<ul><li><p>reduce表示将列表，传入一个函数进行聚合计算</p></li><li><p>方法描述</p></li></ul>
<div class="jb51code"><pre class="brush:scala;">def reduce(op: (A1, A1) ⇒ A1): A1</pre></div>
<table><tbody><tr><th>reduce方法</th><th>API</th><th>说明</th></tr><tr><td>泛型</td><td></td><td>（下界）A1必须是集合元素类型的子类</td></tr><tr><td>参数</td><td>op: (A1, A1) &rArr; A1</td><td>传入函数对象，用来不断进行聚合操作 第一个A1类型参数为：当前聚合后的变量 第二个A1类型参数为：当前要进行聚合的元素</td></tr><tr><td>返回值</td><td>A1</td><td>列表最终聚合为一个元素</td></tr></tbody></table>
<div class="jb51code"><pre class="brush:scala;">def main(args: Array): Unit = {
    val a = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    //基础的写法
    var b = a.reduce((x, y) =&amp;gt; x + y)
    println("基础的写法"+b)
    //简单的写法
    var c = a.reduce(_ + _)
    println("简单的写法"+c)
    //从左往右计算
    var d = a.reduceLeft(_ + _)
    println("从左往右计算"+d)
   //从右往左计算
    var f = a.reduceRight(_ + _)
    println("从右往左计算"+f)
}
</pre></div>
<div class="jb51code"><pre class="brush:scala;">基础的写法55
简单的写法55
从左往右计算55
从右往左计算55</pre></div>
<h3>（6）、折叠 - fold</h3>
<p>fold与reduce很像，但是多了一个指定初始值参数</p>
<div class="jb51code"><pre class="brush:scala;">def fold(z: A1)(op: (A1, A1) ⇒ A1): A1</pre></div>
<table><tbody><tr><th>reduce方法</th><th>API</th><th>说明</th></tr><tr><td>泛型</td><td></td><td>（下界）A1必须是集合元素类型的子类</td></tr><tr><td>参数1</td><td>z: A1</td><td>初始值</td></tr><tr><td>参数2</td><td>op: (A1, A1) &rArr; A1</td><td>传入函数对象，用来不断进行折叠操作 第一个A1类型参数为：当前折叠后的变量 第二个A1类型参数为：当前要进行折叠的元素</td></tr><tr><td>返回值</td><td>A1</td><td>列表最终折叠为一个元素</td></tr></tbody></table>
<div class="jb51code"><pre class="brush:scala;">def main(args: Array): Unit = {
    val a = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

    var e = a.fold(0)(_ + _)
    println("简单折叠:",e)
    var g = a.fold(5)(_ + _)
    println("给定一个初始值，，折叠求和:"+g)
    var h=a.foldLeft(10)(_ + _)
    println("从左往右折叠:",h)

}</pre></div>
<div class="jb51code"><pre class="brush:scala;">(简单折叠:,55)
给定一个初始值，，折叠求和:60
(从左往右折叠:,65)</pre></div>
<h2>13、高阶函数</h2>
<p>使用函数值作为参数，或者返回值为函数值的&ldquo;函数&rdquo;和&ldquo;方法&rdquo;，均称之为&ldquo;高阶函数&rdquo;。</p>
<h3>1、函数值作为参数</h3>
<div class="jb51code"><pre class="brush:scala;">def main(args: Array): Unit = {
    //定义一个数组
    val array = Array(1, 2, 3, 4, 5)
    //定义一个函数
    val func = (x: Int) =&amp;gt; x * 10
    //函数作为参数传递到方法中
    val tt=array.map(func)
    println("通过map转化的新数组:",tt)
    println("通过map转化的新数组最大:",tt.max)
}</pre></div>
<p>打印的值为：</p>
<div class="jb51code"><pre class="brush:scala;">(通过map转化的新数组:,[I@17550481)
(通过map转化的新数组:,50)</pre></div>
<h3>2、匿名函数</h3>
<p>一个没有名称的函数---<strong>-匿名函数</strong></p>
<div class="jb51code"><pre class="brush:scala;"> def main(args: Array): Unit = {
    val array = Array(1, 2, 3, 4, 5)
    var a = array.map(x =&amp;gt; x * 10)
    println(a.max)
}</pre></div>
<p>打印的值为：&nbsp;</p>
<div class="jb51code"><pre class="brush:scala;">50</pre></div>
<h3>3、柯里化</h3>
<p>方法可以定义多个参数列表，当使用较少的参数列表调用多参数列表的方法时，会产生一个新的函数，该函数接收剩余的参数列表作为其参数。这被称为柯里化。</p>
<p></p>
<div class="jb51code"><pre class="brush:scala;"> def main(args: Array): Unit = {
    def getAddress(a: String): (String, String) =&amp;gt; String = {
      (b: String,c: String) =&amp;gt; a + "-" + b + "-" + c
    }
    var b=getAddress("china");
    var c=b("beijing","tianAnMen")
    println(c)
}</pre></div>
<div class="jb51code"><pre class="brush:scala;">china-beijing-tianAnMen</pre></div>
<p></p>
<h3>&nbsp;4、闭包</h3>
<p>函数里面引用外面类成员变量叫作闭包</p>
<div class="jb51code"><pre class="brush:scala;">def main(args: Array): Unit = {
    var factor = 1
    val f1 = (x: Int) =&amp;gt; x * factor
    println(f1(8))
    factor=2
    println(f1(8))
}</pre></div>
<div class="jb51code"><pre class="brush:scala;">8
16</pre></div>
<p>//定义的函数f1，它的返回值是依赖于不在函数作用域的一个变量<br />//后期必须要要获取到这个变量才能执行<br />//spark和flink程序的开发中大量的使用到函数，函数的返回值依赖的变量可能都需要进行大量的网络传输获取得到。这里就需要这些变量实现序列化进行网络传输。</p>
<div class="jb51code"><pre class="brush:scala;"> def main(args: Array): Unit = {
   
    def multiply(x: Double) = (y: Double) =&amp;gt; x * y

    //先进行科尔化
    val doubleFunc = multiply(2)
    val tripleFunc = multiply(3)
    //    再对闭包进行计算
    var u = doubleFunc(10)
    var u2 = tripleFunc(10)
    println(u)
    println(u2)
}</pre></div>
<div class="jb51code"><pre class="brush:scala;">20.0
30.0</pre></div>
<h2>14、scala面向对象编程之类</h2>
<h3>1、类的定义</h3>
<p>scala是支持面向对象的，也有类和对象的概念。</p>
<ul><li><p>定义一个Customer类，并添加成员变量/成员方法</p></li><li><p>添加一个main方法，并创建Customer类的对象，并给对象赋值，打印对象中的成员，调用成员方法</p></li></ul>
<p>与java相比，他无需get set方法，就可以对变量进行赋值封装操作&nbsp;</p>
<div class="jb51code"><pre class="brush:scala;">import java.util.Date

class Customer {
var name: String = _
var sex: String = _
val registerDate: Date = new Date

def sayHi(msg: String) = {
    println(msg)
}
}

object Main {
def main(args: Array): Unit = {
    val customer = new Customer
    //给对象的成员变量赋值
    customer.name = "张三"
    customer.sex = "男"

    println(s"姓名: ${customer.name}, 性别：${customer.sex}, 注册时间: ${customer.registerDate}")
    //对象调用方法
    customer.sayHi("你好!")
}
}</pre></div>
<p>&nbsp;打印的结果为：</p>
<div class="jb51code"><pre class="brush:scala;">姓名: 张三, 性别：男, 注册时间: Fri Apr 22 16:23:21 CST 2022
你好!</pre></div>
<blockquote><p>(1). var name:String = _， &nbsp;_表示使用默认值进行初始化<br />&nbsp; &nbsp;例如：String类型默认值是null，Int类型默认值是0，Boolean类型默认值是false...<br />(2). val变量不能使用_来进行初始化，因为val是不可变的，所以必须手动指定一个默认值<br />(3). main方法必须要放在一个scala的object（单例对象）中才能执行</p></blockquote>
<p></p>
<h3>2、类的构造器</h3>
<p>主构造器</p>
<ul><li><p>主构造器是指在类名的后面跟上一系列参数，例如</p></li></ul>
<div class="jb51code"><pre class="brush:scala;">class 类名(var/val 参数名: 类型 = 默认值, var/val 参数名: 类型 = 默认值){
    // 构造代码块
}</pre></div>
<p>辅助构造器</p>
<ul><li><p>在类中使用this来定义，例如</p>
<div class="jb51code"><pre class="brush:scala;">def this(参数名: 类型, 参数名: 类型) {
    ...
}</pre></div>
<div class="jb51code"><pre class="brush:scala;">package com.testScala.D_lei

class Student(val name: String, val age: Int) {

val address: String = "beijing"

// 定义一个参数的辅助构造器
def this(name: String) {
    // 辅助构造器的第一行必须调用主构造器或其他辅助构造器或者super父类的构造器
    this(name, 20)
}

def this(age: Int) {
    this("某某某", age)
}

}

object test {
def main(args: Array): Unit = {
    val tt = new Student("张三");
    println(s"name等于:${tt.name},address:${tt.address},age:${tt.age}")
}
}</pre></div>
<h2>15、scala面向对象编程之对象</h2></li></ul>
<h3>1、scala中的object</h3>
<ul><li><p>scala中是没有Java中的静态成员的。如果将来我们需要用到static变量、static方法，就要用到scala中的单例对象object</p></li><li><p>定义object</p>
<ul><li><p>定义单例对象和定义类很像，就是把class换成object</p></li></ul></li><li><p>演示</p>
<ul><li><p>定义一个工具类，用来格式化日期时间</p></li></ul></li></ul>
<div class="jb51code"><pre class="brush:scala;">object DateUtils {
/// 在object中定义的成员变量，相当于Java中定义一个静态变量
// 定义一个SimpleDateFormat日期时间格式化对象
val simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm")

// 构造代码
println("构造代码")

// 相当于Java中定义一个静态方法
def format(date: Date) = simpleDateFormat.format(date)

// main是一个静态方法，所以必须要写在object中
def main(args: Array): Unit = {

    println { DateUtils.format(new Date()) };
}
}</pre></div>
<blockquote><p>&nbsp;(1). 使用object 单例对象名定义一个单例对象，可以用object作为工具类或者存放常量<br />(2). 在单例对象中定义的变量，类似于Java中的static成员变量<br />(3). 在单例对象中定义的方法，类似于Java中的static方法<br />(4). object单例对象的构造代码可以直接写在花括号中<br />(5). 调用单例对象的方法，直接使用单例对象名.方法名，访问单例对象的成员变量也是使用单例对象名.变量名<br />(6). 单例对象只能有一个无参的主构造器，不能添加其他参数</p></blockquote>
<h3>2、scala中的伴生对象</h3>
<ul><li><p>在==同一个scala文件，有一个class和object具有同样的名字==，那么就称这个object是class的伴生对象，class是object的伴生类；</p></li><li><p>伴生类和伴生对象的最大特点是，可以相互访问；</p></li></ul>
<div class="jb51code"><pre class="brush:scala;">package com.testScala.E_duixiang

class Dog {
val id = 1
private var name = "kkb"
def printName(): Unit = {
    //在Dog类中可以访问伴生对象Dog的私有属性
    println(Dog.CONSTANT + name )
}
}

object Dog{
//伴生对象中的私有属性
private val CONSTANT = "汪汪汪 : "
def main(args: Array) {
    val dog = new Dog
    //访问私有的字段name
    dog.name = "123"
    dog.printName()
}
}</pre></div>
<div class="jb51code"><pre class="brush:scala;">汪汪汪 : 123</pre></div>
<blockquote><p>(1). 伴生类和伴生对象的名字必须是一样的<br />(2). 伴生类和伴生对象需要在一个scala源文件中<br />(3). 伴生类和伴生对象可以互相访问private的属性</p></blockquote>
<h3>3、scala中object的apply方法</h3>
<ul><li><p>：<strong>==实现伴生对象Array的apply方法==</strong></p></li><li><p>伴生对象的apply方法用来快速地创建一个伴生类的对象。</p></li></ul>
<p></p>
<div class="jb51code"><pre class="brush:scala;">package com.testScala.E_duixiang

class Person(var name: String, var age: Int) {

override def toString = s"Person($name, $age)"
}

object Person {
// 实现apply方法
// 返回的是伴生类的对象
def apply(name: String, age: Int): Person = new Person(name, age)

// apply方法支持重载
def apply(name: String): Person = new Person(name, 20)

def apply(age: Int): Person = new Person("某某某", age)

def apply(): Person = new Person("某某某", 20)
}

object Main2 {
def main(args: Array): Unit = {
    val p1 = Person("张三", 20)
    val p2 = Person("李四")
    val p3 = Person(100)
    val p4 = Person()

    println(p1)
    println(p2)
    println(p3)
    println(p4)
}
}</pre></div>
<div class="jb51code"><pre class="brush:scala;">Person(张三, 20)
Person(李四, 20)
Person(某某某, 100)
Person(某某某, 20)</pre></div>
<blockquote><p>&nbsp;（1）. 当遇到类名(参数1, 参数2...)会自动调用伴生对象相应的apply方法，在apply方法中来创建对象<br />（2）. 定义apply时，如果参数列表是空，也不能省略括号()，否则引用的是伴生对象</p></blockquote>
<h3>4、scala中object的main方法</h3>
<ul><li><p>scala和Java一样，如果要运行一个程序，必须有一个main方法。</p></li><li><p>而在Java中main方法是静态的，而在scala中没有静态方法。</p></li></ul>
<div class="jb51code"><pre class="brush:scala;">object Main1{
def main(args: Array) = {
    println("hello, scala")
}
}</pre></div>
<h2>16、scala面向对象编程之继承</h2>
<h3>1、继承extends</h3>
<ul><li><p>scala和Java一样，使用<strong>extends</strong>关键字来实现继承。可以在子类中定义父类中没有的字段和方法，或者重写父类的方法。</p></li><li><div class="jb51code"><pre class="brush:scala;">package com.testScala.F_jicheng

class Person1 {
var name = "jianghaojie"

def getName = this.name
}

class Student extends Person1

object main1 {
def main(args: Array): Unit = {
    val p1 = new Person1()
    val p2 = new Student()
    p2.name = "蒋皓洁"
    println(p1.getName)
    println(p2.getName)
}
}</pre></div>
<div class="jb51code"><pre class="brush:scala;">jianghaojie
蒋皓洁</pre></div>
<h3>2、override和super</h3>
<h3>&nbsp;​​​如果子类要覆盖父类中的一个非抽象方法，必须要使用override关键字</h3></li><li><p>可以使用override关键字来重写一个val字段</p></li><li><p>可以使用super关键字来访问父类的成员</p></li><li><p>==示例1：class继承class==</p></li></ul>
<div class="jb51code"><pre class="brush:scala;">
class Person3 {
val name = "super"

def getName = name
}

class Student3 extends Person3 {
// 重写val字段
override val name: String = "child"

// 重写getName方法
override def getName: String = "hello, " + super.getName
}

object Main3 {
def main(args: Array): Unit = {
    val p = new Student3();
    println(p.name)
    println(p.getName)
}
}
</pre></div>
<div class="jb51code"><pre class="brush:scala;">child
hello, child</pre></div>
<h3>3、isInstanceOf和asInstanceOf</h3>
<ul><li><p>我们经常要在代码中进行类型的判断和类型的转换。在Java中，我们可以使用instanceof关键字、以及(类型)object来实现，在scala中如何实现呢？</p></li><li><p>scala中对象提供==isInstanceOf==和==asInstanceOf==方法。</p>
<ul><li><p>isInstanceOf判断对象是否为指定类的对象</p></li><li><p>asInstanceOf将对象转换为指定类型</p></li></ul></li></ul>
<table><tbody><tr><th></th><th>Java</th><th>Scala</th></tr><tr><td>判断对象是否是C类型</td><td>obj instanceof C</td><td>obj.isInstanceof</td></tr><tr><td>将对象强转成C类型</td><td>(C ) obj</td><td>obj.asInstanceof</td></tr><tr><td>获取类型为T的class对象</td><td>C.class</td><td>classOf</td></tr></tbody></table>
<ul><li><p>==示例==</p></li></ul>
<div class="jb51code"><pre class="brush:scala;">class Person4
class Student4 extends Person4

object Main4 {
def main(args: Array): Unit = {
    val s1: Person4 = new Student4

    // 判断s1是否为Student4类型
    if(s1.isInstanceOf) {
      // 将s1转换为Student3类型
      val s2 =s1.asInstanceOf
      println(s2)
    }
}
}</pre></div>
<div class="jb51code"><pre class="brush:scala;">com.testScala.F_jicheng.Student4@ea4a92b</pre></div>
<h3>4、getClass和classOf</h3>
<p>isInstanceOf 只能判断出对象是否为指定类以及其子类的对象，而不能精确的判断出，对象就是指定类的对象。如果要求精确地判断出对象就是指定类的对象，那么就只能使用 getClass 和 classOf 。</p>
<ul><li><p>对象.getClass可以精确获取对象的类型</p></li><li><p>classOf可以精确获取类型</p></li><li><p>使用==操作符就可以直接比较</p></li></ul>
<div class="jb51code"><pre class="brush:scala;">
class Person5
class Student5 extends Person5

object Student5{
def main(args: Array) {
    val p: Person5 = new Student5
    //判断p是否为Person5类的实例
    println(p.isInstanceOf)//true

    //判断p的类型是否为Person5类
    println(p.getClass == classOf)//false

    //判断p的类型是否为Student5类
    println(p.getClass == classOf)//true
}
}</pre></div>
<h3>5、访问修饰符</h3>
<p>java中的访问控制，同样适用于scala，可以在成员前面添加private/protected关键字来控制成员的可见性。但在scala中，==<strong>没有public关键字</strong>，任何没有被标为private或protected的成员都是公共的==。<br />&nbsp;</p>
<p>==<strong>private修饰符</strong>==</p>
<ul><li><p>被修饰的成员只能在当前类中被访问。或者可以理解为：<code>只能通过this.来访问</code>（在当前类中访问成员会自动添加this.）</p></li></ul>
<div class="jb51code"><pre class="brush:scala;">package com.testScala.F_jicheng
class Person6 {
// 只有在当前对象中能够访问
private var name = "super"

def getName = this.name        // 正确！

def sayHelloTo(p: Person6) = {
    println("hello" + p.name)   // 报错!无法访问
}
}

object Person6 {
def showName(p: Person6) = println(p.name)// 报错!无法访问
}
</pre></div>
<p></p>
<p><strong>protected修饰符</strong>==</p>
<ul><li><p>==被修饰的成员只能在当前类和当前类的子类中被访问==。也可以理解为：当前类通过<strong>this.</strong>访问或者子类通过<strong>this.</strong>访问</p></li><li><p>示例</p></li></ul>
<div class="jb51code"><pre class="brush:scala;">package com.testScala.F_jicheng

class Person7 {
// 只有在当前类以及继承该类的当前对象中能够访问
protected var name = "super"

def getName = {
    // 正确！
    this.name
}

def sayHelloTo1(p: Person7) = {
    // 编译错误！无法访问
//    println(p.name)
}
}

object Person7 {
def sayHelloTo3(p: Person7) = {
    // 编译错误！无法访问
//    println(p.name)
}
}

class Student7 extends Person7 {
def showName = {
    // 正确！
    println(name)
}

def sayHelloTo2(p: Person7) = {
    // 编译错误！无法访问
//    println(p.name)
}
}
objectyy{
def main(args: Array): Unit = {
    var yu=    new Student7();
    yu.showName
//    println()
}
}</pre></div>
<h3>6、调用父类的constructor</h3>
<ul><li><p>==实例化子类对象，必须要调用父类的构造器==，在scala中，只能在子类的<code>主构造器</code>中调用父类的构造器</p></li><li><p>示例</p></li></ul>
<p>&nbsp;​​​​​​</p>
<div class="jb51code"><pre class="brush:scala;">package com.testScala.F_jicheng

class Person8(var name: String){
println("name:"+name)
}

// 直接在子类的类名后面调用父类构造器
class Student8(name: String, var clazz: String) extends Person8(name)

object Main8 {
def main(args: Array): Unit = {
    val s1 = new Student8("张三", "三年二班")
    println(s"${s1.name} - ${s1.clazz}")
}
}
</pre></div>
<div class="jb51code"><pre class="brush:scala;">name:张三
张三 - 三年二班</pre></div>
<p></p>
<h3>7、抽象类</h3>
<p></p>
<ul><li><p>如果类的某个成员在当前类中的定义是不包含完整的，它就是一个<strong>抽象类</strong></p></li><li><p>不完整定义有两种情况：</p>
<ul><li><p>1.方法没有方法体</p></li><li><p>2.变量没有初始化</p></li></ul></li><li><p>没有方法体的方法称为<strong>抽象方法</strong>，没有初始化的变量称为<strong>抽象字段</strong>。定义抽象类和Java一样，在类前面加上<strong>abstract</strong>关键字就可以了</p></li></ul>
<div class="jb51code"><pre class="brush:scala;">package com.testScala.F_jicheng

abstract class Person9(val name: String) {
//抽象方法
def sayHello: String
def sayBye: String
//抽象字段
val address: String
}
class Student9(name: String) extends Person9(name){
//重写抽象方法或字段，def前不必加override关键字
def sayHello: String = "Hello," + name
def sayBye: String ="Bye," + name
//重写抽象字段
   val address: String = "beijing "
}
object Main9{
def main(args: Array) {
    val s = new Student9("tom")
    println(s.sayHello)
    println(s.sayBye)
    println(s.address)
}
}
</pre></div>
<div class="jb51code"><pre class="brush:scala;">Hello,tom
Bye,tom
beijing </pre></div>
<h2>17、scala面向对象编程之trait特质</h2>
<ul><li><p>特质是scala中代码复用的基础单元</p></li><li><p>它可以将方法和字段定义封装起来，然后添加到类中</p></li><li><p>与类继承不一样的是，类继承要求每个类都只能继承<code>一个</code>超类，而一个类可以添加<code>任意数量</code>的特质。</p></li><li><p>特质的定义和抽象类的定义很像，但它是使用<code>trait</code>关键字</p></li></ul>
<h3><strong>1、作为接口使用</strong></h3>
<p></p>
<ul><li><p>使用<code>extends</code>来继承trait（scala不论是类还是特质，都是使用extends关键字）</p></li><li><p>如果要继承多个trait，则使用<code>with</code>关键字</p></li></ul>
<p>==<strong>示例一：继承单个trait</strong>== &nbsp;</p>
<div class="jb51code"><pre class="brush:scala;">
trait Logger1 {
// 抽象方法
def log(msg: String)
}

class ConsoleLogger1 extends Logger1 {
override def log(msg: String): Unit = println(msg)
}

object LoggerTrait1 {
def main(args: Array): Unit = {
    val logger = new ConsoleLogger1
    logger.log("控制台日志: 这是一条Log")
}
}</pre></div>
<div class="jb51code"><pre class="brush:scala;">控制台日志: 这是一条Log</pre></div>
<p>==<strong>示例二：继承多个trait</strong>==</p>
<div class="jb51code"><pre class="brush:scala;">trait Logger2 {
// 抽象方法
def log(msg: String)
}

trait MessageSender {
def send(msg: String)
}

class ConsoleLogger2 extends Logger2 with MessageSender {

override def log(msg: String): Unit = println(msg)

override def send(msg: String): Unit = println(s"发送消息:${msg}")
}

object LoggerTrait2 {
def main(args: Array): Unit = {
    val logger = new ConsoleLogger2
    logger.log("控制台日志: 这是一条Log")
    logger.send("你好!")
}
}</pre></div>
<div class="jb51code"><pre class="brush:scala;">控制台日志: 这是一条Log
发送消息:你好!</pre></div>
<h3>2、定义具体的方法</h3>
<ul><li><p>和类一样，trait中还可以定义具体的方法。</p></li><li><p>==示例==</p></li></ul>
<div class="jb51code"><pre class="brush:scala;">package com.testScala.G_trait

trait LoggerDetail {
// 在trait中定义具体方法
def log(msg: String) = println(msg)
}

class PersonService extends LoggerDetail {
def add() = log("添加用户")
}

object MethodInTrait {
def main(args: Array): Unit = {
    val personService = new PersonService
    personService.add()
}
}</pre></div>
<div class="jb51code"><pre class="brush:scala;">添加用户
</pre></div>
<h3>3、定义具体方法和抽象方法</h3>
<ul><li><p>在trait中，可以混合使用具体方法和抽象方法</p></li><li><p>使用具体方法依赖于抽象方法，而抽象方法可以放到继承trait的子类中实现，这种设计方式也称为<strong>模板模式</strong></p></li></ul>
<p><strong>==示例==</strong></p>
<div class="jb51code"><pre class="brush:scala;">package com.testScala.G_trait

trait Logger3 {
// 抽象方法
def log(msg: String)
// 具体方法（该方法依赖于抽象方法log
def info(msg: String) = log("INFO:" + msg)
def warn(msg: String) = log("WARN:" + msg)
def error(msg: String) = log("ERROR:" + msg)
}

class ConsoleLogger3 extends Logger3 {
override def log(msg: String): Unit = println(msg)
}

object LoggerTrait3 {
def main(args: Array): Unit = {
    val logger3 = new ConsoleLogger3

    logger3.log("这是一条日志信息")
    logger3.info("这是一条普通信息")
    logger3.warn("这是一条警告信息")
    logger3.error("这是一条错误信息")
}
}
</pre></div>
<div class="jb51code"><pre class="brush:scala;">这是一条日志信息
INFO:这是一条普通信息
WARN:这是一条警告信息
ERROR:这是一条错误信息</pre></div>
<h3>4、定义具体字段和抽象字段</h3>
<ul><li><p>在trait中可以定义具体字段和抽象字段</p></li><li><p>继承trait的子类自动拥有trait中定义的字段</p></li><li><p>字段直接被添加到子类中</p></li></ul>
<div class="jb51code"><pre class="brush:scala;">package com.testScala.G_trait

import java.text.SimpleDateFormat
import java.util.Date

trait LoggerEx {
// 具体字段
val sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm")
val INFO = "信息:" + sdf.format(new Date)
// 抽象字段
val TYPE: String

// 抽象方法
def log(msg: String)
}

class ConsoleLoggerEx extends LoggerEx {
// 实现抽象字段
override val TYPE: String = "控制台"
// 实现抽象方法
override def log(msg: String): Unit = print(s"$TYPE$INFO $msg")
}

object FieldInTrait {
def main(args: Array): Unit = {
    val logger = new ConsoleLoggerEx

    logger.log("这是一条消息")
}
}
</pre></div>
<div class="jb51code"><pre class="brush:scala;">控制台信息:2022-04-24 15:05 这是一条消息</pre></div>
<h3>5、实例对象混入trait</h3>
<ul><li><p>trait还可以混入到<code>实例对象</code>中，给对象实例添加额外的行为</p></li><li><p>只有混入了trait的对象才具有trait中的方法，其他的类对象不具有trait中的行为</p></li><li><p>使用with将trait混入到实例对象中</p></li><li><p><strong>==示例==</strong></p></li></ul>
<div class="jb51code"><pre class="brush:scala;">package com.testScala.G_trait

trait LoggerMix {
def log(msg: String) = println(msg)
}

class UserService

object FixedInClass {
def main(args: Array): Unit = {
    // 使用with关键字直接将特质混入到对象中
    val userService = new UserService with LoggerMix
    userService.log("你好")
}
}
</pre></div>
<div class="jb51code"><pre class="brush:scala;">你好
</pre></div>
<h2>18、模式匹配和样例类</h2>
<ul><li><p>scala有一个十分强大的模式匹配机制，可以应用到很多场合。</p>
<ul><li><p>switch语句</p></li><li><p>类型查询</p></li><li><p>以及快速获取数据</p></li></ul></li><li><p>并且scala还提供了样例类，对模式匹配进行了优化，可以快速进行匹配。</p></li></ul>
<h3>1、匹配字符串</h3>
<div class="jb51code"><pre class="brush:scala;">import scala.util.Random


//todo:匹配字符串
object CaseDemo01 extends App{
//定义一个数组
val arr = Array("hadoop", "zookeeper", "spark", "storm")

//随机取数组中的一位，使用Random.nextInt
val name = arr(Random.nextInt(arr.length))
println(name)

name match {
    case "hadoop"   =&amp;gt; println("大数据分布式存储和计算框架...")
    case "zookeeper"=&amp;gt; println("大数据分布式协调服务框架...")
    case "spark"      =&amp;gt; println("大数据分布式内存计算框架...")
    //表示以上情况都不满足才会走最后一个
    case _            =&amp;gt; println("我不认识你")
}
}
</pre></div>
<div class="jb51code"><pre class="brush:scala;">hadoop
大数据分布式存储和计算框架...</pre></div>
<h3>2、匹配类型</h3>
<div class="jb51code"><pre class="brush:scala;">//todo:匹配类型
object CaseDemo02 extends App{
//定义一个数组
val arr = Array("hello", 1, -2.0, CaseDemo02)

//随机获取数组中的元素
val value = arr(Random.nextInt(arr.length))
println(value)

value match {
    case x: Int                =&amp;gt; println("Int=&amp;gt;"+x)
    case y: Double if(y &amp;gt;= 0)    =&amp;gt; println("Double=&amp;gt;"+y)
    case z: String             =&amp;gt; println("String=&amp;gt;"+z)
    case _                     =&amp;gt; throw new Exception("not match exception")
}
}
</pre></div>
<div class="jb51code"><pre class="brush:scala;">hello
String=&amp;gt;hello</pre></div>
<h3>3、匹配数组</h3>
<div class="jb51code"><pre class="brush:scala;">package com.testScala.H_pipei

//匹配数组
object CaseDemo03 extends App{

//匹配数组
val arr = Array(1, 3, 5)
arr match {
    case Array(1, x, y) =&amp;gt; println(x + "---" + y)
    case Array(1, _*)   =&amp;gt; println("1...")
    case Array(0)       =&amp;gt; println("only 0")
    case _            =&amp;gt; println("something else")

}
}
</pre></div>
<p></p>
<div class="jb51code"><pre class="brush:scala;">1...</pre></div>
<h3>4、匹配集合</h3>
<div class="jb51code"><pre class="brush:scala;">//匹配集合
object CaseDemo04 extends App{

val list = List(0, 3, 6)
list match {
    case 0::Nil      =&amp;gt; println("only 0")
    case 0::tail       =&amp;gt; println("0....")
    case x::y::z::Nil=&amp;gt; println(s"x:$x y:$y z:$z")
    case _             =&amp;gt; println("something else")
}
}</pre></div>
<div class="jb51code"><pre class="brush:scala;">0....</pre></div>
<h3>5、匹配元组</h3>
<div class="jb51code"><pre class="brush:scala;">package com.testScala.H_pipei

//匹配元组
object CaseDemo05 extends App{

val tuple = (1, 3, 5)
tuple match {
    case (1, x, y)    =&amp;gt; println(s"1,$x,$y")
    case (2, x, y)    =&amp;gt; println(s"$x,$y")
    case _            =&amp;gt; println("others...")
}
}</pre></div>
<div class="jb51code"><pre class="brush:scala;">1,3,5</pre></div>
<h3>6、样例类</h3>
<ul><li><p>样例类是一种特殊类，它可以用来快速定义一个用于<strong>保存数据</strong>的类（类似于Java POJO类），==而且它会自动生成apply方法，允许我们快速地创建样例类实例对象==。后面在并发编程和spark、flink这些框架也都会经常使用它。</p></li><li><p>定义样例类</p></li><li><p>语法结构</p></li></ul>
<blockquote><p>case class 样例类名(成员变量名1: 类型1, 成员变量名2: 类型2 ...)</p></blockquote>
<p></p>
<div class="jb51code"><pre class="brush:scala;">package com.testScala.H_pipei

// 定义一个样例类
// 样例类有两个成员name、age
case class CasePerson(name: String, age: Int)

// 使用var指定成员变量是可变的
case class CaseStudent(var name: String, var age: Int)

object CaseClassDemo {
def main(args: Array): Unit = {
    // 1. 使用new创建实例
    val zhagnsan = new CasePerson("张三", 20)
    println(zhagnsan)

    // 2. 使用类名直接创建实例
    val lisi = CasePerson("李四", 21)
    println(lisi)

    // 3. 样例类默认的成员变量都是val的，除非手动指定变量为var类型
    //lisi.age = 22// 编译错误！age默认为val类型

    val xiaohong = CaseStudent("小红", 23)
    xiaohong.age = 24
    println(xiaohong)
}
}</pre></div>
<div class="jb51code"><pre class="brush:scala;">CasePerson(张三,20)
CasePerson(李四,21)
CaseStudent(小红,24)</pre></div>
<p><strong>样例对象</strong></p>
<ul><li><p>使用case object可以创建样例对象。样例对象是单例的，而且它<strong>没有主构造器</strong>。样例对象是可序列化的。格式：</p></li></ul>
<blockquote><p>case object 样例对象名</p></blockquote>
<div class="jb51code"><pre class="brush:scala;">case class SendMessage(text: String)

// 消息如果没有任何参数，就可以定义为样例对象
case object startTask
case object PauseTask
case object StopTask</pre></div>
<p></p>
<div class="jb51code"><pre class="brush:scala;">
case class SubmitTask(id: String, name: String)
case class HeartBeat(time: Long)
case object CheckTimeOutTask

object CaseDemo06 extends App{
val arr = Array(CheckTimeOutTask,
    HeartBeat(10000),
    SubmitTask("0001", "task-0001"))

arr(Random.nextInt(arr.length)) match {

    case SubmitTask(id, name) =&amp;gt; println(s"id=$id, name=$name")
    case HeartBeat(time)      =&amp;gt; println(s"time=$time")
    case CheckTimeOutTask   =&amp;gt; println("检查超时")
}
}</pre></div>
<div class="jb51code"><pre class="brush:scala;">检查超时</pre></div>
<h3>7、Option类型</h3>
<ul><li><p>在Scala中Option类型用样例类来表示可能存在或也可能不存在的值</p></li><li><p>Option类型有2个子类</p></li><li><p>一个是Some</p>
<ul><li><p>Some包装了某个值</p></li></ul></li></ul>
<ul><li><p>一个是None</p>
<ul><li><p>None表示没有值</p></li></ul></li></ul>
<div class="jb51code"><pre class="brush:scala;">
object TestOption {
def main(args: Array) {
    val map = Map("a" -&amp;gt; 1, "b" -&amp;gt; 2)

    val value: Option = map.get("b")
    println(value)
    val v1 = value match {
      case Some(i) =&amp;gt; i
      case None =&amp;gt; 0
    }
    println(v1)

    //更好的方式
    val v2 = map.getOrElse("c", 0)
    println(v2)
}
}</pre></div>
<div class="jb51code"><pre class="brush:scala;">Some(2)
2
0</pre></div>
<h3>8、偏函数</h3>
<ul><li><p>被包在花括号内==没有match的一组case语句==是一个偏函数</p></li><li><p>它是PartialFunction的一个实例，</p>
<ul><li><p>A代表输入参数类型</p></li><li><p>B代表返回结果类型</p></li><li><p>可以理解为：偏函数是一个参数和一个返回值的函数。</p></li></ul></li><li><p><strong>==示例==</strong></p></li></ul>
<div class="jb51code"><pre class="brush:scala;">object TestPartialFunction {
// func1是一个输入参数为Int类型，返回值为String类型的偏函数
val func1: PartialFunction = {
    case 1 =&amp;gt; "一个"
    case 2 =&amp;gt; "二个"
    case 3 =&amp;gt; "三个"
    case _ =&amp;gt; "其他"
}

def main(args: Array): Unit = {
    println(func1(1))

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

    //使用偏函数操作
    val result = list.filter{
      case x if x &amp;gt;3 =&amp;gt; true
      case _ =&amp;gt; false
    }
    println(result)
}</pre></div>
<h2>19、异常处理</h2>
<p></p>
<p>&nbsp;​​​​​​</p>
<div class="jb51code"><pre class="brush:scala;">def main(args: Array): Unit = {
   val i = 10 / 0
   
    println("你好！")
}

Exception in thread "main" java.lang.ArithmeticException: / by zero
        at ForDemo$.main(ForDemo.scala:3)
        at ForDemo.main(ForDemo.scala)</pre></div>
<p>执行程序，可以看到scala抛出了异常，而且没有打印出来&quot;你好&quot;。说明程序出现错误后就终止了。那怎么解决该问题呢？</p>
<h3>1、 捕获异常</h3>
<ul><li><p>在scala中，可以使用异常处理来解决这个问题。</p>
<ul><li><p>在Scala里，借用了==模式匹配的思想来做异常的匹配==</p></li><li><p>以下为scala中try...catch异常处理的语法格式：</p></li></ul></li></ul>
<blockquote><p>try {<br />&nbsp; &nbsp; // 代码<br />}<br />catch {<br />&nbsp; &nbsp; case ex: 异常类型1 =&gt; // 代码<br />&nbsp; &nbsp; case ex: 异常类型2 =&gt; // 代码<br />}<br />finally {<br />&nbsp; &nbsp; // 代码<br />}&nbsp;</p></blockquote>
<ul><li><p>try中的代码是我们编写的业务处理代码</p></li><li><p>在catch中表示当出现某个异常时，需要执行的代码</p></li><li><p>在finally中，是不管是否出现异常都会执行的代码</p></li></ul>
<blockquote><p>try {<br />&nbsp; &nbsp; val i = 10 / 0</p>
<p>} catch {<br />&nbsp; &nbsp; case ex: Exception =&gt; println(ex.getMessage)<br />} finally {<br />&nbsp; &nbsp; println(&quot;我始终都会执行!&quot;)<br />}</p>
<p></p></blockquote>
<h3>2、抛出异常</h3>
<ul><li><p>我们也可以在一个方法中，抛出异常。语法格式和Java类似，使用throw new Exception...</p></li></ul>
<ul><li><p>==示例==</p></li></ul>
<div class="jb51code"><pre class="brush:scala;">def main(args: Array): Unit = {
    throw new Exception("这是一个异常")
}

Exception in thread "main" java.lang.Exception: 这是一个异常
        at ForDemo$.main(ForDemo.scala:3)
        at ForDemo.main(ForDemo.scala)</pre></div>
<p></p>
<h2>20、提取器(Extractor)</h2>
<p></p>
<ul><li><p>=提取器是从传递给它的对象中提取出构造该对象的参数==。(回想样例类进行模式匹配提取参数)</p></li><li><p>scala 提取器是一个带有unapply方法的对象。</p>
<ul><li><p>==unapply方法算是apply方法的反向操作==</p></li><li><p>unapply接受一个对象，然后从对象中提取值，提取的值通常是用来构造该对象的值。</p></li></ul></li></ul>
<div class="jb51code"><pre class="brush:scala;">package com.testScala.I_Extractor

class Student {
var name: String = _   // 姓名
var age: Int = _       // 年龄

// 实现一个辅助构造器
def this(name: String, age: Int) = {
    this()

    this.name = name
    this.age = age
}
}

object Student {
def apply(name: String, age: Int): Student = new Student(name, age)

// 实现一个解构器
def unapply(arg: Student): Option[(String, Int)] = Some(arg.name, arg.age)
}

object extractor_DEMO {
def main(args: Array): Unit = {
    val zhangsan = Student("张三", 20)

    zhangsan match {
      case Student(name, age) =&amp;gt; println(s"姓名：$name 年龄：$age")
      case _ =&amp;gt; println("未匹配")
    }
}
}
</pre></div>
<div class="jb51code"><pre class="brush:scala;">姓名：张三 年龄：20</pre></div>
<h2>21、泛型</h2>
<p>&nbsp; &nbsp; scala和Java一样，类和特质、方法都可以支持泛型。我们在学习集合的时候，一般都会涉及到泛型。</p>
<p>在scala中，使用方括号来定义==类型参数==。</p>
<h3>1、定义一个泛型方法</h3>
<div class="jb51code"><pre class="brush:scala;">object learn01 {
def getMiddle(arr: Array) = arr(arr.length / 2)

def main(args: Array): Unit = {
    val arr1 = Array(1, 2, 3, 4, 5)
    val arr2 = Array("a", "b", "c", "d", "f")

    println(getMiddle(arr1))
    println(getMiddle(arr2))

    // 简写方式,scala自动进行类型推断
    println(getMiddle(arr1))
    println(getMiddle(arr2))
}
}</pre></div>
<h3>2、定义一个泛型类</h3>
<p>定义一个Pair类包含2个类型不固定的泛型</p>
<div class="jb51code"><pre class="brush:scala;">package com.testScala.J_fanxing


// 类名后面的方括号，就表示这个类可以使用两个类型、分别是T和S
// 这个名字可以任意取
class Pair(val first: T, val second: S)

case class People(var name: String, val age: Int)

object Pair {
    def main(args: Array): Unit = {

      val p1 = new Pair("张三", 10)
      println(p1.first)
      val p2 = new Pair("张三", "1988-02-19")
      println(p2.first)
      val p3 = new Pair(People("张三", 20), People("李四", 30))
      println(p3.first.age)
    }
}</pre></div>
<div class="jb51code"><pre class="brush:scala;">张三
张三
20
</pre></div>
<h2>22、上下界</h2>
<ul><li><p>==在指定泛型类型时，有时需要界定泛型类型的范围，而不是接收任意类型==。比如，要求某个泛型类型，必须是某个类的子类，这样在程序中就可以放心的调用父类的方法，程序才能正常的使用与运行.</p></li><li><p>scala的上下边界特性允许泛型类型是某个类的子类，或者是某个类的父类</p>
<ul><li><p>1、 ==U &gt;: T==</p>
<p>这是类型==下界==的定义，也就是U必须是类型T的父类或者是T类型本身。</p></li><li><p>2、 ==U &lt;: T==</p>
<p>这是类型==上界==的定义，也就是U必须是类型T的子类或者是T类型本身。</p></li></ul></li><li><p><strong>==示例一==</strong></p></li></ul>
<p></p>
<div class="jb51code"><pre class="brush:scala;">package com.testScala.J_fanxing

// 类名后面的指定泛型的范围 ----上界
class Pair1(val first: T, val second: S) {
def chat(msg: String) = println(s"${first.name}对${second.name}说: $msg")
}

class Person(var name: String, val age: Int)

object Pair1 {
def main(args: Array): Unit = {

    val p3 = new Pair1(new Person("张三", 20), new Person("李四", 30))
    p3.chat("你好啊！")
}
}
</pre></div>
<div class="jb51code"><pre class="brush:scala;">张三对李四说: 你好啊！</pre></div>
<p><strong>==示例二==</strong></p>
<div class="jb51code"><pre class="brush:scala;">class Pair22(val first: T, val second: S) {
def chat(msg: String) = println(s"${first.name}对${second.name}说: $msg")
}

class Person(var name: String, val age: Int)
class Policeman(name: String, age: Int) extends Person(name, age)
class Superman(name: String) extends Policeman(name, -1)

object Pai {
def main(args: Array): Unit = {
    // 编译错误：第二个类型参数必须是Person的子类（包括本身）、Policeman的父类（包括本身）
    val p3 = new Pair22(new Person("张三", 20), new Policeman("李四",20))
    p3.chat("你好啊！")
}
}
</pre></div>
<div class="jb51code"><pre class="brush:scala;">张三对李四说: 你好啊！
</pre></div>
<h2>23、协变、逆变、非变</h2>
<ul><li><p>来一个类型转换的问题</p></li></ul>
<p></p>
<div class="jb51code"><pre class="brush:scala;">class Pair(a: T)

object Pair {
def main(args: Array): Unit = {
    val p1 = new Pair("hello")
    // 编译报错，无法将p1转换为p2
    val p2: Pair = p1

    println(p2)
}
}</pre></div>
<p>==<strong>协变</strong>==</p>
<blockquote><p>class Pair[+T]，这种情况是协变。类型B是A的子类型，Pair可以认为是Pair的子类型。这种情况，参数化类型的方向和类型的方向是一致的。</p></blockquote>
<p>==<strong>逆变</strong>==</p>
<blockquote><p>class Pair[-T]，这种情况是逆变。类型B是A的子类型，Pair反过来可以认为是Pair的子类型。这种情况，参数化类型的方向和类型的方向是相反的。&nbsp;</p></blockquote>
<p>==<strong>非变</strong>==</p>
<blockquote><p>class Pair{}，这种情况就是非变（默认），类型B是A的子类型，Pair和Pair没有任何从属关系，这种情况和Java是一样的。&nbsp;</p></blockquote>
<div class="jb51code"><pre class="brush:scala;">package com.testScala.K_xieBian

class Super
class Sub extends Super

//非变
class Temp1(title: String)
//协变
class Temp2[+A](title: String)
//逆变
class Temp3[-A](title: String)

object Covariance_demo {
def main(args: Array): Unit = {
    val a = new Sub()
    // 没有问题，Sub是Super的子类
    val b: Super = a

    // 非变
    val t1: Temp1 = new Temp1("测试")
    // 报错！默认不允许转换
    // val t2: Temp1 = t1

    // 协变
    val t3: Temp2 = new Temp2("测试")
    val t4: Temp2 = t3

    // 逆变
    val t5: Temp3 = new Temp3("测试")
    val t6: Temp3 = t5
}
}
</pre></div>
<p><strong>&nbsp;==总结==</strong></p>
<blockquote><p><strong>C[+T]：如果A是B的子类，那么C是C的子类。<br />C[-T]：如果A是B的子类，那么C是C的子类。<br />C： 无论A和B是什么关系，C和C没有从属关系。</strong></p></blockquote>
<h2></h2>
<h2>24、隐式转换和隐式参数</h2>
<h3>1 隐式转换</h3>
<ul><li><p>Scala提供的隐式转换和隐式参数功能，是非常有特色的功能。是Java等编程语言所没有的功能。</p></li><li><p>它可以允许你手动指定，将某种类型的对象转换成其他类型的对象或者是给一个类增加方法。通过这些功能，可以实现非常强大、特殊的功能。</p></li><li><p>隐式转换其核心就是定义一个使用 ==implicit== 关键字修饰的方法 实现把一个原始类转换成目标类，进而可以调用目标类中的方法</p></li></ul>
<h3>.2 隐式参数</h3>
<ul><li><p>所谓的隐式参数，指的是在函数或者方法中，定义一个用implicit修饰的参数，此时Scala会尝试找到一个指定类型的用implicit修饰的值，即==隐式值==，并注入参数。</p></li></ul>
<ul><li><p>==所有的隐式转换和隐式参数必须定义在一个object中==</p></li><li><div class="jb51code"><pre class="brush:scala;">package com.kaikeba.implic_demo

//todo:隐式转换案例二:超人变身
class Man(val name: String)

class SuperMan(val name: String) {
def heat = print("超人打怪兽")
}

object SuperMan{
//隐式转换方法
implicit def man2SuperMan(man: Man) = new SuperMan(man.name)

def main(args: Array) {
      val hero = new Man("hero")
      //Man具备了SuperMan的方法
      hero.heat
}
}</pre></div></li></ul>
<p>到此这篇关于Scala基础语法总结的文章就介绍到这了,更多相关Scala基础语法详解内容请搜索琼殿技术社区以前的文章或继续浏览下面的相关文章希望大家以后多多支持琼殿技术社区！</p>
                           
                            <div class="art_xg">
                              <b>您可能感兴趣的文章:</b><ul><li>IDEA中scala生成变量后自动显示变量类型问题</li><li>Idea中添加Maven项目支持scala的详细步骤</li><li>Scala数据库连接池的简单实现</li><li>Java和Scala集合间的相互转换方式</li><li>C# ExecuteScalar()方法案例讲解</li><li>idea中如何创建scala项目</li><li>Scala函数式编程专题--scala集合和函数</li><li>Scala函数式编程专题--scala基础语法介绍</li><li>Scala入门教程详解</li><li>scala中常用特殊符号详解</li></ul>
                            </div>

                        </div>
                        <!--endmain-->
頁: [1]
查看完整版本: Scala基础语法总结