Est-il possible d'utiliser l'opérateur instanceof dans une instruction switch?

J'ai une question d'utiliser le boîtier de commutateur pour l' instanceofobjet:

Par exemple: mon problème peut être reproduit en Java:

if(this instanceof A)
    doA();
else if(this instanceof B)
    doB();
else if(this instanceof C)
    doC():

Comment serait-il mis en œuvre en utilisant switch...case?

Il s'agit d'un scénario typique où le polymorphisme de sous-type aide. Procédez comme suit

interface I {
  void do();
}

class A implements I { void do() { doA() } ... }
class B implements I { void do() { doB() } ... }
class C implements I { void do() { doC() } ... }

Ensuite , vous pouvez simplement appeler do()sur this.

Si vous n'êtes pas libre de changer A, Bet C, vous pouvez appliquer le modèle de visiteur pour obtenir le même.

si vous ne pouvez absolument pas coder sur une interface, vous pouvez utiliser une énumération comme intermédiaire:

public A() {

    CLAZZ z = CLAZZ.valueOf(this.getClass().getSimpleName());
    switch (z) {
    case A:
        doA();
        break;
    case B:
        doB();
        break;
    case C:
        doC();
        break;
    }
}


enum CLAZZ {
    A,B,C;

}

Il suffit de créer une carte où la classe est la clé et la fonctionnalité, c'est-à-dire lambda ou similaire, est la valeur.

Map<Class,Runnable> doByClass = new HashMap<>();
doByClass.put(Foo.class, () -> doAClosure(this));
doByClass.put(Bar.class, this::doBMethod);
doByClass.put(Baz.class, new MyCRunnable());

// bien sûr, refactorisez ceci pour ne l'initialiser qu'une seule fois

doByClass.get(getClass()).run();

Si vous avez besoin d'exceptions vérifiées, implémentez une FunctionalInterface qui lève l'exception et utilisez-la à la place de Runnable.

Juste au cas où quelqu'un le lirait:

La MEILLEURE solution en java est:

public enum Action { 
    a{
        void doAction(...){
            // some code
        }

    }, 
    b{
        void doAction(...){
            // some code
        }

    }, 
    c{
        void doAction(...){
            // some code
        }

    };

    abstract void doAction (...);
}

Les GRANDS avantages d'un tel modèle sont:

1. Vous le faites comme (AUCUN interrupteurs du tout):

   void someFunction ( Action action ) {
       action.doAction(...);   
   }

2. Dans le cas où si vous ajoutez une nouvelle action appelée "d", vous DEVEZ imlement la méthode doAction (...)

REMARQUE: ce modèle est décrit dans le Bloch de Joshua "Effective Java (2nd Edition)"

