Comment émuler C# en tant qu'opérateur dans Java

Question

Il existe des situations où il est pratique d'avoir une valeur de type null renvoyée par une distribution de type au lieu de lancer une exception ClassCastException. C# a l'opérateur as pour ce faire. Y at-il quelque chose d'équivalent disponible en Java, donc vous n'avez pas à vérifier explicitement l'exception ClassCastException?

Answer 1

est ici une mise en œuvre comme, comme le suggère @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

Vous pouvez utiliser le mot-clé instanceof à la place du is de C#, mais il n'y a rien comme as.

Exemple:

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

Answer 3

Je pense que vous auriez à rouler votre propre:

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

EDIT: Si vous ne voulez pas que votre code client pour traiter les valeurs NULL, puis vous pouvez introduire 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

je spécule, vous pouvez créas propably un opérateur comme

quelque chose comme

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

Je ne sais pas comment vous le faites, je suis C# au moment et mon chapeau de Java a obtenu un peu poussiéreux depuis que je quitté l'université.

Answer 5

Vous pouvez écrire une méthode d'utilitaire statique comme celle-ci. Je ne pense pas que ce soit terriblement lisible, mais c'est la meilleure approximation de ce que vous essayez de faire. Et si vous utilisez des importations statiques, ce ne serait pas trop mal en termes de lisibilité.

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

Voici un test qui montre comment cela fonctionne (et qu'il fonctionne.)

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, vous pouvez également utiliser la syntaxe de flux avec facultatif:

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