Scala - 類的定義

成員變量

在java中，咱們定義一個類是這樣的：

public class JavaPerson {
    private String name;
    private Integer age;
    // 省略name、age的setter和getter方法
}

調用是這樣的：

public static void main(String[] args) {
    JavaPerson javaPerson = new JavaPerson();
    javaPerson.setAge(18);
    javaPerson.setName("張三");
    System.out.println("姓名：" + javaPerson.getName() + "，年齡：" + javaPerson.getAge());
}

在scala中，會比較簡潔一點，類的定義以下，由於scala中變量的定義都要有初始值，因此咱們這邊能夠定義爲下劃線說明是空。

class ScalaPerson {
  var age: Integer = _
  var name: String = _
}

調用是這樣的：

val scalaPerson = new ScalaPerson
scalaPerson.age = 18
scalaPerson.name = "張三"
println(s"姓名：${scalaPerson.name}，年齡:${scalaPerson.age}")

看起來咱們是直接調用對象的屬性，其實是scala隱藏了setter和getter，咱們看看反編譯的代碼，這個是ScalaPerson反編譯後的代碼，能夠看到他的屬性實際上是private的，而後還有相似setter和getter的方法，好比age()和age_$eq()方法

有時候爲了兼容java框架，須要setter和getter方法，咱們只要在屬性上面加@BeanProperty註解就能夠用setter和getter方法了。

class ScalaPerson2 {
  @BeanProperty
  var age: Integer = _
  var name: String = _
}
object ScalaPerson2 {
  def main(args: Array[String]): Unit = {
    val scalaPerson = new ScalaPerson2
    scalaPerson.age = 17
    scalaPerson.setAge(18)
    scalaPerson.name = "張三"
    println(s"姓名：${scalaPerson.name}，年齡:${scalaPerson.getAge}")
  }
}

咱們知道，scala的變量聲明包括val和var，若是在類中定義val，那這個變量就是final類型的，好比上面的name經過val定義，他相似於下面的java代碼，而且只有get方法。

private final String name = "張三";

構造器

無參構造

無參的話，能夠在類名加括號，也能夠不加

class ScalaConstruct1 {
  var name: String = _
  var age: Int = _
}

object ScalaConstruct1 {
  def main(args: Array[String]): Unit = {
    val construct = new ScalaConstruct1
    construct.name = "張三"
    construct.age = 18
  }
}

有參構造器

有參的話，變量的修飾符包括沒有修飾符、val和var。下面用例子來講明這三種狀況。

class ScalaConstruct2(param1: String, var param2: String, val param3: String) {

}

object ScalaConstruct2 {
  def main(args: Array[String]): Unit = {
    val construct = new ScalaConstruct2("aa", "bb", "cc")
    //println(construct.param1) //error
    //construct.param1 = "aaa" // error
    construct.param2 = "bbb"
    println(construct.param2)
    //construct.param3 = "ccc"// error
    println(construct.param3)
  }
}

param1是沒有修飾符的，因此他是ScalaConstruct2的局部變量，這樣在類外面就不能調用了。
param2是能夠修改的，因此既能夠讀取也能夠修改。
param3是不能修改的，因此只能讀取不能修改。

主構造器

上面無參的以及放在類名後面的有參構造器都是主構造器，另外主構造器還能夠執行類中可以執行的語句。
因此下面運行後會直接打印hello ScalaConstruct3

class ScalaConstruct3() {
  println("hello ScalaConstruct3")
}

object ScalaConstruct3{
  def main(args: Array[String]): Unit = {
    new ScalaConstruct3
  }
}

輔助構造器

java中用類命當作構造器的名稱，在scala中輔助構造器用this來聲明，他必須直接或者間接的調用主構造器。類的實例化，跟java相似。

class ScalaConstruct4() {
  var age: Int = _
  var name: String = _

  def this(name: String) {
    this()
    this.name = name
  }

  def this(name: String, age: Int) {
    this(name)
    this.age = age
  }
}

object ScalaConstruct4 {
  def main(args: Array[String]): Unit = {
    new ScalaConstruct4
    new ScalaConstruct4("張三")
    new ScalaConstruct4("張三",18)
  }
}