Question

我想以某种方式指定只能从同一个包中定义的后代访问方法。这就像 protected ，但更受限制。

object Some {
  class Base {
    modifier[magic] def test() {
      println("ok")
    }
  }

  class Ok extends Base {
    test()
  }

  class ShouldFail {
    def fail(b : Base) {
      b.test()
    }
  }
}

object Another {
  class ShouldFail extends Some.Base {
    test()
  }
}

这就是我想要的

Answer 1

我有一个解决方案，过于冗长，并且有一些访问受保护方法的开销。

object Some {
  private[Some] class Access[T] private[Some] (aFun : () => T) {
    private[Some] def apply() : T = aFun()
  }
  private[Some] object Access {
    private[Some] def apply[T](aFun : () => T) : Access[T] = new Access(aFun)
  }

  class Base {
    private[this] def test() {
      println("ok")
    }
    protected val accessTest = Access( () => test() )
  }

  class Ok extends Base {
    accessTest()
  }

  class ShouldFail {
    def fail(b : Base) {
      b.accessTest()
    }
  }
}

object Another {
  class ShouldFail extends Some.Base {
    accessTest()
  }
}

这个想法是将方法包装在一个对象中，并在访问修饰符之间链接权限限制，以访问对象和访问对象内部的值。但这会带来开销。

定义只能从同一包中的后代访问的方法

1 个答案: