İnstanceof operatörünü bir switch deyiminde kullanmak mümkün müdür?

instanceofNesne için anahtar durumu kullanarak bir sorum var :

Örneğin: sorunum Java ile çoğaltılabilir:

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

Nasıl kullanılır switch...case?

Bu, alt tip polimorfizmin yardımcı olduğu tipik bir senaryodur. Aşağıdakileri yapın

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

Sonra sadece çağırabilir do()üzerinde this.

Değiştirmek ücretsiz değilseniz A, Bve C, aynı ulaşmak için ziyaretçi desen uygulanabilir.

bir arabirime kesinlikle kod yazamıyorsanız, aracı olarak bir enum kullanabilirsiniz:

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;

}

Sadece sınıfın anahtar olduğu ve lambda ya da benzeri işlevin değer olduğu bir Harita oluşturun.

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

// elbette, bunu yalnızca bir kez başlatmak için yeniden düzenleyin

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

İstisnaları atan ve bir Runnable yerine bunu kullanan bir FunctionalInterface uygulamak yerine İstisnalar işaretli gerekiyorsa.

Birisi okuyacaksa:

Java'daki EN İYİ çözüm:

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

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

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

    };

    abstract void doAction (...);
}

Bu modelin BÜYÜK faydaları:

1. Sadece şöyle yapın (HİÇBİR anahtar yok):

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

2. "D" adlı yeni bir Eylem eklerseniz, doAction (...) yöntemini kaldırmanız GEREKİR

NOT: Bu desen Joshua'nın Bloch "Etkili Java (2. Baskı)" bölümünde açıklanmıştır

Yapamazsın. switchİfadesi yalnızca içerebilir casederleme zamanı sabitleri ve bir tamsayı (Java 6 adet olmak üzere ve Java 7 bir dize) için değerlendirmek ifadeleri.

Aradığınız programlamaya fonksiyonel olarak "desen eşleştirme" denir.

Ayrıca bkz.Java'da örneklemekten kaçınma

Üst yanıtlarda tartışıldığı gibi, geleneksel OOP yaklaşımı anahtar yerine polimorfizm kullanmaktır. Bu hile için iyi belgelenmiş bir yeniden düzenleme modeli bile vardır: Koşulluları Polimorfizm ile Değiştir . Ne zaman bu yaklaşım için ulaşmak, ben de varsayılan davranış sağlamak için bir boş nesne uygulamak istiyorum .

Java 8'den başlayarak, fonksiyonel programcıların tanıdık oldukları bir şey vermek için lambdas ve jenerikleri kullanabiliriz: desen eşleştirme. Temel dil özelliği değildir, ancak Javaslang kütüphanesi bir uygulama sağlar. Javadoc'tan bir örnek :

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

Java dünyasındaki en doğal paradigma değil, bu yüzden dikkatli kullanın. Genel yöntemler sizi eşleşen değeri tahmin etmek zorunda kalmayacak olsa da, örneğin eşleşen nesneyi Scala'nın vaka sınıflarında olduğu gibi ayrıştırmanın standart bir yolunu kaçırıyoruz .

Bunun çok geç olduğunu biliyorum ama gelecekteki okuyucular için ...

Sadece A , B , C sınıfının adına dayanan yukarıdaki yaklaşımlara dikkat edin :

Bunu garanti sürece A , B , C ... (bütün alt sınıflar veya uygulayıcıları Base ) olan nihai sonra alt sınıfları A , B , C ... ele alınmayacaktır.

Olsa bile, elseif, elseif .. yaklaşım daha doğrudur, alt sınıflar / Uygulayıcıların sayıda yavaştır.

Maalesef, switch-case deyimi sabit bir ifade beklediğinden kutunun dışında mümkün değildir. Bunun üstesinden gelmek için bir yol sınıf numaralarıyla enum değerlerini kullanmak olacaktır.

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

Bununla bu şekilde switch deyimini kullanmak mümkündür

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
}

Hayır, bunu yapmanın bir yolu yok. Ancak yapmak isteyebileceğiniz şey, Polimorfizmi bu tür problemleri çözmenin bir yolu olarak düşünmektir .

Bunun gibi switch deyimlerini kullanmak nesne yönelimli bir yol değildir. Bunun yerine polimorfizmin gücünü kullanmalısınız . Basitçe yazın

this.do()

Daha önce bir temel sınıf oluşturmuş olmanız durumunda:

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

bunun için temel sınıftır A, Bve 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() }
}

Bu, daha hızlı çalışacak ve
göreceli olarak çok sayıda ' vakanız' olması durumunda
performansa duyarlı bağlamda süreç yürütülecektir

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

