在 Scala 中控制方法范围

顾名思义，scala 中的访问修饰符有助于限制类、变量、方法或数据成员的范围。在 Scala 中控制方法范围有助于限制方法或数据成员的范围。 Scala中有五种控制方法范围：

1. 公共范围
2. 私有范围
3. 保护范围
4. 对象私有范围
5. 特定包装

公共范围

• 如果没有为类、方法或数据成员指定访问修饰符，则称其默认具有默认访问修饰符。
• 未使用任何访问修饰符（即具有默认访问修饰符）声明的数据成员、类或方法可以使用包和导入或通过创建新实例在任何地方访问。
  例子 ：

  // Scala program of Public Scope
  // package testA
  class classA
  {
      def method1(): Unit=
      {
          println("method1")
      }
  }
    
  // Creating object
  object GfG
  { 
      // Main method
      def main(args: Array[String])
      {
          // classA in the same package 
          // as the main method 
          var x = new classA
          x.method1()
      }
  }
  

  输出 ：

  method1
  

  例子 ：

私有范围

• private 修饰符与Java中的 private 相同。通过将方法或变量标记为私有，它可用于当前类及其成员以及同一类的任何实例。
• 同一包的任何其他对象/类将无法访问私有成员。
• 这是通过使用私有访问修饰符来完成的。

  例子 ：

  // Scala program of Private Scope
  // package testA
  class classA 
  {
      var x = 1
      private def method1: Unit =
      {
          println("method1")
      }
  }
    
  // Creating object
  object GfG
  {
      // Main method
      def main(arg: Array[String])
      {
          var obj1 = new classA
          printf("x = "+obj1.x)
          // println(obj1.method1) error: method 
          // method1 in class classA cannot 
          // be accessed in classA
      }
  }
  

  输出：

  x = 1
  

保护范围

• Scala protected 与Java中的 protected 不同。要将成员标记为受保护，请在类或变量之前使用关键字protected 。
• 受保护的成员只能由同一包中的子类访问。
  例子 ：

  // Scala program of Protected Scope
  // package test
  class classab
  {
      protected var ab: Int=4
      var ad: Int =1
  }
    
  // Creating object
  object GfG extends classab
  { 
      // sub class
      // Main method
      def main(args: Array[String])
      {
          println(ab) //can be accessed
          println(ad) //can be accessed
      }
  }
  

  输出：

  4
  1
  

• 即使使用导入，其他包中的其他成员也无法访问受保护的成员。
  例子 ：

  // Scala program of Protected Scope
  // package testA
  package testA
  {
      class classA 
      {
          protected var ab: Int=4
          var ad: Int =1
      }
  }
    
  // another package testB
  package testB
  {
      // importing all the members 
      // from testA package
      import testA._
        
      // Creating object
      object GfG
      {
          // Main method
          def main(args: Array[String])
          {
              var ta= new classA
              ta.ad
              ta.ab //error
          }
      }
  }
  

  输出：

  error: variable ab in class classA cannot be accessed in testA.classA
  Access to protected method ab not permitted because
  enclosing object GfG in package testB is not a subclass of
  class classA in package testA where target is defined
  ta.ab //error
  ^
  one error found

对象私有/受保护范围

• 私有对象与私有对象相同，唯一的区别是成员声明的私有对象只能从定义该成员的位置获得，即没有对象可以访问它，因此命名为私有对象。
• 受保护的对象与受保护的对象相同，唯一的区别是该成员将仅在定义它的位置或子类中可用，而对对象不可用。
• 要将成员对象标记为私有，请使用关键字private[this] 。
• 要将成员对象标记为受保护，请使用关键字protected[this] ，其中 this 指或指向当前对象。

  例子 ：

  // Scala program of Object Private/Protected Scope
  // package test1.test11
  class class11 
  {
      private[this] var x = 1
      private var t = 2
      var z = 3
      def method11(other: class11): Unit =
      {
          println(x)
          println(t)
          println(z)
            
          // println(other.x)
          println(other.t)
          println(other.z)
      }
  }
  // here on line14 x can only be
  // accessed from inside in which 
  // it is defined
    
  // Creating object
  object GfG
  {
      // Main method
      def main(arg: Array[String])
      {
          var obj11 = new class11() //current instance created
          var y = 2
          println(obj11.method11(obj11))
          println(obj11.z)
          //println(obj11.t) //error: t cannot be accessed
          //println(obj11.x) //error: x is not a member of class11
          //according to obj11 x is not a member
      }
  }
  

  输出 ：

  1
  2
  3
  2
  3
  ()
  3
  

特定包装

• 当我们希望一个成员可用于整个包时。它将该成员声明为private[package_name] 。
• 包内的所有成员都可以访问该成员。
• 任何其他名称符合条件的包都可以访问成员。
  例子 ：

  // Scala program of Package Specific
  // Scala program of Package Specific
  package aa
  class geek
  {
      class g1
      {  
          // inner class
          // private to class g1
          private var a = 0 
            
          // available to package aa
          private[aa] var b = 0 
          def method()
          {
              a = a + 1
              b = b + 1
              println("welcome to inner class g1")
              println("a= "+a)
          }
      }
  } 
    
  // Creating object
  object Main
  {
      // Driver code
      def main(args: Array[String])
      {
          val obj = new geek()
          val o = new obj.g1
          o.method();
          println("b= "+o.b);
      }
  }
  

输出 ：

welcome to inner class g1
a= 1
b= 1