เป็นไปได้ไหมที่จะใช้ตัวดำเนินการ instanceof ในคำสั่ง switch?

ฉันมีคำถามเกี่ยวกับการใช้สวิตช์ตัวพิมพ์เล็กสำหรับinstanceofวัตถุ:

ตัวอย่างเช่นปัญหาของฉันสามารถทำซ้ำได้ใน Java:

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

มันจะใช้งานได้switch...caseอย่างไร?

นี่เป็นสถานการณ์โดยทั่วไปที่ polymorphism ชนิดย่อยช่วยได้ ทำดังต่อไปนี้

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

แล้วคุณก็สามารถโทรได้ที่do()this

หากคุณยังไม่สามารถเปลี่ยนA, BและCคุณสามารถใช้รูปแบบของผู้เข้าชมเพื่อให้บรรลุเดียวกัน

หากคุณไม่สามารถโค้ดไปยังอินเทอร์เฟซได้คุณสามารถใช้ enum เป็นตัวกลางได้:

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;

}

เพียงแค่สร้างแผนที่โดยที่คลาสเป็นกุญแจสำคัญและฟังก์ชั่นเช่นแลมบ์ดาหรือที่คล้ายกันคือค่า

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 นี้เพื่อเริ่มต้นครั้งเดียวเท่านั้น

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

หากคุณต้องการตรวจสอบข้อยกเว้นมากกว่าใช้ FunctionInterface ที่ส่งข้อยกเว้นและใช้สิ่งนั้นแทน Runnable

ในกรณีที่มีคนอ่านมัน:

ทางออกที่ดีที่สุดใน java คือ:

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

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

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

    };

    abstract void doAction (...);
}

ประโยชน์ที่ดีของรูปแบบดังกล่าวคือ:

1. คุณเพียงแค่ชอบ (ไม่มีสวิตช์เลย):

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

2. ในกรณีที่คุณเพิ่มการกระทำใหม่ที่เรียกว่า "d" คุณจะต้องเติมวิธีการ doAction (... )

หมายเหตุ: รูปแบบนี้ได้อธิบายไว้ใน Bloch ของ Joshua "Effective Java (2nd Edition)"

คุณทำไม่ได้ switchคำสั่งสามารถมีcaseงบที่มีค่าคงที่เวลารวบรวมและประเมินผลการศึกษาเป็นจำนวนเต็ม (สูงสุด 6 Java และสตริงใน Java 7)

สิ่งที่คุณกำลังมองหาเรียกว่า "การจับคู่รูปแบบ" ในการเขียนโปรแกรมการทำงาน

ดูเพิ่มเติมการหลีกเลี่ยงอินสแตนซ์ใน Java

ตามที่กล่าวไว้ในคำตอบยอดนิยมวิธี OOP แบบดั้งเดิมคือการใช้ polymorphism แทนสวิตช์ แม้จะมีเอกสารที่ดีรูปแบบ refactoring เคล็ดลับนี้: เปลี่ยนเงื่อนไขที่มีความแตกต่าง เมื่อใดก็ตามที่ฉันเข้าถึงวิธีนี้ฉันชอบที่จะใช้วัตถุ Nullเพื่อให้พฤติกรรมเริ่มต้น

เริ่มต้นด้วย Java 8 เราสามารถใช้ lambdas และ generics เพื่อให้บางสิ่งบางอย่างที่โปรแกรมเมอร์ผู้คุ้นเคยกับการทำงาน: การจับคู่รูปแบบ มันไม่ได้เป็นคุณสมบัติภาษาหลัก แต่ห้องสมุด Javaslangมีการใช้งานเพียงครั้งเดียว ตัวอย่างจากjavadoc :

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

นี่ไม่ใช่กระบวนทัศน์ที่เป็นธรรมชาติที่สุดในโลกของ Java ดังนั้นควรใช้ด้วยความระมัดระวัง ในขณะที่วิธีการทั่วไปที่จะช่วยให้คุณไม่ต้อง typecast ค่าที่ตรงกับที่เรากำลังขาดหายไปเป็นวิธีมาตรฐานในการย่อยสลายวัตถุจับคู่เช่นเดียวกับกาลาเรียนกรณีตัวอย่าง

ฉันรู้ว่ามันสายมาก แต่สำหรับผู้อ่านในอนาคต ...

ระวังวิธีการข้างต้นที่ใช้ชื่อคลาสA , B , C เท่านั้น :

