Skip to content

Commit 8cd7ab3

Browse files
jxnu-liguobinjxnu-liguobin
committed
新增重写，重载，隐式转换
1 parent f89c4fc commit 8cd7ab3

3 files changed

Lines changed: 67 additions & 14 deletions

File tree

‎src/cn/edu/jxnu/scala/basic/FunctionObjects.scala‎

Lines changed: 59 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -9,3 +9,62 @@ package cn.edu.jxnu.scala.basic
99
object FunctionObjects {
1010

1111
}
12+
13+
/**
14+
* ============================方法重载、重写、前置条件检查、隐式转换==============================
15+
*
16+
* n:分子
17+
* d:分母
18+
*
19+
* @see 《Scala编程》 P97
20+
*/
21+
class Rantional(val n: Int, val d: Int) {
22+
//给构造方法加前置条件
23+
require(d != 0)
24+
25+
// println(n + "/" + d) //构造对象时执行
26+
//重写非抽象方法，必须加override
27+
override def toString: String = n + "/" + d
28+
29+
def this(n: Int) {
30+
this(n, 1)
31+
}
32+
33+
//重载
34+
def *(that: Rantional): Rantional = new Rantional(that.n * n, that.d * d)
35+
36+
// 只是为了演示
37+
def *(i: Int): Rantional = new Rantional(n * i, d * i)
38+
39+
//重载
40+
def test() = "test"
41+
42+
//重载
43+
def test(name: String) = "test" + name
44+
45+
// implicit def intToRational(x: Int) = new Rantional(x) //定义在这里，下面访问不到
46+
}
47+
48+
object TestRantional extends App {
49+
val r = new Rantional(1, 2) // 打印1/2
50+
println(r)
51+
println("================定义操作符==============")
52+
// val a = new Rantional(1, 0) // 抛出IllegalArgumentException异常，构建对象失败
53+
val c = new Rantional(1, 2)
54+
val ret = r * c
55+
val ret1 = r.*(c)
56+
println(ret) // 输出1/4
57+
println(ret1) // 输出1/4
58+
println("================重载方法===============")
59+
println(ret.test("name"))
60+
println(ret.test)
61+
println("================隐式转换===============")
62+
val n = new Rantional(2, 2)
63+
println(n * 3) // 输出2*3/2*3 //这里不需要隐式转换等同 n.*(3)
64+
implicit def intToRational(x: Int) = new Rantional(x)
65+
66+
println(3 * n) // 上面定义了隐式转换，不报错，否则3.*(n) 会提示3是Int没有*方法
67+
println(3.*(n)) //等同new Rantional(3,1)*Rantional(2,2)
68+
69+
70+
}

‎src/cn/edu/jxnu/scala/basic/ObjectsAndClasses.scala‎

Lines changed: 3 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,7 @@ class CompanionClass {
1515
println(CompanionClass.str2)
1616
}
1717

18-
18+
// 源文件名称可以和类名不同
1919
}
2020

2121
/**
@@ -38,7 +38,7 @@ object CompanionClass extends App {
3838
}
3939

4040
class Construction {
41-
//class有主构造器和辅助构造器，辅助构造器第一行代码必须用调用主构造器
41+
//class有主构造器和辅助构造器，辅助构造器第一行代码须用调用主构造器（例外可以是：另一个调用了主构造的辅助构造）
4242
def this(var1: String) = {
4343
//无返回值类型
4444
this() //因为此时默认的主构造就是无参
@@ -51,7 +51,7 @@ class Construction2(var1: String, var2: String) {
5151
//类结构可以嵌入主构造，此时主构造就是2个参数
5252
//定义一个参数的辅助构造
5353
def this(var1: String) = {
54-
this(null, "hello") //同样需要第一行调用主构造
54+
this(null, "hello") //同样需要第一行调用主构造，或者是调用另一个出现在发起调用的构造方法之前的另一个辅助构造
5555
}
5656
}
5757

@@ -171,7 +171,3 @@ object TestInnerPrivateClass extends App {
171171

172172
//PS:内部==内层==被嵌套类，外部==外层==嵌套类
173173
}
174-
175-
/**
176-
* ============================函数重载、重写、前置条件检查==============================
177-
*/

