(一) Scala的访问权限概述
Scala中的属性、方法可以通过访问控制符来设置不同的访问权限。不同的访问控制符可以决定是否可以被外部类访问。
有四种访问控制权限，分别为：
（1）默认访问权限。Scala中的默认访问权限相当于Java中的public，Scala中如果一个变量没有任何修饰符，就代表默认访问权限。作用域：全部
（2）protected访问权限。作用域：本类，子类
（3）private访问权限。作用域：类内部（伴生对象：定义方法传入类的对象）
（4）private[this]访问权限。
(二) private访问权限
private : 私有的。它的特点有如下三个。
(1) 在类的内部可以访问。
(2) 在类的外部不能访问。
(3) 在伴生对象中可以访问。
1.1 默认访问权限
代码：
package levelo3
/*
访问权限控制
1.默认访问权限
*/
object class013 {
// name 属性具有默认的访问权限
class Student(var name:String) {
}
def main(args: Array[String]): Unit = {
val s1 = new Student("小花")
println(s1.name)
}
}
结果：
1.2protected访问权限
protected : 受保护的。它的特点有如下4个：
(1) 在类的内部可以访问。
(2) 在类的外部不能访问。
(3) 在伴生对象中可以访问。
(4) 在子类中可以访问，与之对应的是：private修饰的，在子类中无法访问 代码：
package levelo3
/*
访问权限控制
1.默认访问权限
2.使用 protected（被保护的）修饰符
（1） 在类的外部，不能通过直接对象，属性的方式来访问
（2）
*/
object class013 {
// name 属性具有默认的访问权限
class Student(var name:String,protected var gender:String) {
}
def main(args: Array[String]): Unit = {
val s1 = new Student("小花","女")
println(s1.name)
// protected属性，在类的外部无法访问
println(s1.gender)
}
}
结果：
1.3 private访问权限
private : 私有的。它的特点有如下三个。
(1) 在类的内部可以访问。
(2) 在类的外部不能访问。
(3) 在伴生对象中可以访问。 代码：
scala
package levelo3
/*
访问权限控制
1.默认访问权限
2.使用 protected（被保护的）修饰符
（1） 在类的外部，不能通过直接对象，属性的方式来访问
（2） 在子类中，通过super 来访问protected的方法
3.private（私有的）
（1）在子类中，无法访问
*/
object class014 {
// name 属性具有默认的访问权限
class Father {
val name:String="小花"
protected var gender:String="女"
protected def test():Unit={
println("test")
}
private val age:String="18"
private def test1():Unit={
println("test1")
}
}
// 在子类中，我们通过super来访问父类
class Son extends Father{
// 修饰的成员。可以在子类中，访问
super.test()
println(gender)
// private 修饰的成员，在子类中访问·
//super.test1()
// println(age)
}
def main(args: Array[String]): Unit = {
var son1=new Son()
}
}
结果：
/*
访问权限控制
1.默认访问权限
2.使用 protected（被保护的）修饰符
（1） 在类的外部，不能通过直接对象，属性的方式来访问
（2） 在子类中，通过super 来访问protected的方法
3.private（私有的）
（1）在子类中，无法访问
（2）在半身对象，半身类可以访问
*/
object class015 {
class Student() {
private var age:Int=10
}
object Student {
def test(stu:Student):Unit={
// 在半身对象中，哭晕通过对象，属性的方法来访问
println(stu.age)
}
}
def main(args: Array[String]): Unit = {
val stu = new Student()
// private 成员，不能在类的外部，通过对象，属性的方法来访问
// 报错：stu.age
Student.test(stu)
}
}
结果：
1.4 private[this]访问权限
private [this] : 更加严格的私有权限。这个属性（方法）只能在调用它的同一个实例内使用。它的特点如下：
(1) 在类的内部可以访问。
(2) 在类的外部不能访问 private[this]。
(3) 在伴生对象不能访问 private[this]。
(4) 在子类中不能访问 private[this]。 代码：
package levelo3
/*
访问权限控制
1.默认访问权限
2.使用 protected（被保护的）修饰符
（1） 在类的外部，不能通过直接对象，属性的方式来访问
（2） 在子类中，通过super 来访问protected的方法
3.private（私有的）
（1）在子类中，无法访问
（2）在半身对象，半身类可以访问
4.private[this] 私有 只能在当前类被发现
子类无法访问 ,半生对象，伴生类中不可访问
*/
object class015 {
class Student() {
private var age:Int=10
private [this] var secret:String="xx日,xx事"
def test():Unit={
// if(){}
println(secret)
}
}
object Student {
def test(stu:Student):Unit={
// 在半身对象中，哭晕通过对象，属性的方法来访问
println(stu.age)
// secret无法被访问
//println(stu.secret)
}
}
def main(args: Array[String]): Unit = {
val stu = new Student()
// private 成员，不能在类的外部，通过对象，属性的方法来访问
// 报错：stu.age
Student.test(stu)
stu.test()
}
}
结果：
