特质：访问权限

类的成员（属性，方法）在那些地方可以访问？

1.private:私有的

（1）在类的内部可以访问

（2）在类的外部不能访问

（3）在类的半生对象中可以访问

案例1：

object day53 {
  // 定义Student类，包含name（公有）和age（私有）
  class Student(var name: String, private var age: Int) {
    def say(): Unit = {
      println(s"年龄：${this.age}") // 类内部可访问私有成员
    }
  }

  // 伴生对象必须与类名相同（Student），才能访问类的私有成员
  object Student {
    def test(student: Student): Unit = {
      println(s"伴生对象访问年龄：${student.age}") // 伴生对象可访问私有成员
    }
  }

  def main(args: Array[String]): Unit = {
    val s1 = new Student("小花", 18)
    s1.say() // 调用类方法，输出年龄
    Student.test(s1) // 调用伴生对象方法，输出年龄
    // println(s1.age) // 编译报错：类外部无法访问私有成员
  }
}

案例2：

object day54 {
  // 定义Student类，包含name（公有）和age（私有）
  class Student(var name: String, private var age:Int,protected var weight:Int) {
    def say(): Unit = {
      println(s"年龄：${this.age},${weight}") //（1） 在类内部可访问私有成员
    }
    private def sayAge():Unit = {println(s"${age}")}
    protected def sayWeight():Unit= {println(s"${weight}")}
  }
  object Student {
    def test(student: Student): Unit = {
      println(student.weight) // (3)伴生对象可访问私有成员
    }
  }
  class Major(name:String,age:Int,weight:Int) extends Student(name, age,weight){
    sayWeight()  //正常（4）protected修饰的，在子类中无法访问。
  //sayAge() // 报错（4）private修饰的，在子类中无法访问。
    //println(super.weight)  // 报错 在子类中通过super来访问父类：只能调用方法，不能直接调用属性
  }

  def main(args: Array[String]): Unit = {
    val s1 = new Student("小花",18,180)
    s1.say() // 调用类方法，输出年龄
    Student.test(s1) // 调用伴生对象方法，输出年龄
    // println(s1.age) // 编译报错：类外部无法访问私有成员
  }
}

访问权限：

类的成员（属性，方法）在那些地方可以访问？

1.private[this]:更加严格的私有权限，这个属性（方法）只能在调用它的同一个实例内使用。

（1）在类的内部可以访问。

（2）在类的外部不能访问 private[this]

（3）在半生对象中不能访问 private[this]

（4）在子类中不能访问 private[this]

/*

*/
object day55 {
  class Student(var name: String, private var age:Int,protected var weight:Int) {
    private [this] var pwd = 123 // 密码
  }
  object Student {
    def test(student: Student):Unit={
      println(student.age) // 普通的private在伴生对象中可以访问
  //  println(student.pwd) // 报错（3）在伴生对象中不能访问 private[this]
    }
  }

  def main(args: Array[String]): Unit = {
    val s1 = new Student("小花",18,180)
    Student.test(s1)
  }
}

访问权限：
     类的成员（属性，方法）在那些地方可以访问？
       1.private[this]:更加严格的私有权限，这个属性（方法）只能在调用它的同一个实例内使用。
          （1）在类的内部可以访问。
          （2）在类的外部不能访问 private[this]
          （3）在半生对象中不能访问 private[this]
          （4）在子类中不能访问 private[this]
*/
object day55 {
  class Student(var name: String, private var age:Int,protected var weight:Int) {
    private [this] var pwd = 123 // 密码
  }
  object Student {
    def test(student: Student):Unit={
      println(student.age) // 普通的private在伴生对象中可以访问
  //  println(student.pwd) // 报错（3）在伴生对象中不能访问 private[this]
    }
  }

  def main(args: Array[String]): Unit = {
    val s1 = new Student("小花",18,180)
    Student.test(s1)
  }
}

案例3：

模拟银行账号要求实现： 1.余额 2.存款 3.取款 4.转账

object day56 {
  class Bank(private[this] var balance:Double) {
    // 存款
    def deposit(amount:Double):Unit={
      balance +=amount
    }
    // 取款
    def withdraw(amount:Double):Unit={
      if(balance >= amount){
        balance -= amount
      }
    }
    def getBalance():Double = balance
  }
  object Bank {
    def clear(bank: Bank):Unit={
      bank.balance = 0  // 在9行添加了private[this]之后，就不能再直接访问balance属性
    }
  }

  def main(args: Array[String]): Unit = {
    val bank = new Bank(100)
    bank.deposit(1000)
    bank.withdraw(200)
    Bank.clear(bank)
    println(bank.getBalance())
  }
}