scala中访问控制与方法重写

主构造函数和辅助构造函数

scala 复制代码

package level02

// class 类
// var 修饰的属性是可以被修改的
// val 修饰的属性是只读的，不能被修改
//Student()构造函数(构造器)，用来创造对象
class Student(var name:String, val age:Int) {
  println("student...........")

  def this() = {
    this("未知的",18)
    println("辅助构造器被调用了...")
  }

  def this(age:Int)={
    this("未知的",age)
  }
  def sayHi(): Unit = {
    println(s"我是${name}，我今年${age}")
  }
}

object Class01 {
  def main(args: Array[String]): Unit = {
    //创建对象
    val stu1 = new Student("小花",18)
    val stu2 = new Student()
    val stu3 = new Student(20)
    //调用对象的方法
    stu1.sayHi()
    //修改对象的属性
    stu2.sayHi()
    //调用对象的方法
    stu3.sayHi()
  }
}

private

默认情况下，类的属性在可以通过对象.属性名的方式来获取，如果不希望在类的外部被访问，可以用private来修饰。

scala 复制代码

package level02

object Class02 {
  class Student(val name: String,val age:Int) {
    //private:私有的，不对外公布，不对外发布，在外面不可以访问。在家之外的地方，不可以被别人知道
    private val hobbies:String = "躲在被子打手电看恐怖小说"
    private  def hobby():Unit = {
      println(s"${hobbies}")
    }
    def sayHi():Unit = {
      println(s"${name},${age}")
      hobby()//在类的内部可以调用私有方法
    }
  }

  def main(args: Array[String]): Unit = {
    val stu = new Student("小花",18)
    stu.sayHi()//在类的外部无法访问私有属性
  }
}

判断类和对象的关系

方法1: 对象.getClass()

方法2：对象.isInstanceof[类]

scala 复制代码

package level02

object Class03 {
  // 判断类和对象的关系？亲子鉴定？

  // 方式1：对象.getClass()    // 找爹
  // 方式2：对象.isInstanceOf[类] // DNA对比
  class Student() {}
  class Teacher() {}

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

    val age: Int = 1

    val stu = new Student()
    // stu 是对象名
    // Student是类名
    // stu是Student类的实例。

    // 返回类名
    println(stu.getClass) // class level02.Class03$Student
    println(age.getClass) // int

    // 注意：[], 结果是boolean值
    println(stu.isInstanceOf[Student]) // true

    println(stu.isInstanceOf[Teacher]) // false
  }
}
# 重写toString
## 1.1使用println来输出对象是```
，他会自动调用toString方法。
在Scala中，要重写一个方法，你需要使用override关键字。对于toString方法，你可以在你的类中定义它，并使用override来指明这是对父类方法的重写。
## 1.2定义toString方法
你可以在类的内部直接定义toString方法。这个方法通常不需要任何参数，并且返回一个String类型的结果。
```scala
package level02

object Class04 {
  //目标：改进类的代码，让他在println的时候，输出的信息更友好一点！
  //重写 toString的方法
  //（1）override 重写，覆盖...
  //(2) toString 方法，是每个对象都会自带的一个方法，当我们使用println时，他就会自动被调用，返回一个字符，就是输出的内容
  class Student(var name:String,var age:Int) {
    override def toString: String = s"姓名：${name},年龄：${age}"
  }

  def main(args: Array[String]): Unit = {
    val stu1 = new Student("小花",18)
    val stu2 = new Student("小明",18)
    println(stu1)
    println(stu2)
  }
}

判断两个对象是相等的？

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

scala 复制代码

package level02

object Class05 {
  // 目标：判断两个Student对象是否相等的依据是学号相同姓名相同
  // 目标equals方法
 //在使用 == 判断的时候，会自动调用
  class Student(val  id:String,val name:String,val age:Int) {
    override def equals(obj: Any): Boolean = {
      println(s"比较是否相等...￥{this.id},${this.name},")
      val other = obj.asInstanceOf[Student]
      this.id == other.id && this.name == other.name
    }
  }

  def main(args: Array[String]): Unit = {
    val  stu1 = new Student("2024101001","小花",18)
    val  stu2 = new Student("2024101001","小花",19)
    if (stu1 == stu2){
      println("他们是同一个人")
    }else{
      println("不是同一个人")
    }
  }
}

辅助构造器

1.主构造函数的参数

2.this关键字实现链式调用

3.辅助构造函数

4.案例- 任务:定义一个学生注册信息类，要求有姓名、电话、专业和身份证。其中你可以选择用姓名和电话或姓名身份证注册。电话、姓名和身份证为不可修改属性，专业为非必要属性且可修改。(提示:提供2个构造器)

scala 复制代码

package level02

object Class06 {
  // 链式
  // arr1.map(x => 2*x).filter(x=>x>5).foreach(println)

  // 实现要点：把当前方法的返回值设置为当前对象！
  class Student() {
    def sayHi(): Student = {
      println("sayHi")
      this
    }

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

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

    // val arr1 = Array(1,2,3)
    // arr1.map(x => 2*x).filter(x=>x>5).foreach(println)
  }
}