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

Java now allows you to switch in the manner of the OP. They call it Pattern Matching for switch. It was released as a preview feature of Java 17 (1) and is a full-fledged (non-preview) feature of Java 21(2). 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 the lambda syntax and returning a value:

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

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

Create a Map where the key is Class<?> and the value is an expression (lambda or similar). Consider:

Map<Class,Runnable> doByClass = new HashMap<>(); doByClass.put(Foo.class, () -> 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<?> 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<Class<?>, Function<String, Object>> UNMARSHALL = Map.of( SimpleBooleanProperty.class, Boolean::parseBoolean, SimpleDoubleProperty.class, Double::parseDouble, SimpleFloatProperty.class, Float::parseFloat, SimpleFileProperty.class, File::new ); private Object unmarshall( final Property<?> property, final Object configValue ) { return UNMARSHALL .getOrDefault( property.getClass(), ( v ) -> v ) .apply( configValue.toString() ); } 

This avoids repetition, eliminates nearly all branching statements, and simplifies maintenance.

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:

1. You just do it like (NO switches at all):

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

2. 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)"

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

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) -> i) .caze((String s) -> new BigDecimal(s)) .orElse(() -> -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.

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

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 } 

java 7+

public <T> T process(Object model) { switch (model.getClass().getSimpleName()) { case "Trade": return processTrade((Trade) model); case "InsuranceTransaction": return processInsuranceTransaction((InsuranceTransaction) model); case "CashTransaction": return processCashTransaction((CashTransaction) model); case "CardTransaction": return processCardTransaction((CardTransaction) model); case "TransferTransaction": return processTransferTransaction((TransferTransaction) model); case "ClientAccount": 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 String TRADE = Trade.class.getName(); ... switch (model.getClass().getName()) { case TRADE: 

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.

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.

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

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)

I personally like the following 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"); }); 

Will output:

YYyy 

The sample code uses Strings but you can use any object type, including Class. e.g. .myCase(this.getClass(), (o) -> ...

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

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.

It is totally possible in Java21.

Here is the example for the same

package org.example; import java.util.List; interface Message { } class TextMessage implements Message { } class ByteMessage implements Message { } class ObjectMessage implements Message { } class BooleanMessage implements Message { } public class SwitchClass { public static void main(String[] args) { List<Message> messageList = List.of( new TextMessage(), new ByteMessage(), new ObjectMessage(), new BooleanMessage() ); for (Message message : messageList) { switch (message) { case TextMessage textMessage-> { System.out.println(textMessage.getClass()); } case ByteMessage byteMessage-> { System.out.println(byteMessage.getClass()); } case ObjectMessage objectMessage-> { System.out.println(objectMessage.getClass()); } case BooleanMessage booleanMessage-> { System.out.println(booleanMessage.getClass()); } default -> { System.out.println("Unknown message type"); } } } } } 

How about this ?

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

Before we get stable pattern matching for switch statement, Java 16/17 could provide limited support with "Pattern Matching for instanceof":

if (req instanceof UserRequest userReq) { userReq.doUserStuff(); } else if (req instanceof AdminRequest adminReq) { adminReq.doAdminStuff(); } 

It frees you from extra casting statement.

See https://openjdk.org/jeps/394

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

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.

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.

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

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

Then where ever the "switch" is needed, you can do it as follows:

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

Starting from Java 17 you can use pattern matching for switch expressions (preview feature) JEP-406.

public void doAction(Object o) { return switch (o) { case A a -> doA(a); case B b -> doB(b); case C c -> doC(c); default -> log.warn("Unrecognized type of {}", o); }; } 

Guard pattern is also available:

public void doAction(Object o) { return switch (o) { case String s && !s.isBlank() -> handle(s); }; } 

You need to enable preview features to use it: java --enable-preview

In Java 19 recent release this has been very easy and useful : Create interface and have method called makesomenoise() which accepts animal parameter.

void makeSomeNoise (Animal animal) { switch (animal) { case Dog dog → dog.bark(); case Cat catcat.meow(); default throw new RuntimeException ("WTH is it???"); } } 

In Java 21 you can use "Pattern Matching for Switch". See https://openjdk.org/jeps/441. This is no preview feature anymore.

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

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.

I think we can do it more naturally without any modifications like this:

switch (true) { case X instanceof A: // do something; break; case X instanceof B: // do something; break; default: // do something; break; } 

Hope it helps! :)

For an even cleaner version, try combining two recent additions to Java

• sealed classes

• switching on instanceof

This allows you to drop the default case as the compiler can now exhaustively check that you have covered all cases.

sealed interface Effect permits Shout, Bark { } record Shout(String value) implements Effect { } record Bark(int times) implements Effect {} 

Which can be switched on like this

switch(effect) { case Shout s -> System.out.println(s.value.toUpperCase()); case Bark b -> { for(int i = 0; i < b.times; i++) System.out.println("Whooof!"); } } 

Works great for approaches relying on Functional Core, Imperative Shell. A fully runnable example is in this Gist