伴生类和伴生对象

object class06 {
  /**
   * 伴生类 和 伴生对象
   * 1. 类和对象同名
   * 2. 在一个文件中
   * 类就是伴生类， 对象就是伴生对象。
   * 特点：可以相互访问对方的私有成员
   */

  class Student() {
    // private 修饰的属性，无法在类的外部被访问！
    private val hobby = "打游戏"
  }

  object Student {
    def introduce(stu: Student): Unit = {
      println(s"我的爱好是:${stu.hobby}")
    }
  }

  def main(args: Array[String]): Unit = {
    val stu1 = new Student()
    // stu1.hobby // 无法访问私有属性

    Student.introduce(stu1)
  }
}
s

单例模式

object class07 {
  /**
   * 伴生类和伴生对象，实现一种特殊的编程的模式： 单例模式
   * 单例模式： 让一个类只能有一个实例对象。 一个类只能被 new 一次
   * 特点：可以相互访问对方的私有成员
   */
  // 1. 把构造函数设置为private
  class Student private() {
  }

  // 2. 伴生对象中，访问private
  object Student {
    private val instance = new Student() // 在伴生对象中可以访问private修饰的构造器

    def getInstance(): Student = {
      instance
    }
  }

  def main(args: Array[String]): Unit = {
    // 无法通过 new 来创建对象！
    //val stu1 = new Student()
    //val stu2 = new Student()
    //println(stu1 == stu2) // false
    val stu1 = Student.getInstance()
    val stu2 = Student.getInstance()

    println(stu1 == stu2)
  }
}

s

在伴生对象中补充一个apply方法

object class08 { /***

• 伴生类和伴生对象
• 在伴生对象中补充一个apply方法，这样创建对象的时候，就可以省略 new
• 伴生类名（参数） ==== 伴生对象名.apply(参数) */ // 日志 class Logger(var filename: String) { }

object Logger { def apply(filename: String): Logger = { println("apply...") new Logger(filename) } }

def main(args: Array[String]): Unit = { // 省略 new val log1 = Logger("test.log") println(log1.filename) } }