Dans Scala, comment puis-je sous-classer une classe Java avec plusieurs constructeurs?

Supposons que j’ai une classe Java avec plusieurs constructeurs:

class Base { Base(int arg1) {...}; Base(Ssortingng arg2) {...}; Base(double arg3) {...}; } 

Comment puis-je l’étendre dans Scala et toujours permettre l’access aux trois constructeurs de Base? Dans Scala, une sous-classe ne peut appeler qu’un des constructeurs de sa super classe. Comment puis-je contourner cette règle?

Supposons que la classe Java soit un code hérité que je ne peux pas modifier.

Il est facile d’oublier qu’un trait peut étendre une classe. Si vous utilisez un trait, vous pouvez reporter la décision de quel constructeur appeler, comme ceci:

 trait Extended extends Base { ... } object Extended { def apply(arg1: Int) = new Base(arg1) with Extended def apply(arg2: Ssortingng) = new Base(arg2) with Extended def apply(arg3: Double) = new Base(arg3) with Extended } 

Les caractères peuvent ne pas avoir eux-mêmes de parameters de constructeur, mais vous pouvez contourner ce problème en utilisant des membres abstraits.

EDITil s’agit d’une question sur la liste de diffusion scala que je pensais avoir été dupliquée ici. Ma réponse concerne la fourniture de trois constructeurs différents (c.-à-d. La réplication de la conception Java), sans extension de la classe.

En supposant que chacun de vos constructeurs crée finalement l’ état S de l’object, créez un object compagnon avec des méthodes “statiques” pour créer cet état

 object Base { private def stateFrom(d : Double) : S = error("TODO") private def stateFrom(s : Str) : S = error("TODO") private def stateFrom(i : Int) : S = error("TODO") } 

Ensuite, créez un constructeur privé prenant l’état et les constructeurs (publics) surchargés qui se reportent au constructeur principal

 import Base._ class Base private(s : S) { //private constructor takes the state def this(d : Double) = this(stateFrom(d)) def this(str : Ssortingng) = this(stateFrom(str)) def this(i : Int) = this(stateFrom(i)) //etc } 

Ceci est une réponse idiote qui fonctionnerait probablement un peu mais qui pourrait être trop compliquée si la classe Java a beaucoup trop de constructeurs, mais:

Ecrire une sous-classe en Java qui implémente un constructeur qui prend toutes les entrées des différents constructeurs et appelle le constructeur approprié de sa super-classe en fonction de la présence ou de l’absence d’entrées (via l’utilisation de “null” ou une sorte de valeur sentinelle), puis sous-classe cette classe Java dans Scala et atsortingbuez les valeurs de la sentinelle comme parameters par défaut.

Je choisirais le plus générique (dans ce cas, Ssortingng) et effectuer la conversion interne si elle répond aux autres critères.

Bien que j’admette que ce n’est pas la meilleure solution et que quelque chose me semble erroné. 🙁