单例对象和伴生类

判断两个类的关系

两个对象做比较==时，会自动调用equals方法。我们可以重写equals方法，并自己定义两个对象相等的标准。

基本案例

class Student(var name: String,var id:String,var age: Int) {
  //equals 相等
  override def equals(obj: Any): Boolean = {
    println("调用了equals...")

    //判断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",19)
  val stu3=new Student("小花","20230013",19)
  //目标,判断他们是一个人。使用 == 来输出的时候，应该要是true

  println(stu1==stu2)
  println(stu1==stu3)
}

单例对象

用 object 关键字来创建一个单例对象。单例对象在整个应用程序中只有一个实例，适合用于存放工具方法、常量或共享状态。

格式

object 对象名{

属性

方法

}

基本案例

//  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. 类和对象同名
 * 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) 报错

  val stu1 = Student.getInstance()
  val stu2 = Student.getInstance()

  println(stu1 == stu2)
}