scala equals 单例对象 伴生类...

一.equals

• equals 方法是定义在根类 Any 中的核心方法，用于判断两个对象是否 “逻辑相等”，其核心作用是比较两个对象的内容或逻辑状态是否一致，而非引用是否相同。

package level02
// 两个对象作比较==时 会自动调用equals方法
object class04 {
  class Student (var name:String,var id :String,var age :Int) {
    // equals 相等
    override def equals(obj: Any): Boolean = {
      println("调用了equals")

      println(this, obj)
      // 判断this 和 obj 是否相等的逻辑 姓名和学号都相等 说明这两个学生时同一个人
      val other = obj.asInstanceOf[Student]
      this.name == other.name && this.id == other.id
    }
  }

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

    val stu1 = new Student("小王","20230012",18)
    val stu2 = new Student("小王","20230012",18)
    val stu3 = new Student("小王","20230012",18)
    println(stu1 == stu2)
    println(stu2 == stu3)
  }
}

二.单例对象

• 单例对象是一种特殊的结构，它只有一个实例，在程序运行期间全局唯一

package level02

object class05 {
  // object 对象名{
  // 属性;
  // 方法;...
  // }
  //单例对象
  //只有一个 不能被new
  //适用于存放工具方法 常量
  object MyTool {
    //属性
    val PI = 3.14

    //方法
    def Area(r:Double):Double = {
      PI * r * r
    }
  }

  def main(args: Array[String]): Unit = {
    //D对象.属性名
    //对象.方法名()
    println(MyTool.PI)
    println(MyTool.Area(10))
  }
}

三. 伴生类 和 伴生对象

3.1. 伴生类 和 伴生对象:

1. 类 和 对象同名

2. 在一个文件中

3.2. 类就是伴生类 对象就是伴生对象

3.3. 特点: 可以相互访问对方的私有成员

package level02

object class06 {
  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()
    // sttu1.hobby //无法访问私有属性

    Student.introduce(stu1)
  }
}

四.

4.1.

package level02
//在伴生对象中补充一个apply方法 这样创建对象的时候 就可以省略new
//伴生类名(参数) ===== 伴生对象名.apply(参数)

object class08 {
  //日志
  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)
  }
}

4.2.

package level02
//在伴生对象中补充一个apply方法 这样创建对象的时候 就可以省略new
//伴生类名(参数) ===== 伴生对象名.apply(参数)

object class08 {
  //日志类
  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")
    println(log1.filename)
  }
}

4.3.

package level02

import java.io.FileWriter
//在伴生对象中补充一个apply方法 这样创建对象的时候 就可以省略new
//伴生类名(参数) ===== 伴生对象名.apply(参数)

object class08 {
  //日志类
  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 = {
    //省略new
    val log1 = Logger("test.log")

    log1.log("2025-11-03 helloworld")
    log1.log("2025-11-03 你好世界")
    log1.log("2025-11-03 你好world")
  }
}