遇到巨难一问题：能不能用不确定的对象类生成内隐类。

因为你的接口是定了的
而实现的策略不一样

我不明白为什么一定要用你所谓的 内隐类？
好象没一定这么用的必要

你要这么说我就明白了

解决方法也出来了

如下：

把你在B方法中要使用的类，通过配置并解析，
在b方法中:

UsedInB uib = (UsedInB)BeanFactory.getBean("willuseinB");

这个只是个大概

要实现解析方法，实现BeanFactory

我要在任何一个对象不知不觉的情况下给它用上b的方法。用我上面的方法已经实现了，但是那个对象是不知不觉，但是b方法还是知觉的。

我现在想实现在任何一个对象不知不觉的情况下给它用上任何一个方法，而这个方法也不知不觉。

搞来搞去我都快成先知先觉了！唉，太麻烦，搞不定了。

就是希望内隐类可以这样来写interface 接口 = Class.forName("子借口或抽象实现").newInstance() {......}

Collection cl1 = Class.forName(list或者set).newInstance() {.....};

如何作

class MyCollection implements Collection {
private Collection proxy;
public 你要overrde的方法{
do whatever u like;
}
public other mehods() {
call proxy object;
}
}

典型的装饰或者代理的用法

1、装饰器接口
interface 装饰器接口 {
//装饰的具体算法
private Object 装饰算法();
//装饰器要调用被装饰对象，才可以实现装饰功能。
//这里给调用别装饰对象的操作定个方法。
private Object 调用被装饰对象();
}

2、装饰器两个抽象实现
public abstract class 装饰器抽象实现A {
//装饰的具体算法
private Object 装饰算法()｛
Object 对象 ＝ 调用被装饰对象();
内存优先算法装饰（对象）。
return 对象;
｝
//装饰器要调用被装饰对象，才可以实现装饰功能。
//这里给调用别装饰对象的操作定个方法。
private abstract Object 调用被装饰对象();
}

public abstract class 装饰器抽象实现B {
//装饰的具体算法
private Object 装饰算法()｛
Object 对象 ＝ 调用被装饰对象();
速度优先算法装饰（对象）。
return 对象;
｝
//装饰器要调用被装饰对象，才可以实现装饰功能。
//这里给调用别装饰对象的操作定个方法。
private abstract Object 调用被装饰对象();
}

3、强大装饰器的抽象实现完成，现在可以装饰任何一种对象了。因为我可能会装饰任何一个对象，因此不希望在写所有的对象的时候都为了以后可能会被装饰就让所有的对象都来实现一个可修饰接口。

例如有个对象A，实现接口A
interface 接口A {
Object 方法A（）；
}

class 对象A ｛
Object 方法A（）｛
｝
｝

4、开始装饰。用到内隐类来实现抽象类未实现的方法。

class 装饰的对象A implemented 接口A｛
public 接口A 对象A ＝ null;
//构造函数
装饰的对象A（被装饰对象 对象A1）｛
this.对象A ＝ 对象A1；
｝

//开始内隐类
装饰器接口 装饰器A ＝ new 装饰器抽象实现A（）｛
private Object 调用被装饰对象()｛
return 对象A.方法A（）；
｝
｝

//实现接口A的方法
Object 方法A（）｛
//这里不是调用对象A.方法A（）
return 装饰器A.装饰算法();
｝
｝

那么你可以把b()这个函数单独封装在一个abstract class F里，把A->A1/A2->C这种结构独立出来，把需要用到b()的地方改为用一个类型为F的proxy对象参数，在D中用newInstance创建A的实现类的实例，然后用内隐类生成一个F的实例，并传递给上面的A的实例，这样应该能够达到你的要求吧。

代码如下：

public abstract class F {
  public abstract void b();
}

public abstract class A {
  private F proxy;

  public void setProxy(F obj) {
    proxy = obj;
  }
}

public class A1 extends A {
  public void b1() {
    proxy.b();
  }
}

F f = new F {
  public b() {
    ...
  }
}


A theA = (A)Class.forName("abc").newInstance();
theA.setProxy(f);

后面就可以用你的theA了

public abstract class F {
public abstract void b();
}

public abstract class A {
private F proxy;

public void setProxy(F obj) {
proxy = obj;
}
}

public class A1 extends A {
public void b1() {
proxy.b();
}
}

F f = new F {
public b() {
...
}
}

在D中这样写：
A theA = (A)Class.forName("abc").newInstance();
theA.setProxy(f);

但是我目前的算法选择还有有硬编码，因为我是用内隐类实现了一个抽象实现类，虽然也是当接口来用，但是不能动态的使用其它的抽象实现来作内隐类，因为实现内隐类时要写死类名的，而只用接口作内隐类又无法使用抽象实现类的抽象出去的算法，而且因为算法要特殊的调用被装饰对象，因此我不可能再把算法专门再抽出去搞一套接口和实现。因此，想来想去，要写死实现算法的抽象实现类，因此我希望可以一个装饰器可以使用任何算法，而且如果不用内隐类，很好实现，一个接口统统搞定，但是，用了内隐类就麻烦喽，不知道怎么搞了。

似乎.........有点明白了.......似乎行的同，容我再想想！

ajoo兄圣贤。