6

我碰巧发现一个特征中不允许有抽象的私有字段，也就是说，

trait A1 {
    //private val a: Int         // Not allowed
    protected val b: Int         // OK
}

如果私有字段是构造函数参数，那么对抽象类做这样的事情似乎没问题，也就是说，

abstract class A2 (private val i: Int) // OK

所以我猜一个特征没有构造函数参数，所以没有办法初始化它们，因此不允许抽象私有字段。

如果它们是“受保护的”，那么子类可以使用预先初始化的字段来初始化它们。这种方法允许子类看到这些字段。

如果我只想初始化它们并在之后隐藏它们怎么办，如下例所示？

object holding {
    trait trick {
        protected val seed: Int                     // Can't be private
        final def magic: Int = seed + 123
    }

    trait new_trick extends trick {
        def new_magic: Int = magic + 456
        def the_seed: Int = seed                    // [1]
    }

    def play: new_trick = new { val seed = 1 } with new_trick 

    def show_seed(t: new_trick): Int = t.the_seed   // [2]
}

我不希望任何人能够看到种子，也就是说，不应该允许 [2]（因此 [1]）。有没有办法让特质做到这一点？

正如@Randall 和@pagoda_5b 所指出的，我的问题没有多大意义。但幸运的是@Régis 和@axel22 将它变成了另一个有趣的问题，并提供了解决它的模式。

4

2 回答 2

10

在允许子特征初始化它的同时保持 val 私有的一种简单方法是将其定义为私有，但使用另一个受保护方法返回的值对其进行初始化。然后子特征可以定义这个受保护的方法来改变初始值，但不能访问该值本身。所以你会改变这个：

trait A {
  protected val foo: Bar
}

进入： 

trait A {
  private val foo: Bar = initFoo 
  protected def initFoo: Bar
}

现在，只有 traitA可以访问 val foo。子特征可以foo通过定义设置初始值initFoo，但不能访问foo自身：

trait B extends A {
  protected def initFoo: Bar = ???
}

显然，initFoo它本身仍然可以通过子特征访问。initFoo如果每次都创建一个新实例（换句话说，它是一个工厂），这通常不是问题，因为我们可能只对将实例设为私有A而不关心子特征能够创建新的实例Bar （不管新实例是否等于foo按照他们的equals方法）。

但是如果这是一个问题（在你的情况下肯定是seedfo 类型Int，因此你想要隐藏的是一个值而不仅仅是一个引用），我们可以使用一个额外的技巧来允许子特征定义initFoo但防止他们（及其子特征）无法调用它。让我们面对现实吧，这个技巧对于这种简单的需求来说非常糟糕，但它说明了高级访问控制的一个很好的模式。这个想法归功于标准库作者（参见http://www.scala-lang.org/api/current/index.html#scala.concurrent.CanAwait）。

trait A {
  // A "permit" to call fooInit. Only this instance can instantiate InitA
  abstract class InitA private[this]()
  // Unique "permit"
  private implicit def initA: InitA = null

  private def foo: Int = fooInit
  protected def fooInit( implicit init: InitA ): Int
}

trait B extends A {
  protected def fooInit( implicit init: InitA ): Int = 123
}

现在，如果B尝试调用initFoo，编译器将抱怨它找不到隐式类型InitA（唯一的此类实例是A.initA并且只能访问 in A）。

正如我所说，这有点糟糕，并且 axel22 提供的包私有解决方案肯定是一个更容易的选择（尽管它不会阻止任何人在与您相同的包中定义他们的子特征，从而克服访问限制）。

于 2013-04-05T16:49:51.547 回答
6

你能做的最好的就是将这些包声明为私有 - private[package_name]。这将允许您在执行实现的同一包中扩展和定义特征，但不允许客户端从其他包中使用它。

于 2013-04-05T14:38:22.753 回答