หากคุณไม่สามารถรับประกันได้ว่าA , B , C ... (คลาสย่อยทั้งหมดหรือตัวดำเนินการของฐาน ) ถือเป็นที่สิ้นสุดดังนั้นคลาสย่อยของA , B , C ... จะไม่ได้รับการจัดการ

ถึงแม้ว่าif, elseif, elseif .. จะช้ากว่าสำหรับ subclasses / implementers จำนวนมาก แต่ก็มีความแม่นยำมากกว่า

น่าเสียดายที่มันเป็นไปไม่ได้นอกกรอบเนื่องจากคำสั่ง switch-case คาดว่านิพจน์คงที่ เพื่อเอาชนะสิ่งนี้วิธีหนึ่งคือใช้ค่า enum กับชื่อคลาสเช่น

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

ด้วยที่เป็นไปได้ที่จะใช้คำสั่งเปลี่ยนเช่นนี้

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
}

ไม่ไม่มีวิธีการทำเช่นนี้ สิ่งที่คุณอาจต้องการทำคือพิจารณาความแตกต่างเป็นวิธีจัดการกับปัญหาเหล่านี้

การใช้คำสั่งสวิตช์เช่นนี้ไม่ใช่วิธีการวางวัตถุ คุณควรใช้พลังของพหุสัณฐานแทน เพียงแค่เขียน

this.do()

มีก่อนหน้านี้ตั้งค่าคลาสฐาน:

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

ซึ่งเป็นชั้นฐานสำหรับA, Bและ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() }
}

สิ่งนี้จะทำงานได้เร็วขึ้นและทำให้รู้สึกได้ในกรณีที่
คุณมี 'กรณี' จำนวนมาก
- กระบวนการถูกดำเนินการในบริบทที่อ่อนไหวด้านประสิทธิภาพ

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

คุณไม่สามารถสลับใช้งานได้เฉพาะกับไบต์, สั้น, ถ่าน, int, สตริงและประเภทที่ระบุ (และรุ่นวัตถุของดั้งเดิมก็ยังขึ้นอยู่กับรุ่นจาวาของคุณ Strings สามารถแก้ไขได้switchใน java 7)

ส่วนตัวผมชอบโค้ด 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");
            });

จะส่งออก:

YYyy

โค้ดตัวอย่างใช้ Strings แต่คุณสามารถใช้ชนิดวัตถุใดก็ได้รวมถึง Class เช่น.myCase(this.getClass(), (o) -> ...

ต้องการตัวอย่างต่อไปนี้:

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 อนุญาตให้คุณสลับในลักษณะของ OP พวกเขาเรียกมันว่าการจับคู่แบบสำหรับสวิตช์ ขณะนี้อยู่ภายใต้ร่าง แต่เห็นจำนวนงานที่พวกเขาใส่สวิตช์เมื่อเร็ว ๆ นี้ฉันคิดว่ามันจะผ่านไป ตัวอย่างที่ให้ไว้ใน 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();
}  

หรือใช้ไวยากรณ์แลมบ์ดาของพวกเขาและคืนค่า

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

ไม่ว่าพวกเขาจะทำสิ่งที่ยอดเยี่ยมด้วยสวิตช์

หากคุณสามารถจัดการกับอินเตอร์เฟสทั่วไปคุณสามารถเพิ่มใน enum และให้แต่ละคลาสส่งคืนค่าที่ไม่ซ้ำกัน คุณไม่ต้องการอินสแตนซ์หรือรูปแบบผู้เยี่ยมชม

สำหรับฉันแล้วตรรกะจำเป็นต้องอยู่ในคำสั่ง switch ในการเขียนไม่ใช่วัตถุเอง นี่คือทางออกของฉัน:

ClassA, ClassB, and ClassC implement CommonClass

อินเตอร์เฟซ:

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

หากคุณอยู่บน java 7 คุณสามารถใส่ค่าสตริงสำหรับ enum และบล็อกตัวสลับ case จะยังคงทำงาน

แล้วเรื่องนี้ล่ะ

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

ฉันคิดว่ามีเหตุผลที่จะใช้คำสั่งเปลี่ยน หากคุณใช้รหัส xText ที่สร้างขึ้นอาจจะ หรือคลาสอื่นที่สร้างคลาส EMF

instance.getClass().getName();

ส่งคืนสตริงของชื่อการใช้งานคลาส ie: org.eclipse.emf.ecore.util.EcoreUtil

instance.getClass().getSimpleName();

ส่งคืนการพิมพ์ซ้ำอย่างง่ายเช่น: EcoreUtil

