Apakah mungkin untuk menggunakan instance dari operator dalam pernyataan switch?

Saya memiliki pertanyaan tentang penggunaan sakelar untuk instanceofobjek:

Sebagai contoh: masalah saya dapat direproduksi di Jawa:

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

Bagaimana itu diterapkan menggunakan switch...case?

Ini adalah skenario khas di mana subtipe polimorfisme membantu. Lakukan hal berikut

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

Maka Anda hanya dapat memanggil do()pada this.

Jika Anda tidak bebas untuk mengubah A, Bdan C, Anda bisa menerapkan pola pengunjung untuk mencapai yang sama.

jika Anda benar-benar tidak bisa membuat kode ke antarmuka, maka Anda bisa menggunakan enum sebagai perantara:

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;

}

Cukup buat Peta di mana kelas adalah kuncinya dan fungsinya, yaitu lambda atau sejenisnya, adalah nilainya.

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

// tentu saja, perbaiki ini hanya untuk menginisialisasi sekali

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

Jika Anda perlu memeriksa Pengecualian daripada mengimplementasikan FunctionalInterface yang melempar Pengecualian dan gunakan itu alih-alih Runnable.

Untuk jaga-jaga jika seseorang akan membacanya:

Solusi TERBAIK di java adalah:

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

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

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

    };

    abstract void doAction (...);
}

Manfaat BESAR dari pola tersebut adalah:

1. Anda cukup melakukannya (TIDAK ADA saklar sama sekali):

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

2. Jika Anda menambahkan Aksi baru yang disebut "d", Anda HARUS menerapkan metode doAction (...)

CATATAN: Pola ini dijelaskan dalam Joshua's Bloch "Java Efektif (Edisi 2)"

Kamu tidak bisa The switchpernyataan hanya dapat berisi casepernyataan yang konstanta waktu kompilasi dan yang mengevaluasi ke integer (Sampai dengan Java 6 dan string di Jawa 7).

Apa yang Anda cari disebut "pencocokan pola" dalam pemrograman fungsional.

Lihat juga Menghindari contoh di Jawa

Sebagaimana dibahas dalam jawaban teratas, pendekatan OOP tradisional adalah menggunakan polimorfisme alih-alih beralih. Bahkan ada pola refactoring yang terdokumentasi dengan baik untuk trik ini: Ganti Kondisional dengan Polimorfisme . Setiap kali saya meraih pendekatan ini, saya juga ingin mengimplementasikan objek Null untuk memberikan perilaku default.

Dimulai dengan Java 8, kita bisa menggunakan lambdas dan generik untuk memberi kita sesuatu yang programmer sangat akrab dengan: pencocokan pola. Ini bukan fitur bahasa inti tetapi perpustakaan Javaslang menyediakan satu implementasi. Contoh dari javadoc :

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

Ini bukan paradigma paling alami di dunia Jawa jadi gunakan dengan hati-hati. Sementara metode generik akan menyelamatkan Anda dari keharusan mengetikkan nilai yang cocok, kami kehilangan cara standar untuk menguraikan objek yang cocok seperti dengan kelas kasus Scala misalnya.

Saya tahu ini sangat terlambat tetapi bagi pembaca di masa depan ...

Waspadalah terhadap pendekatan di atas yang hanya didasarkan pada nama kelas A , B , C ...:

Kecuali jika Anda dapat menjamin bahwa A , B , C ... (semua subclass atau pelaksana Basis ) final, maka subclass dari A , B , C ... tidak akan ditangani.

Meskipun pendekatan if, elseif, elseif .. lebih lambat untuk sejumlah besar subclass / pelaksana, itu lebih akurat.

Sayangnya, tidak mungkin keluar dari kotak karena pernyataan switch-case mengharapkan ekspresi yang konstan. Untuk mengatasinya, salah satu caranya adalah dengan menggunakan nilai enum dengan nama kelas mis

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

Dengan itu dimungkinkan untuk menggunakan pernyataan switch seperti ini

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
}

Tidak, tidak ada cara untuk melakukan ini. Namun yang mungkin ingin Anda lakukan adalah mempertimbangkan Polimorfisme sebagai cara untuk menangani masalah semacam ini.

Menggunakan pernyataan switch seperti ini bukan cara berorientasi objek. Anda sebaiknya menggunakan kekuatan polimorfisme . Cukup tulis

this.do()

Setelah sebelumnya membuat kelas dasar:

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

yang merupakan kelas dasar untuk A, Bdan 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() }
}

Ini akan bekerja lebih cepat dan masuk akal jika
- Anda memiliki banyak 'kasus'
- proses dieksekusi dalam konteks sensitif kinerja

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

Anda tidak dapat beralih hanya bekerja dengan byte, pendek, char, int, String dan jenis enumerated (dan versi objek primitif, itu juga tergantung pada versi java Anda, String dapat switchdiedit di dalam java 7)

Saya pribadi suka kode Java 1.8 berikut:

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

Akan menghasilkan:

YYyy

