前言

Scala语言是完全面向对象的语言，所以并没有静态的操作（即在Scala中没有静态的概念）。但是为了能够和Java语言交互（因为Java中有静态概念），就产生了一种特殊的对象来模拟类对象，该对象为单例对象。若单例对象名与类名一致，则称该单例对象这个类的伴生对象，这个类的所有“静态”内容都可以放置在它的伴生对象中声明。

伴生类[class]与伴生对象[object]

1. class 与 object 名称要一样
2. class 与 object 必须在同一个.scala 源文件中。

/**
 * 伴生对象
 */
object Demo02 {

}

/**
 * 伴生类
 */
class Demo02{
  
}

在 java中静态的使用类名调用，非静态的使用对象调用。在scala中亦是如此。只不过scala没有static关键字，如何区分静态与非静态呢？
object 与 class 可以很好的区分静态与非静态。

/**
 * 伴生类
 */
class Demo02 {

  def sayHello(): Unit = {
    println("hello...class")
  }

}

/**
 * 伴生对象
 */
object Demo02 {

  def sayHello():Unit={
    println("hello...object")
  }
}

运行：

  def main(args: Array[String]): Unit = {
    Demo02.sayHello() // hello...object
    val demo=new Demo02
    demo.sayHello() // hello...class
  }

以这样的方式做案例，就是想表达，他们虽然是伴生关系，但是相互间可以互不影响。

伴生对象使用 类名访问
伴生类使用对象访问。

伴生类与伴生对象的特性：对方可以互相访问对方private 修饰的成员。

/**
 * 伴生对象
 */
object Demo02 {

  private val b="b..."

  def sayHello():Unit={
    println(s"访问伴生类的私有成员${new Demo02().a}")
  }
  
}

/**
 * 伴生类
 */
class Demo02 {

  private val a="a..."


  def sayHello(): Unit = {
    println(s"访问伴生对象的私有成员${Demo02.b}")
  }
}

运行 main 方法

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

    Demo02.sayHello()

    val demo=new Demo02
    demo.sayHello()
  }

运行结果

访问伴生类的私有成员a...
访问伴生对象的私有成员b...

伴生类与伴生对象解析

apply()

1. 必须定义在伴生对象中。
2. 主要用于简化伴生类的创建。

/**
 * 伴生对象
 */
object Demo02 {
  def apply(): Demo02 = new Demo02()
}

有了apply 方法，创建伴生类对象就可以通过；伴生对象object名称.apply() 进行调用

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

    val o1=Demo02.apply()
    o1.sayHello()
  }

或者简写

  def main(args: Array[String]): Unit = {
    val o1=Demo02()
    o1.sayHello()
  }

如果 伴生类有有参构造，apply() 也是可以传参的。

伴生类

/**
 * 伴生类
 */
class Demo02(val name:String,val age:Int) {
  def info(): Unit ={
    println(s"姓名：$name，年龄：$age")
  }
}

伴生对象

/**
 * 伴生对象
 */
object Demo02 {

  def apply(name:String,age:Int): Demo02 = new Demo02(name,age)

}

main

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

    val o1=Demo02("张三",18) // 姓名：张三，年龄：18
    o1.info()
  }

也可以指定多个 apply()。

新增一个 副构造器

/**
 * 伴生类
 */
class Demo02(val name:String,val age:Int) {
  
  def this(sex:Char){
    this("富贵",20)
  }
  def info(): Unit ={
    println(s"姓名：$name，年龄：$age")
  }
}

配置带有一个参数的 apply()

/**
 * 伴生对象
 */
object Demo02 {

  def apply(name:String,age:Int): Demo02 = new Demo02(name,age)

  def apply(sex:Char): Demo02 = new Demo02(sex)
}

调用运行

  def main(args: Array[String]): Unit = {
    val o1=Demo02('男')
    o1.info() //  姓名：富贵，年龄：20
  }

根据你的业务，可以配置更多apply()

除了 apply 还有一个 unapply（之后再写） 。

apply和unapply 属于Scala的一种语法糖,在class的伴生对象里面定义，apply方法的主要作用可以像调用方法一样创建对象，而unapply方法主要作用是和match一起使用,