Tu ne peux pas. L' switchinstruction ne peut contenir que des caseinstructions qui sont des constantes de temps de compilation et qui s'évaluent en un entier (jusqu'à Java 6 et une chaîne en Java 7).

Ce que vous recherchez est appelé "pattern matching" dans la programmation fonctionnelle.

Voir aussi Éviter instanceof en Java

Comme indiqué dans les principales réponses, l'approche OOP traditionnelle consiste à utiliser le polymorphisme au lieu du commutateur. Il existe même un modèle de refactorisation bien documenté pour cette astuce: remplacer le conditionnel par le polymorphisme . Chaque fois que j'atteins cette approche, j'aime également implémenter un objet Null pour fournir le comportement par défaut.

À partir de Java 8, nous pouvons utiliser des lambdas et des génériques pour nous donner quelque chose que les programmeurs fonctionnels connaissent très bien: la mise en correspondance de modèles. Ce n'est pas une fonctionnalité de langage de base, mais la bibliothèque Javaslang fournit une implémentation. Exemple du javadoc :

Match.ofType(Number.class)
    .caze((Integer i) -> i)
    .caze((String s) -> new BigDecimal(s))
    .orElse(() -> -1)
    .apply(1.0d); // result: -1

Ce n'est pas le paradigme le plus naturel du monde Java, alors utilisez-le avec prudence. Alors que les méthodes génériques vous éviteront d'avoir à transtyper la valeur correspondante, il nous manque une façon standard de décomposer l'objet correspondant comme avec les classes de cas de Scala par exemple.

Je sais que c'est très tard mais pour les futurs lecteurs ...

Méfiez-vous des approches ci-dessus qui ne sont basées que sur le nom de la classe A , B , C ...:

A moins que vous ne puissiez garantir que A , B , C ... (toutes les sous-classes ou implémenteurs de Base ) sont finales, puis les sous-classes de A , B , C ... ne seront pas traitées.

Même si l' approche if, elseif, elseif .. est plus lente pour un grand nombre de sous-classes / implémenteurs, elle est plus précise.

Malheureusement, il n'est pas possible de sortir de la boîte car l'instruction switch-case attend une expression constante. Pour surmonter cela, une façon serait d'utiliser des valeurs d'énumération avec les noms de classe, par exemple

public enum MyEnum {
   A(A.class.getName()), 
   B(B.class.getName()),
   C(C.class.getName());

private String refClassname;
private static final Map<String, MyEnum> ENUM_MAP;

MyEnum (String refClassname) {
    this.refClassname = refClassname;
}

static {
    Map<String, MyEnum> map = new ConcurrentHashMap<String, MyEnum>();
    for (MyEnum instance : MyEnum.values()) {
        map.put(instance.refClassname, instance);
    }
    ENUM_MAP = Collections.unmodifiableMap(map);
}

public static MyEnum get(String name) {
    return ENUM_MAP.get(name);
 }
}

Avec cela, il est possible d'utiliser l'instruction switch comme ceci

MyEnum type = MyEnum.get(clazz.getName());
switch (type) {
case A:
    ... // it's A class
case B:
    ... // it's B class
case C:
    ... // it's C class
}

Non, il n'y a aucun moyen de le faire. Ce que vous pourriez vouloir faire est cependant de considérer le polymorphisme comme un moyen de gérer ce genre de problèmes.

L'utilisation d'instructions de commutation comme celle-ci n'est pas orientée objet. Vous devriez plutôt utiliser le pouvoir du polymorphisme . Ecrivez simplement

this.do()

Après avoir configuré une classe de base:

abstract class Base {
   abstract void do();
   ...
}

qui est la classe de base pour A, Bet C:

class A extends Base {
    void do() { this.doA() }
}

class B extends Base {
    void do() { this.doB() }
}

class C extends Base {
    void do() { this.doC() }
}

Cela fonctionnera plus rapidement et fera sence au cas où
- vous avez relativement de nombreux cas
- le processus est exécuté dans un contexte sensible aux performances

public <T> T process(Object model) {
    switch (model.getClass().getSimpleName()) {
        case "Trade":
            return processTrade();
        case "InsuranceTransaction":
            return processInsuranceTransaction();
        case "CashTransaction":
            return processCashTransaction();
        case "CardTransaction":
            return processCardTransaction();
        case "TransferTransaction":
            return processTransferTransaction();
        case "ClientAccount":
            return processAccount();
        ...
        default:
            throw new IllegalArgumentException(model.getClass().getSimpleName());
    }
}

Vous ne pouvez pas un commutateur ne fonctionne qu'avec les types byte, short, char, int, String et énumérés (et les versions d'objet des primitives, cela dépend aussi de votre version java, les chaînes peuvent être switchéditées dans java 7)

Personnellement, j'aime le code Java 1.8 suivant:

    mySwitch("YY")
            .myCase("AA", (o) -> {
                System.out.println(o+"aa");
            })
            .myCase("BB", (o) -> {
                System.out.println(o+"bb");
            })
            .myCase("YY", (o) -> {
                System.out.println(o+"yy");
            })
            .myCase("ZZ", (o) -> {
                System.out.println(o+"zz");
            });

Sortira:

YYyy

L'exemple de code utilise des chaînes mais vous pouvez utiliser n'importe quel type d'objet, y compris la classe. par exemple.myCase(this.getClass(), (o) -> ...

Nécessite l'extrait de code suivant:

public Case mySwitch(Object reference) {
    return new Case(reference);
}

public class Case {

    private Object reference;

    public Case(Object reference) {
        this.reference = reference;
    }

    public Case myCase(Object b, OnMatchDo task) {
        if (reference.equals(b)) {
            task.task(reference);
        }
        return this;
    }
}

public interface OnMatchDo {

    public void task(Object o);
}

Java vous permet désormais de basculer à la manière de l'OP. Ils l'appellent Pattern Matching pour switch. Il est actuellement en cours de rédaction, mais vu combien de travail ils ont mis dans les commutateurs récemment, je pense que cela va passer. L'exemple donné dans le JEP est

