Merge pull request #1 from jxnu-liguobin/master

jxnu-liguobin · web-flow · commit 6302e9685eb0 · 2018-12-21T21:23:44.000+08:00
更新尝试
diff --git a/src/cn/edu/jxnu/scala/basic/FunctionObjects.scala b/src/cn/edu/jxnu/scala/basic/FunctionObjects.scala
@@ -0,0 +1,89 @@
+package cn.edu.jxnu.scala.basic
+
+/**
+ * 函数式对象即是：没有任何可变属性的对象
+ *
+ * @author 梦境迷离
+ * @time 2018-12-17
+ */
+object FunctionObjects {
+
+}
+
+/**
+ * ============================方法重载、重写、前置条件检查、隐式转换==============================
+ *
+ * n:分子
+ * d:分母
+ *
+ * @see 《Scala编程》 P97
+ */
+class Rantional(val n: Int, val d: Int) {
+    //给构造方法加前置条件
+    require(d != 0)
+
+    //    println(n + "/" + d) //构造对象时执行
+    //重写非抽象方法，必须加override
+    override def toString: String = n + "/" + d
+
+    def this(n: Int) {
+        this(n, 1)
+    }
+
+    //重载
+    def *(that: Rantional): Rantional = new Rantional(that.n * n, that.d * d)
+
+    // 只是为了演示
+    def *(i: Int): Rantional = new Rantional(n * i, d * i)
+
+    //重载
+    def test() = "test"
+
+    //重载
+    def test(name: String) = "test" + name
+
+    //    implicit def intToRational(x: Int) = new Rantional(x) //定义在这里，下面访问不到
+}
+
+object TestRantional extends App {
+    val r = new Rantional(1, 2) // 打印1/2
+    println(r)
+    println("================定义操作符==============")
+    //    val a = new Rantional(1, 0) // 抛出IllegalArgumentException异常，构建对象失败
+    val c = new Rantional(1, 2)
+    val ret = r * c
+    val ret1 = r.*(c)
+    println(ret) // 输出1/4
+    println(ret1) // 输出1/4
+    println("================重载方法===============")
+    println(ret.test("name"))
+    println(ret.test)
+    println("================隐式转换===============")
+    val n = new Rantional(2, 2)
+    println(n * 3) // 输出2*3/2*3 //这里不需要隐式转换等同 n.*(3)
+    implicit def intToRational(x: Int) = new Rantional(x)
+
+    //可以定义隐式类，作为类型的转换
+    println(3 * n) // 上面定义了隐式转换，不报错，否则3.*(n) 会提示3是Int没有*方法
+    println(3.*(n)) //等同new Rantional(3,1)*Rantional(2,2)
+
+    /**
+     * 隐式类
+     * 在scala2.10后提供了隐式类，可以使用implicit声明类，但是需要注意以下几点：
+     * 1.其所带的构造参数有且只能有一个
+     * 2.隐式类必须被定义在类，伴生对象和包对象里
+     * 3.隐式类不能是case class（case class在定义会自动生成伴生对象与2矛盾）
+     * 4.作用域内不能有与之相同名称的标示符
+     *
+     * 转换前提
+     * 1.不存在二义性（如例1）
+     * 2.隐式操作不能嵌套使用，即一次编译只隐式转换一次(One-at-a-time Rule)
+     * Scala不会把 x + y 转换成 convert1(convert2(x)) + y
+     * 3.代码能够在不使用隐式转换的前提下能编译通过，就不会进行隐式转换。
+     *
+     * @param name
+     */
+    implicit class implicitClass(val name: String) //隐式类必须用要有一个有一个参的主构造方法
+
+
+}
diff --git a/src/cn/edu/jxnu/scala/basic/ObjectsAndClasses.scala b/src/cn/edu/jxnu/scala/basic/ObjectsAndClasses.scala
@@ -9,15 +9,18 @@ package cn.edu.jxnu.scala.basic
 class CompanionClass {
 
 
-    private val str1 = "hello";
+    private val str1 = "hello"
 
     def print(): Unit = {
         println(CompanionClass.str2)
     }
 
-
+    // 源文件名称可以和类名不同
 }
 
