Qual è il caso d'uso dei costruttori secondari nelle classi astratte?

Question

Considerate questo codice:

abstract class Foo(val s: String) { 
    def this(i: Int) = this("" + (i+2)) 
} 

Per quanto ho capito i costruttori non sono ereditate e costruttori secondarie non possono essere chiamati da sottoclassi con super come in Java.

Sono solo un artefatto inutile o esiste un caso d'uso ragionevole per questo costrutto?

Answer 1

scala> object Bar extends Foo(3) 
defined module Bar 

scala> Bar.s 
res3: String = 5 

Answer 2

Il costruttore principale della sottoclasse deve chiamare uno dei costruttori della superclasse, non necessariamente quello principale.

abstract class A(s: String) { 
    def this(i: Int) = this(i.toString) 
} 
class B(i: Int) extends A(i) 

Answer 3

Oltre alla risposta di @ coubeatczech, è anche possibile creare istanze di classi astratte (e tratti) se si aggiunge una raffinatezza,

scala> :paste 
// Entering paste mode (ctrl-D to finish) 

abstract class Foo(val s: String) { 
    def this(i: Int) = this("" + (i+2)) 
} 

// Exiting paste mode, now interpreting. 

defined class Foo 

scala> val f = new Foo(23) {} 
f: Foo = $anon$1@13d874e 

scala> f.s 
res3: String = 25 

anche se ho mostrare una raffinatezza vuoto sopra (" {} ") di solito fornisci alcune definizioni aggiuntive, spesso fornendo implementazioni per membri astratti,

scala> abstract class Bar { def bar : Int } 
defined trait Bar 

scala> val b : Bar = new Bar { def bar = 23 } 
b: Bar = $anon$1@1e17c6d 

scala> b.bar 
res1: Int = 23