类和对象

一、初识类和对象

Scala 的类与 Java 的类具有非常多的相似性，示例如下：

  1. // 1. 在 scala 中，类不需要用 public 声明,所有的类都具有公共的可见性
  2. class Person {
  4.   // 2. 声明私有变量,用 var 修饰的变量默认拥有 getter/setter 属性
  5.   private var age = 0
  7.   // 3.如果声明的变量不需要进行初始赋值，此时 Scala 就无法进行类型推断，所以需要显式指明类型
  8.   private var name: String = _
  11.   // 4. 定义方法,应指明传参类型。返回值类型不是必须的，Scala 可以自动推断出来，但是为了方便调用者，建议指明
  12.   def growUp(step: Int): Unit = {
  13.     age += step
  14.   }
  16.   // 5.对于改值器方法 (即改变对象状态的方法),即使不需要传入参数,也建议在声明中包含 ()
  17.   def growUpFix(): Unit = {
  18.     age += 10
  19.   }
  21.   // 6.对于取值器方法 (即不会改变对象状态的方法),不必在声明中包含 ()
  22.   def currentAge: Int = {
  23.     age
  24.   }
  26.   /**
  27.    * 7.不建议使用 return 关键字,默认方法中最后一行代码的计算结果为返回值
  28.    *   如果方法很简短，甚至可以写在同一行中
  29.    */
  30.   def getName: String = name
  32. }
  35. // 伴生对象
  36. object Person {
  38.   def main(args: Array[String]): Unit = {
  39.     // 8.创建类的实例
  40.     val counter = new Person()
  41.     // 9.用 var 修饰的变量默认拥有 getter/setter 属性，可以直接对其进行赋值
  42.     counter.age = 12
  43.     counter.growUp(8)
  44.     counter.growUpFix()
  45.     // 10.用 var 修饰的变量默认拥有 getter/setter 属性，可以直接对其进行取值，输出: 30
  46.     println(counter.age)
  47.     // 输出: 30
  48.     println(counter.currentAge)
  49.     // 输出: null
  50.     println(counter.getName)
  51.   }
  53. }


二、类

2.1 成员变量可见性

Scala 中成员变量的可见性默认都是 public，如果想要保证其不被外部干扰，可以声明为 private，并通过 getter 和 setter 方法进行访问。

2.2 getter和setter属性

getter 和 setter 属性与声明变量时使用的关键字有关：

  • 使用 var 关键字：变量同时拥有 getter 和 setter 属性；
  • 使用 val 关键字：变量只拥有 getter 属性；
  • 使用 private[this]：变量既没有 getter 属性、也没有 setter 属性，只能通过内部的方法访问；

需要特别说明的是：假设变量名为 age,则其对应的 get 和 set 的方法名分别叫做 age 和 age_=。

  1. class Person {
  3.   private val name = "heibaiying"
  4.   private var age = 12
  5.   private[this] var birthday = "2019-08-08"
  6.   // birthday 只能被内部方法所访问
  7.   def getBirthday: String = birthday
  8. }
  10. object Person {
  11.   def main(args: Array[String]): Unit = {
  12.     val person = new Person
  13.     person.age = 30
  14.     println(person.name)
  15.     println(person.age)
  16.     println(person.getBirthday)
  17.   }
  18. }

解释说明：

示例代码中 person.age=30 在执行时内部实际是调用了方法 person.age_=(30)，而 person.age 内部执行时实际是调用了 person.age() 方法。想要证明这一点，可以对代码进行反编译。同时为了说明成员变量可见性的问题，我们对下面这段代码进行反编译：

  1. class Person {
  2. var name = ""
  3. private var age = ""
  4. }

依次执行下面编译命令：

  1. > scalac Person.scala
  2. > javap -private Person

编译结果如下，从编译结果可以看到实际的 get 和 set 的方法名 (因为 JVM 不允许在方法名中出现＝，所以它被翻译成$eq)，同时也验证了成员变量默认的可见性为 public。

  1. Compiled from "Person.scala"
  2. public class Person {
  3. private java.lang.String name;
  4. private java.lang.String age;
  6. public java.lang.String name();
  7. public void name_$eq(java.lang.String);
  9. private java.lang.String age();
  10. private void age_$eq(java.lang.String);
  12. public Person();
  13. }

2.3 @BeanProperty

在上面的例子中可以看到我们是使用 . 来对成员变量进行访问的，如果想要额外生成和 Java 中一样的 getXXX 和 setXXX 方法，则需要使用@BeanProperty 进行注解。

  1. class Person {
  2.   @BeanProperty var name = ""
  3. }
  5. object Person {
  6.   def main(args: Array[String]): Unit = {
  7.     val person = new Person
  8.     person.setName("heibaiying")
  9.     println(person.getName)
  10.   }
  11. }

2.4 主构造器

和 Java 不同的是，Scala 类的主构造器直接写在类名后面，但注意以下两点：

  • 主构造器传入的参数默认就是 val 类型的，即不可变，你没有办法在内部改变传参；
  • 写在主构造器中的代码块会在类初始化的时候被执行，功能类似于 Java 的静态代码块 static{}
  1. class Person(val name: String, val age: Int) {
  3.   println("功能类似于 Java 的静态代码块 static{}")
  5.   def getDetail: String = {
  6.     //name="heibai" 无法通过编译
  7.     name + ":" + age
  8.   }
  9. }
  11. object Person {
  12.   def main(args: Array[String]): Unit = {
  13.     val person = new Person("heibaiying", 20)
  14.     println(person.getDetail)
  15.   }
  16. }
  18. 输出：
  19. 功能类似于 Java 的静态代码块 static{}
  20. heibaiying:20

