Ist es möglich, den Operator instanceof in einer switch-Anweisung zu verwenden?

Ich habe eine Frage zur Verwendung von Switch Case für instanceofObjekt:

Zum Beispiel: Mein Problem kann in Java reproduziert werden:

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

Wie würde es mit implementiert werden switch...case?

Dies ist ein typisches Szenario, in dem Subtyp-Polymorphismus hilfreich ist. Mach Folgendes

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

Dann können Sie rufen Sie einfach do()an this.

Wenn Sie nicht frei Asind B, und zu ändern , können CSie das Besuchermuster anwenden, um dasselbe zu erreichen.

Wenn Sie absolut nicht für eine Schnittstelle codieren können, können Sie eine Aufzählung als Vermittler verwenden:

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;

}

Erstellen Sie einfach eine Map, in der die Klasse der Schlüssel und die Funktionalität, dh Lambda oder ähnliches, der Wert ist.

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

// Refactor dies natürlich so, dass es nur einmal initialisiert wird

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

Wenn Sie aktivierte Ausnahmen benötigen, implementieren Sie ein FunctionalInterface, das die Ausnahme auslöst, und verwenden Sie diese anstelle von Runnable.

Nur für den Fall, dass jemand es liest:

Die beste Lösung in Java ist:

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

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

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

    };

    abstract void doAction (...);
}

Die großen Vorteile eines solchen Musters sind:

1. Du machst es einfach so (KEINE Schalter überhaupt):

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

2. Wenn Sie eine neue Aktion mit dem Namen "d" hinzufügen, MÜSSEN Sie die Methode doAction (...) implementieren

HINWEIS: Dieses Muster ist in Joshuas Bloch "Effective Java (2nd Edition)" beschrieben.

Das kannst du nicht. Die switchAnweisung kann nur caseAnweisungen enthalten , die Kompilierzeitkonstanten sind und eine Ganzzahl ergeben (bis zu Java 6 und eine Zeichenfolge in Java 7).

Was Sie suchen, wird in der funktionalen Programmierung als "Pattern Matching" bezeichnet.

Siehe auch Vermeiden von Instanzen in Java

Wie in den Top-Antworten erläutert, besteht der traditionelle OOP-Ansatz darin, Polymorphismus anstelle von Switch zu verwenden. Es gibt sogar ein gut dokumentiertes Refactoring-Muster für diesen Trick: Ersetzen Sie Bedingt durch Polymorphismus . Wann immer ich nach diesem Ansatz greife, möchte ich auch ein Null-Objekt implementieren , um das Standardverhalten bereitzustellen.

Ab Java 8 können wir Lambdas und Generika verwenden, um uns etwas zu geben, mit dem funktionale Programmierer sehr vertraut sind: Pattern Matching. Es ist keine Kernsprache, aber die Javaslang-Bibliothek bietet eine Implementierung. Beispiel aus dem Javadoc :

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

Es ist nicht das natürlichste Paradigma in der Java-Welt. Verwenden Sie es daher mit Vorsicht. Mit den generischen Methoden müssen Sie zwar den übereinstimmenden Wert nicht typisieren, es fehlt jedoch eine Standardmethode zum Zerlegen des übereinstimmenden Objekts, wie beispielsweise bei Scalas Fallklassen .

Ich weiß, dass dies sehr spät ist, aber für zukünftige Leser ...

Beachten Sie die oben genannten Ansätze, die nur auf dem Namen der Klasse von A , B , C ... basieren :

Sofern Sie nicht garantieren können, dass A , B , C ... (alle Unterklassen oder Implementierer von Base ) endgültig sind, werden Unterklassen von A , B , C ... nicht behandelt.

Obwohl der Ansatz if, elseif, elseif .. für eine große Anzahl von Unterklassen / Implementierern langsamer ist, ist er genauer.

Leider ist dies nicht sofort möglich, da die switch-case-Anweisung einen konstanten Ausdruck erwartet. Um dies zu überwinden, besteht eine Möglichkeit darin, Enum-Werte mit den Klassennamen zu verwenden, z

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

Damit ist es möglich, die switch-Anweisung so zu verwenden

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
}

Nein, dazu gibt es keine Möglichkeit. Was Sie jedoch tun möchten, ist, Polymorphismus als einen Weg zu betrachten, um diese Art von Problemen zu behandeln.

Die Verwendung solcher switch-Anweisungen ist nicht objektorientiert. Sie sollten stattdessen die Kraft des Polymorphismus nutzen . Einfach schreiben

this.do()

Nachdem Sie zuvor eine Basisklasse eingerichtet haben:

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

Das ist die Basisklasse für A, Bund 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() }
}

Dies funktioniert schneller und macht Sinn, falls
- Sie haben relativ viele "Fälle"
- der Prozess in einem leistungsabhängigen Kontext ausgeführt wird

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

Sie können nicht, dass ein Switch nur mit den Typen Byte, Short, Char, Int, String und Enumerated funktioniert (und den Objektversionen der Grundelemente, es hängt auch von Ihrer Java-Version ab, Strings können switchin Java 7 bearbeitet werden).

Ich persönlich mag den folgenden Java 1.8-Code:

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

Wird ausgegeben:

YYyy

