哪種設計模式允許基於運行時類型的功能抽象？

Question

我有一個抽象類A和它的幾個實現。我期望通過添加更多的實現來隨着時間的推移而發展。

我也有一個接口，在上面的類層次結構的實例（例如打印它們）做一些事情。

我希望接口的實現爲A的某些子類提供一些特殊功能，併爲其餘的子類提供默認功能。

我希望這個例子闡明事情：

abstract class A { } 
class B extends A { } 
class C extends A { } 

interface Processor { 
    public void process(A a); 
} 

class SimpleProcessor implements Processor { 

    //I want this to be called when argument is instance of A or C or any 
    //new class that will be added in the future 
    public void process(A a) { 
     //Line 14 
     System.out.println("Default processing"); 
    } 

    //I want this to be called when argument is instance of B 
    public void process(B b) { 
     System.out.println("Special processing"); 
    } 

} 

public class Runner { 

    public static void main(String[] args) { 
     B b = new B(); 
     Processor p = new SimpleProcessor(); 
     p.process(b); 
    } 

} 

的示例打印 「默認處理」。問題是要執行的方法是根據接口方法的編譯時類型來選擇的。有沒有一種方法（或設計模式），使這個程序打印「特別處理」，而不在第14行加入

if (a instance of B) 
    process((B) a); 

列表爲每一個需要特別處理類？

我看了一下visitor模式，但它看起來沒有什麼改進，因爲我不想用A的每個子類的方法「污染」處理器接口，因爲會添加更多的A子類。

換一種方式，我想接口的實現：

• 提供的
• 具體子類的方法的自定義實現提供了將在被添加類的默認實現未來
• 避免列出所有的類在一個大的if-then-else的列表

謝謝！

Answer 1

如果您創建一個適配器，接受要處理的對象並返回該對象的處理器，那麼該怎麼辦？

if A -> return ProcessorA 
if B -> return ProcessorB 

代碼例如：

class Adapter { 

    Processor getProcessor(Object o) { 
     if (o instance of A) { 
      return new ProcessorA(); 
     } else if ... 
    } 

} 

Answer 2

移動代碼分成而變化，並使用多態性的類型。見Open Closed Principle。

interface Processable { 
    void process(); 
} 

abstract class A implements Processable { 
    public void process() { 
     System.out.println("Default processing"); 
    } 
} 
class B extends A { 
    public void process() { 
     System.out.println("Special processing"); 
    } 
} 
class C extends A { 
    // default implementation inherited from A 
} 


class SimpleProcessor { 
    public void process(Processable p) { 
     p.process() 
    } 
} 

public class Runner { 
    public static void main(String[] args) { 
     B b = new B(); 
     Processor p = new SimpleProcessor(); 
     p.process(b); 
    } 
} 

Answer 3

這是使用Adapter的進一步改進。這種解決方案需要思考圖書館來源：http://code.google.com/p/reflections/

優勢：

• 沒有如果再用的instanceof其他
• 沒有配置

缺點：

• 需要思考圖書館
• 可以在一開始是緩慢

這是它：

import java.lang.reflect.ParameterizedType; 

public abstract class Processor<T> { 

    private final Class<T> processedClass; 

    public Processor() { 
     ParameterizedType parameterizedType = (ParameterizedType) getClass().getGenericSuperclass(); 
     processedClass = (Class<T>) parameterizedType.getActualTypeArguments()[0]; 
    } 

    public Class<T> getProcessedClass() { 
     return processedClass; 
    } 

    protected abstract void process(T message); 

} 

public class A { 

} 

public class B { 

} 

public class ProcessorA extends Processor<A> { 

    @Override 
    protected void process(A message) { 
     System.out.println("Processing object A"); 
    } 

} 

public class ProcessorB extends Processor<B> { 

    @Override 
    protected void process(B message) { 
     System.out.println("Processing object B"); 
    } 

} 

import java.lang.reflect.Constructor; 
import java.util.HashMap; 
import java.util.Iterator; 
import java.util.Map; 
import java.util.Set; 

import org.reflections.Reflections; 

public class Adapter { 

    private Map<Class<?>, Processor<Class<?>>> mapping = new HashMap<Class<?>, Processor<Class<?>>>(); 

