java - unir - scala ejemplos

En Scala, ¿cómo puedo subclasificar una clase Java con múltiples constructores?

Question

Supongamos que tengo una clase Java con múltiples constructores:

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

¿Cómo puedo extenderlo en Scala y todavía proporcionar acceso a los tres constructores de Base? En Scala, una subclase solo puede llamar a uno de los constructores de su superclase. ¿Cómo puedo evitar esta regla?

Supongamos que la clase Java es un código heredado que no puedo cambiar.

Answer 1

Es fácil olvidar que un rasgo puede extender una clase. Si usa un rasgo, puede posponer la decisión de qué constructor llamar, de esta manera:

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

Puede que los rasgos no tengan parámetros de constructor, pero puede solucionarlos utilizando miembros abstractos.

Answer 2

Escogería la más genérica (en este caso, Cadena) y realizaría la conversión interna usted mismo si cumple con los otros criterios.

Aunque admito que esta no es la mejor solución y algo me parece erróneo al respecto. :-(

Answer 3

Esta es una respuesta tonta que probablemente funcionaría un poco, pero podría ser demasiado esfuerzo si la clase Java tiene demasiados constructores, pero:

Escriba una subclase en Java que implemente un constructor que tome todas las entradas de los otros constructores y llame al constructor apropiado de su superclase en función de la presencia o ausencia de entradas (mediante el uso de "nulo" o algún tipo de valores centinela), luego subclase esa clase Java en Scala y asigne los valores centinela como parámetros predeterminados.

Answer 4

EDITAR - esto es de una pregunta en la lista de correo de scala que pensé que estaba duplicada aquí. Mi respuesta se refiere a proporcionar tres constructores diferentes (es decir, replicar el diseño de Java) y no extender la clase

Suponiendo que cada uno de sus constructores finalmente cree el estado S del objeto, cree un objeto complementario con métodos "estáticos" para crear este estado.

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")
}

A continuación, cree un constructor privado que tome el estado y los constructores sobrecargados (públicos) que difieren del constructor principal.

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