protected : 受保护的。它的特点有如下4个：
(1) 在类的内部可以访问。
(2) 在类的外部不能访问。
(3) 在伴生对象中可以访问。
(4) 在子类中可以访问，与之对应的是：private修饰的，在子类中无法访问
package level02
/*
*
* 访问权限控制
*
* 1.默认访问权限
* 2.使用 protected (被保护的) 修饰符
* （1） 在类的外部，不能直接通过对象，属性的方式来访问
* （2）
*/
object l20 {
//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.默认访问权限
-
2.使用 protected (被保护的) 修饰符
（1） 在类的外部，不能直接通过对象，属性的方式来访问
（2）在子类中，可以访问protected 修饰的成员
3.private (私有的)
(1)在子类中,无法访问
package level02
/*
*
* 访问权限控制
*
* 1.默认访问权限
* 2.使用 protected (被保护的) 修饰符
* （1） 在类的外部，不能直接通过对象，属性的方式来访问
* （2）在子类中，可以访问protected 修饰的成员
* 3.private (私有的)
* (1)在子类中,无法访问
*
*/
object l21 {
//name 属性具有默认的访问权限
class Father() {
var name:String="小花"
protected var gender:String="女"
protected def test():Unit={
println("test")
}
private val age:String="18"
protected 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()
}
}
package level02
/*
*
* 访问权限控制
*
* 1.默认访问权限
* 2.使用 protected (被保护的) 修饰符
* （1） 在类的外部，不能直接通过对象，属性的方式来访问
* （2）在子类中，可以访问protected 修饰的成员
* 3.private (私有的)
* (1)在子类中,无法访问
* (2)在伴生对象，伴生来中可以访问
*/
object l22 {
class Student() {
private var age:Int=10
}
object Student {
def test(student: Student):Unit={
println(student.age)
}
}
def main(args:Array[String]):Unit={
val stu=new Student()
//private 成员，不能在来的外部，通过对象，属性的方法来访问。
//报错:stu.age
Student.test(stu)
}
}
4.private [this] 私有，只能在当前的类中访问。
- 子类无法访问，伴生对象、伴生类中不可以访问
package level02
/*
*
* 访问权限控制
*
* 1.默认访问权限
* 2.使用 protected (被保护的) 修饰符
* （1） 在类的外部，不能直接通过对象，属性的方式来访问
* （2）在子类中，可以访问protected 修饰的成员
* 3.private (私有的)
* (1)在子类中,无法访问
* (2)在伴生对象，伴生来中可以访问
* 4.private [this] 私有，只能在当前的类中访问。
* 子类无法访问，伴生对象、伴生类中不可以访问
*/
object l22 {
class Student() {
private var age:Int=10
private [this] var secret:String="xx日，xxx事"
}
object Student {
def test(student: Student):Unit={
//在伴生对象中，可以通过对象，属性的方法来访问
println(student.age)
//private [this] 只能在当前的类中访问
//println(stu.secdent)
}
}
def main(args:Array[String]):Unit={
val stu=new Student()
//stu.test()
//private 成员，不能在来的外部，通过对象，属性的方法来访问。
//报错:stu.age
Student.test(stu)
}
}
