Is it possible to use the instanceof operator in a switch statement

Question

I have a question of using switch case for instanceof object   For example  my problem can be reproduced in Java   if this instanceof A      doA    else if this instanceof B      doB    else if this instanceof C      doC      How would it be implemented using switch   case

User · Answer

Here s a functional way of accomplishing it in Java 8 using 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 - gt  th

User · Answer

If you need to  switch  thru the class type of  this  object  this answer is the best https   stackoverflow com a 5579385 2078368  But if you need to apply  switch  to any other variable  I would suggest another solution  Define following interface   public interface ClassTypeInterface       public String getType        Implement this interface in every class you want to  switch   Example   public class A extends Something implements ClassTypeInterface        public final static String TYPE    A         Override     public String getType             return TYPE            After that you can use it in following way   switch  var getType          case A TYPE            break            case B TYPE            break                    The only thing you should care about - keep the  types  unique across all the classes implementing the ClassTypeInterface  It s not a big problem  because in case of any intersection you receive a compile-time error for the  switch-case  statement

User · Answer

You can t a switch only works with the byte  short  char  int  String and enumerated types  and the object versions of the primitives  it also depends on your java version  Strings can be switched on in java 7

User · Answer

You can t  The switch statement can only contain case statements which are compile time constants and which evaluate to an integer  Up to Java 6 and a string in Java 7     What you are looking for is called  pattern matching  in functional programming   See also Avoiding instanceof in Java

User · Answer

The Eclipse Modelling Framework has an interesting idea that also considers inheritance  The basic concept is defined in the Switch interface  switching is done by invoking the doSwitch method   What is really interesting is the implementation  For each type of interest  a  public T caseXXXX XXXX object     method must be implemented  with a default implementation returning null   The doSwitch implementation will attempt to call al the caseXXX methods on the object for all its type hierarchy  Something in the lines of   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    The actual framework uses an integer id for each class  so the logic is actually a pure 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                                You can look at a complete implementation of the ECoreSwitch to get a better idea

User · Answer

Unfortunately  it is not possible out of the box since the switch-case statement expects a constant expression  To overcome this  one way would be to use enum values with the class names e g   public enum MyEnum      A A class getName         B B class getName        C C class getName      private String refClassname  private static final Map lt String  MyEnum gt  ENUM MAP   MyEnum  String refClassname        this refClassname   refClassname     static       Map lt String  MyEnum gt  map   new ConcurrentHashMap lt String  MyEnum gt         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          With that is is possible to use the switch statement like this  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

User · Answer

there is an even simpler way of emulating a switch structure that uses instanceof  you do this by creating a code block in your method and naming it with a label  Then you use if structures to emulate the case statements  If a case is true then you use the break LABEL NAME to get out of your makeshift switch structure           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

User · Answer

Java now allows you to switch in the manner of the OP  They call it Pattern Matching for switch  It is currently under Draft but seeing how much work they have been putting into switches recently I think it will go through  The example given in the JEP is   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          or using their lambda syntax and returning a value   String formatted        switch  obj            case Integer i - gt  String format  int  d   i          case Byte b    - gt  String format  byte  d   b           case Long l    - gt  String format  long  d   l            case Double d  - gt  String format  double  f   d            case String s  - gt  String format  String  s   s            default        - gt  obj toString             either way they ve been doing cool stuff with switches

User · Answer

I know this is very late but for future readers       Beware of the approaches above that are based only on the name of the class of A  B  C         Unless you can guarantee that A  B  C      all subclasses or implementers of Base  are final then subclasses of A  B  C     will not be dealt with   Even though the if  elseif  elseif     approach is slower for large number of subclasses implementers  it is more accurate

User · Answer

Just in case if someone will read it   The BEST solution in java is     public enum Action        a          void doAction                      some code                        b          void doAction                      some code                        c          void doAction                      some code                        abstract void doAction            The GREAT benefits of such pattern are    You just do it like  NO switches at all    void someFunction   Action action         action doAction             In case if you add new Action called  d  you MUST imlement doAction      method   NOTE  This pattern is described in Joshua s Bloch  Effective Java  2nd Edition

User · Answer

If you can manipulate the common interface  you could do add in an enum and have each class return a unique value  You won t need instanceof or a visitor pattern   For me  the logic needed to be in the written in the switch statement  not the object itself  This was my 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            If you are on java 7  you can put string values for the enum and the switch case block will still work

User · Answer

This is a typical scenario where subtype polymorphism helps  Do the following  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             Then you can simply call do   on this    If you are not free to change A  B  and C  you could apply the visitor pattern to achieve the same

User · Answer

I think there are reasons to use a switch statement  If you are using xText generated Code perhaps  Or another kind of EMF generated classes   instance getClass   getName      returns a String of the Class Implementation Name  i e      org eclipse emf ecore util EcoreUtil  instance getClass   getSimpleName      returns the simple represenation i e      EcoreUtil

User · Answer

Using switch statements like this is not the object oriented way  You should instead use the power of polymorphism  Simply write  this do     Having previously set up a base class   abstract class Base      abstract void do               which is the base class for A  B and 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

User · Answer