Kode sampel menggunakan Strings tetapi Anda dapat menggunakan jenis objek apa pun, termasuk Kelas. misalnya.myCase(this.getClass(), (o) -> ...

Perlu cuplikan berikut:

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 sekarang memungkinkan Anda untuk beralih dengan cara OP. Mereka menyebutnya Pencocokan Pola untuk sakelar. Saat ini sedang dalam Rancangan tetapi melihat berapa banyak pekerjaan yang telah mereka masukkan ke switch baru-baru ini saya pikir itu akan melalui. Contoh yang diberikan dalam JEP adalah

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

atau menggunakan sintaks lambda mereka dan mengembalikan nilai

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

bagaimanapun mereka telah melakukan hal-hal keren dengan sakelar.

Jika Anda dapat memanipulasi antarmuka umum, Anda bisa menambahkan enum dan meminta setiap kelas mengembalikan nilai unik. Anda tidak memerlukan instanceof atau pola pengunjung.

Bagi saya, logika perlu ditulis dalam pernyataan switch, bukan objek itu sendiri. Ini solusi saya:

ClassA, ClassB, and ClassC implement CommonClass

Antarmuka:

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

Implan:

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

Jika Anda menggunakan java 7, Anda bisa meletakkan nilai string untuk enum dan blok kasus sakelar akan tetap berfungsi.

Bagaimana dengan ini ?

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

Saya pikir ada alasan untuk menggunakan pernyataan switch. Jika Anda menggunakan xText, kode yang dihasilkan mungkin. Atau jenis lain dari kelas yang dihasilkan EMF.

instance.getClass().getName();

mengembalikan sebuah String dari Nama Implementasi Kelas. yaitu: org.eclipse.emf.ecore.util.EcoreUtil

instance.getClass().getSimpleName();

mengembalikan representasi sederhana yaitu: EcoreUtil

Jika Anda perlu "beralih" melalui tipe objek "ini" kelas ini, jawaban ini adalah yang terbaik https://stackoverflow.com/a/5579385/2078368

Tetapi jika Anda perlu menerapkan "beralih" ke variabel lain. Saya akan menyarankan solusi lain. Tetapkan antarmuka berikut:

public interface ClassTypeInterface {
    public String getType();
}

Terapkan antarmuka ini di setiap kelas yang Anda ingin "beralih". Contoh:

public class A extends Something implements ClassTypeInterface {

    public final static String TYPE = "A";

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

Setelah itu Anda bisa menggunakannya dengan cara berikut:

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

Satu-satunya hal yang harus Anda perhatikan - pertahankan "tipe" unik di semua kelas yang mengimplementasikan ClassTypeInterface. Ini bukan masalah besar, karena jika ada persimpangan Anda menerima kesalahan waktu kompilasi untuk pernyataan "sakelar kasus".

Berikut cara fungsional untuk menyelesaikannya di Java 8 menggunakan 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)
        );
    }

Meskipun tidak mungkin untuk menulis pernyataan switch, dimungkinkan untuk bercabang ke pemrosesan spesifik untuk setiap jenis yang diberikan. Salah satu cara untuk melakukan ini adalah dengan menggunakan mekanisme pengiriman ganda standar. Contoh di mana kita ingin "beralih" berdasarkan tipe adalah Jersey Exception mapper di mana kita perlu memetakan banyak pengecualian untuk respons kesalahan. Sementara untuk kasus khusus ini mungkin ada cara yang lebih baik (yaitu menggunakan metode polimorfik yang menerjemahkan setiap pengecualian ke respons kesalahan), menggunakan mekanisme pengiriman ganda masih berguna dan praktis.

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

Maka di mana pun "saklar" dibutuhkan, Anda dapat melakukannya sebagai berikut:

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

Buat Enum dengan nama Kelas.

public enum ClassNameEnum {
    A, B, C
}

Temukan nama kelas objek. Tulis kotak saklar di atas 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;
        }
    }
}

Semoga ini membantu.

Kerangka Pemodelan Eclipse memiliki ide menarik yang juga mempertimbangkan warisan. Konsep dasar didefinisikan dalam antarmuka Switch : switching dilakukan dengan memanggil metode doSwitch .

Yang benar-benar menarik adalah implementasinya. Untuk setiap jenis bunga, a

public T caseXXXX(XXXX object);

Metode harus diimplementasikan (dengan implementasi standar mengembalikan nol). The doSwitch implementasi akan mencoba untuk memanggil al caseXXX metode pada objek untuk semua jenis hirarki-nya. Sesuatu di baris:

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;

Kerangka kerja yang sebenarnya menggunakan id integer untuk setiap kelas, jadi logikanya sebenarnya adalah saklar murni:

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

Anda dapat melihat implementasi lengkap ECoreSwitch untuk mendapatkan ide yang lebih baik.

bahkan ada cara yang lebih sederhana untuk meniru struktur saklar yang menggunakan instanceof, Anda melakukan ini dengan membuat blok kode dalam metode Anda dan menamainya dengan label. Kemudian Anda menggunakan struktur jika untuk meniru pernyataan kasus. Jika kasing benar maka Anda menggunakan break LABEL_NAME untuk keluar dari struktur sakelar sementara Anda.

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