È possibile utilizzare l'operatore instanceof in un'istruzione switch?

Ho una domanda sull'uso di switch case per instanceofoggetto:

Ad esempio: il mio problema può essere riprodotto in Java:

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

Come verrebbe implementato usando switch...case?

Questo è uno scenario tipico in cui il polimorfismo dei sottotipi aiuta. Eseguire le seguenti operazioni

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() } ... }

Poi si può semplicemente chiamare do()su this.

Se non sei libero di cambiare A, Be C, puoi applicare lo schema visitatore per ottenere lo stesso.

se non puoi assolutamente codificare un'interfaccia, allora puoi usare un enum come intermediario:

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;

}

Basta creare una mappa in cui la classe è la chiave e la funzionalità, ovvero lambda o simile, è il valore.

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

// ovviamente, refactor questo per inizializzare solo una volta

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

Se è necessario selezionare Eccezioni anziché implementare una FunctionalInterface che genera l'eccezione e utilizzarla al posto di Runnable.

Nel caso in cui qualcuno lo leggerà:

La soluzione MIGLIORE in Java è:

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

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

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

    };

    abstract void doAction (...);
}

I GRANDI benefici di tale modello sono:

1. Lo fai semplicemente come (NO switch affatto):

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

2. Nel caso in cui aggiungi una nuova azione chiamata "d" DEVI implementare il metodo doAction (...)

NOTA: questo modello è descritto in Bloch di Joshua "Effective Java (2nd Edition)"

Non puoi. L' switchistruzione può contenere solo caseistruzioni che sono costanti di tempo di compilazione e che valutano un numero intero (fino a Java 6 e una stringa in Java 7).

Quello che stai cercando è chiamato "pattern matching" nella programmazione funzionale.

Vedi anche Evitare istanza di Java

Come discusso nelle risposte migliori, l'approccio OOP tradizionale prevede l'uso del polimorfismo anziché dell'interruttore. Esiste anche un modello di refactoring ben documentato per questo trucco: sostituire il condizionale con il polimorfismo . Ogni volta che cerco questo approccio, mi piace anche implementare un oggetto Null per fornire il comportamento predefinito.

A partire da Java 8, possiamo usare lambda e generici per darci qualcosa con cui i programmatori funzionali hanno molta familiarità: il pattern matching. Non è una funzionalità del linguaggio principale ma la libreria Javaslang fornisce un'implementazione. Esempio dal javadoc :

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

Non è il paradigma più naturale nel mondo Java, quindi usalo con cautela. Mentre i metodi generici ti eviteranno di dover digitare il valore abbinato, ci manca un modo standard per scomporre l'oggetto abbinato come ad esempio con le classi di case di Scala .

So che è molto tardi, ma per i futuri lettori ...

Fai attenzione agli approcci sopra che si basano solo sul nome della classe di A , B , C ...:

A meno che non sia possibile garantire che A , B , C ... (tutte le sottoclassi o gli implementatori di Base ) siano definitivi, le sottoclassi di A , B , C ... non verranno trattate.

Anche se l' approccio if, elseif, elseif .. è più lento per un gran numero di sottoclassi / implementatori, è più accurato.

Sfortunatamente, non è possibile out of the box poiché l'istruzione switch-case prevede un'espressione costante. Per ovviare a questo, un modo sarebbe quello di utilizzare i valori enum con i nomi delle classi es

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

Con ciò è possibile usare l'istruzione switch in questo modo

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
}

No, non c'è modo di farlo. Ciò che potresti voler fare è tuttavia considerare il polimorfismo come un modo per gestire questo tipo di problemi.

L'uso di istruzioni switch come questa non è orientato agli oggetti. Dovresti invece usare il potere del polimorfismo . Basta scrivere

this.do()

Avendo precedentemente impostato una classe base:

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

che è la classe base per A, Be 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() }
}

Funzionerà più velocemente e renderà conto nel caso in cui
tu abbia relativamente molti "casi"
- il processo viene eseguito in un contesto sensibile alle prestazioni

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

Non è possibile che uno switch funzioni solo con i tipi byte, short, char, int, String e enumerati (e le versioni degli oggetti delle primitive, dipende anche dalla versione java, Le stringhe possono essere modificate switchin java 7)

Personalmente mi piace il seguente codice Java 1.8:

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

Uscita:

YYyy

