函数闭包，修改类名

jxnu-liguobin · jxnu-liguobin · commit eec8770009a2 · 2019-01-03T23:27:34.000+08:00
diff --git a/src/cn/edu/jxnu/scala/basic/FunctionBasic.scala b/src/cn/edu/jxnu/scala/basic/FunctionBasic.scala
@@ -6,7 +6,7 @@ package cn.edu.jxnu.scala.basic
  * @author 梦境迷离
  * @time 2018-12-17
  */
-object FunctionObjects {
+object FunctionBasic {
 
 }
 
@@ -139,6 +139,55 @@ object Function extends App {
  *
  * 闭包
  */
-object Function extends App {
+object Function2 extends App {
+
+    val m = 1;
+    //引用外部变量
+    // 因为闭包实际捕获的是变量本身，所以m被修改后会体现到fun中，即闭包里面仍可以观察到闭包外面的m被修改后的值
+    //反过来闭包中对变量的修改，在闭包外也能看到
+    val fun = (x: Int) => x + m
+
+    val nums = List(1, 2, 3, 4, 5, 5, 3)
+
+    var sum = 0
+    nums.foreach(sum += _)
+
+    println(sum)
+
+    // (x: Int) => x + m  是一个闭包，每次m都是新传入的值
+    def sum(m: Int) = (x: Int) => x + m
+
+    // (x: Int) => x + m  是一个闭包，每次m都是固定值
+    def sum2(x: Int) = (x: Int) => x + m // 即使方法已经调用并返回了，但是scala编译器会重新组织安排，让被捕获的参数在堆上继续存活
+    //无论是val var 或者是参数
+
+}
+
+/**
+ * 其他函数特性
+ *
+ * 重复参数，带名参数，缺省参数
+ */
+object Function3 extends App {
+
+    //重复参数
+    def prt(args: String*) = for (arg <- args) println(arg)
+
+    prt("hello", "world")
+
+    val arr = Array("hello", "world")
+    //    prt(arr)//编译报错
+    prt(arr: _*) //OK，告诉编译器将arr的每个元素作为参数传进去，而不是将arr作为一个整体
+
+    //带名字参数,字面量/匿名函数不能使用带名参数
+    val su = (x: Int, y: Int) => x + y
+    //    val suu = su(y = 1, x = 2)
+
+    def sum(x: Int, y: Int) = x + y
+
+    val s = sum(y = 1, x = 2) //参数顺序不再固定
+
+    //缺省函数，y有默认值1
+    def sum2(x: Int, y: Int = 1) = x + y
 
 }
diff --git a/src/cn/edu/jxnu/scala/basic/IOBasic.scala b/src/cn/edu/jxnu/scala/basic/IOBasic.scala
@@ -6,9 +6,9 @@ import scala.io.Source
  * 从文件读取行，文件写入使用Java IO
  *
  * 从命令行运行不用加包名
- * scala IOExamples.scala IOExamples.scala 后面一个是参数
+ * scala IOBasic.scala IOBasic.scala 后面一个是参数
  */
-object IOExamples {
+object IOBasic {
 
     val file = "D:\\git_project\\Java-Learning-Summary\\src\\cn\\edu\\jxnu\\scala\\basic\\IOExamples.scala"
     val liness = Source.fromFile(file).getLines().toList
diff --git a/src/cn/edu/jxnu/scala/basic/LoopBasic.scala b/src/cn/edu/jxnu/scala/basic/LoopBasic.scala
@@ -13,7 +13,7 @@ import scala.util.control.Breaks._
  * 5. Scala的for是for表达式，更接近函数式
  * 6. 纯函数式for：list.foreach(println) @see loopTest.scala
  */
-object LoopExamples {
+object LoopBasic {
     //这种是独立对象
 
     //普通遍历整形数组@see Test4.scala
@@ -102,4 +102,13 @@ object LoopExamples {
         next(0)
     }
 
+    //Scala赋值语句返回的不是赋值的那个值而是（）
+    var line = ""
+    while ((line = readLine()) != "") {
+        //这样永远是（）！=“”
+        println(line)
+    }
+
+    //需要在外部赋值初始化，并在while里面进行更新
+    //因为while没有返回值，并且使用了var变量，实际上函数式语言并不推荐。可以使用尾递归替代
 }
diff --git a/src/cn/edu/jxnu/scala/basic/ObjectBasic.scala b/src/cn/edu/jxnu/scala/basic/ObjectBasic.scala
@@ -6,13 +6,13 @@ package cn.edu.jxnu.scala.basic
  * @author 梦境迷离
  * @time 2018-12-14
  */
-class CompanionClass {
+class ObjectBasic {
 
 
     private val str1 = "hello"
 
     def print(): Unit = {
-        println(CompanionClass.str2)
+        println(ObjectBasic.str2)
     }
 
     // 源文件名称可以和类名不同
@@ -23,15 +23,15 @@ class CompanionClass {
  */
 //伴生对象与伴生类同名，同一源文件中
 //注意单例对象是一等的，是特殊的class
-object CompanionClass extends App {
+object ObjectBasic extends App {
     //启动Scala程序
     //1.混入App，默认就可以执行里面的语句
     //2.增加自己的main方法
     //3.混入特质并重写main
     //继承/混入APP特质
     //单例可以混入特质
     private val str2 = "world"
-    val companionClass = new CompanionClass() //new只能实例化类
+    val companionClass = new ObjectBasic() //new只能实例化类
     println(companionClass.str1) //单例对象类似Java的static方法调用
     companionClass.print() //可以互相访问对方的私有属性，方法
 
diff --git a/src/cn/edu/jxnu/scala/basic/ScalaBasic.scala b/src/cn/edu/jxnu/scala/basic/ScalaBasic.scala
@@ -125,7 +125,7 @@ package object basic {
      * 如果没有指定访问修饰符符，默认情况下，Scala 对象的访问级别都是 public。
      * Scala 中的 private 限定符，比 Java 更严格，在嵌套类情况下，外层类不能访问被嵌套类的私有成员。（内部可以访问外层的私有，不如内部/层就没意义了。。。）
      *
-     * @see ObjectsAndClasses.scala->OutPrivateClass.scala | TestInnerPrivateClass.scala
+     * @see ObjectBasic.scala->OutPrivateClass.scala | TestInnerPrivateClass.scala
      **/
 
     /** 在 scala 中，对保护（Protected）成员的访问比 java 更严格一些。因为它只允许保护成员在定义了该成员的的类的子类中被访问。
@@ -194,15 +194,15 @@ package object basic {
      **/
     /**
      * Scala的main方法执行 @see SingletonObject.scala、Test2.scala
-     * Scala的for循环中断和List的交并差 @see LoopExamples.scala
+     * Scala的for循环中断和List的交并差 @see LoopBasic.scala
      * Scala的数组 @see Test3.scala、Test4.scala
      * Scala中的方法调用 操作符表示法 @see Test4.scala
      * Scala的列表 @see Test6.scala
      * Scala的元组 @see Test7.scala
      * Scala的集合和映射(map) @see Test8.scala
      * Scala的可变集合主要用于命令式传统编程（当Java用），不可变主要用于函数式编程，推荐使用不可变，减少副作用，也更加安全 @see immutable.png、mutable.png
-     * Scala从文件读取 @see IOExamples.scala、Test10.scala、Test11.scala
-     * Scala 面向对象的类、单例对象、构造函数、序列化、注解、重写、重载、函数字面量等  @see ObjectsAndClasses.scala FunctionObjects.scala Function.scala
+     * Scala从文件读取 @see IOBasic.scala、Test10.scala、Test11.scala
+     * Scala 面向对象的类、单例对象、构造函数、序列化、注解、重写、重载、函数字面量等  @see ObjectBasic.scala FunctionObjects.scala Function.scala
      * Scala基础语法图解 @see Scala语法图解.png  （已经取得作者本人同意）
      **/
 
@@ -263,7 +263,7 @@ object Test3 extends App {
     arr.foreach(println)
 }
 
-//循环中断@see LoopExamples.scala
+//循环中断@see LoopBasic.scala
 object Test4 extends App {
 
     for (i <- 0 to 2) //to包含了右边界  to实际是(0).to(2)的缩写，to返回一种包含了0、1、2的序列。对于单参数方法的调用时  () . 可以被省略
