Como emular C # como operador em Java
Pergunta
Há situações, onde é prático ter um tipo-cast retornar um valor nulo em vez de jogar um ClassCastException. C # tem o operador as
para fazer isso. Existe algo equivalente disponível em Java, assim você não tem que verificar explicitamente a ClassCastException?
Solução
Aqui está uma implementação de como, como sugerido por @Omar Kooheji:
public static <T> T as(Class<T> clazz, Object o){
if(clazz.isInstance(o)){
return clazz.cast(o);
}
return null;
}
as(A.class, new Object()) --> null
as(B.class, new B()) --> B
Outras dicas
Eu acho que você tem que rolar seus próprios:
return (x instanceof Foo) ? (Foo) x : null;
EDIT: Se você não quer que seu código de cliente para lidar com valores nulos, então você pode introduzir um Null objeto
interface Foo {
public void doBar();
}
class NullFoo implements Foo {
public void doBar() {} // do nothing
}
class FooUtils {
public static Foo asFoo(Object o) {
return (o instanceof Foo) ? (Foo) o : new NullFoo();
}
}
class Client {
public void process() {
Object o = ...;
Foo foo = FooUtils.asFoo(o);
foo.doBar(); // don't need to check for null in client
}
}
Você pode usar a palavra-chave instanceof
no lugar de is
's C #, mas não há nada como as
.
Exemplo:
if(myThing instanceof Foo) {
Foo myFoo = (Foo)myThing; //Never throws ClassCastException
...
}
Você poderia escrever um método utilitário estático como este. Eu não acho que é terrivelmente legível, mas é a melhor aproximação do que você está tentando fazer. E se você usar importações estáticas não seria muito ruim em termos de legibilidade.
package com.stackoverflow.examples;
public class Utils {
@SuppressWarnings("unchecked")
public static <T> T safeCast(Object obj, Class<T> type) {
if (type.isInstance(obj)) {
return (T) obj;
}
return null;
}
}
Aqui está um caso de teste que demonstra como funciona (e que ela não funciona.)
package com.stackoverflow.examples;
import static com.stackoverflow.examples.Utils.safeCast;
import static junit.framework.Assert.assertNotNull;
import static junit.framework.Assert.assertNull;
import org.junit.Test;
public class UtilsTest {
@Test
public void happyPath() {
Object x = "abc";
String y = safeCast(x, String.class);
assertNotNull(y);
}
@Test
public void castToSubclassShouldFail() {
Object x = new Object();
String y = safeCast(x, String.class);
assertNull(y);
}
@Test
public void castToUnrelatedTypeShouldFail() {
Object x = "abc";
Integer y = safeCast(x, Integer.class);
assertNull(y);
}
}
Em java 8 você também pode usar sintaxe de fluxo com Opcional:
Object o = new Integer(1);
Optional.ofNullable(o)
.filter(Number.class::isInstance)
.map(Number.class::cast)
.ifPresent(n -> System.out.print("o is a number"));
Estou especulando que poderia propably CREAS um como operador
algo como
as<T,Type> (left, right)
which evaluates to
if (typeof(left) == right)
return (right)left
else
return null
Eu não sei como você faria isso, eu sou um c # no momento e meu chapéu Java ficou um pouco poeirento desde que saí da universidade.