[6] - 类和对象之进阶（二）

2016-05-31 本文已影响224人牛肉圆粉不加葱

Scala 中的可见性非常灵活且复杂，这篇文章希望通过大量的示例来说清楚各种情况下的可见性是怎么样的。

默认可见性

Scala 中的默认可见性为 public，所谓默认即你没有在类或者成员前显示加 private 或 protected 可见性关键字。虽然默认可见性为 public，但这是逻辑上的，实际上 Scala 中并没有 public 这个关键字，如果你用 public 来声明一个类或成员，编译器会报错。

可见性作用域

在 Scala 中，可以在类型的 class 或 trait 关键字之前、字段的 val 或 var 之前，方法定义的 def 关键字之前指定可见性。

公有可见性

对于公有可见性，任何作用域内都可以访问公有成员或公有类型。

Protected 可见性

对于受保护可见性，用 protected 声明，受保护成员对本类型、继承类型可见。而受保护的类型则只对包含该类的包内可见。

下面例子是关于 protected 成员的：

package P1 {
  class C1 {
    protected val c = 0

    //< 受保护可见性中,嵌套类可访问 protected 成员
    class C11 {
      println( c )
    }
  }

  package P11 {
    //< 继承类客房为父类 protected 成员
    class C1Child extends C1 {
      println( c )
    }
  }

}

package P2 {
  //< 继承类客房为父类 protected 成员
  class C2Child extends P1.C1 {
    println( c )
  }
}

接下来是 protected 类型的：

package P1 {
  protected class C1 {
  }

  //< 对于 protected 类型,相同包内可见
  class C1Child extends C1 {
  }

  package P11 {
    //< 对于 protected 类型,子包内可见
    class C11Child extends C1 {
    }
  }
}

package P2 {
//< 对于 protected 类型,外部包不可见
  class C2Child extends P1.C1 {
  }
}

编译报错如下，这是因为 protected 类型只在包含该类的包内可见