Bir anahtar yalnızca bayt, kısa, char, int, String ve numaralandırılmış türlerle (ve ilkellerin nesne sürümleri ile çalışır, ayrıca java sürümünüze bağlıdır, Dizeler switchjava 7'de düzenlenebilir)

Şahsen aşağıdaki Java 1.8 kodunu beğendim:

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

Çıktı olacak:

YYyy

Örnek kod Dizeler kullanır, ancak Sınıf dahil herhangi bir nesne türünü kullanabilirsiniz. Örneğin.myCase(this.getClass(), (o) -> ...

Aşağıdaki snippet'e ihtiyaç var:

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 artık OP biçiminde geçiş yapmanıza izin veriyor. Buna anahtar için Desen Eşleme diyorlar . Şu anda Taslak altında ama son zamanlarda anahtarlara ne kadar iş koyduklarını görünce bence geçecek. JEP'te verilen örnek

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

veya lambda sözdizimlerini kullanarak ve bir değer döndürerek

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

her iki durumda da anahtarlarla harika şeyler yapıyorlar.

Ortak arabirimi değiştirebiliyorsanız, bir numaralandırma ekleyebilir ve her sınıfın benzersiz bir değer döndürmesini sağlayabilirsiniz. Anlık veya ziyaretçi modeline ihtiyacınız olmayacak.

Benim için, mantığın nesnenin kendisi değil, switch deyiminde yazılı olması gerekiyordu. Bu benim çözümümdü:

ClassA, ClassB, and ClassC implement CommonClass

Arayüz:

public interface CommonClass {
   MyEnum getEnumType();
}

Sıralama:

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 kullanıyorsanız, numaralandırma için dize değerleri koyabilirsiniz ve anahtar kutusu bloğu yine de çalışır.

Buna ne dersin ?

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

Bir anahtar deyimi kullanmanın nedenleri olduğunu düşünüyorum. Belki xText tarafından üretilen Kod kullanıyorsanız. Ya da başka bir tür EMF tarafından üretilen sınıflar.

instance.getClass().getName();

Sınıf Uygulama Adı Dizesini döndürür. ör .: org.eclipse.emf.ecore.util.EcoreUtil

instance.getClass().getSimpleName();

basit temsili döndürür yani: EcoreUtil

"Bu" nesnenin sınıf türünden "geçmeniz" gerekiyorsa, bu yanıt en iyisidir https://stackoverflow.com/a/5579385/2078368

Ancak başka bir değişkene "switch" uygulamanız gerekiyorsa. Başka bir çözüm öneririm. Aşağıdaki arayüzü tanımlayın:

public interface ClassTypeInterface {
    public String getType();
}

Bu arabirimi "değiştirmek" istediğiniz her sınıfa uygulayın. Misal:

public class A extends Something implements ClassTypeInterface {

    public final static String TYPE = "A";

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

Bundan sonra aşağıdaki şekilde kullanabilirsiniz:

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

İlgilenmeniz gereken tek şey, "türleri" ClassTypeInterface uygulayan tüm sınıflar boyunca benzersiz tutun. Bu büyük bir sorun değildir, çünkü herhangi bir kavşak durumunda "switch-case" ifadesi için derleme zamanı hatası alırsınız.

İşte http://www.vavr.io/ kullanarak Java 8'de bunu gerçekleştirmenin işlevsel bir yolu

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

Bir switch deyimi yazmak mümkün olmasa da, verilen her tip için belirli işlemlere dallanmak mümkündür. Bunu yapmanın bir yolu, standart çift sevk mekanizmasını kullanmaktır. Türe dayalı olarak "değiştirmek" istediğimiz bir örnek, çok sayıda istisnayı hata yanıtlarına eşlememiz gereken Jersey İstisna eşleştiricisidir. Bu özel durum için muhtemelen daha iyi bir yol olsa da (yani, her bir istisnayı bir hata yanıtına çeviren polimorfik bir yöntem kullanmak), çift gönderme mekanizması kullanmak hala yararlı ve pratiktir.

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

Sonra "anahtar" gerekli olduğunda, bunu aşağıdaki gibi yapabilirsiniz:

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

Sınıf adlarıyla bir Numaralandırma oluşturun .

public enum ClassNameEnum {
    A, B, C
}

Nesnenin Sınıf adını bulun . Numaralandırma üzerine bir anahtar kutusu yazın .

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

Bu yardımcı olur umarım.

Eclipse Modelleme Çerçevesi miras olarak da değerlendiren ilginç bir fikre sahiptir. Temel kavram Anahtar arayüzünde tanımlanır : Anahtarlama doSwitch yöntemi çağrılarak yapılır .

Gerçekten ilginç olan uygulama. Her bir ilgi türü için,

public T caseXXXX(XXXX object);

yönteminin uygulanması gerekir (varsayılan uygulama null döndürür). DoSwitch uygulaması arkadaşları aramayı dener caseXXX tüm tip hiyerarşisi için nesne üzerinde yöntemler. Çizgilerdeki bir şey:

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;

Gerçek çerçeve, her sınıf için bir tamsayı kimliği kullanır, bu nedenle mantık aslında saf bir anahtardır:

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

Daha iyi bir fikir edinmek için ECoreSwitch'in eksiksiz bir uygulamasına bakabilirsiniz .

instanceof kullanan bir anahtar yapısını taklit etmenin daha basit bir yolu var, bunu yönteminizde bir kod bloğu oluşturarak ve bir etiketle adlandırarak yaparsınız. Sonra case yapılarını vaka ifadelerini taklit etmek için kullanırsınız. Bir durum doğruysa derme çatma anahtar yapınızdan çıkmak için LABEL_NAME adlı mola kullanırsınız.

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