内容如下：
1. 伴生类的定义；
2. 伴生类的作用和格式;
3. 单例对象的定义；
4. 单例对象的作用和格式。
（一）单例对象
用 object 关键字来创建一个单例对象。单例对象在整个应用程序中只有一个实例，适合用于存放工具方法、常量或共享状态。
格式
object 对象名{
属性
方法
}
[ 编码示范 ]
package level02
object class01 {
/*
*伴生类 和 伴生对象
* 1. 类和对象的名字是一样的
* 2. 他们在同一个文件中
*
* 特点：可以访问对方的私有（private）属性
* */
class Student() {
// private 修饰的属性，在类的外部（在当前的class之外）无法访问！
private val name:String = "小花"
}
object Student {
def sayHello(stu:Student):Unit = {
// 在伴生对象中，访问伴生类的私有属性！
println(s"${stu.name}")
}
}
def main(args: Array[String]): Unit = {
val stu1 = new Student()
// stu1.name 是错误的，无法访问
Student.sayHello(stu1)
}
}
[ 代码说明 ] ：
1. 通过object关键字创建的是一个对象，不是一个类型。
2. 不能使用new关键字：声明单例对象的时候不可以使用new关键字。
3. 不能传递参数：单例对象无法传递参数。
（二）伴生类和伴生对象
[定义]:当同名的类和单例对象在同一个源码文件时，这个类称为单例对象的伴生类，对象称为类的伴生对象。
object Person {
}
class Person{
}
代码说明：
1. 类名和对象名必须同名。
2. 必须在同一个源码文件中。
【特点】:Scala的伴生对象和伴生类的特点：
伴生对象和类的私有private成员可以相互访问。
[编码示范]：访问私有方法
class User (val 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 Test {
def main(args: Array[String]): Unit = { // 入口函数
var u1 = new User("小明", "123456")
print(User.check(u1, "123456"))
}
}
（三）单例模式
什么是单例模式？
定义：就是通过技术手段，让某个类只能有一个对象实例。这样做的好处就节约资源，能更加精准地管理。
思路：使用private来修饰构造器，这样在类的外部就无法访问了。在伴生对象中提供获取这个实例的入口方法。
【编写示范】
package level02
object class02 {
/*
*伴生类 和 伴生对象 实现 单列模式： 一个类只能有一个对象！
*
* */
// 1.让构造函数变成私有的。在类的外部，就无能通过new来创建对象了
class Student private() {
// private 修饰的属性，在类的外部（在当前的class之外）无法访问！
private val name:String = "小花"
}
// 2.在伴生对象中创建类的实例，并返回
object Student {
val instance = new Student() // 在伴生对象中，可以访问伴生类的私有成员
def getInstance:Student = {
instance
}
}
def main(args: Array[String]): Unit = {
// val stu1 = new Student()
// val stu2 = new Student()
// val stu3 = new Student()
// val stu4 = new Student()
val stu1 = Student.getInstance
val stu2 = Student.getInstance
println(stu1 == stu2) // true
}
}
private是私有的意思，这样就会让class不能被new。而通过getInstance可以确保返回的实例就只有一个。
