scala中的单例对象和伴生类

一.单例对象

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

格式

object 对象名{属性方法}

package level02

/**
 * 创建对象的方式:
 * 1. class => new
 * 2. 直接通过object来定义（单例对象，只有一个，很单一）
 * 适用了数据库，提供一些工具方法，公用方法……
 */
object Base52 {
  object Myschool {
    val name: String = "xxx学校"

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

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

1. 通过object关键字创建的是一个对象，不是一个类型。

2. 不能使用new关键字：声明单例对象的时候不可以使用new关键字。

3. 不能传递参数：单例对象无法传递参数。

二.伴生类和伴生对象

【定义】

当同名的类和单例对象在同一个源码文件时，这个类称为单例对象的伴生类，对象称为类的伴生对象

object Person {
}
class Person{
}

代码说明：

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

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

【讲授特点】Scala的伴生对象和伴生类的特点：

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

object Base53 {
  /**
   * 类（class）和对象（object）同名，且在同一个文件中，此时 它们互为伴生关系。
   * 伴生类，伴生对象
   * 特点：可以相互访问对方的私有（private）成员
   */
  class Student(private val password: String) {
    private def validatePassword(input: String): Boolean = {
      input == password
    }
  }

  object Student {
    def check(stu: Student, pwd: String): Boolean = {
      // 在伴生对象的内部，可以访问类的private成员
      stu.validatePassword(pwd)
    }
  }

  def main(args: Array[String]): Unit = {
    val stu1 = new Student("12345")
    if (Student.check(stu1, "12345")) {
      println("验证通过！")
    }
    // 在类的外部，无法访问类的private成员
    // if( stu1.validatePassword("12345") ) {
    //   println("验证通过")
    // }
  }
}

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

【讲解】 什么是单例模式？

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

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

package level02

/**
 * 单例模式：一个类（Class）只能有一个对象！
 * new 会自动调用 ... 构造 ... 函数？
 * 步骤：
 * 1. 不让它 new：把构造函数设置为私有！
 * 2. 在伴生对象中用 new 来生一个对象；提供一个方法来获取这个对象
 */
object Base54 {
  // 添加了 private 之后，构造函数在外部就不可访问！
  class Student(private var name: String, private 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)  // 私有构造函数，外部无法直接new
    // val stu2 = new Student("小名", 18)

    val stu1 = Student.getInstance
    val stu2 = Student.getInstance
    println(stu1 == stu2)  // 输出true，因为是同一个单例对象
  }
}

private是私有的意思，这样就会让class不能被new。而通过getInstance可以确保返回的实例就只有一个。