一，scala的访问权限概述
Scala中的属性、方法可以通过访问控制符来设置不同的访问权限。不同的访问控制符可以决定是否可以被外部类访问。
import level02.class77.Student.test
/*
访问权限：类的成员（属性，方法）在哪些地方可以被访问。
1. private ：私有的。
（1）在类的内部可以访问。
（2）在类的外部不能访问。
（3）在伴生对象中可以访问。
*/
object class77 {
class Student(var name:String,private var age:Int) {
def say():Unit = {
println(s"${this.age}") //（1）在类的内部可以访问。
}
}
object Student {
def test(student: Student): Unit = {
println(student.age) //（3）在伴生对象中可以访问。
}
}
def main(args: Array[String]): Unit = {
val s1 = new Student("小花", 18)
s1.say()
// println(s1.age) // 报错。（2）在类的外部不能访问。
Student.test(s1)
}
}
二，Scala的属性访问权限
有四种访问控制权限，分别为：
（1）默认访问权限。Scala中的默认访问权限相当于Java中的public，Scala中如果一个变量没有任何修饰符，就代表默认访问权限。作用域：全部
（2）protected访问权限。作用域：本类，子类
（3）private访问权限。作用域：类内部（伴生对象：定义方法传入类的对象）
（4）private[this]访问权限。
/*
访问权限：类的成员（属性，方法）在哪些地方可以被访问。
1. protected ：受保护的
（1）在类的内部可以访问。
（2）在类的外部不能访问。
（3）在伴生对象中可以访问。
(4) 在子类中可以访问，与之对应的是： private修饰的，在子类中无法访问。
*/
object day78 {
class Student(var name:String,private var age:Int,protected var weight:Int) {
def say():Unit = {
println(s"${this.age},${weight}") //
}
private def sayAge():Unit ={println(age)}
protected def sayWeight():Unit = {println(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){
// 在子类中通过super来访问父类
// sayAge()// 报错（4）private修饰的，在子类无法访问。
sayWeight()// 正常（4）protected修饰的，在子类中可以访问。
}
def main(args: Array[String]): Unit = {
val s1 = new Student("小花",18,100)
s1.say()
// println（是。weight）// 报错。（2）在类的外部不能访问。
Student.test(s1)
}
}
三，private[this]的例子
更加严格的私有权限，表示该字段或方法只能在调用它的同一个实例内部可见。这意味着即使在同一类的其他实例中，也无法访问该字段或方法。不能在伴生对象中访问，不能在函数参数中访问。
/*
访问权限：类的成员（属性，方法）在哪些地方可以被访问。
1. private[this] ：更加严格的私有权限。这个属性（方法）只能在调用它的同一个实例内使用。
（1）在类的内部可以访问。
（2）在类的外部不能访问 private[this]。
（3）在伴生对象不能访问 private[this]。
（4）在子类中不能访问 private[this]。
*/
object day79 {
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, 100)
Student.test(s1)
}
}
输出结果：18
重点纪要：
例：银行账户存钱取钱的例子。
账户类：
-
balance 余额
-
deposit() 存钱
-
withdraw() 取钱
-
transfer(to: 账户, amount:Dobule) 转账。是调用to对象的方法来增加余额，而不是直接操作balance属性！
object day80 {
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 // 在第11行，添加了private[this]之后，就不能再直接访问balance属性
}
}
def main(args: Array[String]): Unit = {
val bank = new Bank(100)
bank.deposit(1000)
bank.withdraw(200)
// bank.balance -= 100
// bank.balance -= 100
Bank.clear(bank)
println(bank.getBalance())
}
}