2.5 辅助构造器

辅助构造器有两点硬性要求：

  • 辅助构造器的名称必须为 this；
  • 每个辅助构造器必须以主构造器或其他的辅助构造器的调用开始。
  1. class Person(val name: String, val age: Int) {
  3.   private var birthday = ""
  5.   // 1.辅助构造器的名称必须为 this
  6.   def this(name: String, age: Int, birthday: String) {
  7.     // 2.每个辅助构造器必须以主构造器或其他的辅助构造器的调用开始
  8.     this(name, age)
  9.     this.birthday = birthday
  10.   }
  12.   // 3.重写 toString 方法
  13.   override def toString: String = name + ":" + age + ":" + birthday
  14. }
  16. object Person {
  17.   def main(args: Array[String]): Unit = {
  18.     println(new Person("heibaiying", 20, "2019-02-21"))
  19.   }
  20. }

2.6 方法传参不可变

在 Scala 中，方法传参默认是 val 类型，即不可变，这意味着你在方法体内部不能改变传入的参数。这和 Scala 的设计理念有关，Scala 遵循函数式编程理念，强调方法不应该有副作用。

  1. class Person() {
  3.   def low(word: String): String = {
  4.     word="word" // 编译无法通过
  5.     word.toLowerCase
  6.   }
  7. }


三、对象

Scala 中的 object(对象) 主要有以下几个作用：

  • 因为 object 中的变量和方法都是静态的，所以可以用于存放工具类；
  • 可以作为单例对象的容器；
  • 可以作为类的伴生对象；
  • 可以拓展类或特质；
  • 可以拓展 Enumeration 来实现枚举。

3.1 工具类&单例&全局静态常量&拓展特质

这里我们创建一个对象 Utils,代码如下：

  1. object Utils {
  3.   /*
  4.    *1. 相当于 Java 中的静态代码块 static,会在对象初始化时候被执行
  5.    *   这种方式实现的单例模式是饿汉式单例,即无论你的单例对象是否被用到，
  6.    *   都在一开始被初始化完成
  7.    */
  8.   val person = new Person
  10.   // 2. 全局固定常量 等价于 Java 的 public static final 
  11.   val CONSTANT = "固定常量"
  13.   // 3. 全局静态方法
  14.   def low(word: String): String = {
  15.     word.toLowerCase
  16.   }
  17. }

其中 Person 类代码如下：

  1. class Person() {
  2.   println("Person 默认构造器被调用")
  3. }

新建测试类：

  1. // 1.ScalaApp 对象扩展自 trait App
  2. object ScalaApp extends App {
  4.   // 2.验证单例
  5.   println(Utils.person == Utils.person)
  7.   // 3.获取全局常量
  8.   println(Utils.CONSTANT)
  10.   // 4.调用工具类
  11.   println(Utils.low("ABCDEFG"))
  13. }
  15. // 输出如下：
  16. Person 默认构造器被调用
  17. true
  18. 固定常量
  19. abcdefg

3.2 伴生对象

在 Java 中，你通常会用到既有实例方法又有静态方法的类，在 Scala 中，可以通过类和与类同名的伴生对象来实现。类和伴生对象必须存在与同一个文件中。

  1. class Person() {
  3.   private val name = "HEIBAIYING"
  5.   def getName: String = {
  6.     // 调用伴生对象的方法和属性
  7.     Person.toLow(Person.PREFIX + name)
  8.   }
  9. }
  11. // 伴生对象
  12. object Person {
  14.   val PREFIX = "prefix-"
  16.   def toLow(word: String): String = {
  17.     word.toLowerCase
  18.   }
  20.   def main(args: Array[String]): Unit = {
  21.     val person = new Person
  22.     // 输出 prefix-heibaiying  
  23.     println(person.getName)
  24.   }
  26. }

3.3 实现枚举类

Scala 中没有直接提供枚举类，需要通过扩展 Enumeration，并调用其中的 Value 方法对所有枚举值进行初始化来实现。

  1. object Color extends Enumeration {
  3.   // 1.类型别名,建议声明,在 import 时有用
  4.   type Color = Value
  6.   // 2.调用 Value 方法
  7.   val GREEN = Value
  8.   // 3.只传入 id
  9.   val RED = Value(3)
  10.   // 4.只传入值
  11.   val BULE = Value("blue")
  12.   // 5.传入 id 和值
  13.   val YELLOW = Value(5, "yellow")
  14.   // 6. 不传入 id 时,id 为上一个声明变量的 id+1,值默认和变量名相同
  15.   val PINK = Value
  17. }

使用枚举类：

  1. // 1.使用类型别名导入枚举类
  2. import com.heibaiying.Color.Color
  4. object ScalaApp extends App {
  6.   // 2.使用枚举类型,这种情况下需要导入枚举类
  7.   def printColor(color: Color): Unit = {
  8.     println(color.toString)
  9.   }
  11.   // 3.判断传入值和枚举值是否相等
  12.   println(Color.YELLOW.toString == "yellow")
  13.   // 4.遍历枚举类和值
  14.   for (c <- Color.values) println(c.id + ":" + c.toString)
  15. }
  17. //输出
  18. true
  19. 0:GREEN
  20. 3:RED
  21. 4:blue
  22. 5:yellow
  23. 6:PINK


参考资料

  1. Martin Odersky . Scala 编程 (第 3 版)[M] . 电子工业出版社 . 2018-1-1
  2. 凯.S.霍斯特曼 . 快学 Scala(第 2 版)[M] . 电子工业出版社 . 2017-7