Java是一种强类型语言，每个实例都必须有指定的类型,本例中使用了XOM 来生成XML...

java 代码

1. public class AdaptableList implements IAdaptable, List {    
2.   public Object getAdapter(Class adapter) {    
3.    return Platform.getAdapterManager().getAdapter(this, adapter);    
4.   }    
5.   private List delegate = new ArrayList();    
6.   public int size() {    
7.    return delegate.size();    
8.   }    
9.   // ...    
10.   

实际上， Java类型有两种声明类型和运行时类型 (也可以相应的说是静态类型 和动态类型 ). 像Python这样的弱类型语言通常称为无类型，
但是这样说并不严谨，因为每个实例都有它的运行时类型。你只是不用事先声明一个实例的类型而已。

   要想调用一个对象中的方法，这个方法需要在声明类型中存在。也就是说，你只能调用定义在父类中的方法，即使该实例是一个确定的子类型：

java 代码

1. List list = new ArrayList();    
2. list.add("data"); // 在这里没问题    
3. list.ensureCapacity(4); // 这里就不行了ensureCapacity() 只在ArrayList中才有。   

   如果我们要调用实际类型中的方法，我们首先要将它转为正确的类型。在本例中，我们可以把 ArrayList 转为List,因为
ArrayList实现了List 接口. 也可以在运行时动态的检验，使用 list instanceof ArrayList.

   可扩展的接口

   糟糕的是，一个类不能总是实现你所需要实现的接口。可能是因为这只对少数几种情况才有效，或者它是一个没有被关联的库中的类型，或者这个接口在后
期又被改变了。

   这种情况就可以使用IAdaptable。 你可以把 IAdaptable 动态的进行类型转化。使用如下方法避免直接的类型转化:

java 代码

1. Object o = new ArrayList();    
2. List list = (List)o;    

   我们可以这样做:

java 代码

1. IAdaptable adaptable = new ArrayList();    
2. List list = (List)adaptable.getAdapter(java.util.List.class);   

   你可认为它是一种类型动态转化; 我们把adaptable转为List实例。

   为什么不直接转化，而要用额外的getAdapter() 呢?这种机制可以使我们将目标类转化为没有实现的接口。例如， 我们可能想使用
HashMap 作为一个 List, 尽管他们并不兼容。

java 代码

1. IAdaptable adaptable = new HashMap();    
2. List list = (List)adaptable.getAdapter(java.util.List.class);    

   实现IAdaptable

   大多数IAdaptable的实现看起来就想是为支持类型构造多个if表达式的叠加。如果要为HashMap实现getAdapter() 可以
这样:

java 代码

1. public class HashMap implements IAdaptable {    
2.   public Object getAdapter(Class clazz) {    
3.    if (clazz == java.util.List.class) {    
4.     List list = new ArrayList(this.size());    
5.     list.addAll(this.values());    
6.     return list;    
7.    }    
8.    return null;    
9.   }    
10.   // ...    
11.   
12.   
13.   
14. }    

   返回的是一个对自身的代理，而不是直接转化类型。如果请求的是不支持的类型，可以直接返回null表明失败，这样比抛出异常要好。

   PlatformObject

   当你想添加新的要扩展的类型时，只是简单的修改一下就可以了。在任何情况下，如果已经得到了类型，为什么不修改接口？不修改类（如果使用接口，不
容易保证向后兼容）或者改变它的类型（HashMap不是 List，但是可以转化）是有原因的。要解决这个问题，在Eclipse中，使用了一个抽象
类 PlatformObject。它为你实现了 IAdaptable接口，你就可以不用再操心了。

   PlatformObject 代理所有的它对getAdapter()的请求到 IAdapterManager.
IAdapterManager是平台默认提供的，通过 Platform.getAdapterManager()来访问。你可以将它想象为一个巨大
的 Map ，它负责关联类和适当的适配器。PlatformObject的 getAdapter() 方法可以访问到这个Map.

  适配已存在的类

   这样的好处是可以为每一个PlatformObject对象动态的关联新的适配器，而不用重新编译。在Eclipse中的很多地方都是这样来支持
扩展的。

   这里希望将装有String的List转为XML节点。 XML节点显示为:

＜List＞
＜Entry＞First String＜/Entry＞
＜Entry＞Second String＜/Entry＞
＜Entry＞Third String＜/Entry＞
＜/List＞

   因为List的toString方法可能有别的用途，所以不能使用。 可以为List添加一个工厂，当有转为XML节点的请求时，一个Node对
象就会自动返回。

   这里需要3个步骤:

   1. 从List中生成Node

   使用IAdapterFactory 来封装转换机制:

java 代码

1. import nu.xom.*;    
2. public class NodeListFactory implements IAdapterFactory {    
3.   /** The supported types that we can adapt to */    
4.   private static final Class[] types = {    
5.    Node.class,    
6.   };    
7.   public Class[] getAdapterList() {    
8.    return types;    
9.   }    
10.   /** The actual conversion to a Node */    
11.   public Object getAdapter(Object list, Class clazz) {    
12.    if (clazz == Node.class && list instanceof List) {    
13.     Element root = new Element("List");    
14.     Iterator it = list.iterator();    
15.     while(it.hasNext()) {    
16.      Element item = new Element("Entry");    
17.      item.appendChild(it.next().toString());    
18.      root.appendChild(item);    
19.     }    
20.     return root;    
21.    } else {    
22.     return null;    
23.    }    
24.   }    
25.   
26.   
27.   
28. }    

   2. 注册工厂到Platform的AdapterManager

   我们需要注册工厂到适配器工厂，当我们向 List实例请求Node时, 它就会知道是使用我们注册的工厂。 Platform为我们管理
IAdapterManager ，而且注册过程相当简单:

java 代码

1. Platform.getAdapterManager().registerAdapters(    
2. new NodeListFactory(), List.class    
3. );   

   上面的代码要求平台管理者关联NodeListFactory和List。但我们要求List实例的适配器，它会调用这个工厂。根据我们对工厂的
定义，会获得一个Node对象。在Eclispe中,这一步必须在插件启动的时候显式的执行，要隐式执行可以通过
org.eclipse.core.runtime.adapters 扩展点。

   3. 向List要求Node

   这里是要求适配器返回一个 Node 对象:

java 代码

1. Node getNodeFrom(IAdaptable list) {    
2.   Object adaptable = list.getAdapter(Node.class);    
3.   if (adaptable != null) {    
4.    Node node = (Node)adaptable;    
5.    return node;    
6.   }    
7.   return null;    
8.   
9.   
10.   
11. }    

   总结

   如果你要在运行时为已存在的类添加功能，只要定义一个能完成转换功能的工厂，然后注册工程到 Platform的 AdapterManager
就可以了. 这项功能可以用来为一个非UI组件注册一个指定的UI组件，同时保持两部分的完全分离。就像在
org.rcpapps.rcpnews.ui 和org.rcpapps.rcpnews 插件中的使用。在这些例子中,
IPropertySource 在UI插件中，它需要与非UI插件的数据相关联。当UI插件初始化时，它注册IPropertySource 到
Platform, 当数据对象在浏览器中被选中时，属性视图中就会显示相应的属性。

   很明显, java.util.List不能扩展PlatformObject, 所以你不能指望例子中的代码能够编译通过，你可以重新构造
List的子类来实现目的.继承PlatformObject 也不是必须的: