Olası Java yöntemleri Scala özellikleri uygulanan çağırmak için değil sanırım, ya da orada bir yol var mı?

Ben Scala olarak varsayalım:

trait Trait {
  def bar = {}
}

ve Java olarak eğer kullanırsam

class Foo implements Trait {
}

Java Trait is not abstract and does not override abstract method bar() in Trait yakınıyor

Cevap

Java açıdan Trait.scala Trait derlenmişarayüzü. Dolayısıyla Java Trait uygulama hata mesajları açık hale getiren bir arayüz - uygulama olarak yorumlanır. Kısa cevap: bu Java'da çoklu kalıtım sağlayacak çünkü Java özelliği uygulamaları yararlanmak, olmaz (!)

Scala nasıl uygulanır?

Scala olarak nasıl çalışır? bu kadar uzun cevap: Oluşturulan koduna bakarak aşağıdaki kodu bulabilirsiniz/sınıflar:

interface Trait {
    void bar();
}

abstract class Trait$class {
    public static void bar(Trait thiz) {/*trait implementation*/}
}

class Foo implements Trait {
    public void bar() {
        Trait$class.bar(this);  //works because `this` implements Trait
    }
}

• Trait bir arabirim
• Özet Trait$class (Trait.class ile karıştırmayın) sınıf teknik olarak yapan şeffaf bir şekilde oluşturulurdeğilTrait arabirim uygulamak. Ancak static bar() yöntem Trait değişken olarak örnek (this çeşit kullanımı var
• Foo Trait arabirimi uygular
• scalac otomatik olarak Trait$class temsilciliği tarafından Trait yöntemleri uygular. Bu aslında Trait$class.bar(this) demek oluyor.

Trait$class ne Foo üyesi, ne de Foo uzatmak unutmayın. Sadece this geçirerek delegeler.

Birden çok özellikleri karıştırma

Scala nasıl çalıştığı hakkında anlatılanlar devam etmek... ... olmak kolay birden çok özellikleri karıştırma altında nasıl çalıştığını hayal etmek mümkün " dedi

trait Trait1 {def ping(){}};
trait Trait2 {def pong(){}};
class Foo extends Trait1 with Trait2

çeviren:

class Foo implements Trait1, Trait2 {
  public void ping() {
    Trait1$class.ping(this);    //works because `this` implements Trait1
  }

  public void pong() {
    Trait2$class.pong(this);    //works because `this` implements Trait2
  }
}

Birden çok özellikleri aynı yöntem geçersiz kılma

Şimdi kolay birden çok özellikleri karıştırma nasıl aynı yöntem geçersiz kılma hayal edemiyorum.:

trait Trait {def bar(){}};
trait Trait1 extends Trait {override def bar(){}};
trait Trait2 extends Trait {override def bar(){}};

Yine Trait1 Trait2 arayüzler Trait uzanan olacak. Eğer Trait2 Foo tanımlanması en son ne zaman gelirse artık:

class Foo extends Trait1 with Trait2

alırsınız:

class Foo implements Trait1, Trait2 {
    public void bar() {
        Trait2$class.bar(this); //works because `this` implements Trait2
    }
}

Ancak Trait1 ve Trait2 (Trait1 en son yapmak) geçiş neden olur:

class Foo implements Trait2, Trait1 {
    public void bar() {
        Trait1$class.bar(this); //works because `this` implements Trait1
    }
}

Tercümesi değişiklikler

Tercümesi değişiklikler gibi özelliklerin nasıl çalıştığını düşünün. Hayal gerçekten yararlı bir sınıf Foo sahip:

class Foo {
  def bar = "Foo"
}

istediğiniz bazı yeni işlevler kullanma özellikleri ile zenginleştirme:

trait Trait1 extends Foo {
  abstract override def bar = super.bar   ", Trait1"
}

trait Trait2 extends Foo {
  abstract override def bar = super.bar   ", Trait2"
}

Burada '' steroid: . Foo yeni

class FooOnSteroids extends Foo with Trait1 with Trait2

İçin bizimle iletişime geçiniz

Trait1

interface Trait1 {
  String Trait1$$super$bar();
  String bar();
}
abstract class Trait1$class {
  public static String bar(Trait1 thiz) {
    // interface call Trait1$$super$bar() is possible
    // since FooOnSteroids implements Trait1 (see below)
    return thiz.Trait1$$super$bar()   ", Trait1";
  }
}

Trait2

public interface Trait2 {
  String Trait2$$super$bar();
  String bar();
}
public abstract class Trait2$class {
  public static String bar(Trait2 thiz) {
    // interface call Trait2$$super$bar() is possible
    // since FooOnSteroids implements Trait2 (see below)
    return thiz.Trait2$$super$bar()   ", Trait2";
  }
}

FooOnSteroids

class FooOnSteroids extends Foo implements Trait1, Trait2 {
  public final String Trait1$$super$bar() {
    // call superclass 'bar' method version
    return Foo.bar();
  }

  public final String Trait2$$super$bar() {
    return Trait1$class.bar(this);
  }

  public String bar() {
    return Trait2$class.bar(this);
  }      
}

Bütün dualar şunlardır: yığın

• 'bar' yöntemi örneği (giriş noktası) FooOnSteroids;
• Trait2$sınıfın '' statik yöntemi, argüman olarak geçen ve bir birleştirme dönen Trait2$$'süper bar$()' ve "Trait2"; . yöntem çağrısı dize bar
• Trait2$$'süper bar$() çağıran bir' FooOnSteroids örneği ...
• Trait1$sınıfın '' statik yöntemi, argüman olarak geçen ve bir birleştirme dönen Trait1$$'süper bar$()' ve "Trait1"; . yöntem çağrısı dize bar
• Trait1$$'süper bar' FooOnSteroids çağırıyor . örnek$
• orijinal Foo 'bar' yöntemi

Ve sonuç", Trait1, Trait2 Foo".

Sonuç

Eğer her şeyi okumak için idare ettik, asıl soruya cevap ilk dört satır