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)
  }
}