scala中的单例对象和伴生类

（一）单例对象

用 object 关键字来创建一个单例对象。单例对象在整个应用程序中只有一个实例，适合用于存放工具方法、常量或共享状态。

/*
创建对象的方式:
1. class --> new
2.直接通过object来定义（单例对象，只有一个，孤单）
      适用了数据存储，提供一些工具方法，公用方法....
 */

object Class07 {

  object Myschool {
    val name:String = "xxx学校"

    def say():Unit = {
      println(s"say:${name}")
    }
  }


  def main(args:Array[String]): Unit = {
    //对象名.属性名
    Myschool.name
    //对象名.方法名（）
    Myschool.say()
  }
}

（二）伴生类和伴生对象

1. 类名和对象名必须同名。

2. 必须在同一个源码文件中。

Scala的伴生对象和伴生类的特点：

伴生对象和类的私有private成员可以相互访问。

package level02

/*
* 类（class）和对象（object）同名，且在同一个文件中，此时，它们互为伴生关系
*
* 伴生类，伴生对象
* 特点：可以相互访问对方的 私有（private）成员
 */

object Class08 {

  class Student(val password:String) {
    def validatePassword(input:String):Boolean = {
      input == password
    }
  }
  object Student {
    def check(stu:Student,pwd:String):Boolean = {
      stu.validatePassword(pwd)
    }
  }

  def main(args:Array[String]): Unit = {
    val stu1 = new Student("12345")

    if(Student.check(stu1,"12345")){
      println("验证通过！")
    }
    //在类的内部，无法访问类的private成员
//    if(stu.validatePassword("12345")){
//      println("验证通过")
//    }
  }
}

（ 三）应用-单例模式（一个类只能有一个对象）

什么是单例模式？

就是通过技术手段，让某个类只能有一个对象实例。这样做的好处就节约资源，能更加精准地管理。

思路：使用private来修饰构造器，这样在类的外部就无法访问了。在伴生对象中提供获取这个实例的入口方法。

package level02

/*
*单例模式：一个类（class）只能有一个对象：
*
*new会自动调用__构造___函数
* 步骤：
* 1：不让它new,把构造函数设置为私有的！
* 2.在伴生对象中调用news来生成一个对象：提供一个方法来获取这个对象
*
 */

object Class09 {
//添加了private之后，构造函数在类的外部就不可访问！
  class Student private (var name:String,var age:Int) {

  }
  object  Student {
    //在伴生对象中,可以访问伴生类中的私有成员
    private  val ins = new Student("小花",18)
    def getInstance:Student = ins
  }
  def main(args:Array[String]):Unit = {

//    val stu1 = new Student("小花",18)
//    val stu2 = new Student("小名",18)

      val stu1 = Student.getInstance
      val stu2 = Student.getInstance
    
    println(stu1 == stu2)
  }
}