scala中的构造器概念：构造器是一个函数，在new的时候，被自动调用，它的作用是实例化对象。 new Class()

概念：

构造器是一个函数，在new的时候，被自动调用，它的作用是实例化对象。 new Class() 就是在调用构造器，或者叫调用构造函数。

object Main {
    // 定义类 
class Customer() {
    println("构造函数被调用")
  }
  def main(args: Array[String]): Unit = {
    val c = new Customer()
  }
}

构造函数的参数

格式：

class 类名([参数列表])

object Main {
 // 定义类 
class Customer(var name:String="小花", var:sex:String="男") {
    def sayHello(msg:String ) = {
      println("msg:", msg)
    }
  }
  def main(args: Array[String]): Unit = {
    val c = new Customer(“小花”,”女”)
    c.sayHello("你好 ")
  }
}

主构造函数的参数

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

this关键字

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

格式：

对象.方法1().方法2().方法3()...

原理：

在方法中返回this

辅助构造函数

构造函数(构造器)的作用是创建对象。
构造函数可以有多个。可以有很多个，其他的叫辅助构造函数。

格式

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


// 定义类
// 主构造函数
class Customer(var name:String, var:sex:String) {
  var age:Int = 0     
//   辅助构造器
  def this(name: String, sex: String, age: Int){
   this(name, sex)  
   this.age = age  
  }  
}

辅助构造器的作用

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

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

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

//类是属性的集合
//student，构造函数用来创建对象
//         辅助构造函数，提供多种创建方式
  class Student (var name:String,var age:Int) {
    println("构造函数被调用")

    def sayHi():Unit={
      println(s"我是${name},我今年${age}")
    }
    //辅助构造函数
    //它的名字就是this
    //它内部的第一句代码就必须是调用 主构造函数 this("无名氏",0)
    def this()={
      this("无名氏",0)
      println("辅助构造函数1被调用")
    }
    def this(name:String)={
      this(name,0)
      println("辅助构造函数2被调用")
    }
  }
  object day20 {
    def main(args: Array[String]): Unit = {
      //创建一个学生对象
      // val stu1=new Student("小花"，18)
      //调用对象的方法
      //stu1.sayHi()

      //stu1.age=19
      //调用对象的方法
      //stu1.sayHi()

      //这里没有设置参数，它会调用辅助构造函数
      // val stu2=new Student()
      // stu2.sayHi()
      val stu3=new Student(("小明"))
      stu3.sayHi()
    }
}

私有 private

介绍：

在编程中，private 是一种访问修饰符（Access Modifier）被 private 修饰的成员，仅能在当前类的内部被访问和使用，类外部（包括该类的子类）都无法直接访问。

object day21 {
//私有 private
  class Student1(var name:String,var age:Int) {
//在方法前面添加private,那这个方法是私有的，它不能在class的外部被访问
  private def song(): Unit = {
    println("我在唱歌。。。")
  }

  def sayHi(): Unit = {
    println(s"我是${name},我今年${age}")
   //私有方法，在类的内部是可以正常调用的
    song()
  }
}
  def main(args: Array[String]): Unit = {
    val stu3 = new Student1("小明", 18)
    stu3.sayHi()
    //stu3.song()//会报错
  }
}

object 对象

单例对象，直接使用object来定义。不能用new！
单例对象，只有一个，不能通过new来生成多个。它一般用来存放工具方法，常量...。

示例代码：

object day22 {
  //object 对象
  // 单例对象，直接使用object来定义。不能用new！
  // 单例对象，只有一个，不能通过new来生成多个。它一般用来存放工具方法，常量...。
  object Tools {
    val PI = 3.14

    def doubleN(n: Int): Int = {
      n * 2
    }
  }
  def main(args: Array[String]): Unit = {
    val rst=Tools.PI*Tools.doubleN(2)
    println(s"rst=${rst}")
  }
}