(Por favor, no se aconseja que debe abstracta X
más y añadir otro método para ello.)java: instanceof y cast combinados?
En C++, cuando tengo una variable x
de tipo y quiero hacer algo específico si también es de tipo Y*
(Y
ser una subclase de X
), estoy escribiendo esto: (¿o es)
if(Y* y = dynamic_cast<Y*>(x)) {
// now do sth with y
}
lo mismo no parece posible en Java.
He leído el código de Java en su lugar:
if(x instanceof Y) {
Y y = (Y) x;
// ...
}
A veces, cuando usted no tiene una variable x
pero es una expresión más compleja en su lugar, simplemente debido a este problema, se necesita una variable ficticia en Java:
X x = something();
if(x instanceof Y) {
Y y = (Y) x;
// ...
}
// x not needed here anymore
(cosa común es que something()
es iterator.next()
Y hay que ver que también no se puede llamar a que sólo dos veces usted realmente necesita la variable ficticia...)
Realmente no necesita x
en absoluto aquí - solo lo tiene porque no puede hacer el control instanceof
de una vez con el yeso. Comparación de nuevo al código bastante común C++:
if(Y* y = dynamic_cast<Y*>(something())) {
// ...
}
Debido a esto, he introducido una función castOrNull
que hace que sea posible para evitar la variable ficticia x
. Puedo escribir esto ahora:
Y y = castOrNull(something(), Y.class);
if(y != null) {
// ...
}
Implementación de castOrNull
:
public static <T> T castOrNull(Object obj, Class<T> clazz) {
try {
return clazz.cast(obj);
} catch (ClassCastException exc) {
return null;
}
}
Ahora, me dijeron que using this castOrNull
function in that way is an evil thing do to. ¿Porqué es eso? (O dicho de la cuestión más general: ¿Está de acuerdo y creo que esto es malo Si es así, ¿por qué tan ¿O usted piensa que esto es un tal vez rara caso válido() utiliza???)
Como se ha dicho , No quiero una discusión sobre si el uso de dicho downcast es una buena idea. Pero quiero aclarar en breve por eso que a veces lo uso:
A veces me meto en el caso en que tengo que elegir entre añadir otro nuevo método para una cosa muy específica (que sólo se aplicará por una sola subclase en una caso específico) o usando tal cheque
instanceof
. Básicamente, tengo la opción entre agregar una funcióndoSomethingVeryVerySpecificIfIAmY()
o hacer la verificacióninstanceof
. Y en tales casos, siento que este último es más limpio.A veces tengo una colección de alguna clase de interfaz/base y para todas las entradas de tipo
Y
, quiero hacer algo y luego eliminarlos de la colección. (Por ejemplo que tenía el caso en que tenía una estructura de árbol y quería borrar todos los del niño que son hojas vacías.)
me gustaría utilizar en lugar de _instanceOf_ _class.cast_ para evitar excepciones innecesarias en _castOrNull_, pero aparte de eso parece que tienes ayudante perfectamente normal. Deje que ** Tom ** aclare lo que quiso decir. –
Si Y es una _superclass_ de X, no necesita ningún tipo de conversión, ¿quiso decir _subclass_? –
Si bien esto no es de una sola línea en Java, el rendimiento de instanceof y casting es bastante bueno. Publicando algunos tiempos en Java7 sobre diferentes enfoques del problema aquí: http://stackoverflow.com/questions/16320014/java-optimization-nitpick-is-it-faster-to-cast-something-and-let-it- throw-excep/28858680 # 28858680 – Wheezil