108

「instanceof」操作のチェーンを持つことは、「コードの匂い」と見なされます。標準的な答えは、「ポリモーフィズムを使用する」です。この場合、どうすればよいでしょうか?

基本クラスにはいくつかのサブクラスがあります。それらのどれも私の管理下にはありません。同様の状況は、Java クラスの Integer、Double、BigDecimal などにも当てはまります。

if (obj instanceof Integer) {NumberStuff.handle((Integer)obj);}
else if (obj instanceof BigDecimal) {BigDecimalStuff.handle((BigDecimal)obj);}
else if (obj instanceof Double) {DoubleStuff.handle((Double)obj);}

私は NumberStuff などを制御できます。

数行で済むところに多くのコード行を使用したくありません。(時々、Integer.class を IntegerStuff のインスタンスに、BigDecimal.class を BigDecimalStuff のインスタンスにマッピングする HashMap を作成します。しかし、今日はもっと単純なものが必要です。)

私はこのような単純なものが欲しいです:

public static handle(Integer num) { ... }
public static handle(BigDecimal num) { ... }

しかし、Java はそのようには機能しません。

書式設定時に静的メソッドを使用したいと思います。私が書式設定しているものは複合であり、Thing1 には配列 Thing2 を含めることができ、Thing2 には Thing1 の配列を含めることができます。次のようにフォーマッターを実装したときに問題が発生しました。

class Thing1Formatter {
  private static Thing2Formatter thing2Formatter = new Thing2Formatter();
  public format(Thing thing) {
      thing2Formatter.format(thing.innerThing2);
  }
}
class Thing2Formatter {
  private static Thing1Formatter thing1Formatter = new Thing1Formatter();
  public format(Thing2 thing) {
      thing1Formatter.format(thing.innerThing1);
  }
}

はい、私は HashMap を知っており、もう少しコードを修正することもできます。しかし、「instanceof」は比較すると非常に読みやすく、保守しやすいようです。シンプルだけど臭くないものってありますか?

2010 年 5 月 10 日に追加された注:

新しいサブクラスが将来追加される可能性が高く、既存のコードでそれらを適切に処理する必要があることがわかりました。その場合、クラスが見つからないため、クラスの HashMap は機能しません。最も具体的なものから始まり、最も一般的なもので終わる一連の if ステートメントは、結局のところ、おそらく最適です。

if (obj instanceof SubClass1) {
    // Handle all the methods and properties of SubClass1
} else if (obj instanceof SubClass2) {
    // Handle all the methods and properties of SubClass2
} else if (obj instanceof Interface3) {
    // Unknown class but it implements Interface3
    // so handle those methods and properties
} else if (obj instanceof Interface4) {
    // likewise.  May want to also handle case of
    // object that implements both interfaces.
} else {
    // New (unknown) subclass; do what I can with the base class
}
4

9 に答える 9

60

Steve Yegge の Amazon ブログのエントリ「when polymorphism fails」に興味があるかもしれません。基本的に彼は、ポリモーフィズムが解決するよりも多くの問題を引き起こす、このようなケースに取り組んでいます。

問題は、ポリモーフィズムを使用するには、各「スイッチング」クラスの「ハンドル」部分のロジックを作成する必要があることです。つまり、この場合は整数などです。明らかにこれは実用的ではありません。コードを配置するのに論理的にも適切でない場合もあります。彼は、'instanceof' アプローチをいくつかの悪の中でより少ないものとして推奨しています。

においのするコードを書かざるを得ないすべての場合と同様に、においが漏れないように、コードを 1 つのメソッド (または多くても 1 つのクラス) に留めておきます。

于 2010-05-07T16:51:34.100 に答える
20

コメントで強調されているように、訪問者パターンは適切な選択です。しかし、ターゲット/アクセプター/ビジティーを直接制御しないと、そのパターンを実装できません。ラッパーを使用してサブクラスを直接制御することはできませんが (例として Integer を取り上げます)、ビジター パターンをここで使用できる可能性がある方法の 1 つを次に示します。

public class IntegerWrapper {
    private Integer integer;
    public IntegerWrapper(Integer anInteger){
        integer = anInteger;
    }
    //Access the integer directly such as
    public Integer getInteger() { return integer; }
    //or method passthrough...
    public int intValue() { return integer.intValue(); }
    //then implement your visitor:
    public void accept(NumericVisitor visitor) {
        visitor.visit(this);
    }
}

もちろん、最終的なクラスをラップすることは、それ自体が臭いと見なされるかもしれませんが、サブクラスには適しているかもしれません。instanceof個人的には、特にそれが1つの方法に限定されていて、喜んでそれを使用する場合(おそらく上記の私自身の提案を超えて)、ここでの臭いはそれほど悪いとは思いません. あなたが言うように、それは非常に読みやすく、タイプセーフで、保守可能です。いつものように、シンプルにしてください。

于 2010-05-07T20:02:09.220 に答える
17

huge の代わりに、if処理するインスタンスをマップ (キー: クラス、値: ハンドラー) に配置できます。

キーによるルックアップが を返す場合null、一致するハンドラーを見つけようとする特別なハンドラー メソッドを呼び出します (たとえばisInstance()、マップ内のすべてのキーを呼び出すことによって)。

ハンドラが見つかったら、新しいキーの下に登録します。

これにより、一般的なケースが迅速かつ簡単になり、継承を処理できるようになります。

于 2010-06-05T22:43:01.780 に答える
15

リフレクションを使用できます:

