Scala 可见性

最新推荐文章于 2021-12-30 00:04:16 发布

原创最新推荐文章于 2021-12-30 00:04:16 发布 · 置顶 · 7.7w 阅读

0 ·

CC 4.0 BY-SA版权

Scala 专栏收录该内容

20 篇文章

订阅专栏

Scala public protected private 作用域

1 Public可见性

2 Protected可见性

3 Private可见性

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

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

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

https://www.cbedai.net/u014646662

Scala程序设计第2版 - 原版.pdf 下载：https://download.youkuaiyun.com/download/u014646662/10805074

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

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
  }
}