9.19知识点

  1.Scala的单例对象

        在Java中如果一个类只允许创建一个对象，那么就把这个对象称为单例对象。

2.Scala的单例对象声明

        Scala中不需要像Java中那样需要三个条件，Scala内部已经独立完成了。Scala的单例对象使用Object关键字声明，方式如下：

Object identifier{
}

        object是声明单例对象的关键字，identifier表示一个合法的标识符，是对象的名字。

如下：

object MyUtils{
  var PI = 3.1415

  def getMax(a:Int,b:Int): Int = {
    if(a>b) {
      a
    }else{
      b
    }
  }
}

object TestObject {
  def main(args: Array[String]): Unit = {
    println(MyUtils.PI)  //不能用new
    println(MyUtils.getMax(1,2))
  }
}

3.Scala的单例对象注意点

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

        2）不能使用new关键字：声明单例对象时不可以使用new关键字

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

4.Scala的单例对象应用场景

        1）资源共享的情况：节省存储空间，优化性能

        2）控制资源的情况：可以直接控制资源的配置情况，比如数据库的连接池

5.Scala的伴生类和伴生对象

        定义：当同名的类和单例对象在同一个源码文件中时，这个类称为单例对象的伴生类，对象称为类的伴生对象，这两者是相互的。

class User(var username:String, private val password: String){
  private def validatePassword(input:String): Boolean = {
    input == password
  }
}
//伴生对象
object  User{
  def check(u:User,pwd:String):Boolean ={
    u.validatePassword(pwd)
  }
}

//入口函数
object TestComp{
  def main(args: Array[String]): Unit = {

    //调用类的构造函数，来创造对象
    var u1 = new User("小明","123456")

    println(User.check(u1,"123456"))
  }
}

        两个要点：

        1）必须同名

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

6.Scala的伴生对象与伴生类解决的问题

        1）生成静态成员：如果Scala中需要生成类似静态成员的应用场景，可以使用伴生对象解决该问题

        2）伴生对象和类之间的相互访问：伴生对象和类的私有成员可以相互访问

        3）构建单例对象：这一点与静态成员问题相似

class Logger private(){

  var age = 1
}
object Logger{
  //在伴生对象中可以访问伴生类的私有成员，所以可以new
  private val instance = new Logger()
  def getInstance():Logger = instance
}
object TestSingle{
  def main(args: Array[String]): Unit = {
//    var p1 = new Logger()//构造函数是private，不能访问
//    var p2 = new Logger()
    var p = Logger.getInstance()//调用方法，得到这个唯一的对象
    println(p.age)
//    var p1 = Logger.getInstance()
//    println(p1 == p)
  }
}