‎src/cn/edu/jxnu/scala/basic/basicAndInfo.scala‎

Lines changed: 5 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -114,9 +114,8 @@ package object basic {
114114
/**
115115
* 方法参数方法参数是在调用该方法时用于传递方法中的值的变量。
116116
* 方法参数只能从方法内部访问，但是如果从方法外部引用了对象，则可以从外部访问传入的对象。
117-
* 方法参数始终是不可变的，由val关键字定义。（这里有坑，val是隐式定义的，自己写的时候没有写val也是不可变）
117+
* 方法参数始终是不可变的，由val关键字定义。（这里有坑，val是隐式定义的，自己写的时候没有写val也是不可变，函数每次调用的时候val有重写的值，所以val不能说是常量，绝对的常量应该加final）@see scala.math.Pi
118118
* 可变变量用var定义。应该尽量使用val @see Test3.scala
119-
*
120119
* 不能对数值进行++ --操作，Scala不支持 @see Test2.scala
121120
*
122121
*/
@@ -125,9 +124,8 @@ package object basic {
125124
* Scala 访问修饰符基本和Java的一样，分别有：private，protected，public。
126125
* 如果没有指定访问修饰符符，默认情况下，Scala 对象的访问级别都是 public。
127126
* Scala 中的 private 限定符，比 Java 更严格，在嵌套类情况下，外层类不能访问被嵌套类的私有成员。（内部可以访问外层的私有，不如内部/层就没意义了。。。）
128-
*
129127
* @see ObjectsAndClasses.scala->OutPrivateClass.scala | TestInnerPrivateClass.scala
130-
* */
128+
**/
131129

132130
/** 在 scala 中，对保护（Protected）成员的访问比 java 更严格一些。因为它只允许保护成员在定义了该成员的的类的子类中被访问。
133131
* 而在java中，用protected关键字修饰的成员，除了定义了该成员的类的子类可以访问，同一个包里的其他类也可以进行访问。
@@ -182,7 +180,7 @@ package object basic {
182180
* 以下实例中，apply() 函数使用了另外一个函数 f 和 值 v 作为参数，而函数 f 又调用了参数 v：
183181
*
184182
* @see Test1.scala
185-
* */
183+
**/
186184

187185
/** 函数式编程核心理念：
188186
* 函数是一等的值
@@ -201,7 +199,7 @@ package object basic {
201199
* Scala的集合和映射(map) @see Test8.scala
202200
* Scala的可变集合主要用于命令式传统编程（当Java用），不可变主要用于函数式编程，推荐使用不可变，减少副作用，也更加安全 @see immutable.png、mutable.png
203201
* Scala从文件读取 @see IOExamples.scala、Test10.scala、Test11.scala
204-
* Scala 面向对象的类、单例对象、构造函数、序列化、注解、重写、重载等 @see ObjectsAndClasses.scala
202+
* Scala 面向对象的类、单例对象、构造函数、序列化、注解、重写、重载等 @see ObjectsAndClasses.scala FunctionObjects.scala
205203
* Scala基础语法图解 @see Scala语法图解.png （已经取得作者本人同意）
206204
**/
207205

@@ -272,7 +270,7 @@ object Test4 extends App {
272270
s toLowerCase; //无参，无副作用不用括号,使用后缀需要隔断，用分号
273271
println() //有副作用用括号
274272
var num = -1 //-是前缀操作符，实际也是方法调用 可用的前缀操作符：！ + - ~ 都是一元的
275-
var num2 = 1.unary_-
273+
var num2 = 1.unary_- // unary_是混合操作符 yield在Scala是关键字，需要使用反引号`yield`，其他如match类似
276274
if (num == num2) println(true) //true 都是-1，Scala的==比较的是值的相等性，不同于Java的==（比较引用的地址或者基本类型的值），但是Scala的值比较自动处理null
277275
//且样例类可以直接使用值比较（==），因为样例类实现了很多譬如：equals、toString等方法 @T
278276
//若想要比较引用地址可用eq/ne方法，不过这只对Scala对象直接映射到Java对象的对象有效。比如String

0 commit comments

Comments
 (0)