17scala中的辅助构造器

一. 主构造函数的参数

参数修饰符的三种情况：var 和 val的区别？

1. var 是可以修改的属性

2. val 是不可以修改的属性

3.而没有使用val或者var修饰的，不是属性，不可在外部访问，不可改写。

// Student() 构造函数(构造器)，用来创建对象
// 1. 主构造函数 class Student()
// 2. 辅助构造函数

class Student(var name: String, val age: Int) {

  def sayHi(): Unit = {
    println(s"我是${name}，我今年${age}")
  }

}

object Class01 {

  def main(args: Array[String]): Unit = {
    // 创建对象
    val stu1 = new Student("小花", 18)
    // 调用对象的方法
    stu1.sayHi()

    // 修改对象的属性
    stu1.name = "小花花"

    // 调用对象的方法
    stu1.sayHi()
  }
}

结果如图：

二. this关键字链式风格

this在类内部表示当前对象，我们可以利用这个特点实现对象方法的链式调用。

如何实现对象.方法1().方法2().方法3()...

格式：对象.方法1().方法2().方法3()...

原理：在方法中返回this

// 链式
// arr1.map(x => 2*x).filter(x=>x>5).foreach(println)

// 实现要点：把当前方法的返回值设置为当前对象！
class Student() {
  def sayHi(): Student = {
    println("sayHi")
    this
  }

  def sayHello(): Student = {
    println("sayHello")
    this // 返回当前对象
  }
}

def main(args: Array[String]): Unit = {
  val stu1 = new Student()
  // 链式调用 方法.方法.方法......
  stu1.sayHi().sayHello()
  // val arr1 = Array(1,2,3)
  // arr1.map(x => 2*x).filter(x=>x>5).foreach(println)
}

结果如图：

代码说明： 每个方法都返回this，所以可以继续调用其他方法。

三. 辅助构造函数

1. 构造函数(构造器)的作用是创建对象。

2. 构造函数可以有很多个，其他的叫辅助构造函数。

辅助构造函数的作用是支持更多的创建对象的方式。

格式:

辅助构造器的方法名固定为this，其参数不能使用var或val修饰，且必须在第一行代码中直接或间接调用主构造器

class Student(var name: String, val age: Int) {
  println("student........")
  // 辅助构造函数
  // 特点： 1. 名字就是this 2. 第一句代码就是调用主构造函数
  def this() = {
    this("未知的", 18) // 调用主构造函数
    println("辅助构造函数被调用了...")
  }

  def this(age: Int) = {
    this("未知的", age)
  }

  def sayHi(): Unit = {
    println(s"我是${name}，我今年${age}")
  }
}

object Class01 {
  def main(args: Array[String]): Unit = {
    // 创建对象，new 会自动调用构造函数
    val stu1 = new Student("小花", 18)
    val stu2 = new Student()
    val stu3 = new Student(20)

    // 调用对象的方法
    stu1.sayHi()
    stu2.sayHi()
    stu3.sayHi()
  }
}

结果如图：

辅助构造器的作用

1.提供多种初始化方式：

辅助构造器允许类提供多种初始化选项，使得创建对象时更加灵活。

2.简化对象创建：

通过定义多个辅助构造器，您可以简化对象的创建过程，避免在主构造器中处理过多的参数。

3.调用主构造器：

辅助构造器可以通过 this 关键字调用主构造器，从而确保所有初始化逻辑都集中在主构造器中。