Scala 可见性

￡神魔★判官ぃ 2022-04-15 06:12 253阅读 0赞

# Scala public protected private 作用域 #

1 Public可见性

2 Protected可见性

3 Private可见性

4 作用域内私有和作用域内受保护可见性

对人工智能感兴趣的同学，可以点击以下链接：

[现在人工智能非常火爆，很多朋友都想学，但是一般的教程都是为博硕生准备的，太难看懂了。最近发现了一个非常适合小白入门的教程，不仅通俗易懂而且还很风趣幽默。所以忍不住分享一下给大家。点这里可以跳转到教程。][Link 1]

[https://www.cbedai.net/u014646662][Link 1]

Scala程序设计 第2版 - 原版.pdf 下载：[https://download.csdn.net/download/u014646662/10805074][https_download.csdn.net_download_u014646662_10805074]

<table> 
 <tbody> 
 <tr> 
 <td style="vertical-align:bottom;width:98pt;">可见性名称</td> 
 <td style="vertical-align:bottom;width:98pt;">关键字</td> 
 <td style="text-align:center;vertical-align:bottom;">描述</td> 
 </tr> 
 <tr> 
 <td style="vertical-align:bottom;">public</td> 
 <td style="vertical-align:bottom;">无关键字</td> 
 <td style="vertical-align:bottom;">任何作用域内均能访问公有成员或公有类型，public 可见性无视所有限制</td> 
 </tr> 
 <tr> 
 <td style="vertical-align:bottom;">protected</td> 
 <td style="vertical-align:bottom;">protected</td> 
 <td style="vertical-align:bottom;">受保护（protected）成员对本类型、继承类型以及嵌套类型可见。而受保护的类型则只对相同包内或子包内的某些类型可见</td> 
 </tr> 
 <tr> 
 <td style="vertical-align:bottom;">private</td> 
 <td style="vertical-align:bottom;">private</td> 
 <td style="vertical-align:bottom;">私有（private）成员只对本类型和嵌套类型可见，而且可以访问私有成员的类型必须位于相同包内</td> 
 </tr> 
 <tr> 
 <td style="vertical-align:bottom;">作用域内受保护</td> 
 <td style="vertical-align:bottom;">protected[scope]</td> 
 <td style="vertical-align:bottom;"> 只能在某一作用域内可见，该作用域可以是包作用域、类型作用域或this 作用域 （这意味着如果成员使用了该可见性，this 代表了相同实例，如果类型使用该可见性，则this 表示该类型所在的包）。 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:bottom;">作用域内私有</td> 
 <td style="vertical-align:bottom;">private[scope]</td> 
 <td style="vertical-align:bottom;">除了对具有继承关系的类的可见性不同之外，与作用域内受保护可见性相同</td> 
 </tr> 
 </tbody> 
</table>

## 1 Public可见性 ##

对于任何声明体，如果未指定可见性，它们对应的可见性关键字便默认为public，这意味着在任何作用域中，该声明体均可见。Scala 未提供public 关键字，这与Java 截然不同。

package cn.com.tengen.test.obj
    
    import cn.com.tengen.test.obj.scopeC.C3
    
    package scopeA{
      class C1(var a:Int){
        var b:String = "a"
        def f ={
          println(a + " " + b)
        }
      }
    }
    
    package scopeB{
      class C2(var a:Int){
        var b:String = "b"
    
        def f ={
          println(a + " " + b)
        }
      }
    }
    
    package scopeC{
    
    
      class C3(){
    
        def f = {
          var c1:cn.com.tengen.test.obj.scopeA.C1 = new scopeA.C1(1)
         c1.b = c1.b+"a"
         c1.f
          var c2:cn.com.tengen.test.obj.scopeB.C2 = new scopeB.C2(2)
          c2.b = c2.b+"B"
         c2.f
        }
      }
    }
    
    class Test {
      def f ={
        var c3 = new C3()
        c3.f
      }
    }
    
    object Test extends App {
      var t =  new Test()
      t.f
    }
    
    
    输出结果：
    1 aa
    2 bB

C3与C1、C2不在同一个包，之间没有继承关系，C3仍可以访问C1和C2的属性和方法，因为C1和c2的属性和方法都是public

## 2 Protected可见性 ##

package cn.com.tengen.test.obj
    
    package scopeA{
      class C1(var a:Int){
        protected var b:String = "a"
        def f ={
          println(a + " " + b)
        }
      }
    }
    
    package scopeB{
      class C2(var a:Int){
        protected var b:String = "b"
    
        def f ={
          println(a + " " + b)
        }
      }
    
    
      class C3(){
    
        def f = {
          val c1:cn.com.tengen.test.obj.scopeA.C1 = new scopeA.C1(1)
          c1.a = 11
          c1.b = c1.b+"a"   //编译出错
          c1.f
          val c2:cn.com.tengen.test.obj.scopeB.C2 = new scopeB.C2(2)
          c2.a = 22
          c2.b = c2.b+"B"  //编译出错
          c2.f
    
          //protected 同包内可以访问
          val c5 = new C5(5);
          c5.a = 55
          c5.b = c5.b+"d"
          c5.f
        }
      }
    
      protected class C5(var a:Int){
        var b:String = "d"
        def f ={
          println(a + " " + b)
        }
      }
    }
    
    //protected 子类可以访问
    package scopeC{
      class C4(a:Int) extends scopeA.C1(a){
        this.a = 4
        this.b = "d"
      }
    
    }
    
    class Test {
      def f ={
        var c4 = new scopeC.C4(1)
        c4.a
        c4.f
        c4.b  //编译出错
      }
    
      def  f1 ={
        //protected 不同包内不可以访问
        val c5 = new scopeB.C5(5)//编译出错
        c5.a = 55
        c5.b = c5.b+"d"
        c5.f
      }
    }
    
    object Test extends App {
      var t =  new Test()
      t.f
    }

对于被protected修饰的，只能同包和子类可以访问

## 3 Private可见性 ##

私有（private）可见性将实现细节完全隐藏起来，即便是继承类的实现者也无法访问这些细节。声明中包含了private 关键字的所有成员都只对定义该成员的类型可见，该类型的其他实例也能访问这些成员。如果类型被声明为私有可见性类型，那么该类型的可见性将被限定到包含该类型的包内：

package cn.com.tengen.test.obj
    
    class PriTest1{
      private var a = 1;
      var b = "a"
    
      //可以本类内的private 成员（包括属性、方法、类）
      def f = {
        f1
        val p2 = new PriTest2()
        p2.f
        //p2.c = 0 //编译出错
        println(a + " " + b)
      }
    
      private def f1 = {
        a = a+1
      }
    
      private class PriTest2{
        private var c = 1
        def f = {
          b = b + "：PriTest2"
        }
      }
    }
    
    
    
    class Test1 {
    
      def f ={
        val p1 = new PriTest1()
        p1.f
    //    val p2 = new p1.PriTest2() //编译出错
    //    p2.f
        println(p1.b)
    //    p1.a = p1.a + 1 //编译出错
    //    p1.b =  p1.b + "Test1 "
    //    p1.f
    //    p1.f1 //编译出错
      }
    }
    
    object Test1 extends App{
    
      val t = new Test1()
      t.f
    
    }

对于被private修饰的只能被当前对象访问

## 4 作用域内私有和作用域内受保护可见性 ##

Scala 为用户提供了一些额外方法，以帮助用户以更小的粒度对可见性的作用域进行调整。从这一点看，Scala 超过了大多数的语言。Scala 提供了作用域内私有（scoped private）可见性声明和作用域内受保护（scoped protected）可见性声明。请注意，在具有继承关系的情况下，对类成员应用这两类可见性后表现不同。但除此之外，这两类可见性的表现完全一致，因此在同一个作用域内，私有可见性可以和受保护可见性交换使用。

package scopeA {
      class C1 {
        private[scopeA] val scopeA_privateField = 1
        protected[scopeA] val scopeA_protectedField = 2
        private[C1] val c1_privateField = 3
        protected[C1] val c1_protectedField = 4
        private[this] val this_privateField = 5
        protected[this] val this_protectedField = 6
      }
      class C2 extends C1 {
        val field1 = scopeA_privateField
        val field2 = scopeA_protectedField
    //    val field3 = c1_privateField // 错误
        val field4 = c1_protectedField
    //    val field5 = this_privateField // 错误
        val field6 = this_protectedField
      }
    }
    package scopeB {
      class C3 extends scopeA.C1 {
    //    val field1 = scopeA_privateField // 错误
        val field2 = scopeA_protectedField
    //    val field3 = c1_privateField // 错误
        val field4 = c1_protectedField
    //    val field5 = this_privateField // 错误
        val field6 = this_protectedField
      }
    }

[Link 1]: https://www.cbedai.net/u014646662
[https_download.csdn.net_download_u014646662_10805074]: https://download.csdn.net/download/u014646662/10805074