Il metodo astratto Scala è nullo nella superclasse quando la sottoclasse lo implementa usando val?

Question

Ho trovato un errore nel mio codice di scala, che mi lascia perplesso. Di seguito è una versione semplificata del problema.

Nel costruttore di una classe astratta, voglio verificare alcune affermazioni sui metodi astratti. Così, quando viene creato un oggetto di una sottoclasse, questi assert sono controllati, per vedere se tutto è implementato come dovrebbe.

va male quando la sottoclasse implementa un metodo astratto utilizzando un "val", tuttavia: il codice

Scala:

abstract class A { 
    def aval : String 
    assert(aval != null, "aval == null") 
    assert(aval == "B", "aval: "+aval) 
} 

class B extends A { 
    def aval = "B" 
} 

class C extends A { 
    val aval = "B" 
} 

object VariousScalaTests { 
    def main(args : Array[String]) : Unit = { 
     val b = new B 
     val c = new C 
    } 
} 

Scala Errore:

Exception in thread "main" java.lang.AssertionError: assertion failed: aval == null 
    at scala.Predef$.assert(Predef.scala:92) 
    at A.<init>(VariousScalaTests.scala:4) 
    at C.<init>(VariousScalaTests.scala:12) 
    at VariousScalaTests$.main(VariousScalaTests.scala:19) 
    at VariousScalaTests.main(VariousScalaTests.scala) 

Quindi non riesce a ultima riga di codice: "val c = new C". La classe B funziona perfettamente, ma la classe C no! L'unica differenza è che C implementa aval usando "val" e B usando "def".

Quindi la mia domanda, soprattutto, perché questa differenza? Non capisco cosa sta succedendo.

E c'è un modo per farlo funzionare come voglio in entrambi i casi in scala? O sto semplicemente perdendo un modo più elegante per affermare ciò che voglio in scala?

Answer 1

Questo codice Java equivalente dovrebbe spiegare il problema:

public abstract class A { 
    public String aval(); 
} 

public class B extends A { 
    public String aval() { 
     return "B"; 
    } 
} 

public class C extends A { 
    private String _aval; 

    public C() { 
     _aval = "B"; 
    } 

    public String aval() { 
     return _aval; 
    } 
} 

Quando si esegue

val c = new C 

il costruttore di A piste prima il costruttore del C e il campo _aval non è stato assegnato ancora. Quindi il metodo aval() restituisce null (il valore iniziale del campo _aval). Ma in

val b = new B 

non esiste alcun problema.

In generale, you should try to avoid calling virtual methods from a constructor.

And is there a way to make it work as I want in both cases in scala?

Vedi this question per alcuni approcci.

Answer 2

In Scala è possibile utilizzare le definizioni primi funzione per causare la val di sottoclasse inizializzato prima costruttore eccellente si chiama:

class C extends { 
    val aval = "B" 
} with A