一。单例对象
package l1
object l03 {
//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))
}
}
二.伴生类 和 伴生对象
类和对象同名 在一个文件中 类就是伴生类， 对象就是伴生对象。 特点：可以相互访问对方的私有成员
package l1
object l04 {
/***
伴生类 和 伴生对象
类和对象同名
在一个文件中
类就是伴生类， 对象就是伴生对象。
特点：可以相互访问对方的私有成员
*/
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 一次！ 特点：可以相互访问对方的私有成员
package l1
object l05 {
/***
伴生类和伴生对象，实现一种特殊的编程的模式： 单例模式
单例模式：让一个类只能有一个实例对象， 一个类只能被 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)
}
}
伴生类和伴生对象 在伴生对象中补充一个 apply 方法，这样创建对象的时候，就可以省略 new 伴生类名（参数）==== 伴生对象名.apply (参数)
package l1
object l06 {
/***
伴生类和伴生对象
在伴生对象中补充一个 apply 方法，这样创建对象的时候，就可以省略 new
伴生类名（参数）==== 伴生对象名.apply (参数)
*/
// 日志
class Logger(var filename:String)
object Logger {
def apply(filename:String):Logger={
println("appl...")
new Logger(filename)
}
}
def main(args: Array[String]): Unit = {
// 省略 new
val log1=Logger("test.log")
println(log1.filename)
}
}
package l1
object l07 {
/***
伴生类和伴生对象 +apply 实现 单例 模式
在伴生对象中补充一个 apply 方法，这样创建对象的时候，就可以省略 new
伴生类名（参数）==== 伴生对象名.apply (参数)
*/
// 日志
class Logger(var filename:String) {
def log(message:String):Unit={
println(s"Log:$message")
}
}
object Logger {
private var instance: Option[Logger]=None
def apply(filename: String):Logger={
if(instance.isEmpty){
instance=Some(new Logger(filename))
}
instance.get
}
}
def main(args: Array[String]): Unit = {
// 省略 new
val log1=Logger("test.log")
log1.log("2025-11-03 上午上课")
}
}
package l1
import java.io.FileWriter
object l08 {
class Logger(var filename:String) {
def log(message:String): Unit={
//把日志信息写入到文件中
val writer=new FileWriter(filename,true)
writer.write(s"$message \n")
writer.close()
}
}
object Logger {
private var instance: Option[Logger]=None
def apply(filename:String):Logger={
if(instance.isEmpty){
instance-Some(new Logger(filename))
}
instance.get
}
}
def main(args: Array[String]): Unit = {
val log1=Logger("test.log")
log1.log("2025-11-03 上午上课")
log1.log("2025-11-05 开运动会")
log1.log("2025-11-07 周末")
}
}