Il codice di esempio utilizza le stringhe ma è possibile utilizzare qualsiasi tipo di oggetto, inclusa la classe. per esempio.myCase(this.getClass(), (o) -> ...

Ha bisogno del seguente frammento:

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 ora consente di cambiare nel modo dell'OP. Lo chiamano Pattern Matching per switch. Attualmente è in bozza, ma vedendo quanto lavoro hanno svolto recentemente negli switch, penso che passerà attraverso. L'esempio fornito nel JEP è

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

o usando la loro sintassi lambda e restituendo un valore

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

in entrambi i casi hanno fatto cose interessanti con gli switch.

Se riesci a manipolare l'interfaccia comune, potresti aggiungere un enum e fare in modo che ogni classe restituisca un valore univoco. Non avrai bisogno di instanceof o di un modello di visitatore.

Per me, la logica doveva essere scritta nell'istruzione switch, non l'oggetto stesso. Questa era la mia soluzione:

ClassA, ClassB, and ClassC implement CommonClass

Interfaccia:

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

Se sei su Java 7, puoi inserire i valori di stringa per l'enum e il blocco del case switch continuerà a funzionare.

Cosa ne pensi di questo ?

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

Penso che ci siano ragioni per usare un'istruzione switch. Se stai usando forse il codice generato da xText. O un altro tipo di classi generate da EMF.

instance.getClass().getName();

restituisce una stringa del nome di implementazione della classe. cioè: org.eclipse.emf.ecore.util.EcoreUtil

instance.getClass().getSimpleName();

restituisce la rappresentazione semplice, ovvero: EcoreUtil

Se è necessario "passare" attraverso il tipo di classe di "questo" oggetto, questa risposta è la migliore https://stackoverflow.com/a/5579385/2078368

Ma se è necessario applicare "switch" a qualsiasi altra variabile. Vorrei suggerire un'altra soluzione. Definire la seguente interfaccia:

public interface ClassTypeInterface {
    public String getType();
}

Implementa questa interfaccia in ogni classe che desideri "cambiare". Esempio:

public class A extends Something implements ClassTypeInterface {

    public final static String TYPE = "A";

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

Dopodiché puoi usarlo nel modo seguente:

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

L'unica cosa di cui dovresti preoccuparti: mantenere i "tipi" unici in tutte le classi che implementano ClassTypeInterface. Non è un grosso problema, perché in caso di intersezione si riceve un errore di compilazione per l'istruzione "switch-case".

Ecco un modo funzionale per realizzarlo in Java 8 usando 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)
        );
    }

Sebbene non sia possibile scrivere un'istruzione switch, è possibile eseguire il branch out all'elaborazione specifica per ciascun tipo specificato. Un modo per farlo è utilizzare il meccanismo standard di doppia spedizione. Un esempio in cui vogliamo "cambiare" in base al tipo è il mappatore di eccezioni Jersey in cui dobbiamo mappare una moltitudine di eccezioni alle risposte di errore. Mentre per questo caso specifico esiste probabilmente un modo migliore (ovvero usare un metodo polimorfico che traduce ogni eccezione in una risposta di errore), l'uso del doppio meccanismo di invio è ancora utile e pratico.

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

Quindi ovunque sia necessario lo "switch", puoi farlo come segue:

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

Crea un Enum con nomi di classe.

public enum ClassNameEnum {
    A, B, C
}

Trova il nome della classe dell'oggetto. Scrivi un interruttore caso sopra l'enum.

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

Spero che questo ti aiuti.

Eclipse Modeling Framework ha un'idea interessante che considera anche l'eredità. Il concetto di base è definita nello Switch interfaccia : la commutazione viene effettuata richiamando il doSwitch metodo.

Ciò che è veramente interessante è l'implementazione. Per ogni tipo di interesse, a

public T caseXXXX(XXXX object);

il metodo deve essere implementato (con un'implementazione predefinita che restituisce null). L' implementazione di doSwitch tenterà di chiamare tutti i metodi caseXXX sull'oggetto per tutta la sua gerarchia di tipi. Qualcosa nelle righe di:

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;

Il framework effettivo utilizza un ID intero per ogni classe, quindi la logica è in realtà un puro switch:

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:
    {
      ...
    }
  ...

Puoi vedere un'implementazione completa di ECoreSwitch per avere un'idea migliore.

c'è un modo ancora più semplice di emulare una struttura di switch che utilizza instanceof, lo fai creando un blocco di codice nel tuo metodo e nominandolo con un'etichetta. Quindi usi if strutture per emulare le dichiarazioni del caso. Se un caso è vero, utilizzare l'interruzione LABEL_NAME per uscire dalla struttura dell'interruttore di fortuna.

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