หากคุณต้องการ "สลับ" ผ่านประเภทคลาสของวัตถุ "this" คำตอบนี้เป็นhttps://stackoverflow.com/a/5579385/2078368 ที่ดีที่สุด

แต่ถ้าคุณต้องการใช้ "เปลี่ยน" กับตัวแปรอื่น ๆ ฉันขอแนะนำวิธีแก้ไขปัญหาอื่น กำหนดอินเตอร์เฟสต่อไปนี้:

public interface ClassTypeInterface {
    public String getType();
}

ใช้อินเทอร์เฟซนี้ในทุกคลาสที่คุณต้องการ "สลับ" ตัวอย่าง:

public class A extends Something implements ClassTypeInterface {

    public final static String TYPE = "A";

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

หลังจากนั้นคุณสามารถใช้วิธีดังต่อไปนี้:

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

สิ่งเดียวที่คุณควรใส่ใจ - รักษา "ประเภท" ที่ไม่ซ้ำกันในทุกคลาสที่ใช้ ClassTypeInterface ไม่ใช่ปัญหาใหญ่เพราะในกรณีที่มีการตัดกันคุณได้รับข้อผิดพลาดในการคอมไพล์สำหรับคำสั่ง "switch-case"

นี่คือวิธีการใช้งานเพื่อให้บรรลุผลใน Java 8 โดยใช้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)
        );
    }

แม้ว่ามันจะเป็นไปไม่ได้ที่จะเขียนคำสั่ง switch แต่มันก็เป็นไปได้ที่จะแยกออกไปประมวลผลเฉพาะสำหรับแต่ละประเภทที่กำหนด วิธีหนึ่งในการทำเช่นนี้คือการใช้กลไกการจัดส่งแบบคู่มาตรฐาน ตัวอย่างที่เราต้องการ "สลับ" ตามชนิดคือ mapper การยกเว้นของ Jersey ที่เราต้องการแมปข้อยกเว้นมากมายกับการตอบสนองข้อผิดพลาด ในขณะที่กรณีเฉพาะนี้อาจเป็นวิธีที่ดีกว่า (เช่นการใช้วิธี polymorphic ที่แปลแต่ละข้อยกเว้นเพื่อตอบสนองข้อผิดพลาด) การใช้กลไกการจัดส่งคู่ยังคงมีประโยชน์และใช้งานได้จริง

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

จากนั้นเมื่อใดก็ตามที่จำเป็นต้องใช้ "สวิตช์" คุณสามารถทำได้ดังนี้:

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

สร้างEnumด้วยชื่อคลาส

public enum ClassNameEnum {
    A, B, C
}

ค้นหาชื่อคลาสของวัตถุ เขียนเคสสวิตช์บน 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;
        }
    }
}

หวังว่านี่จะช่วยได้

Eclipse Modeling Framework มีแนวคิดที่น่าสนใจที่พิจารณาการสืบทอด แนวคิดพื้นฐานถูกกำหนดไว้ในส่วนต่อประสาน Switch : การสลับทำโดยเรียกใช้doSwitchเมธอด

สิ่งที่น่าสนใจจริงๆคือการนำไปใช้ สำหรับความสนใจแต่ละประเภทก

public T caseXXXX(XXXX object);

วิธีการจะต้องดำเนินการ การประยุกต์ใช้doSwitchจะพยายามเรียกใช้เมธอด caseXXXบนอ็อบเจ็กต์สำหรับลำดับชั้นชนิดทั้งหมด บางอย่างในบรรทัด:

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;

กรอบงานที่แท้จริงใช้จำนวนเต็มสำหรับแต่ละชั้นเรียนดังนั้นตรรกะจึงเป็นสวิตช์บริสุทธิ์:

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

คุณสามารถดูการนำECoreSwitchไปปฏิบัติอย่างสมบูรณ์เพื่อรับแนวคิดที่ดียิ่งขึ้น

มีวิธีที่ง่ายกว่าในการเลียนแบบโครงสร้างสวิตช์ที่ใช้อินสแตนซ์ของคุณทำสิ่งนี้โดยการสร้างบล็อคโค้ดในวิธีการของคุณและตั้งชื่อมันด้วยฉลาก จากนั้นคุณใช้ถ้าโครงสร้างเลียนแบบคำสั่ง case หากกรณีเป็นจริงคุณต้องใช้ตัวแบ่ง LABEL_NAME เพื่อออกจากโครงสร้างสวิตช์ชั่วคราว

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