Error:(22, 28) class C1 in package P1 cannot be accessed in package P1
 Access to protected class C1 not permitted because
 enclosing package P2 is not a subclass of 
 package P1 where target is defined
  class C2Child extends P1.C1 {
                           ^

私有可见性

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

package P1 {
  class C1 {
    private val c = 0
  }

  //< 对于 private 类型,相同包内的子类都不可见
  class C1Child extends C1 {
    println( c )
  }
}

package P2 {
  //< 对于 private 类型,外部包内的子类也不可见
  class C2Child extends P1.C1 {
    println( c )
  }
}

编译报错：

Error:(12, 14) value c in class C1 cannot be accessed in P1.C1Child
    println( c )
             ^

Error:(19, 14) value c in class C1 cannot be accessed in P2.C2Child
    println( c )
             ^

另外，嵌套类中的私有成员也是无法访问的。在私有可见性中，私有类型只在包含该类型的包中可见，在子包或外部包中均不可见。我们用下面的例子进一步说明，具体说明见代码中的注释：

package P1 {
  private class C1

  class C11 extends C1            //< 错误,这样相当于变相改变了C1的可见性,子包和外部包都能访问C11,也就间接能访问C1
  protected class C12 extends C1  //< 错误这样相当于变相改变了C1的可见性,子包能访问C11,也就间接能访问C1
  private class C13 extends C1    //< 正确,由于C13也为 private,是的C1的 private 可见性不会

  class C14 {
    val c14_1 = new C1            //< 正确,私有类型在其所在包内可见
  }
}

package P2 {

  //< 对于私有类型,外部包内不可见
  class C2 {
    val c1 = new P1.C1
  }
}

编译报错：

Error:(8, 21) private class C1 escapes its defining scope as part of type P1.C1
  class C11 extends C1            //< 错误
                    ^

Error:(9, 31) private class C1 escapes its defining scope as part of type P1.C1
  protected class C12 extends C1  //< 错误
                              ^

Error:(22, 21) class C1 in package P1 cannot be accessed in package P1
    val c1 = new P1.C1
                    ^

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

所谓作用域内私有/受保护可见性，就是你可以更细粒度指定某个类或某个成员在某个作用域（可以是包或类）私有或受保护可见性

成员在类和包中的 private/protected 可见性
该可见性可以有16种组合，下面的例子列举除了这些组合：

package P1 {
  class C1 {
    private[C1] val m1 = 1
    private[this] val m2 = 2
    private[P1] val m3 = 3
    private[P2] val m4 = 4

    protected[C1] val n1 = 1
    protected[this] val n2 = 2
    protected[P1] val n3 = 3
    protected[P2] val n4 = 4

    //< 不管什么样的作用域内 private 或 protected,在自身类中都是可见的
    println( m1 )
    println( m2 )
    println( m3 )
    println( m4 )

    println( n1 )
    println( n2 )
    println( n3 )
    println( n4 )
  }

  class C11 extends C1 {
    println( m1 )   //< 1, 错误
    println( m2 )   //< 2, 错误
    println( m3 )   //< 3, 正确
    println( m4 )   //< 4, 正确

    println( n1 )   //< 5, 正确
    println( n2 )   //< 6, 正确
    println( n3 )   //< 7, 正确
    println( n4 )   //< 8, 正确
  }
}

package P2 {
  class C21 extends P1.C1 {
    println( m1 )   //< 9, 错误
    println( m2 )   //< 10, 错误
    println( m3 )   //< 11, 错误
    println( m4 )   //< 12, 正确

    println( n1 )   //< 13, 正确
    println( n2 )   //< 14, 正确
    println( n3 )   //< 15, 正确
    println( n4 )   //< 16, 正确
  }
}

下面我们对每一项进行解释，并穿插介绍一些规则：

private[C1]指定成员在自身类作用域 private，在该类所在的包内和包外均不可见（9也是这个道理）
private[this]比 private[C1]更加严格，前者只对相同实例可见，相同类的不同实例都不可见；而后者对相同类的不同实例也可见
private[P1]指定在包 P1 内 private，则在 P1 包中的类中均可见，而在 P1外的包均不可见
private[P2]指定在包 P2 内 private，则在包 P2 及该类所在包内均可见
protected[C1]指定在 C1 中 protected，则在 C1 所在包内的继承类及外部包内所在的继承类均可见
同5
protected[P1]指定在包 P1 内 protected，在 P1 包内的 C1 继承类及 P1 外的包内的继承类可见
protected[P1]指定在包 P2 内 protected，在 P1 包内的 C1 继承类及 P1 外的包内的继承类可见
见1
见2
见3
见4
见5
见6
见7
见8

类型在类和包中的 private/protected 可见性
类型的情况就会少一点：

package P1 {

  private[P1] class C1
  protected[P1] class C2

  package P11 {
    private[P1] class C3
    protected[P1] class C4
    private[P11] class C5
    protected[P11] class C6
  }


  class C11 extends C1  //< 1, 正确
  class C12 extends C2  //< 2, 正确

  import P11._
  class C13 extends C3  //< 3, 正确
  class C14 extends C4  //< 4, 正确
  class C15 extends C5  //< 5, 错误
  class C16 extends C6  //< 6, 正确
}

package P2 {
  import P1._
  import P1.P11._


  class C21 extends C1  //< 7, 错误
  class C22 extends C2  //< 8, 正确

  class C23 extends C3  //< 9, 错误
  class C24 extends C4  //< 10, 正确
  class C25 extends C5  //< 11, 错误
  class C26 extends C6  //< 12, 正确
}

从上面的例子我们可以得出以下结论：

对于 private[package] 声明的类型，在 package 包内及 package 子包内可见；在外部包内不可见
对于 protected[package] 声明的类型，在 package 包内、package 子包内及外部包均可见
有包 package 的子包为 package1，对于 private[package1]，在 package1 包内、package1 子包及其父包即 package 内可见，在外部包不可见
有包 package 的子包为 package1，对于 protected[package1]，在 package1包内、package1子包、package1父包及外部包可见

**传送门: **Scala 在简书目录

欢迎关注我的微信公众号：FunnyBigData

FunnyBigData