0

我正在尝试将一堆方法从一个类导入另一个类而不扩展它。我已经成功了，但为什么一种方法有效而另一种方法无效，这超出了我的理解。

剥离下来，这就是我想要做的

class A {def x() {println("x")}}
object A

class B {
   import A._
   def y() {x()}
}

编译器告诉我“未找到：值 x”

但如果我这样做，它会起作用

class C extends A

class B {
   import C._

或者如果我这样做

object C extends A

class B {
   import C._

有人可以解释为什么会这样吗？

4

2 回答 2

3

您的代码示例class C extends A不起作用的原因是您导入了只能存在于它们定义的类中的类成员。

而当您编写时，object C extends A您将创建一个单例（在 Scala 中称为 object like 关键字），它表示一个实例并允许您导入其成员。

因此，要使其他类的成员可见，您总是必须通过对象或另一个类/特征来扩展它们。声明一个类的伴生对象是不够的，因为它不包含其伴生类的实例。

于 2012-06-15T15:57:31.873 回答
0

还有使用隐式的可能性。

您需要有一种从 B 的实例到所需的 A 实例的方法。在下面的示例中，我使用了成员值，但也应该可以将其设为函数。

暴露的特征将 B 中的 this 暴露给 A 中声明的隐式。特征 PathTo 可用于暴露 A 的所需实例的路径。

class A {
  def a1(){ println("a1") };
  def a2(){ println("a2") };
  def a3(){ println("a3") };
}
object A{
    def a1()(implicit a:A){a.a1};
    def a2()(implicit a:A){a.a2};
    def a3()(implicit a:A){a.a3};

    //makes it possible to use a1() instead of a1()(this.a)
    implicit def insertPathToA(implicit path:PathTo[A]):A=path.pathTo;

    // Makes it possible to write this.a2() instead of this.a.a2();
    implicit def convertPathToA(path:PathTo[A]):A=path.pathTo;
};

trait exposed[U]{
    implicit def self:U=this.asInstanceOf[U];
}

trait PathTo[U]{
    implicit def pathTo:U;
}

class B(val a:A) extends exposed[B] with PathTo[A] {
    // imports the magic
    import A._

    override def pathTo:A=a;

    def y() {
       a1() ;
       this.a2();
   };
}
于 2014-01-29T17:42:43.877 回答