Create a Map where the key is Class lt   gt  and the value is an expression  lambda or similar   Consider   Map lt Class Runnable gt  doByClass   new HashMap lt  gt     doByClass put Foo class     - gt  doAClosure this    doByClass put Bar class  this  doBMethod   doByClass put Baz class  new MyCRunnable         of course  refactor this to only initialize once  doByClass get getClass    run     If you need checked exceptions than implement a FunctionalInterface that throws the Exception and use that instead of Runnable   Here s a real-word before-and-after showing how this approach can simplify code  The code before refactoring to a map  private Object unmarshall    final Property lt   gt  property  final Object configValue       final Object result    final String value   configValue toString       if  property instanceof SimpleDoubleProperty         result   Double parseDouble  value          else if  property instanceof SimpleFloatProperty         result   Float parseFloat  value          else if  property instanceof SimpleBooleanProperty         result   Boolean parseBoolean  value          else if  property instanceof SimpleFileProperty         result   new File  value          else       result   value         return result     The code after refactoring to a map  private final Map lt Class lt   gt   Function lt String  Object gt  gt  UNMARSHALL    Map of    SimpleBooleanProperty class  Boolean  parseBoolean    SimpleDoubleProperty class  Double  parseDouble    SimpleFloatProperty class  Float  parseFloat    SimpleFileProperty class  File  new     private Object unmarshall    final Property lt   gt  property  final Object configValue       return UNMARSHALL      getOrDefault  property getClass      v   - gt  v        apply  configValue toString         This avoids repetition  eliminates nearly all branching statements  and simplifies maintenance

User · Answer

java 7  public  lt T gt  T process Object model        switch  model getClass   getSimpleName          case  quot Trade quot           return processTrade  Trade  model       case  quot InsuranceTransaction quot           return processInsuranceTransaction  InsuranceTransaction  model       case  quot CashTransaction quot           return processCashTransaction  CashTransaction  model       case  quot CardTransaction quot           return processCardTransaction  CardTransaction  model       case  quot TransferTransaction quot           return processTransferTransaction  TransferTransaction  model       case  quot ClientAccount quot           return processAccount  ClientAccount  model               default          throw new IllegalArgumentException model getClass   getSimpleName               You can be even faster by for omitting string manipulation inside getSimpleName by for introducing constants and using full class name  public static final TRADE   Trade class getName        switch  model getClass   getName      case TRADE

User · Answer

How about this    switch  this name       case  A       doA        break    case  B       doB        break    case  C       doC        break    default      console log  Undefined instance

User · Answer

While it is not possible to write a switch statement  it is possible to branch out to specific processing for each given type  One way of doing this is to use standard double dispatch mechanism  An example where we want to  switch  based on type is Jersey Exception mapper where we need to map multitude of exceptions to error responses  While for this specific case there is probably a better way  i e  using a polymorphic method that translates each exception to an error response   using double dispatch mechanism is still useful and practical   interface Processable        lt R gt  R process final Processor lt R gt  processor      interface Processor lt R gt        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       lt R gt  R process final Processor lt R gt  processor           return processor process this            class B implements Processable          other class logic here       lt R gt  R process final Processor lt R gt  processor           return processor process this            class C implements Processable          other class logic here       lt R gt  R process final Processor lt R gt  processor           return processor process this             Then where ever the  switch  is needed  you can do it as follows   public class LogProcessor implements Processor lt String gt        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

User · Answer

I personally like the following Java 1 8 code       mySwitch  YY                myCase  AA    o  - gt                    System out println o  aa                                myCase  BB    o  - gt                    System out println o  bb                                myCase  YY    o  - gt                    System out println o  yy                                myCase  ZZ    o  - gt                    System out println o  zz                      Will output   YYyy   The sample code uses Strings but you can use any object type  including Class  e g   myCase this getClass     o  - gt       Needs the following 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

User · Answer

Nope  there is no way to do this  What you might want to do is however to consider Polymorphism as a way to handle these kind of problems

User · Answer

As discussed in the top answers  the traditional OOP approach is to use polymorphism instead of switch  There is even a well documented refactoring pattern for this trick  Replace Conditional with Polymorphism  Whenever I reach for this approach  I like to also implement a Null object to provide the default behaviour  Starting with Java 8  we can use lambdas and generics to give us something functional programmers are very familiar with  pattern matching  It s not a core language feature but the VAVR Library - formerly Javaslang library provides one implementation  Example from the docs  Match ofType Number class       caze  Integer i  - gt  i       caze  String s  - gt  new BigDecimal s        orElse    - gt  -1       apply 1 0d      result  -1  It s not the most natural paradigm in the Java world so use it with caution  While the generic methods will save you from having to typecast the matched value  we re missing a standard way to decompose the matched object as with Scala s case classes for example

User · Answer

Create an Enum with Class names   public enum ClassNameEnum       A  B  C     Find the Class name of the object  Write a switch case over the 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                      Hope this helps

User · Answer

If you want to avoid the verbosity of if     else if    you may consider switching this single file to kotlin and use the switch-like when expression in combination with is operator  In any case Kotlin and java files can co-exist in a project  when  this      switch-like statement in kotlin supporting class-pattern-matching and smart casts via  is  operator      is A - gt  doA       is B - gt  doB       is C - gt  doC

User · Answer

if you absolutely cannot code to an interface  then you could use an enum as an intermediary   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

[java] Is it possible to use the instanceof operator in a switch statement?

Examples related to java

Examples related to switch-statement

Examples related to instanceof