public final class Handler {
  public static void handle(Object o) {
    try {
      Method handler = Handler.class.getMethod("handle", o.getClass());
      handler.invoke(null, o);
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }
  public static void handle(Integer num) { /* ... */ }
  public static void handle(BigDecimal num) { /* ... */ }
  // to handle new types, just add more handle methods...
}

アイデアを拡張して、特定のインターフェイスを実装するサブクラスとクラスを一般的に処理できます。

于 2011-01-14T16:13:05.470 に答える
10

最良の解決策は、Class をキー、Handler を値とする HashMap だと思います。HashMap ベースのソリューションは一定のアルゴリズムの複雑さ θ(1) で実行されますが、if-instanceof-else の臭いチェーンは線形のアルゴリズムの複雑さ O(N) で実行されます。ここで、N は if-instanceof-else チェーンのリンクの数です。 (つまり、処理される異なるクラスの数)。したがって、HashMap ベースのソリューションのパフォーマンスは、if-instanceof-else チェーン ソリューションのパフォーマンスよりも漸近的に N 倍高くなります。Message クラスのさまざまな子孫を異なる方法で処理する必要があることを考慮してください: Message1、Message2 など。以下は、HashMap ベースの処理のコード スニペットです。

public class YourClass {
    private class Handler {
        public void go(Message message) {
            // the default implementation just notifies that it doesn't handle the message
            System.out.println(
                "Possibly due to a typo, empty handler is set to handle message of type %s : %s",
                message.getClass().toString(), message.toString());
        }
    }
    private Map<Class<? extends Message>, Handler> messageHandling = 
        new HashMap<Class<? extends Message>, Handler>();

    // Constructor of your class is a place to initialize the message handling mechanism    
    public YourClass() {
        messageHandling.put(Message1.class, new Handler() { public void go(Message message) {
            //TODO: IMPLEMENT HERE SOMETHING APPROPRIATE FOR Message1
        } });
        messageHandling.put(Message2.class, new Handler() { public void go(Message message) {
            //TODO: IMPLEMENT HERE SOMETHING APPROPRIATE FOR Message2
        } });
        // etc. for Message3, etc.
    }

    // The method in which you receive a variable of base class Message, but you need to
    //   handle it in accordance to of what derived type that instance is
    public handleMessage(Message message) {
        Handler handler = messageHandling.get(message.getClass());
        if (handler == null) {
            System.out.println(
                "Don't know how to handle message of type %s : %s",
                message.getClass().toString(), message.toString());
        } else {
            handler.go(message);
        }
    }
}

Java での Class 型の変数の使用に関する詳細: http://docs.oracle.com/javase/tutorial/reflect/class/classNew.html

于 2014-12-19T13:39:24.220 に答える
9

Chain of Responsibility パターンを考えることができます。最初の例では、次のようになります。

public abstract class StuffHandler {
   private StuffHandler next;

   public final boolean handle(Object o) {
      boolean handled = doHandle(o);
      if (handled) { return true; }
      else if (next == null) { return false; }
      else { return next.handle(o); }
   }

   public void setNext(StuffHandler next) { this.next = next; }

   protected abstract boolean doHandle(Object o);
}

public class IntegerHandler extends StuffHandler {
   @Override
   protected boolean doHandle(Object o) {
      if (!o instanceof Integer) {
         return false;
      }
      NumberHandler.handle((Integer) o);
      return true;
   }
}

次に、他のハンドラーについても同様です。次に、StuffHandlers を順番に並べる場合 (最も具体的なものから最も具体的でないものへ、最終的な「フォールバック」ハンドラーを使用) であり、ディスパッチャー コードはfirstHandler.handle(o);.

(別の方法として、チェーンを使用するのではなく、ディスパッチャー クラスに を入れて、 true が返さList<StuffHandler>れるまでリストをループさせることもできます)。handle()

于 2010-06-06T04:21:51.603 に答える
7

instanceof を使用するだけです。すべての回避策はより複雑に見えます。これについて説明しているブログ投稿は次のとおりです

于 2012-07-18T23:37:54.513 に答える
0

私はこの問題をreflection(ジェネリック以前の約15年前に)使用して解決しました。

GenericClass object = (GenericClass) Class.forName(specificClassName).newInstance();

ジェネリック クラス (抽象基本クラス) を 1 つ定義しました。基本クラスの具体的な実装を多数定義しました。各具象クラスは、className をパラメータとしてロードされます。このクラス名は構成の一部として定義されます。

基本クラスはすべての具象クラスに共通の状態を定義し、具象クラスは基本クラスで定義された抽象規則をオーバーライドすることによって状態を変更します。

当時、私はこのメカニズムの名前を知りませんでした reflection.

この記事Mapにはenum、リフレクション以外の選択肢がいくつかリストされています。

于 2015-08-26T15:29:38.187 に答える
0

クラスの名前を返す BaseClass にメソッドを追加します。そして、特定のクラス名でメソッドをオーバーライドします

public class BaseClass{
  // properties and methods
  public String classType(){
      return BaseClass.class.getSimpleName();
  }
}

public class SubClass1 extends BaseClass{
 // properties and methods
  @Override
  public String classType(){
      return SubClass1.class.getSimpleName();
  }
}

public class SubClass2 extends BaseClass{
 // properties and methods
  @Override
  public String classType(){
      return SubClass1.class.getSimpleName();
  }
}

次の方法でスイッチケースを使用します-

switch(obj.classType()){
    case SubClass1:
        // do subclass1 task
        break;
    case SubClass2:
        // do subclass2 task
        break;
}
于 2020-09-05T06:13:56.410 に答える