+/**
+ * ============================构造函数、实例化规则==============================================
+ */
 //伴生对象与伴生类同名，同一源文件中
 //注意单例对象是一等的，是特殊的class
 object CompanionClass extends App {
@@ -27,28 +30,28 @@ object CompanionClass extends App {
     //3.混入特质并重写main
     //继承/混入APP特质
     //单例可以混入特质
-    private val str2 = "world";
+    private val str2 = "world"
     val companionClass = new CompanionClass() //new只能实例化类
     println(companionClass.str1) //单例对象类似Java的static方法调用
     companionClass.print() //可以互相访问对方的私有属性，方法
 
 }
 
 class Construction {
-    //class有主构造器和辅助构造器，辅助构造器第一行代码必须用调用主构造器
+    //class有主构造器和辅助构造器，辅助构造器第一行代码须用调用主构造器（例外可以是：另一个调用了主构造的辅助构造）
     def this(var1: String) = {
         //无返回值类型
         this() //因为此时默认的主构造就是无参
     }
 }
 
-//使用var表示在类的内部和外部均可以修改（因为生成字段var1，和var1的set方法）
+//使用var表示在类的内层和外层均可以修改（因为生成字段var1，和var1的set方法）
 //var1不使用val、var修饰则Scala不会为其生成字段以及访问器，只能暂时使用该变量
 class Construction2(var1: String, var2: String) {
     //类结构可以嵌入主构造，此时主构造就是2个参数
     //定义一个参数的辅助构造
     def this(var1: String) = {
-        this(null, "hello") //同样需要第一行调用主构造
+        this(null, "hello") //同样需要第一行调用主构造，或者是调用另一个出现在发起调用的构造方法之前的另一个辅助构造
     }
 }
 
@@ -69,7 +72,7 @@ class Construction4 @SerialVersionUID(1L)(override val var1: String, override va
 
     //1.java的super是静态绑定的
     //在java（单一继承）里面，假设有一个对象a，它既是类型X，又是类型Y，那么X和Y必定具有“父子关系”，也就是说，其中一个是另一个的父类。
-    //因为java的继承是单一继承，不管实际类型是什么，一个对象的“继承链”，从super所在类开始往左的部分，都是在编译时期就可以确定下来的。
+    //因为java的继承是单一继承，不管实际类型是什么，一个对象的“继承链”，从super所在类开始往左的层分，都是在编译时期就可以确定下来的。
     //2.scala的super是动态绑定的
     //在scala（多重继承）里面，假设有一个对象a，它既是trait X，又是trait Y， X和Y可能具有父子关系，也可能是共享同一个祖先的“兄弟”，反正，它们的关系不再限定在“父子”上。
     //因为scala允许多重继承，父亲类和trait们的优先顺序，是由对象的实际类型的线性化结果决定的，所以需要动态绑定。
@@ -88,3 +91,84 @@ class Construction4 @SerialVersionUID(1L)(override val var1: String, override va
 
 }
 
+//样例类的主构造必须得有参数
+//初始化可以省略new
+//因为默认自带equals、toString等。可以使用==比较，也可以使用println直接打印内容
+//match模式匹配时用的比较多
+//默认生成自己的伴生对象
+case class Construction5(name: String, pws: String = "pass")
+
+object TestcaseClass extends App {
+
+    val jack = Construction5("name", "password")
+    val rese = Construction5("name")
+    println(jack, rese)
+    val name = jack.name //样例类的实例内容可以直接打印
+    println(jack.name == "name", rese == Construction5("name"))
+
+}
+
+/**
+ * ==============================内层类，访问权限============================
+ **/
+object OutPrivateClass extends App {
+
+    private val name: String = "hello"
+
+    //    def getInnerName = println(InnerPrivateClass.innerName) //编译出差，禁止访问内层单例的私有
+
+    object InnerPrivateClass {
+
+        private val innerName: String = "hello"
+
+        def test() = print(name)
+    }
+
+    InnerPrivateClass.test() //内层单例，可以读取外层单例的私有属性
+
+}
+
+class OutPrivateClass {
+    //外层类别名，这之间不能有任何代码
+    outer =>
+
+    class InnerPrivateClass2 {
+        //访问内层类的私有，拒绝访问
+        // private val innerName = "world"//
+        //可以访问
+        val innerName = "world"
+
+        def info() = println("访问外层类的私有属性试试：" + name)
+
+        // 在内层类通过【外层类.this.成员名称】 访问外层类成员
+        def info1 = println("Outer name :" + OutPrivateClass.this.name + ",Inner Name :" + name)
+
+        //在内层类通过【外层类别名】 访问外层类成员
+        def info2 = println("Outer name :" + outer.name + ",Inner Name :" + name)
+
+    }
+
+    // 访问内层类的私有，拒绝访问（即使你new了这个对象，你也无法得到私有属性，是非常严格的判定，与Java不同）
+    // def getInnerName = new InnerPrivateClass2().innerName
+    //可以访问
+    def getInnerName = println("外层类访问内层类的属性：" + new InnerPrivateClass2().innerName)
+
+    // private val name: String = "hello" //下面方法均正常输出
+    // val name: String = "hello" //下面方法均正常输出
+    //限定具体的包的权限
+    private[basic] val name: String = "hello" //下面方法均正常输出
+
+
+}
+
+object TestInnerPrivateClass extends App {
+
+    val out1 = new OutPrivateClass()
+    out1.getInnerName
+    val inner1 = new out1.InnerPrivateClass2() //注意：Scala内层类是从属于外层类对象的。类似Java的static内部类的实例方式
+    inner1.info()
+    inner1.info1
+    inner1.info2 //定义的时候不加括号，调用的时候就不能加
+
+    //PS:内部==内层==被嵌套类，外部==外层==嵌套类
+}
diff --git a/src/cn/edu/jxnu/scala/basic/Scala语法图解.png b/src/cn/edu/jxnu/scala/basic/Scala语法图解.png
diff --git a/src/cn/edu/jxnu/scala/basic/basicAndInfo.scala b/src/cn/edu/jxnu/scala/basic/basicAndInfo.scala
@@ -114,18 +114,18 @@ package object basic {
     /**
      * 方法参数方法参数是在调用该方法时用于传递方法中的值的变量。
      * 方法参数只能从方法内部访问，但是如果从方法外部引用了对象，则可以从外部访问传入的对象。
-     * 方法参数始终是不可变的，由val关键字定义。（这里有坑，val是隐式定义的，自己写的时候没有写val也是不可变）
+     * 方法参数始终是不可变的，由val关键字定义。（这里有坑，val是隐式定义的，自己写的时候没有写val也是不可变，函数每次调用的时候val有重写的值，所以val不能说是常量，绝对的常量应该加final）@see scala.math.Pi
      * 可变变量用var定义。应该尽量使用val @see Test3.scala
-     *
      * 不能对数值进行++ --操作，Scala不支持 @see Test2.scala
      *
      */
     /** 需要特别注意scala的访问权限
      * 1、访问控制符
      * Scala 访问修饰符基本和Java的一样，分别有：private，protected，public。
      * 如果没有指定访问修饰符符，默认情况下，Scala 对象的访问级别都是 public。
-     * Scala 中的 private 限定符，比 Java 更严格，在嵌套类情况下，外层类不能访问被嵌套类的私有成员。
-     * */
+     * Scala 中的 private 限定符，比 Java 更严格，在嵌套类情况下，外层类不能访问被嵌套类的私有成员。（内部可以访问外层的私有，不如内部/层就没意义了。。。）
+     * @see ObjectsAndClasses.scala->OutPrivateClass.scala | TestInnerPrivateClass.scala
+     **/
 
     /** 在 scala 中，对保护（Protected）成员的访问比 java 更严格一些。因为它只允许保护成员在定义了该成员的的类的子类中被访问。
      * 而在java中，用protected关键字修饰的成员，除了定义了该成员的类的子类可以访问，同一个包里的其他类也可以进行访问。
@@ -199,7 +199,8 @@ package object basic {
      * Scala的集合和映射(map) @see Test8.scala
      * Scala的可变集合主要用于命令式传统编程（当Java用），不可变主要用于函数式编程，推荐使用不可变，减少副作用，也更加安全 @see immutable.png、mutable.png
      * Scala从文件读取 @see IOExamples.scala、Test10.scala、Test11.scala
-     * Scala 面向对象的类、单例对象、构造函数、序列化、注解使用等  @see CompanionClass.scala
+     * Scala 面向对象的类、单例对象、构造函数、序列化、注解、重写、重载等  @see ObjectsAndClasses.scala FunctionObjects.scala
+     * Scala基础语法图解 @see Scala语法图解.png  （已经取得作者本人同意）
      **/
 
 }
@@ -211,12 +212,21 @@ object Test1 {
     // scala 数组下标用(),泛型用[]，@see Test3.scala
     def main(args: Array[String]) {
         println(apply(layout, 10))
+        useLambda()
     }
 
     // 函数 f 和 值 v 作为参数，而函数 f 又调用了参数 v
     def apply(f: Int => String, v: Int) = f(v)
 
     def layout[A](x: A) = "[" + x.toString() + "]"
+
+    //声明一个lambda
+    //实现对传入的两个参数进行凭借,lambda可以当做def使用
+    val lambda = (param1: String, param2: String) => param1 + param2
+
+    def useLambda(): Unit = {
+        println(lambda("hello", "world"))
+    }
 }
 
 object Test2 extends App {
@@ -260,8 +270,9 @@ object Test4 extends App {
     s toLowerCase; //无参，无副作用不用括号,使用后缀需要隔断，用分号
     println() //有副作用用括号
     var num = -1 //-是前缀操作符，实际也是方法调用 可用的前缀操作符：！ + - ~  都是一元的
-    var num2 = 1.unary_-
-    if (num == num2) println(true) //true 都是-1，Scala的==比较的是值的相等性，不同于Java的==（比较引用的地址或者基本类型的值）
+    var num2 = 1.unary_- // unary_是混合操作符 yield在Scala是关键字，需要使用反引号`yield`，其他如match类似
+    if (num == num2) println(true) //true 都是-1，Scala的==比较的是值的相等性，不同于Java的==（比较引用的地址或者基本类型的值），但是Scala的值比较自动处理null
+    //且样例类可以直接使用值比较（==），因为样例类实现了很多譬如：equals、toString等方法 @T
     //若想要比较引用地址可用eq/ne方法，不过这只对Scala对象直接映射到Java对象的对象有效。比如String
     println("======================new eq=====================")
     val str1 = new String("hello")
@@ -272,7 +283,6 @@ object Test4 extends App {
     if (str1 == str2) println("==比较内容") //输出
     if (str1 equals str2) println("equals比较内容") //输出
     println("======================常量 eq=====================")
-
     if (str3 eq str4) println("比较地址") //输出，指向同一个常量池的引用
     if (str3 == str4) println("==比较内容") //输出
     if (str3 equals str4) println("equals比较内容") //输出