    public Adapter() throws Exception { 
     Reflections r = new Reflections(""); 
     Set<Class<? extends Processor>> subTypesOf = r.getSubTypesOf(Processor.class); 

     for (Iterator iterator = subTypesOf.iterator(); iterator.hasNext();) { 
      Class<? extends Processor> c = (Class<? extends Processor>) iterator.next(); 
      Constructor<? extends Processor> constructor = c.getConstructor(); 
      Processor p = constructor.newInstance(); 
      mapping.put(p.getProcessedClass(), p); 
     } 
    } 

    public <T> Processor<T> getProcessor(T obj) { 
     return (Processor<T>) mapping.get(obj.getClass()); 
    } 
} 

public class Main { 

    public static void main(String[] args) 
      throws Exception { 
     Adapter adapter = new Adapter(); 

     A a = new A(); 

     adapter.getProcessor(a).process(a); 

     B b = new B(); 

     adapter.getProcessor(b).process(b); 
    } 

} 

結果：

14:01:37.640 [main] INFO org.reflections.Reflections - Reflections took 375 ms to scan 4 urls, producing 222 keys and 919 values 
Processing object A 
Processing object B 

Answer 4

您可以讓類本身返回處理器

interface Widget { 
    Processor getProcessor(); 
} 
interface Processor { 
    void process(Widget w); 
} 
abstract class WidgetA implements Widget { 
    Processor getProcessor() { 
     return new Processor() { 
     void process(Widget w) {// do magic default process stuff} 
     }; 
    } 
} 
class WidgetB extends WidgetA { 
    // uses default processor 
} 
class WidgetC extends WidgetA { 
    Processor getProcessor() { 
     return new Processor() { 
     void process(Widget w) {// do magic widget C process stuff} 
     }; 
    } 
} 

然而對於不同的皮膚故事，也許它會更好創建一個處理器工廠，取決於部件返回合適的處理器，爲不同的皮膚，那麼你可以創建ProcessorFactory取決於其皮膚使用

interface ProcessorFactory { 
    Processor getWidgetAProcessor(); 
    .... 
} 



abstract class WidgetA implements Widget { 
    Processor getProcessor() { 
     return factory.getWidgetAProccesor(); 
    } 

    void setProcessorFactory(ProcessorFactory pf) { 
     this.factory = pf; // move method signature also to interface 
    } 
} 

注：這只是一個想法，肯定不是最好的解決辦法我認爲

Answer 5

如何爲每個對象創建Processor實現，然後將它們註冊到CompositeProcessor中，例如

public class ProcessorB implements Processor 
{ 
    public void process(A input) { // do something here for B. } 
} 
public class ProcessorC implements Processor 
{ 
    public void process(A input) { // do something here for C} 
} 
// add more processors if needed 

public class CompositeProcessor implements Processor 
{ 
    private Map<Class,Processor> processors; 
    public CompositeProcessor(Map<Class,Processor> processors) 
    { 
      this.processors=processors; 
    } 
    public void process(A input) 
    { 
      for (Map.Entry<Class<?>,Processor> entry : processors.entries()) 
      { 
       if (entry.getKey().isAssignableFrom(input.getClass()) 
       { 
        entry.getValue().process(input); 
        return; 
       } 
      } 
      // do default processing here 
    } 
} 

現在在Runner類中使用CompositeProcessor。

注意：我沒有編譯上面的代碼，只是在這個編輯器中輸入，因此可能會出現一些錯誤，但是您有想法:)。

一些優點是： - 處理器與其處理的類分離（例如A和ProcessorA分開）。 - 可能有多於1個處理器的給定對象 - 處理器的映射可以在運行時更改

Answer 6

模板方法。

基類實現默認行爲，派生類實現特定的行爲。

Class BaseWithTemplateMethod { 
    void process() { 
    // Default behavior goes here 
    } 
} 

Class DerivedWithSpecific extends BaseWithTemplate { 
    @override 
    void process() { 
    // Specific behavior goes here 
    } 
} 

你可以做到這一點的主題很多變化，比如在另一個類封裝的行爲，在運行時配置的情況下，爲他們使用的具體行爲，實質上是使用組成代替。這在Java和沒有多重繼承的其他語言中特別有用。