《scala函数式编程》之java程序员学习scala前必看的技术文档(2)

最新推荐文章于 2021-08-14 18:26:58 发布

原创最新推荐文章于 2021-08-14 18:26:58 发布 · 316 阅读

0 ·

CC 4.0 BY-SA版权

Scala 专栏收录该内容

25 篇文章

订阅专栏

本文介绍了Scala中的类定义与使用，对比了Scala与Java在类定义上的差异，并详细解释了如何定义类参数、方法以及如何实现方法覆盖。此外，还讨论了在Scala中何时可以省略类型定义。

这篇文章是参考其他博客，并加了一些自己的理解和注释

源博客地址:https://www.iteblog.com/archives/1325.html

XML Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

package com.lyzx.day01

class T3 {
  def f1(): Unit ={
    //显示虚部im后面必须加()，因为在定义时im是一个函数
    val c = new Complex(1.2, 3.4)
    println("imaginary part: " + c.im())
  }

  def f2(): Unit ={
    val c =new NewComplex(1.2,4.5)
    //显示虚部im不需要加()，因为在定义时没有加()
    println("虚部是:"+c.im)
  }

  def f3(): Unit ={
    var c1 = new Complex(22,3.4)
    var c2 = new Complex_toString(22,3.4)

    println("未覆盖toString方法:"+c1)
    println("覆盖了toString方法:"+c2)
  }

}

class Complex(real: Double, imaginary: Double) {
     def re() = real
      def im() = imaginary
}

class NewComplex(real: Double, imaginary: Double) {
  def re = real
  def im = imaginary
}

class Complex_toString(real: Double, imaginary: Double) {
  def re = real
  def im = imaginary
  override def toString() =
    "" + re + (if (im < 0) "" else "+") + im + "i"
}

/**
* 二：Scala类
*    正如我们所见，Scala是一门面向对象的语言，因此它拥有很多关于“类”的描述。
*    Scala类使用和Java类似的语法进行定义。
*    但是一个重要的不同点在于Scala中的类可以拥有参数，例如：Complex
*    我们的复数类（Complex）接受两个参数：实部和虚部。这些参数必须在实例化时进行传递，
*    就像这样：new Complex(1.5, 2.3)。
*    类定义中包括两个叫做re和im的方法，分别接受上面提到的两个参数。
*    值得注意的是这两个方法的返回类型并没有显式的声明出来。他们会被编译器自动识别。
*    在本例中他们被识别为Double 但是编译器并不总是像本例中的那样进行自动识别。
*    不幸的是关于什么时候识别，什么时候不识别的规则相当冗杂。
*    在实践中这通常不会成为一个问题，因为当编译器处理不了的时候会发出相当的抱怨。
*    作为一个推荐的原则，
*    Scala的新手们通常可以试着省略类型定义而让编译器通过上下文自己判断。
*    久而久之，新手们就可以感知到什么时候应该省略类型,什么时候不应该。
*
*    1.1 无参方法
*      关于方法re和im还有一个小问题：你必须在名字后面加上一对括号来调用它们。
*      eg:T3.f1()
*
*   1.2 继承和覆盖
*   Scala中的所有类都继承一个父类，当没有显示声明父类时（就像上面定义的Complex一样），
*   它们的父类隐形指定为scala.AnyRef。
*   在子类中覆盖父类的成员是可能的。但是你需要通过override修饰符显示指定成员的覆盖。
*   这样的规则可以避免意外覆盖的情况发生。作为演示，
*   我们在Complex_toString的定义中覆盖了Object的toString方法。
*
*/
object T3{
  def main(args: Array[String]) {
    val t3 = new T3
    //t3.f1()
   // t3.f2()
    t3.f3()
  }
}