饿汉方式

class Phone private() {

  def call(num:String):Unit = {
    println(s"给 $num 打电话")
  }
}


object Phone{
  //饿汉模式，直接创建类对象
  //伴生对象可以调用伴生类的私有方法
  private val instance = new Phone()
  def apply():Phone={
    instance
  }
}


object test{
  def main(args: Array[String]): Unit = {

    //不能调用主构造器，因为是private
  //    val iphone=new Phone()

    //调用伴生对象的 apply() 获取 Phone类对象
    val iphone1 = Phone.apply()
    //简写
    val iphone2 = Phone()

    println(phone1 == phone2)
    println(phone1)
    println(phone2)
    phone1.call("119")
    phone2.call("111")

  }
}

懒汉方式

class Phone private (){

  def call(num:String):Unit = {
    println(s"给 $num 打电话")
  }
}


object Phone{

  //定义在object中的变量都是静态变量、方法都是静态方法
  private var instance :Phone= _

  def apply() : Phone ={
    if( instance == null){
      //在伴生对象中，可以调用伴生类的私有方法、构造器、属性
      instance = new Phone()
    }

    instance
  }

}

object test{
  def main(args: Array[String]): Unit = {

    //不能调用私有的方法、构造器、属性
//    val iphone = new Phone()

    val iphone=Phone.apply()
    //省略写法apply方法，调用时可以省略
    val iphone2=Phone()

    println(  iphone == iphone2  )

    println(phone)
    println(phone2)
    phone.call("119")
    phone2.call("119")

  }
}

原文出处：/show_1IX1DP8Ch1bx.html