访问控制权限在Java中已经有所了解，下面通过与Java中的权限对比，介绍Scala中的几种访问权限。
（一） Scala的访问权限概述
Scala中的属性、方法可以通过访问控制符来设置不同的访问权限。不同的访问控制符可以决定是否可以被外部类访问。
package level02
/*
访问权限:类的成员（属性，方法）在哪些地方可以被访问
1.private : 私有的
（1）在类的内部可以访问
（2）在类的外部不能访问
（3）在伴生对象中可以访问
*/
object calaa1 {
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(s"{Student.age}") //（3）在伴生对象中可以访问
}
}
def main(args: Array[String]): Unit = {
val s1 = new Student("小花", 18)
s1.say()
//println(s1.age) // 报错 （2）在类的外部不能访问
Student.test(s1)
}
（ 二 ） Scala的控制方法作用域
protected修饰的属性
package level02
/*
protected：受保护的
（1）在类的内部可以访问。
（2）在类的外部不能访问。
（3）在子生对象中可以访问。
（4）在子类中可以访问，与之对应的是：private修饰的，在子类中无法访问。
*/
object calaa1 {
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 访问父类
// println(super.age) // 报错 (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
/*
protect[this]: 更加严格的私有权限。这个属性（方法）只能在调用它的同一个实例内使用
（1）在类的内部可以访问。
（2）在类的外部不能访问。private[this]
（3）在子生对象中可以访问。private[this]
（4）在子类中可以访问private[this]
*/
object calaa1 {
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) // 普通的privat在伴生对象中可以访问
//private(student.pwd)
}
}
def main(args: Array[String]): Unit = {
val s1 = new Student("小花", 18, 100)
Student.test(s1)
}
}
private[this]的例子*
更加严格的私有权限，表示该字段或方法只能在调用它的同一个实例内部可见。这意味着即使在同一类的其他实例中，也无法访问该字段或方法。不能在伴生对象中访问，不能在函数参数中访问。
[例] 银行账户存钱取钱的例子。
object class18 {
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
}
}
def main(args: Array[String]): Unit = {
val bank = new Bank(100)
bank.deposit(1000)
bank.withdraw(200)
Bank.clear(bank)
println(bank.getBalance())
}
- 完结撒花 ！！！！！！！！！！
- 制作不易 希望·一键三连 在此感谢关注的粉丝宝宝
- 新来的宝宝可以关注下主播哟！！！！！