String formatted;
switch (obj) {
    case Integer i: formatted = String.format("int %d", i); break;
    case Byte b:    formatted = String.format("byte %d", b); break;
    case Long l:    formatted = String.format("long %d", l); break;
    case Double d:  formatted = String.format("double %f", d); break;
    case String s:  formatted = String.format("String %s", s); break
    default:        formatted = obj.toString();
}  

ou en utilisant leur syntaxe lambda et en retournant une valeur

String formatted = 
    switch (obj) {
        case Integer i -> String.format("int %d", i)
        case Byte b    -> String.format("byte %d", b);
        case Long l    -> String.format("long %d", l); 
        case Double d  -> String.format("double %f", d); 
        case String s  -> String.format("String %s", s); 
        default        -> obj.toString();
    };

de toute façon, ils ont fait des trucs sympas avec des interrupteurs.

Si vous pouvez manipuler l'interface commune, vous pouvez ajouter une énumération et demander à chaque classe de renvoyer une valeur unique. Vous n'aurez pas besoin de instanceof ou d'un modèle de visiteur.

Pour moi, la logique devait être dans l'écrit dans l'instruction switch, pas l'objet lui-même. C'était ma solution:

ClassA, ClassB, and ClassC implement CommonClass

Interface:

public interface CommonClass {
   MyEnum getEnumType();
}

Enum:

public enum MyEnum {
  ClassA(0), ClassB(1), ClassC(2);

  private int value;

  private MyEnum(final int value) {
    this.value = value;
  }

  public int getValue() {
    return value;
  }

Impl:

...
  switch(obj.getEnumType())
  {
    case MyEnum.ClassA:
      ClassA classA = (ClassA) obj;
    break;

    case MyEnum.ClassB:
      ClassB classB = (ClassB) obj;
    break;

    case MyEnum.ClassC:
      ClassC classC = (ClassC) obj;
    break;
  }
...

Si vous utilisez Java 7, vous pouvez mettre des valeurs de chaîne pour l'énumération et le bloc de casse de commutateur fonctionnera toujours.

Que dis-tu de ça ?

switch (this.name) 
{
  case "A":
    doA();
    break;
  case "B":
    doB();
    break;
  case "C":
    doC();
    break;
  default:
    console.log('Undefined instance');
}

Je pense qu'il y a des raisons d'utiliser une instruction switch. Si vous utilisez peut-être du code généré par xText. Ou un autre type de classes générées par EMF.

instance.getClass().getName();

renvoie une chaîne du nom d'implémentation de classe. c'est-à-dire: org.eclipse.emf.ecore.util.EcoreUtil

instance.getClass().getSimpleName();

renvoie la représentation simple ie: EcoreUtil

Si vous devez "basculer" via le type de classe de "cet" objet, cette réponse est la meilleure https://stackoverflow.com/a/5579385/2078368

Mais si vous devez appliquer "switch" à toute autre variable. Je proposerais une autre solution. Définissez l'interface suivante:

public interface ClassTypeInterface {
    public String getType();
}

Implémentez cette interface dans chaque classe que vous souhaitez "basculer". Exemple:

public class A extends Something implements ClassTypeInterface {

    public final static String TYPE = "A";

    @Override
    public String getType() {
        return TYPE;
    }
}

Après cela, vous pouvez l'utiliser de la manière suivante:

switch (var.getType()) {
    case A.TYPE: {
        break;
    }
    case B.TYPE: {
        break;
    }
    ...
}

La seule chose à laquelle vous devriez vous soucier - garder les "types" uniques dans toutes les classes implémentant ClassTypeInterface. Ce n'est pas un gros problème, car en cas d'intersection, vous recevez une erreur de compilation pour l'instruction "switch-case".

Voici une manière fonctionnelle de l'accomplir dans Java 8 en utilisant http://www.vavr.io/

import static io.vavr.API.*;
import static io.vavr.Predicates.instanceOf;
public Throwable liftRootCause(final Throwable throwable) {
        return Match(throwable).of(
                Case($(instanceOf(CompletionException.class)), Throwable::getCause),
                Case($(instanceOf(ExecutionException.class)), Throwable::getCause),
                Case($(), th -> th)
        );
    }

Bien qu'il ne soit pas possible d'écrire une instruction switch, il est possible de passer à un traitement spécifique pour chaque type donné. Une façon de procéder consiste à utiliser un mécanisme de double répartition standard. Un exemple où nous voulons «basculer» en fonction du type est le mappeur d'exceptions Jersey où nous devons mapper une multitude d'exceptions aux réponses aux erreurs. Alors que dans ce cas spécifique, il existe probablement un meilleur moyen (c'est-à-dire en utilisant une méthode polymorphe qui traduit chaque exception en une réponse d'erreur), l'utilisation du mécanisme de double répartition est toujours utile et pratique.

interface Processable {
    <R> R process(final Processor<R> processor);
}

interface Processor<R> {
    R process(final A a);
    R process(final B b);
    R process(final C c);
    // for each type of Processable
    ...
}

class A implements Processable {
    // other class logic here

