Scala分布式语言二（基础功能搭建、面向对象基础、面向对象高级、异常、集合）

章节3基础功能搭建

46.函数作为值三

package cn . itbaizhan . chapter03
// 函数作为值，函数也是个对象
object FunctionToTypeValue {
def main ( args : Array [ String ]): Unit = {
//Student stu = new Student()
/*val a = ()=>{"GTJin"}
// 输出对象的地址
//cn.itbaizhan.chapter03.FunctionToTypeValue$$
Lambda1/495053715@3f0ee7cb
println(a)*/
// 完整写法
def funcA (): String = {
println ( "funcA 被执行了。。。 " )
"GTJin"
}
73
/*println("--------before val x = funcA()--
--------")
// 执行下一行代码，输出： funcA 被执行了。。。 表示将
函数 funcA 的结果赋值给了 x ，并不是将 funcA 作为对象赋值给 x
val x = funcA()
println(x)
println("--------after val x = funcA()-----
-----")*/
// 如果想将 funcA 函数作为对象赋值给 x ，那么该如何实
现？
// 使用 " 函数名 + 空格 + _", 将函数作为对象赋值给
x ，在赋值的过程中不会函数体中的代码
val x = funcA _
// 写下 x 后提示框显示 "x ()=>String", 表示 x 是一
个无参返回值类型为 String 的函数
// 万物皆对象，是对象就应该有对应的类型，所以函数也
有对象的类型
//Function0[String] Function0 表示 0 个参数的函
数对象 [String] 表示函数的返回值类型为 String
//Function1[-T1,+R] 表示 1 个参数的函数对象 [] 里
面最后的 +R 表示返回值类型为， -T1 参数类型
//Function2[-T1,-T2,+R] 表示 2 个参数的函数对象

\] 里面最后的 +R 表示返回值类型， -T1 第一参数类型 -T2 第二 个参数类型 //... Function22 将函数作为对象赋值时，参数声明 的个数最多 22 个，对应 Function22 // 函数独立定义和使用时，声明参数的个数时没有限制 的。、 //22 在 Scala 语言中是一个神奇的数字，官方没有明确说 明，后续还会在其它地方见到 Tuple22 val f1 : Function0 \[ String \] = funcA _ println ( x == f1 ) //false 相当于创建了两个函数对象 74 def funcB ( name : String ): String = { "funcB....name=" + name } // 函数类型还有另外一种表示方式： ( 参数类型 )=\> 返回值 类型 ，多个参数之间使用逗号隔开 //val f2:Function1\[String,String\] = funcB _ val f2 :( String ) =\> String = funcB _ // 如果函数只有一个参数小括号可以省略 val f2_1 : String =\> String = funcB _ def funcC ( name : String , age : Int ): String = { s "name=${name},age=${age}" } // 两个或两个以上参数时，小括号不能省略 val f3 :( String , Int ) =\> String = funcC _ //val f3_1:String,Int=\>String = funcC _ // 错误的 /\*\*val x = funcA _ 为什么在函数名后 使用下滑线让 函数作为对象使用，因为代码中没有明确的变量 \* 类型，所以需要通过取值类型进行推断。 \* 如果变量声明时的类型为函数类型，那么可以不适用下 划线让函数作为对象 \* \*/ val f4 :( String ) =\> String = funcB val f5 :( String , Int ) =\> String = funcC } } ### 47.函数作为值四  **实时效果反馈** **1.** **关于** **Scala** **函数作为值的描述，错误的是：** A 函数类型表示方式： ( 参数类型 ) =\> 返回类型 注：多个参数 的话之间逗号隔开。 B 如果在声明时并没有指定具体的函数类型，那么下划线不能 省略。 C 如果变量声明的类型为函数类型，那么可以不使用下划线让 函数作为对象。 D 将函数作为对象赋值时，参数声明的个数没有限制。 **答案：** 1=\>D 将函数作为对象赋值时，参数声明的个数最多 22 个，对 应 Function22 。 ### 48.函数作为参数_无参无返回值  object FunctionToTypeArgXx { def main ( args : Array \[ String \]): Unit = { def funcA ( x : Int , y : Int , 函数 ): Unit = { val result = 函数 ( x , y ) println ( result ) } funcA ( 1 , 2 , 求和函数 ) funcA ( 1 , 2 , 求差函数 ) } } 76 代码拆解分析演示： package com . itbaizhan . chapter03 // 函数作为参数 object FunctionToTypeArg1 { def main ( args : Array \[ String \]): Unit = { //TODO 1 无参无返回值 /\*\*public void method(Student stu){} \* public void method( 参数类型 参数名称 ){} \* Scala 同理，让函数作为参数 \* fun:()=\>Unit 表示参数是一个函数对象，这个函数 是一个无参无返回值的函数 \* () 表示是一个无参的函数 \* Unit 表示是一个无返回值的函数 \*/ def funcA ( fun :() =\> Unit ): Unit = { // 调用传递过来的函数 fun () } def funcObjA (): Unit = { println ( "funcObjA 被调用 " ) } //funcA(funcObjA _) // 下划线可以省略 应该在函数 funcA 声明的时候定义了 参数的函数类型 无参无返回值的类型 //funcA(funcObjA) // TODO 2 有参数以后返回值 /\*\*fun:(Int,Int)=\>Int) 表示 funcB 的参数为一个函 数 \* (Int,Int) 这个函数是一个有两个参数的函数，这两 个参数都是 Int 类型 \* Int 表示这个函数的返回值是一个 Int 类型 77 \* @param fun \*/ def funcB ( fun :( Int , Int ) =\> Int ): Unit = { // 该设计缺陷是 fun(2,1) 写死的参数值 val result = fun ( 2 , 1 ) println ( result ) } // 定义一个函数 def funcObjB1 ( x : Int , y : Int ): Int = { x + y } //funcB(funcObjA) // 错误的，因为 funcObjA 参数和 返回值类型 与 funcB 要求的参数类型不匹配 funcB ( funcObjB1 ) //3 def funcObjB2 ( x : Int , y : Int ): Int = { x - y } funcB ( funcObjB2 ) //1 def funcObjB3 ( x : Int , y : Int ): Int = { x / y } funcB ( funcObjB3 ) //2 //TODO 3. 省略 作为参数的函数 // 省略关键字、函数名、返回值类型 ; 在将 ": =" 改为 "=\>" funcB (( x : Int , y : Int ) =\> { x / y }) // 继续简化： 函数体只有一行，函数体外的 {} 可以省略 funcB (( x : Int , y : Int ) =\> x / y ) // 参数的类型如果能够推断出来，参数的类型可以省略 78 参数函数简化案例一，一个参数无返回值： funcB (( x , y ) =\> x / y ) // 如果参数只有一个的话，参数列表的小括号可以省略 //funcB(x,y=\> x/y) 错误的 参数 \>=2 话，参数列表的 小括号不可以省略 // 如果参数在使用时，按照声明的顺序只使用一次时，那 么可以使用下划线代替 println ( "------------funcObjBn 不需要定义 ----- ------------" ) funcB (( _ / _ )) //2 继续省略 funcB ( _ / _ ) //2 funcB ( _ - _ ) //1 funcB ( _ \* _ ) //2 funcB ( _ + _ ) //3 } } ### 49.函数作为参数_有参有返回值 一个参数无返回值： funcB (( x , y ) =\> x / y ) // 如果参数只有一个的话，参数列表的小括号可以省略 //funcB(x,y=\> x/y) 错误的 参数 \>=2 话，参数列表的 小括号不可以省略 // 如果参数在使用时，按照声明的顺序只使用一次时，那 么可以使用下划线代替 println ( "------------funcObjBn 不需要定义 ----- ------------" ) funcB (( _ / _ )) //2 继续省略 funcB ( _ / _ ) //2 funcB ( _ - _ ) //1 funcB ( _ \* _ ) //2 funcB ( _ + _ ) //3 } } package com . itbaizhan . chapter03 object FunctionToTypeArg2 { def main ( args : Array \[ String \]): Unit = { def funcA ( fun :( String ) =\> Unit ): Unit = { fun ( "GTJin" ) } def funArg ( name : String ): Unit = { println ( name ) } funcA ( funArg ) // 如果函数 funArg 只是被调用一次，可以进行简化 // 首先省略 def 、函数名、返回值类型 funcA ( ( name : String ) =\> { println ( name ) 79 参数函数简化案例二，两个参数有返回值： }) // 函数体只有一行省略大括号 funcA ( ( name : String ) =\> println ( name ) ) // 参数类型可以推导出来，也可以省略 funcA ( ( name ) =\> println ( name ) ) // 只有一个参数，小括号也可以省略 funcA ( name =\> println ( name ) ) // 还可以继续省略，以后在 spark 的代码中会遇到类似的 用法 funcA ( println ( _ )) // 匿名函数的至简原则的最简化版 本 funcA ( println ) // 该方式调用的不再是匿名函数的简化 版了，而是调用 println 函数 //funcA(funArg) } } ### 50.函数作为参数_有参有返回值简化演示  package com . itbaizhan . chapter03 object FunctionToTypeArg3 { def main ( args : Array \[ String \]): Unit = { def funcA ( fun :( Double , Double ) =\> Double ): Double = { fun ( 1.0 , 2.0 ) } 80 参数函数简化案例三： def funcB ( x : Double , y : Double ): Double = { x / y } funcA ( funcB ) // 简化函数 funcA ( ( x : Double , y : Double ) =\> { x / y } ) funcA ( ( x , y ) =\> { x / y } ) funcA ( ( x , y ) =\> x / y ) // 顺序使用且只用一次可以简化为下划线 println ( funcA ( _ / _ )) //0.5 // 但是如果不是顺序使用，无法使用下划线简化，比如： 结果为 2 不是 0.5 println ( funcA ( ( x , y ) =\> y / x ) ) } }  ### 51.函数作为参数_一参无返回值简化演示 package com . itbaizhan . chapter03 81 **3.6.3** **函数作为返回值** // 函数作为参数的常见场景 object FunctionToTypeArg4 { def main ( args : Array \[ String \]): Unit = { def funcA ( x : Int , y : Int , fun :( Int , Int ) =\> Int ): Unit = { val result = fun ( x , y ) println ( result ) } funcA ( 1 , 2 , ( x : Int , y : Int ) =\> x + y ) funcA ( 1 , 2 , ( x , y ) =\> x + y ) funcA ( 1 , 2 , _ + _ ) funcA ( 1 , 2 , _ - _ ) funcA ( 1 , 2 , _ \* _ ) funcA ( 1 , 2 , _ / _ ) } } ### 52.函数作为参数_两参有返回值简化演示 **3.6.3** **函数作为返回值** // 函数作为参数的常见场景 object FunctionToTypeArg4 { def main ( args : Array \[ String \]): Unit = { def funcA ( x : Int , y : Int , fun :( Int , Int ) =\> Int ): Unit = { val result = fun ( x , y ) println ( result ) } funcA ( 1 , 2 , ( x : Int , y : Int ) =\> x + y ) funcA ( 1 , 2 , ( x , y ) =\> x + y ) funcA ( 1 , 2 , _ + _ ) funcA ( 1 , 2 , _ - _ ) funcA ( 1 , 2 , _ \* _ ) funcA ( 1 , 2 , _ / _ ) } } package com . itbaizhan . chapter03 // 函数作为函数的返回值 object FunctionToFunResult { def main ( args : Array \[ String \]): Unit = { //TODO 1. 对比 Java 代码 /\*\*public Student getStudent(){ \* return new Student(); \* } \* 返回的是一个对象，而在 Scala 中函数也是一个对象， 82 为何不直接调用 resultFun()? \* 所以也可以使用一个函数作为另外一个函数的返回值 \*/ def resultFun (): Unit = { println ( "resultFun...." ) } def funcA (): () =\> Unit = { // 写上函数的类型 ()=\>Unit resultFun _ // 返回的是函数对象 } val f1 = funcA _ //f2 就是 resultFun val f2 = f1 () // 调用 f2 f2 () // 简化以上调用 以后的代码中经常遇到 funcA ()() // 上行代码等价于 resultFun(), 那么为何不直接调用 呢？ } }  ### 53.函数作为参数_案例三  ### 54.函数作为返回值一  ### 55.函数作为返回值二  package com . itbaizhan . chapter03 object FunctionToFunResult2 { def main ( args : Array \[ String \]): Unit = { //TODO 2. 将函数作为返回值返回，一般应用在将内部的 函数在外部使用 /\*def outer(): ()=\>Unit ={ def inner():Unit={ println("inner.....") } inner _ } outer()()\*/ //TODO 3. 如果层次多了，就比较麻烦了，这种方式不推 荐自定义开发中使用 def outer (): () =\> () =\> Unit = { def mid (): () =\> Unit = { def inner (): Unit = { println ( "inner....." ) } inner _ } mid _ } outer ()()() } } ### 56.闭包 package com . itbaizhan . chapter03 // 闭包 object FunctionClosure { def main ( args : Array \[ String \]): Unit = { def outer ( x : Int ): ( Int ) =\> Int = { def inner ( y : Int ): Int = { x + y } inner _ } //println(outer(2)(3)) val fun = outer ( 2 ) 84 由于在执行 inner 的时候， outer 已经出栈了，所以变量 x 已经不 存在，那么在 inner 中该如何进行计算呢，底层又是如何实现的呢？ 反编译：选择 target/classes/com/itbaizhan/chapter03/FunctionClosure-\> 右 键 -\>Decompile Scala to Java val fun2 = fun ( 3 ) println ( fun2 ) } }    ### 57.匿名函数  package com . itbaizhan . chapter03 // 匿名函数 object FunctionNoName { def main ( args : Array \[ String \]): Unit = { def funcA ( fun : Int =\> Int ): Int = { fun ( 3 ) } // 使用匿名函数作为参数 println ( funcA (( x : Int ) =\> { x \* 5 })) // 类型可以推导出来所以可以省略 println ( funcA (( x ) =\> { x \* 5 })) // 只有一个参数小括号可以省略 println ( funcA ( x =\> { x \* 5 })) // 函数体只有一行， {} 可以省略 println ( funcA ( x =\> x \* 5 )) // 使用 _ 进行简化 println ( funcA ( _ \* 5 )) // 在 funcA 内部使用 fun(3) 不够灵活，再次进行完善 def funcB ( x : Int , fun : Int =\> Int ): Int = { fun ( x ) } println ( funcB ( 4 , _ \* 2 )) //8 println ( funcB ( 4 , _ + 2 )) //6 } } ### 58.控制抽象  package com . itbaizhan . chapter03 import scala . util . control . Breaks // 函数控制抽象 object FunctionControlAbstract { def main ( args : Array \[ String \]): Unit = { //TODO 1. 对比匿名函数方式 // 函数类型： ()=\>Unit def funcA ( opt : () =\> Unit ): Unit = { opt () } funcA { () =\> { println ( " 函数控制抽象入门 " ) } } //TODO 2. 函数控制抽象 // 参数类型不完整，在传递参数时也是不完整的；只传递 代码就可以了，不需要完整的声明。 def funcB ( opt : =\> Unit ): Unit = { opt } funcB { println ( " 函数控制抽象入门 " ) } //TODO 3. 可以通过控制抽象设计语法 Breaks . breakable { for ( index \<- 1 to 5 ){ if ( index == 3 ){ Breaks . break () 89 **3.10** **柯里化函数** 柯里化是一个数学家 Curry 的音译。 将无关的参数分离开，提高函数效率。 } println ( "index=" + index ) } } } } ### 59.柯里化函数  柯里化是一个数学家 Curry 的音译。 将无关的参数分离开，提高函数效率。 } println ( "index=" + index ) } } } } package com . itbaizhan . chapter03 // 柯里化函数 object FunctionCurry { def main ( args : Array \[ String \]): Unit = { def funcA (): Int = { var result : Int = 1 for ( i \<- 1 to 10 ){ result = i Thread . sleep ( 10 ) } result } def funcB (): Int = { var result : Int = 1 for ( i \<- 1 to 20 ){ result = i Thread . sleep ( 10 ) } result 90 运行输出： 用时几乎缩减百分之五十。 } def funcC ( a : Int , b : Int ): Int = { a + b } def funcD ( a : Int )( b : Int ): Int = { a + b } val start1 : Long = System . currentTimeMillis () println ( funcC ( funcA (), funcB ())) val end1 : Long = System . currentTimeMillis () println ( "------------ 未使用柯里化用时 :" + ( end1 - start1 )) val start2 : Long = System . currentTimeMillis () println ( funcD ( funcA ())( funcB ())) val end2 : Long = System . currentTimeMillis () println ( "------------ 使用柯里化用时 :" + ( end2 - start2 )) } } 30 ------------ 未使用柯里化用时 :695 30 ------------ 使用柯里化用时 :328 ### 60.递归函数  package com . itbaizhan . chapter03 // 递归函数 object FunctionRecursion { def main ( args : Array \[ String \]): Unit = { //TODO 1. 递归函数 /\*\* 递归函数：在函数内部调用函数本身 \* 注意： \* 1.scala 中要求递归函数必须明确声明返回值类型 \* 2. 递归函数一定要有跳出的出口 \* 3. 传递的参数之间存在某种关系时才可以设计成递归函 数 \* @param num \* @return \*/ def funcA ( num : Int ): Int = { if ( num == 1 ) // 跳出的出口 num else num \* funcA ( num - 1 ) } print ( funcA ( 5 )) } }  ### 61.尾递归函数（选修）  tail recursion 义译为尾递归，或伪递归。 package com . itbaizhan . chapter03 import scala . annotation . tailrec // 尾 ( 伪 ) 递归函数 object FunctionRecursion2 { def main ( args : Array \[ String \]): Unit = { /\*def funcA(): Unit = {// funcA() println("funcA....") } funcA()\*/ def funcB (): Unit = { println ( "funcB...." ) funcB () } funcB () 93 Scala 中的尾递归被编译器优化为了 while 循环，所以应该理解 成为伪递归。 **3.12** **惰性函数** **(** **选学** **)** 当函数返回值被声明为 lazy 时，函数的执行将被推迟，直到我 们首次对此取值，该函数才会执行。这种函数我们称之为惰性函 数。 } } public void main ( final String \[\] args ) { this . funcB$1 (); } private final void funcB$1 () { while ( true ) { . MODULE$ . println ( "funcB...." ); } } ### 62.惰性函数（选修）  当函数返回值被声明为 lazy 时，函数的执行将被推迟，直到我 们首次对此取值，该函数才会执行。这种函数我们称之为惰性函 数。 } } public void main ( final String \[\] args ) { this . funcB$1 (); } private final void funcB$1 () { while ( true ) { . MODULE$ . println ( "funcB...." ); } } package com . itbaizhan . chapter03 // 惰性函数 object FunctionLazy { def main ( args : Array \[ String \]): Unit = { // 函数结果没有使用，则函数不执行；直到使用结果才执 行。 def funcA (): String = { println ( "funcA 被执行了 ......" ) " 天王盖地虎 " } // 当函数返回值被声明为 lazy 时，函数的执行将被推迟， 直到我们首次对此取值 , 该函数才会被执行。 94 输出结果如下： lazy val password = funcA () println ( "----------------" ) println ( password ) // 首次对此取值 println ( "================" ) } } ---------------- funcA 被执行了 ...... 天王盖地虎 ## 章节4面向对象基础 ### 63.面向对象基础概述 Scala 是一门完全面向对象的语言，摒弃了 Java 中很多不是面向 对象的语法。虽然如此，但其面向对象思想和 Java 的面向对象思想 还是一致的。 // 包声明 package com . itbaizhan . chapter04 // 类定义 class Point ( xc : Int , yc : Int ) { // 属性 var x : Int = xc var y : Int = yc // 方法 def move ( dx : Int , dy : Int ) { x = x + dx y = y + dy 95 面向对象基础包含：包 package 、导入 import 、类、属性、访 问权限、方法、对象、构造方法等。   ### 64.面向对象基础_包package  Scala 中基本的 package 包语法和 Java 完全一致，就是在代码的 最后不加 ";" 。 println ( "x 的坐标点 : " + x ); println ( "y 的坐标点 : " + y ); } } object ObjectAndClass { def main ( args : Array \[ String \]): Unit = { // 实例化对象 val point = new Point ( 10 , 20 ); // 移到一个新的位置 point . move ( 10 , 10 ); } } package com . itbaizhan . chapter04 object PackageDemo { } 96 Java 中 package 包的语法比较单一， Scala 对此进行如下扩展： 1 Scala 中的包和类的物理路径没有关系 2 package 关键字可以嵌套声明使用 3 同一个源码文件中子包可以直接访问父包中的内容，而无需 import //package com.itbaizhan.chapter04 package com package itbaizhan //package chapter04 package chapter05 object PackageDemo { def main ( args : Array \[ String \]): Unit = { println ( "package.." ) } } //package com.itbaizhan.chapter04 package com package itbaizhan { class Person { def showInfo (): Unit = { println ( "showInfo..." ) } } package chapter04 { object PackageDemo { def main ( args : Array \[ String \]): Unit = { new Person (). showInfo () } 97 4 Scala 中 package 也可以看作对象，并声明属性和函数 在 PackageDemo 的 main 方法中可以直接调用 showMe() **实时效果反馈** **1.** **关于** **Scala** **包的描述，错误的是：** A Scala 中基本的 package 包语法和 Java 完全一致，就是在代码 的最后不加 ";" 。 B package 关键字不可以嵌套声明使用。 C Scala 中 package 也可以看作对象，并声明属性和函数。 D 同一个源码文件中子包可以直接访问父包中的内容，而无需 import 。 **答案：** 1=\>B package 关键字可以嵌套声明使用。 ### 65.面向对象基础_类   ### 66.面向对象基础_java中的导入    ### 67.面向对象基础_Scala中的导入Import一  ### 68.面向对象基础_Scala中的导入Import二 //TODO 6.scala 导入类的操作，是以相对路径 ( 当前所在 包的路径 ) 的方式导入的 // 如果想使用绝对路径的方式，需要在包名前添加： _root_. /\* val hashMap = new java.util.HashMap\[Int, String\]() hashMap.put(1,"tuhao") hashMap.put(2,"baifumei") println(hashMap)//{1=tuhao, 2=baifumei}\*/ //println(new java.util.HashMap())//com.itbaizhan.chapter04.j ava.util.HashMap@2ff4f00f //println(new _root_.java.util.HashMap())//{} 表示使用了 jdk 的 HashMap //TODO 7.Scala 中可以给导入的类起别名，简化使用 import java . util .{ ArrayList =\> AList } println ( new AList ()) } } /\*package java{ package util{ class HashMap{ } } }\*/ 103 B **实时效果反馈** **1.** **关于** **Scala Import** **使用的描述，错误的是：** A 星号在 scala 中有特殊的用途，不能使用在 import 语句中， 需要使用 _ 来代替 \* 。 import 导入语句只能用在 package 语句和 class 定义之间。 C Scala 中可以给导入的类起别名，简化使用。 D 可以在一行中导入一个包中的多个类 , 简化代码。 **答案：** 1=\>B import 导入语句可以在任意地方使用  ### 69.面向对象基础_属性一 package com . itbaizhan . chapter04 import scala . beans . BeanProperty class Animal { // 属性声明， java 中可以不赋值， scala 中属性必须显示地 初始化 //var name:String // 抛错 // 可以直接赋予一个默认值 //var name:String = " 华南虎 " // 如果希望像 java 一样可以由系统进行初始化，后续手动调 用 setter 赋值，声明时使用 _ 赋值 var name : String = _ // 使用 val 声明的属性，编译器将之编译为私有的属性，并使 用 final 修饰，不可修改， // 所以只提供的 get 方法，而没有提供 set 方法 val age : Int = 30 // 属性声明时如果使用 private 修饰，编译器将该属性对应 的 get 和 set 方法也是编译为私有化的方法 104 **实时效果反馈** **1.** **关于** **Scala** **属性的描述，错误的是：** A var 声明的属性编译器将之编译为类的私有属性，通过提供 getter 和 seter 方法。 B 使用 val 声明的属性，编译器将之编译为私有的属性，并使 用 final 修饰，不可修改。 private var color : String = _ // 通过查看 Animal 类的源码，属性的 get 和 set 方法不符合 bean 规范 // 如果想符合 bean 规范 (id=\>getId,setId) ，需要在属性 声明前加上 @BeanProperty @BeanProperty var kind : String = _ } object ClassField { def main ( args : Array \[ String \]): Unit = { val animal = new Animal () //var 声明的属性编译器将之编译为类的私有属性，通过提 供 getter 和 seter 方法 // 如下方式赋值相当于调用的 animal.setName(" 东北 虎 ") animal . name = " 东北虎 " // 访问类的属性时相当于调用了对象的 get 方法 println ( animal . name ) //val 声明的属性被 final 修饰，并未提供 set 方法，所以 不可改变 //animal.age = 10 } } **实时效果反馈** **1.** **关于** **Scala** **属性的描述，错误的是：** A var 声明的属性编译器将之编译为类的私有属性，通过提供 getter 和 seter 方法。 B 使用 val 声明的属性，编译器将之编译为私有的属性，并使 用 final 修饰，不可修改。 private var color : String = _ // 通过查看 Animal 类的源码，属性的 get 和 set 方法不符合 bean 规范 // 如果想符合 bean 规范 (id=\>getId,setId) ，需要在属性 声明前加上 @BeanProperty @BeanProperty var kind : String = _ } object ClassField { def main ( args : Array \[ String \]): Unit = { val animal = new Animal () //var 声明的属性编译器将之编译为类的私有属性，通过提 供 getter 和 seter 方法 // 如下方式赋值相当于调用的 animal.setName(" 东北 虎 ") animal . name = " 东北虎 " // 访问类的属性时相当于调用了对象的 get 方法 println ( animal . name ) //val 声明的属性被 final 修饰，并未提供 set 方法，所以 不可改变 //animal.age = 10 } } 105 **访问权限** **有效范围** private 当前类中 默认缺省 当前类中、本包 ( 以及当前类所在的当前包中 ) 。 protected 当前类中、本包、当前类的子类中 public 任意位置 **访问权限** **有效范围** private 当前类中 private 【包名】 当前类中、本包的类中（包私有） protected 当前类中、子类中 默认缺省 表示公共的， scala 中没有 public 关键字 C 如果想属性的 set 和 get 方法符合 bean 规范 (id=\>getId,setId) ，需要在属性声明前加上 @BeanProperty 。 D 属性声明时是否使用 private 修饰，编译器对属性编译时都 是做一样的处理 **答案：** 1=\>D 不一样处理，使用 private 修饰的属性的 get 和 set 方法也 会被私有化；不使用 private 修饰的属性的 get 和 set 方法是公共的。  ### 70.面向对象基础_属性二  ### 71.面向对象基础_访问权限    ### 72.面向对象基础_方法   ### 73.面向对象基础_对象  ### 74.面向对象基础_构造方法    ## 章节5面向对象高级 ### 75.伴生类和伴生对象一  ### 76.伴生类和伴生对象二  ### 77.伴生类和伴生对象三    ### 78.抽象类和抽象方法一  ### 79.抽象类和抽象方法二   ### 80.抽象属性一   ### 81.抽象属性二    ### 82.Trait_Java中的接口  ###  ### 83.Trait_基本使用一   ### 84.Trait_基本使用二   ### 85.Trait_作用解耦合   ### 86.Trait_原理    ### 87.Trait_初始化叠加一   ### 88.Trait_初始化叠加二   ### 89.Trait_功能叠加   ### 90.Trait_反射一   ### 91.Trait_反射二  ### 92.多学三招_枚举类  ### 93.多学三招_应用类   ### 94.多学三招_type定义新类型 package com . itbaizhan . chapter05 object TypeDemo extends App { //TODO 1.scala 源码 // 将 java.lang.String 定义为 String 类 //type String = java.lang.String // 将 java.lang.Class\[T\] 定义为 Class\[T\] 类 //type Class\[T\] = java.lang.Class\[T

// 使用 type 关键字可以定义新的数据数据类型名称，本质上
就是类型的一个别名
type KIntVStrMap = java . util . HashMap [ Int ,
String ]
private val map = new KIntVStrMap ()
map . put ( 1 , "java" ) // 提示 key 为 Int 类型， value 为
String 类型
map . put ( 2 , "scala" )
}

章节6异常

95.JAVA中的异常一

96.Java中的异常二

97.Scala中的异常

章节7集合类

98.集合类概述

99.队列Queue

100.元祖一

101.元祖二

102.Seq_不可变List一

103.Seq_不可变List二

104.Seq_不可变List三

105.Seq_不可变List四

106.Seq_可变ListBuffer一

107.Seq_可变ListBuffer二

108.Seq_可变ListBuffer三

109.Seq_可变List和不可变List转换

110.不可变Set