Question

我正在尝试将一堆方法从一个类导入到另一个类而不扩展它。我已经成功了，但是为什么一种方法有效，另一种方法不适合我。

剥离，这是我正在尝试做的事情

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._

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

Answer 1

您的代码示例class C extends A无效的原因是您导入的类成员只能存在于定义的类中。

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

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

Answer 2

还有使用隐含的可能性。

您需要有办法从B的实例到达所需的实例答：在下面的示例中，我使用了成员值，但应该可以进行它也是一个功能。

暴露的特征将B中的特征暴露给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();
   };
}

用于导入所有方法的Scala对象

2 个答案: