访问修饰符

1. Scala 访问修饰符有：private，protected，public。
2. Scala中默认情况下的访问修饰符都是 public
3. private限定符在嵌套类情况下，外层类不能访问被嵌套类的私有成员。

private

1. private：修饰的成员A是私有成员A，只能在包含了成员A的类(对象)中可见（使用）。(private修饰的的属性和方法只能在class的内部使用，任何其他的都不可以直接使用，在类的实例对象中都无法使用）

   class man{
     val age = 19
     private val name = "Tom"
     private def getAge =age
     def doThing1(x: man) = x.name // fine
   }
   object VisitTest {
     private val height = 19
     def main(args: Array[String]): Unit = {
       val man = new man
       println(man.age)
       println(man.getAge)  //无法调用报错
       println(man.name)  //无法调用报错
       println(height)
     }
   }

2. private限定符在嵌套类情况下，外层类不能访问被嵌套类的私有成员 

   class Outer{
     class Inner{
       private def f(){println("f")}
       class InnerMost{
         f() // 正确
       }
     }
     (new Inner).f() //错误
   }
   //(new Inner).f( ) 访问不合法是因为 f 在 Inner 中被声明为 private，而访问不在类 Inner 之内。
   //但在 InnerMost 里访问 f 就没有问题的，因为这个访问包含在 Inner 类之内。pravite修饰的成员只可以在平级或下级中使用

protected

1. Protected: scala中，Protected修饰的成员只能在该类和其子类中被使用

     class Super {
       protected def printlnFun() {
         println("..........")
       }
     }
     class Sub extends Super{
       printlnFun()
     }

public

1. Public:如果没有指定任何的修饰符，则默认为 public。Public修饰的成员在任何地方都可以被访问。

   class Outer {
     class Inner {
       def fun() { println("..........") }
       class InnerMost {
         fun() // 正确
       }
     }
     (new Inner).fun() // 正确因为 f() 是 public
   }

作用域保护

1. Scala中，访问修饰符可以通过使用限定词进行强调。
2. 格式为:private[x] 或 protected[x]
   1. 这里的x指代某个所属的包、类或单例对象
   2. private[x]可以放在字段，方法和类上，用来限制访问权限；
   3. private[x] Y ,表示"Y这个成员在X（包，类，对象）和中可见

      /**
        * Person被private[pack1]标记，表示Person可以在pack1这个包中可见（使用）
        * sayHello()别protected[pack2]标记，表示只能在 sayHello()在pack2中可见
        * 所以pack3可以创建Person对象不能调用sayHello方法
        * 
        * age属性被private[Person]修饰，所以子person中可见
        * id被private只能在Teahcer中可见
        * 所以teacher.age编译通过，teacher.id编译不通过
        */
      package pack1{
        package pack2 {
          private[pack1] class Person {
            protected[pack2] def sayHello() {}
            class Teahcer {
              private[Person] val age = 30
              private val  id  = 100
            }
            val teacher =new Teahcer
            teacher.age
            teacher.id //  编译不通过
          }
        }
      
        package pack3{
          import pack2._
          object Vehicle{
            private[launch] val guide = new Person
            guide.sayHello()    // 编译不通过
      
          }
        }
      }

private[this]和private的区别

1. this：用于引用当前对象(this指代当前对象)。可以使用this关键字调用对象的变量，方法，构造函数。
2. private：伴生类和伴生对象可以相互访问彼此的private修饰的成员
3. private[this]：伴生类和伴生对象不能相互访问彼此的private[this]修饰的成员

/**
  * private和private[this] ：Student类
  *     相同点：修饰的成员都是只能在Student类中使用
  *     不同点：private修饰的成员可以被其他的Student对象调用,private[this]private修饰的成员只能别this调用
  */
class Student{
  private[this] val age: Int =0
  private val id: Int = 1
  private[this] def ag{}
  age
 id

 val stu = new Student
  stu.id
  stu.age // 编译不通过
  stu.ag  // 编译不通过
  this.id
  this.age
  this.ag
}