Cómo emular C# as-operator en Java

Question

Existen situaciones en las que es práctico hacer que un valor de retorno de fundido de tipo sea nulo en lugar de arrojar una ClassCastException. C# tiene el operador as para hacer esto. ¿Hay algún equivalente disponible en Java para que no tenga que comprobar explícitamente ClassCastException?

Answer 1

Aquí es una implementación de como, según lo 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 

Answer 2

Puede usar la palabra clave instanceof en lugar de C# 's is, pero no hay nada como as.

Ejemplo:

if(myThing instanceof Foo) { 
    Foo myFoo = (Foo)myThing; //Never throws ClassCastException 
    ... 
} 

Answer 3

yo creo que tendría que rodar su propia:

return (x instanceof Foo) ? (Foo) x : null; 

EDIT: Si no desea que su código de cliente para hacer frente a los nulos, entonces se puede introducir un Null Object

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

Answer 4

estoy especulando que además probablemente podría Creas un operador como

algo así como

as<T,Type> (left, right) 
which evaluates to 
if (typeof(left) == right) 
    return (right)left 
else 
    return null 

No estoy seguro de cómo se haría, yo soy una C# en el momento y mi sombrero de Java ha conseguido un poco de polvo desde que salí de la universidad.

Answer 5

Puede escribir un método de utilidad estático como este. No creo que sea terriblemente legible, pero es la mejor aproximación de lo que estás tratando de hacer. Y si usa importaciones estáticas, no sería tan malo en términos de legibilidad.

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; 
    } 
} 

Aquí es un caso de prueba que muestra cómo funciona (y que 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); 
    } 
} 

Answer 6

En java 8 también puede usar la sintaxis de flujo con 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"));