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

我们一般生成内隐类是这样:

首先一个接口
interface a {
void b();
void b1();
}

然后就是用内隐类
class c {
a theA = new a() {
public b() { ...... }
public b1() { ...... }
};
}

如果我有两个抽象类a1和a2都是属于a接口的抽象实现,实现了接口a的b1函数,如下
abstract class a1 {
public abstract void b();
public void b1() {......}
}

abstract class a2 {
public abstract void b();
public void b1() {......}
}

我同样可以通过抽象类来实现内隐类,如下:
a theA = new a1(){
public void b(){......}
};
或者
a theA = new a2(){
public void b(){......}
};
通过选不同的抽象实现,可以在毫无变化的情况下实现一些算法变化,而且实现松偶合。

注意:

那么我的问题来了,我们根据接口时可以不用关心使用的是哪个实现,只要当接口来用就可以,甚至可以根据一个传入的java.lang.Class对象来newInstance()一个对象再回溯成接口来用,但是在写内隐类的时候必须要指定是通过a1还是a2来实现内隐类,这样有点紧偶合了。

如何能实现,通过一个传入的抽象类,可能是a1,也可能是a2,但是我们不知道,也不关心,只知道它是一个a的抽象实现,如果我们直接拿这个不知道是a1还是a2的a来实现内隐类,还要保留a1或者a2对b1函数的实现算法,如何实现,实现内隐类的时候可以通过Class.forName("a1").newInstance(){...}来作吗?编译器提示newInstance()后必须是分号。

如何实现,各位大哥,小弟跪求了。

我觉得这是个策略模式

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

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

因为方法b要访问一些明确的对象的方法,但是如果把这个对象作为参数传给方法b,那么那么a接口就和要使用的对象紧偶合了,而使用内隐类可以即使用那个对象又不用和那个对象偶合起来。这样我的b方法可以和很多很多不同类型的对象组合使用。

哈哈

你要这么说我就明白了

解决方法也出来了

如下:

把你在B方法中要使用的类,通过配置并解析,
在b方法中:
<bean name="willuseinB" class="h.a.UsedInB"/>
UsedInB uib = (UsedInB)BeanFactory.getBean("willuseinB");

这个只是个大概

要实现解析方法,实现BeanFactory

这样的的话,我那些要在b中用的类都要实现UsedInB接口,这也正是我要避免的,这也是硬编码了!

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

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

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

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

例如:
我有时候要用内隐类做一个list当Collection用,有时候要用内隐类作一个set当Collection用,因此我希望程序可以自动根据情况选择用内隐类作list还是set。我不能写死 new list() {...},而是

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

如何作

首先我不知道你为什么做出这样的设计,这是典型的mixin的手法,其原理类似
class A extends <T> {
.......
}

这种机制java是不支持的...可以用CGLIB等bytecode修改技术,不过实在太复杂,换个设计吧

如果仅是collection的话,根本就不用这么费劲

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()的地方肯定也是在编码阶段就写好的吧?假定在class D中创建了这样一个内隐类,那你在D中创建A类实例的时候是要在b()中调用D的一些方法是吗?

那么你可以把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);

又弄错了,D中的代码如下
F f = new F {
public b() {
...
}
};
A theA = (A)Class.forName("abc").newInstance();
theA.setProxy(f);

有点复杂,我就是要实现松偶合的装饰器。
我不希望我装饰器的算法多两边,因此我希望一个装饰其可以装饰任何对象。我也不想为每个算法写一个装饰器,我希望一个装饰器可以使用任何算法。
因为希望一个装饰其可以装饰任何对象,因此装饰器不能实现一个固定对象的接口,任何对象也不可能都实现一个别装饰的接口。
因此我设计了上边实现抽象实现类的内隐类,方便的做到了一个装饰器装饰任何对象,因为我把装饰器和对象交互的部分放到了一个中间类(相当于一个抽掉算法的装饰器)里,而装饰算法和对象自己的功能都被区分开了。关键是我装饰的是一个接口,只要符合这个接口的对象都可以用这一个中间类来装饰。

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

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


似乎.........有点明白了.......似乎行的同,容我再想想!

历经风雨之后,才明白这句java真谛“只有interface,才是推动历史的唯一力量。”

ajoo兄圣贤。