内容如下：
1. Scala的访问权限概述；
2. 属性访问权限；
3. 特殊属性private[this]；
（一）Scala的访问权限概述
Scala中的属性、方法可以通过访问控制符来设置不同的访问权限。不同的访问控制符可以决定是否可以被外部类访问。
（二）Scala的属性访问权限
package level02
import level02.class18.Student.test
/*
访问权限：类的成员（属性，方法）在哪些地方可以被访问。
1. private ：私有的。
（1）在类的内部可以访问。
（2）在类的外部不能访问。
（3）在伴生对象中可以访问。
*/
object class18 {
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)
}
}
package level02
/*
访问权限：类的成员（属性，方法）在哪些地方可以被访问。
1. protected ：受保护的。
（1）在类的内部可以访问。
（2）在类的外部不能访问。
（3）在伴生对象中可以访问。
（4）在子类中可以访问，与之对应的是：private修饰的，在子类中无法访问
*/
object class19 {
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(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(s1.weight) // 报错（2）在类的外部不能访问。
Student.test(s1)
}
}
（三）private[this]的例子
更加严格的私有权限，表示该字段或方法只能在调用它的同一个实例内部可见。这意味着即使在同一类的其他实例中，也无法访问该字段或方法。不能在伴生对象中访问，不能在函数参数中访问。
package level02
/*
访问权限：类的成员（属性，方法）在哪些地方可以被访问。
1. private [this]：更加严格的私有权限。这个属性（方法）只能在调用它的同一个实例内使用。
（1）在类的内部可以访问。
（2）在类的外部不能访问 private [this]。
（3）在伴生对象不能访问 private [this]。
（4）在子类中不能访问 private [this]
*/
object class20 {
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)
}
}
[例] 银行账户存钱取钱的例子。
账户类：
-
balance 余额
-
deposit() 存钱
-
withdraw() 取钱
-
transfer(to: 账户, amount:Dobule) 转账。是调用to对象的方法来增加余额，而不是直接操作balance属性！
package level02
object class20 {
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())
}
}
