单例对象和伴生类

单例对象

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

格式：

object 对象名{

属性

方法

}

代码说明

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

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

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

代码示例1：

//object 对象

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

  def doubleN(n:Int):Int = {
    n * 2
  }
}

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

代码示例2：

/*
单例对象：通过object 关键字定义的对象
 */
object MyTools {
  val PI = 3.14
  def Area(r:Double) :Double = {
    PI * r * r
  }
}

def main(args: Array[String]): Unit = {
  println( MyTools.PI)
  println( MyTools.Area(10))
}

伴生类和伴生对象

• 伴生类 和 伴生对象
• 1.类和对象的名字是一样的
• 2.他们在同一个文件中
• 特定：可以访问对方的私有（private）属性

  class Student() {
    //private 修饰的属性，在类的外部（在当前的class之外）无法访问！
    private val name:String  = "小花"

  }

  object Student {
    def sayHello(stu:Student):Unit = {
      // 在伴生对象中，访问伴生类的私有属性！
      println(s"${stu.name}")
    }

  }

  def main(args:Array[String]): Unit = {
    val stu1 = new Student()
    // stu1.name 是错误的，无法访问
    Student.sayHello(stu1)
  }

应用-单例模式

什么是单例模式？

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

伴生类 和 伴生对象 实现 单例模式：一个类只能有一个对象

//1.让构造函数变成私有的。在类的外部，就不能通过new来创建对象了
  class Student private () {
    //private 修饰的属性，在类的外部（在当前的class之外）无法访问！
    private val name:String  = "小花"

  }

  //2.在伴生对象中创建类的实例，并返回
  object Student {
    val instance = new Student() // 在伴生对象中，访问伴生类的私有成员！
    def getInstance:Student = {
      instance
    }

  }

  def main(args:Array[String]): Unit = {
//    val stu1 = new Student()
//    val stu2 = new Student()
//    val stu3 = new Student()
//    val stu4 = new Student()
    val stu1 = Student.getInstance
    val stu2 = Student.getInstance
    
    println(stu1 == stu2) // true
  }

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