    <R> R process(final Processor<R> processor){
        return processor.process(this);
    }
}

class B implements Processable {
    // other class logic here

    <R> R process(final Processor<R> processor){
        return processor.process(this);
    }
}

class C implements Processable {
    // other class logic here

    <R> R process(final Processor<R> processor){
        return processor.process(this);
    }
}

Ensuite, partout où le "commutateur" est nécessaire, vous pouvez le faire comme suit:

public class LogProcessor implements Processor<String> {
    private static final Logger log = Logger.for(LogProcessor.class);

    public void logIt(final Processable base) {
        log.info("Logging for type {}", process(base));
    }

    // Processor methods, these are basically the effective "case" statements
    String process(final A a) {
        return "Stringifying A";
    }

    String process(final B b) {
        return "Stringifying B";
    }

    String process(final C c) {
        return "Stringifying C";
    }
}

Créez une énumération avec des noms de classe.

public enum ClassNameEnum {
    A, B, C
}

Recherchez le nom de classe de l'objet. Écrivez un commutateur sur l'énumération.

private void switchByClassType(Object obj) {

        ClassNameEnum className = ClassNameEnum.valueOf(obj.getClass().getSimpleName());

        switch (className) {
            case A:
                doA();
                break;
            case B:
                doB();
                break;
            case C:
                doC();
                break;
        }
    }
}

J'espère que cela t'aides.

Le cadre de modélisation Eclipse a une idée intéressante qui considère également l'héritage. Le concept de base est défini dans l' interface Switch : la commutation se fait en appelant le doSwitch méthode .

Ce qui est vraiment intéressant, c'est l'implémentation. Pour chaque type d'intérêt, un

public T caseXXXX(XXXX object);

doit être implémentée (avec une implémentation par défaut renvoyant null). L' implémentation doSwitch tentera d'appeler toutes les méthodes caseXXX sur l'objet pour toute sa hiérarchie de types. Quelque chose dans les lignes de:

BaseType baseType = (BaseType)object;
T result = caseBaseType(eAttribute);
if (result == null) result = caseSuperType1(baseType);
if (result == null) result = caseSuperType2(baseType);
if (result == null) result = caseSuperType3(baseType);
if (result == null) result = caseSuperType4(baseType);
if (result == null) result = defaultCase(object);
return result;

Le cadre réel utilise un identifiant entier pour chaque classe, donc la logique est en fait un simple commutateur:

public T doSwitch(Object object) {
    return doSwitch(object.class(), eObject);
}

protected T doSwitch(Class clazz, Object object) {
    return doSwitch(getClassifierID(clazz), object);
}

protected T doSwitch(int classifierID, Object theObject) {
    switch (classifierID) {
    case MyClasses.BASETYPE:
    {
      BaseType baseType = (BaseType)object;
      ...
      return result;
    }
    case MyClasses.TYPE1:
    {
      ...
    }
  ...

Vous pouvez consulter une implémentation complète de l' ECoreSwitch pour vous faire une meilleure idée.

il existe un moyen encore plus simple d'émuler une structure de commutateur qui utilise instanceof, vous pouvez le faire en créant un bloc de code dans votre méthode et en le nommant avec une étiquette. Vous utilisez ensuite les structures if pour émuler les instructions case. Si un cas est vrai, vous utilisez la pause LABEL_NAME pour sortir de votre structure de commutateur de fortune.

        DEFINE_TYPE:
        {
            if (a instanceof x){
                //do something
                break DEFINE_TYPE;
            }
            if (a instanceof y){
               //do something
                break DEFINE_TYPE;
            }
            if (a instanceof z){
                // do something
                break DEFINE_TYPE;
            }
        }