首页 > 其他 > 详细

访问修饰符

时间:2019-10-12 14:29:22      阅读:78      评论:0      收藏:0      [点我收藏+]
  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
}

 

访问修饰符

原文:https://www.cnblogs.com/WeiKing/p/11654092.html

(0)
(0)
   
举报
评论 一句话评论(0
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣,分享程序人生!