😍回顾🤩

一.回顾class类

//class类
// var 修饰的属性是可以被修改的
// val 修饰的属性是只读的，不能被修改
class Student(var name:String, val age:Int) {
  def sayHi(): Unit = {
    println(s"我是${name},我今年${age}")
  }
}
object class01 {
  def main(args:Array[String]): Unit= {
    //创建对象
    val stu1 = new Student("小花",18)
    //调用对象的方法
    stu1.sayHi()
    //修改对象的属性
    stu1.name = "小花花"
    //调用对象的方法
    stu1.sayHi()
  }

二.辅助构造器

1. Student（），构造函数（构造器），用来创建对象
2. 主构造函数class Student（）
3. 辅助构造函数，提供更多的方式来创建对象
4. 辅助构造函数的特点：名字就是this，第一句代码就是调用主构造器

class Student(var name:String, val age:Int) {
  println("Student.....")
  def this() = {
    this("未知的",18)//调用主构造函数
    println("辅助构造器被调用了.....")
  }
  def this(age:Int) = {
    this("未知的",age)
  }

三.私有函数

1. private：私有的，不对外公布的，在外面不可以访问的
2. hobby()//在类的内部，可以调用私有方法
3. 在外部，无法访问私有属性

object class02 {
  class Student(val name:String, val age:Int) {
    private  val hobbies:String="躲在被子里，因为我好冷"
    private  def hobby(): Unit = {
      println(s"${hobbies}")
    }
    def sayHi(): Unit = {
      println(s"${name},${age}")
      hobby()//在内部
    }
  }
  def main(array: Array[String]): Unit = {
    val stu = new Student("小花",18)
    stu.sayHi()//在外部
  }
}

例1.判断类和对象的关系

1. 方式1. 对象.getClass()---找爹
2. 方式2. anceof[类]---DNA对比

object class03 {
 class Student() {}
 class Teacher() {}
 def main(arges: Array[String]): Unit = {
 val age:Int = 1
 val stu = new Student()

 println(stu.getClass)
 println(age.getClass)
 println(stu.isInstanceOf[Student])------对
   println(stu.isInstanceOf[Teacher])-----错
 }
}

四.重写toString方法

1. 目标:改进类的代码，让它在println的时候，输出的信息更友好一点
2. 方法：（1）override重写，覆盖....
3. 方法：（2）toString方法，是每个对象都会自带的一个方法，当我们使用println时，它就会自动被调用，返回一个字符串，就是输出的内容。

class Student(var name:String,var age:Int) {
  override def toString: String = s"姓名：${name}"------要返回的字符串
 }
 def main(arges: Array[String]): Unit = {
   val stu1 = new Student("小花",18)
   val stu2 = new Student("小明",15)
   println(stu1)//姓名：小花
   println(stu2)//姓名：小明
 }

例2.判断两个对象是否相同

一.改写equals方法

1. 在使用==判断时，会自动调用
2. 如果返回true，则相等
3. 如果返回是false，则不相等

class Student(val id:String,val name:String,val age:Int) {
  override def equals(obj: Any): Boolean = {
    println(s"比较是否相等......${this.id},${this.name},")
 // 在这里写自己判断逻辑
    //把obj当做Student
    val other = obj.asInstanceOf[Student]

    this.id == other.id && this.name == other.name
  }
 }
 def main(arges: Array[String]): Unit = {
   val stu1 = new Student("20240001","小花", 18)
   val stu2 = new Student("20240001","小明", 15)

   if (stu1 == stu2){
     println("他们是同一人")
   } else{
     println("不是同一人")
   }
 }

五.链式

1. arr1.map(x =>2*x).filter(x=>x>5).foreach(println)
2. 实现要点:把当前方法的返回值设置成当前对象!

 class Student() {
    def sayHi(): Student = {
      println("sayhi")
      this
    }

    def sayHello(): Student = {
      println("sayHello")
      this//返回当前对象
    }
  }

  def main(arges: Array[String]): Unit = {
    val stu1 = new Student()
   //链式调用。方法.方法.方法....
    stu1.sayHi().sayHello()
    
  }
}