👆单例模式案例-日志类

（一）apply的基本使用

[提问] 不使用new关键字创建对象？

在 Scala 中，apply 方法放在类的伴生对象（object）里，主要起到 工厂方法的作用，能够让使用者在创建该类实例时省去显式的 new 关键字，并且可以通过重载提供多种构造方式。

当写ClassName(arg1,arg2)时，编译器会自动翻译ClassName.apply(arg1,arg2),这可以让实例化代码更简单

代码示例：

1. 定义一对伴生类和伴生对象

在伴生对象中还需要实现apply方法，返回伴生类的实例。

package level02

object day53 {
  /*
  *
  * apply
  *      apply方法写在伴生对象中，可以在创建对象的时候，省略new关键字
  *
  *      val 对象 = 伴生类（）  <====>  伴生对象.apply()
   */

  class Person() {

  }

  object Person {
    def  apply():Person = {
      println("apply.......")
      new  Person()
    }
  }

  def main(args: Array[String]): Unit = {
    // 创建一个类的对象
    // val p1 = new Person()
    val P1 = Person() // 自动调用apply方法
    val P2 = Person()

    println(P1)
    println(P2)
  }
}

代码说明：

（1）apply 写在伴生对象中，它返回类的实例

（2）实例化对象时，就可以不用写new

自动调用apply

但是这不是一个单例模式👇

（二）apply实现单例模式

p1 和 p2不相等 是false，是两个不同的对象，如果要实现这是单例模式，我们来改一下这个代码👇：

object day54 {
  /*
  *
  * apply
  *      apply方法写在伴生对象中，可以在创建对象的时候，省略new关键字
  *      实现单例模式
  *        在伴生对象中  创建一个对象，在apply方法中返回它
   */

  class Person() {
    println("主构造器被调用......")
  }

  object Person {
    val P=new Person()
    def  apply():Person = {
    P
    }
  }

  def main(args: Array[String]): Unit = {
    // 创建一个类的对象
    // val p1 = new Person()
    val P1 = Person() // 自动调用apply方法
    val P2 = Person()

    println(P1)
    println(P2)
    println(P1 == P2) // true
  }
}

这就是一个单例模式，
输出结果：

（三）案例-日志类

object day55 {
  /**
   * 实现一个日志类: Logger
   * 1. 把一些操作信息写入到文本文件中。
   * 2. 实现单例模式
   * */

  class Logger(filename:String) {
    def log(content:String) :Unit = {
      println(s"$content ")
    }
  }

  object Logger {
    // 定一个对象
    var instance: Option[Logger] = None
    def apply(filename:String): Logger = {
      if(instance.isEmpty){
        instance = Some(new Logger(filename))
      }
      instance.get
    }
  }

  def main(args: Array[String]): Unit = {
    val logger1 = Logger("test.log")
    val logger2 = Logger("test.log")
    // println(logger2 == logger1)
    // logger1.log("2005-11-4 09:00:03 scala大赛")
    logger2.log("2005-11-5 09:00:03 运动会")
  }
}

输出结果：

（四）案例-改进日志类

接下来👇我们要把内容写入一个文件中

import java.io.FileWriter

object day56 {
  /**
   * 实现一个日志类: Logger
   * 1. 把一些操作信息写入到文本文件中。
   * 2. 实现单例模式
   * */

  class Logger(filename:String) {
    def log(content:String) :Unit = {
      // 把内容写入一个文件中
      val writer = new  FileWriter(filename,true)
      writer.write(content + "\n")
      writer.close()
    //  println(s"$content ")
    }
  }

  object Logger {
    // 定一个对象
    var instance: Option[Logger] = None
    def apply(filename:String): Logger = {
      if(instance.isEmpty){
        instance = Some(new Logger(filename))
      }
      instance.get
    }
  }

  def main(args: Array[String]): Unit = {
    val logger1 = Logger("test.log")
  //  val logger2 = Logger("test.log")
    // println(logger2 == logger1)
    logger1.log("2005-11-4 09:06:03 上scala课")
    logger1.log("2005-11-5 09:06:03 运动会")
    logger1.log("2005-11-5 09:06:03 休息")
  }
}

输出结果：出现这个文件

打开这个文件出现内容