Der Beispielcode verwendet Strings, Sie können jedoch jeden Objekttyp verwenden, einschließlich Class. z.B.myCase(this.getClass(), (o) -> ...

Benötigt das folgende Snippet:

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

Mit Java können Sie jetzt in der Art des OP wechseln. Sie nennen es Pattern Matching für Switch. Es befindet sich derzeit im Entwurf, aber da ich sehe, wie viel Arbeit sie in letzter Zeit in Schalter gesteckt haben, denke ich, dass es durchgehen wird. Das im JEP gegebene Beispiel ist

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

oder verwenden Sie ihre Lambda-Syntax und geben Sie einen Wert zurück

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

So oder so haben sie coole Sachen mit Schaltern gemacht.

Wenn Sie die allgemeine Schnittstelle bearbeiten können, können Sie eine Aufzählung hinzufügen und jede Klasse einen eindeutigen Wert zurückgeben lassen. Sie benötigen keine Instanz oder ein Besuchermuster.

Für mich musste die Logik in der switch-Anweisung geschrieben sein, nicht das Objekt selbst. Das war meine Lösung:

ClassA, ClassB, and ClassC implement CommonClass

Schnittstelle:

public interface CommonClass {
   MyEnum getEnumType();
}

Aufzählung:

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

Wenn Sie mit Java 7 arbeiten, können Sie Zeichenfolgenwerte für die Aufzählung eingeben, und der Switch-Case-Block funktioniert weiterhin.

Wie wäre es damit ?

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

Ich denke, es gibt Gründe, eine switch-Anweisung zu verwenden. Wenn Sie xText generierten Code verwenden, möglicherweise. Oder eine andere Art von EMF-generierten Klassen.

instance.getClass().getName();

Gibt eine Zeichenfolge des Klassenimplementierungsnamens zurück. dh: org.eclipse.emf.ecore.util.EcoreUtil

instance.getClass().getSimpleName();

gibt die einfache Darstellung zurück, dh: EcoreUtil

Wenn Sie durch den Klassentyp "dieses" Objekts "wechseln" müssen, ist diese Antwort die beste https://stackoverflow.com/a/5579385/2078368

Aber wenn Sie "switch" auf eine andere Variable anwenden müssen. Ich würde eine andere Lösung vorschlagen. Definieren Sie folgende Schnittstelle:

public interface ClassTypeInterface {
    public String getType();
}

Implementieren Sie diese Schnittstelle in jeder Klasse, die Sie "wechseln" möchten. Beispiel:

public class A extends Something implements ClassTypeInterface {

    public final static String TYPE = "A";

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

Danach können Sie es folgendermaßen verwenden:

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

Das einzige, was Sie beachten sollten - halten Sie die "Typen" für alle Klassen, die das ClassTypeInterface implementieren, eindeutig. Dies ist kein großes Problem, da bei einer Kreuzung ein Kompilierungsfehler für die Anweisung "switch-case" angezeigt wird.

Hier ist eine funktionale Möglichkeit, dies in Java 8 mithilfe von http://www.vavr.io/ zu erreichen.

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

Erstelle ein Aufzählung mit Klassennamen .

public enum ClassNameEnum {
    A, B, C
}

Suchen Sie den Klassennamen des Objekts. Schreib ein Schalterfall über die Aufzählung.

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

Hoffe das hilft.

Das Eclipse Modeling Framework hat eine interessante Idee, die auch die Vererbung berücksichtigt. Das Grundkonzept ist in der Switch- Schnittstelle definiert : Das Umschalten erfolgt durch Aufrufen der doSwitch- Methode.

Was wirklich interessant ist, ist die Implementierung. Für jede Art von Interesse a

public T caseXXXX(XXXX object);

Methode muss implementiert werden (wobei eine Standardimplementierung null zurückgibt). Die doSwitch- Implementierung versucht, alle caseXXX- Methoden für das Objekt für alle Typhierarchien aufzurufen . Etwas in den Zeilen von:

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;

Das eigentliche Framework verwendet für jede Klasse eine Ganzzahl-ID, sodass die Logik tatsächlich ein reiner Schalter ist:

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

Sie können sich eine vollständige Implementierung des ECoreSwitch ansehen , um eine bessere Vorstellung zu erhalten.

Während es nicht möglich ist, eine switch-Anweisung zu schreiben, ist es möglich, für jeden gegebenen Typ zu einer bestimmten Verarbeitung zu verzweigen. Eine Möglichkeit hierfür ist die Verwendung eines Standard-Doppelversandmechanismus. Ein Beispiel, bei dem wir basierend auf dem Typ "wechseln" möchten, ist der Jersey Exception Mapper, bei dem wir eine Vielzahl von Ausnahmen auf Fehlerantworten abbilden müssen. Während es für diesen speziellen Fall wahrscheinlich einen besseren Weg gibt (dh die Verwendung einer polymorphen Methode, die jede Ausnahme in eine Fehlerantwort übersetzt), ist die Verwendung des Doppelversandmechanismus immer noch nützlich und praktisch.

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

Wo immer der "Schalter" benötigt wird, können Sie dies wie folgt tun:

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

Es gibt eine noch einfachere Möglichkeit, eine Switch-Struktur zu emulieren, die instanceof verwendet. Dazu erstellen Sie einen Codeblock in Ihrer Methode und benennen ihn mit einer Bezeichnung. Dann verwenden Sie if-Strukturen, um die case-Anweisungen zu emulieren. Wenn ein Fall zutrifft, verwenden Sie die Unterbrechung LABEL_NAME, um aus Ihrer provisorischen Schalterstruktur herauszukommen.

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