用 object 关键字来创建一个单例对象。单例对象在整个应用程序中只有一个实例，适合用于存放工具方法、常量或共享状态。
object class05 {
// object 对象名{
// 属性；
// 方法；....
// }
//单例对象
//只有一个，不能被new;
//适用于存放工具方法，常量。
object MyTool {
//属性
val PI = 3.14
//方法
def Area(r:Double):Double = {
PI * r * r
}
}
def main(args: Array[String]): Unit = {
// 对象.属性名
// 对象.方法名()
println(MyTool.PI)
println(MyTool.Area(10))
}
1. 通过object关键字创建的是一个对象，不是一个类型。
2. 不能使用new关键字：声明单例对象的时候不可以使用new关键字。
3. 不能传递参数：单例对象无法传递参数。
## （二）、伴生类和伴生对象
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)
}
/***
*
* 伴生类 和 伴生对象，实现一种特殊的编程模式：单例模式
*
* 单例模式：让一个类只能有一个实例对象，一个类只能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)//true
}
## （三）、应用-单例模式
什么是单例模式？
就是通过技术手段，让某个类只能有一个对象实例。这样做的好处就节约资源，能更加精准地管理。
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)
}
。
