【200分】求JAVA框架整包切换与隔离的调用实现方式，求神代码！！！

Question

package entity;public class A {
    static {
        System.out.println("调用A类a包");
        X1 x1=new entity.a.X1();
        X2 x2=new entity.a.X2();
        X3 x3=new entity.a.X3();
    }
}package entity;/**
 *
 * @author Administrator
 */
public class B {
    static {
         System.out.println("调用B类b包");
        X1 x1=new entity.b.X1();
        X2 x2=new entity.b.X2();
        X3 x3=new entity.b.X3();
    }
}
package entity;public class C {
    static {
         System.out.println("调用C类c包");
        X1 x1=new entity.c.X1();
        X2 x2=new entity.c.X2();
        X3 x3=new entity.c.X3();
    }
}package entity;public class PUB {    public static void main(String[] args) {
        A a = new A();
        B b = new B();
        C c = new C();
    }}
package entity.a;
public class X1 implements entity.X1{
    static {
        System.out.println("a.X1");
    }
}package entity.a;
public class X2 implements entity.X2{
    static {
        System.out.println("a.X2");
    }
}
package entity.a;
public class X3 implements entity.X3{
    static {
        System.out.println("a.X3");
    }
}b.c包中类似，不一一列举了。
entity包下三个接口X1,X2,X3;

Answer 1

运行结果：
run:
调用A类a包
a.X1
a.X2
a.X3
调用B类b包
b.X1
b.X2
b.X3
调用C类c包
c.X1
c.X2
c.X3

Answer 2

skyhitnow  2楼代码显示
A类，B类和C类里面实例化下面各包的类和方法，供PUB调用，这样的话A，B和C类过于庞大，且没有彻底屏蔽其它的b、c包。

Answer 3

是不是可以这么理解PUB是对外部开放的公共类，它可以调用接口A、B、C的各种方法，而接口A、B、C、均有3个同名的实现类，放在目录entity下的a、b、c这三个子文件夹中，可以通过PUB中的参数决定调用A、B、C的哪个实现
这个很难吗竟然提供200分接口A，定义了一个方法sayHello
package com.entity;public interface A {
void sayHello();
}a文件加下A的实现a
package com.entity.a;import com.entity.A;public class a implements A { @Override
public void sayHello() {
System.out.println("hello,I'm in folder a !");
}}b文件夹下A的实现a
package com.entity.b;import com.entity.A;public class a implements A {
@Override
public void sayHello() {
System.out.println("hello,I'm in folder b !");
}
}对外公共类PUB
package com.entity;public class PUB {
public static void main(String[] args) throws Exception {
int positonA=1;//该变量决定访问A接口的哪个实现类，值为0访问a文件夹下的实现类；值为其他值时访问b文件夹下的实现类
String folderName;
if(positonA==0){
folderName="a";
}else {
folderName="b";
}
String path="com.entity."+folderName+".a";
A a1=(A)Class.forName(path).newInstance();
a1.sayHello();
}
}

Answer 4

什么神代码？简单来说，你需要的是面向接口编程！利用反射机制
什么神代码？简单来说，你需要的是面向接口编程！用Class.forname来找到具体实现类，而该类的全名你自己控制就OK了

Answer 5

PUB  pub = new PUB  
pub.X1.Y(); //调用的时候 把a、b、c包这层隐藏掉，X1是类名，Y()就是X1的方法
//或者
pub.xxx("X1").Y(); //其中X1就是a、b、c包下的一个类，Y()就是X1的方法
似乎理论上有问题
既然要new,那就得定位到具体的类；
具体的类有9个，起码得有9种不同标志，或者说3x3种；但你上面的调用根本无法区分这么多。多态依赖于调用者的类型，但是pub就是一种类型；X1,X2,X3有三种类型；怎么会定位到9种不同的类？静候大神光临，俺也学习学习。

Answer 6

我觉得没必要非得靠上一种美其名曰的设计模式直接指定全限定类名就很好，也省了A,B,C这些床单被罩，何必非得要把简单的事情复杂化呢？

Answer 7

回复4楼    yujinlong0001你的理解不对，请看清目的，是为在PUB类里面通过参数切换A类，B类和C类，实现调用a,b,c包下面的各个类的各个方法。

Answer 8

回复 6楼、7楼   skyhitnow开此贴的目的是大家共同学习，这是一个国外论坛上在谈论的一个问题，实现整包切换与隔离的调用实现方式。
我们论坛上也有不少高人，期待大神级的代码和构思。

Answer 9

看下这样子对不对。package entity;public class TestMain {
public static void main(String[] args) {
InterfaceService is = IndustryTest.getInterfaceService("a");//a包下的类
PUB p = new PUB(is);
p.test();
is = IndustryTest.getInterfaceService("b");//b包下的类
p.setIs(is);
p.test();
is = IndustryTest.getInterfaceService("c");//c包下的类
p.setIs(is);
p.test();
}
}
package entity;
/**
 * 
 * <p class="detail">
 * 生产a、b、c包下的类
 * </p>
 *
 * @ClassName: IndustryTest 
 * @version V1.0  @date 2015年1月13日 下午4:46:46 
 *                    
 *
 */
public class IndustryTest {
public static InterfaceService getInterfaceService(String name){
InterfaceService is = null;
try {
 is = (InterfaceService)Class.forName(name+".X1").newInstance();
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return is;
}
}package entity;public interface InterfaceService {
void text();
}
package entity;public class PUB {
private InterfaceService is;
public void test(){
is.text();
}
public InterfaceService getIs() {
return is;
}
public void setIs(InterfaceService is) {
this.is = is;
}
public PUB(InterfaceService is){
this.is = is;
} 
}package a;import entity.InterfaceService;public class X1 implements InterfaceService {
@Override
public void text() {
System.out.println("a包下的text方法！！");
}}
package b;import entity.InterfaceService;public class X1 implements InterfaceService { @Override
public void text() {
System.out.println("b包下的text方法！！");
}}
package c;import entity.InterfaceService;public class X1 implements InterfaceService { @Override
public void text() {
System.out.println("c包下的text方法！！");
}}main的结果是a包下的text方法！！
b包下的text方法！！
c包下的text方法！！

Answer 10

回复 11楼   u010880076   谦虚了，我们是在讨论问题，你能想到类加载机制上已经很有见地了。但是a,b,c包下不只有一个X1呀，还有X2、X3、X4...Xn 。且不可能把所有方法都写到PUB类里吧！

Answer 11

package entity;import java.io.File;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;/**
 * Created by Administrator on 2015/1/13.
 */
public class Main1 {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException, IOException, ClassNotFoundException {
            for (Class<?> c : getAllAssignedClass(PUB.class)) {
                PUB o = (PUB) c.newInstance();
                o.sayX1();
               /* o.sayX2();
                o.sayX3();*/
        }
    }
    
    /**
     * 获取同一路径下所有子类或接口实现类
     *
     * @param intf
     * @return
     * @throws IOException
     * @throws ClassNotFoundException
     */
    public static List<Class<?>> getAllAssignedClass(Class<?> cls) throws IOException,
            ClassNotFoundException {
        List<Class<?>> classes = new ArrayList<Class<?>>();
        for (Class<?> c : getClasses(cls)) {
            if (cls.isAssignableFrom(c) && !cls.equals(c)) {
                classes.add(c);
            }
        }
        return classes;
    }
    
    /**
     * 取得当前类路径下的所有类
     *
     * @param cls
     * @return
     * @throws IOException
     * @throws ClassNotFoundException
     */
    public static List<Class<?>> getClasses(Class<?> cls) throws IOException,
            ClassNotFoundException {
        String pk = cls.getPackage().getName();
        String path = pk.replace('.', '/');
        ClassLoader classloader = Thread.currentThread().getContextClassLoader();
        URL url = classloader.getResource(path);
        return getClasses(new File(url.getFile()), pk);
    }
    
    /**
     * 迭代查找类
     *
     * @param dir
     * @param pk
     * @return
     * @throws ClassNotFoundException
     */
    private static List<Class<?>> getClasses(File dir, String pk) throws ClassNotFoundException {
        List<Class<?>> classes = new ArrayList<Class<?>>();
        if (!dir.exists()) {
            return classes;
        }
        for (File f : dir.listFiles()) {
            if (f.isDirectory()) {
                classes.addAll(getClasses(f, pk + "." + f.getName()));
            }
            String name = f.getName();
            if (name.endsWith(".class")) {
                classes.add(Class.forName(pk + "." + name.substring(0, name.length() - 6)));
            }
        }
        return classes;
    }
}
输出：I'm entity.a X1
I'm entity.b X1
I'm entity.c X1
public interface A {
}
public interface B {
}
public interface C {
}
public class PUB implements A,B,C{//如果还有DEF等更多的话要加上implements后面
    public void sayX1(){//如果有更多的方法也要在父类PUB加上
    }
    public void sayX2(){
    }
    public void sayX3(){
    }
}
package entity.a;import entity.A;
import entity.PUB;/**
 * Created by Administrator on 2015/1/13.
 */
public class X1 extends PUB implements A{
    public void sayX1(){
        System.out.println("I'm entity.a X1");
    }
}
package entity.b;import entity.B;
import entity.PUB;/**
 * Created by Administrator on 2015/1/13.
 */
public class X1 extends PUB implements B {
    public void sayX1(){
        System.out.println("I'm entity.b X1");
    }
}package entity.c;import entity.C;
import entity.PUB;/**
 * Created by Administrator on 2015/1/13.
 */
public class X1  extends PUB implements C{
    public void sayX1(){
        System.out.println("I'm entity.c X1");
    }
}

Answer 12

问题具体一点是否这样：
PUB有若干对外接口，例如B( )，调用X1...Xn的Y( ); PUB还可能有若干对象引用，类型为X1...Xn，需要根据参数决定实际调用哪个包A/B/C中的X1...Xn。
还有，这个需要编译时决定还是运行时决定？

Answer 13

这么简单的东东，你们想多了，分两种场景：
PUB 、 X1、X2、X3是你自己可以修订的类，这种情况最简单PUC实现为：
public class PUB{
String flag ="A";
public PUB(String iflag){
flag=iflag;
}
//如果y函数有参数和返回值相就进行修订
public void y() {
if("A".equals(flag))
a.X1().y();
else if("B".equals(flag))
b.X1().y();
else if("C".equals(flag))
c.X1().y();
else
//异常分支 
}
public String getFlag() { return flag; }
public void setFlag(String flag) { this.flag = flag; }
}
----------------------其它依此类推

Answer 14

package entity;public class PUB {
    public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
        A.get(X1.class).Y1();
        B.get(X1.class).Y1();
        C.get(X1.class).Y1();
      
    }}package entity;
public class A{
    public static <T>T get(Class<T> clazz) throws InstantiationException, IllegalAccessException, ClassNotFoundException{
        Class clazz1=Class.forName("entity.a."+clazz.getSimpleName());
        return (T)clazz1.newInstance();
    }
    
}/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */package entity.a;/**
 *
 * @author Administrator
 */
public class X1 implements entity.X1{    @Override
    public void Y1() {
        System.out.println("a.X1.Y1()");
    }
}package entity;
public interface X1 {
    void Y1();
}
运行结果：a.X1.Y1()
b.X1.Y1()
c.X1.Y1()

Answer 15

pub.xxx("X1").Y(); //其中X1就是a、b、c包下的一个类，Y()就是X1的方法可以在pub中封装成这个样子，我就不写了。

Answer 16

回复 14楼   u011244173对外调用处没有进行很好的封装，比如我指定配置的是a包，那我要调用a包下面X1的Y()方法呢！另外也没有起到屏蔽另外包b、c的作用。还有定义空的A、B、C接口不知道有何意！

Answer 17

你非要用类也可以啊。A类、B类、C类为抽象类，具体实现在a、b、c包里。也就是说你不面向接口编程了，面向抽象类编程了。

Answer 18

回复  19楼   skyhitnow把调用方式略作处理就能满足需求了，思路很有独特性，通过Class创建实例和接口来实现。唯一略显不完美的地方就是要将X1、X2、X3....Xn在外围用接口进行定义，增加代码。但是这样做却也有一个好处就是，a、b、c包下的X1、X2、X3....Xn都要实现外面相应的接口，原则上可以避免不规范的书写。

Answer 19

原理是一样的丫  其它的x2、x3都用接口来做啊，，和x1同理，然后想调用时直接拿接口不就可以了吗？
如果想把类也当成参数也可以在加入一个参数值。
方法也可以写成一个参数，，， 这样只要你在pub中写一个方法就可以调用到所有包下的类中的方法。只要你的参数正确。

Answer 20

其实可以写成边接口都不用，直接用反射，传入包，类，方法，参数。
然后再动态调用只要在pub类中写一个方法，在main方法中通过传参数来调用不同包，的不同类的不同方法。

Answer 21

回复 27、28楼   u010880076  X1、X2、X3....Xn 如果n=10，每个类里面有10个方法，那在PUB里面就要写100个方法，显然有点不合理，或者是我理解的可能有偏差，对于其它文字所表达的意思也不是很明白，可否用具体代码来说明一下呢。您在11楼所贴的代码我已经看了，如果有更好的想法也不妨再试试！

Answer 22

package entity;
public class PUB {
    
    public <T>T A(Class<T> clazz) throws InstantiationException, IllegalAccessException, ClassNotFoundException{
        return (T)A.get(clazz);
    }
    public <T>T B(Class<T> clazz) throws InstantiationException, IllegalAccessException, ClassNotFoundException{
        return (T)B.get(clazz);
    }
    public <T>T C(Class<T> clazz) throws InstantiationException, IllegalAccessException, ClassNotFoundException{
        return (T)C.get(clazz);
    }
    public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
        PUB pub=new PUB();
        pub.A(X1.class).Y1();
      
    }单独用字符串作为参数去调用似乎有些问题；
因为无法确定返回对象的类型；
因为字符串中无法使用类型变量；
也就无法决定返回值的类型。当然，可以这样写：package entity;
public class PUB {
    
    public <T>T A(String t) throws InstantiationException, IllegalAccessException, ClassNotFoundException{
        Class clazz=Class.forName("entity."+t);
        return (T)A.get(clazz);
    }
   
    public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
        PUB pub=new PUB();
        pub.<X1>A("X1").Y1();
    }}但这样看上去并没有省事。或者不指定类型参数，而是在字符串调用返回Object类型对象后手动进行类型转换。

Answer 23

这个是没有接口的，再看看吧package entity;public class TestMain {
public static void main(String[] args) throws ClassNotFoundException {
//无返回的时候 
 new PUB("a","X1","text",null).test();
 new PUB("a","X1","text2",new Object[]{"张三"}).test();
 new PUB("b","X1","text",null).test();
 new PUB("b","X1","text2",new Object[]{"李四"}).test();
 new PUB("c","X1","text",null).test();
 new PUB("c","X1","text2",new Object[]{"王五"}).test();
 new PUB("a","X2","bbb",null).test();
 //有返回的时候
Object o =  new PUB("a","X2","aa",null).test2();
System.out.println(o.toString());
//返回对象的时候
Object o1 =  new PUB("b","X2","test",new Object[]{"哈哈，可以的",19}).test2();
User u = (User)o1;
System.out.println(u.getAge());
System.out.println(u.getName());
}
}
package entity;import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;public class PUB {
private String packageName;
private String className;
private String methodName;
private Object[] params=null;
//无返回值的方法调用 
public void test() throws ClassNotFoundException{
Class c = Class.forName(packageName+"."+className);
Method[]  methods = c.getMethods();
for(Method m : methods){
if(m.getName().equals(methodName)){
try {
try {
m.invoke(c.newInstance(), params);
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}//没有参数时直接传入空
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
//有返回值的方法调用 
public Object test2() throws ClassNotFoundException{
Class c = Class.forName(packageName+"."+className);
Method[]  methods = c.getMethods();
Object o = null;
for(Method m : methods){
if(m.getName().equals(methodName)){
try {
try {
o = m.invoke(c.newInstance(), params);
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}//没有参数时直接传入空
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
return o;
}

public PUB(String packageName, String className, String methodName,
Object[] params) throws ClassNotFoundException {
super();
this.packageName = packageName;
this.className = className;
this.methodName = methodName;
this.params = params;

} public PUB() {
super();
} public String getClassName() {
return className;
} public void setClassName(String className) {
this.className = className;
} public String getMethodName() {
return methodName;
} public Object[] getParams() {
return params;
} public void setMethodName(String methodName){
this.methodName = methodName;
}
public void setParams(Object[] params){
this.params = params;
} public String getPackageName() {
return packageName;
} public void setPackageName(String packageName) {
this.packageName = packageName;
}

}package a;public class X2 {
public void bbb(){
System.out.println("a包下的X2类的bbb方法");
}
public String aa(){
return "哈哈";
}
}package a;public class X1 {
public void text(){
System.out.println("a包下的text方法");
}
public void text2(String name){
System.out.println("a包下的text2，参数name的值为："+name);
}
}package b;public class X1 {
public void text(){
System.out.println("b包下的text方法");
}
public void text2(String name){
System.out.println("b包下的text2，参数name的值为："+name);
}
}package b;import entity.User;public class X2 {
public User test(String name,int age){
User u = new User();
u.setName(name);
u.setAge(age);
return u;
}
}package c;public class X1 {
public void text(){
System.out.println("c包下的text方法");
}
public void text2(String name){
System.out.println("c包下的text2，参数name的值为："+name);
}
}只要在BUP里有两个方法就可以了，当然  你也可以把两个方法写成一个方法

Answer 24

把User忘给了package entity;public class User {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}

}

Answer 25

把User忘给了package entity;public class User {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}

}
结果：a包下的text方法
a包下的text2，参数name的值为：张三
b包下的text方法
b包下的text2，参数name的值为：李四
c包下的text方法
c包下的text2，参数name的值为：王五
a包下的X2类的bbb方法
哈哈
19
哈哈，可以的

Answer 26

做了一个最简单核心的实现。。 看看是不是你要的。。1 包结构图：(这里省略了A,B,C类)2 客户端测试代码图：
3 核心类的实现图：
4 辅助类图：
5抽象：

Answer 27

客户端测试结果，是因为我刚刚手动 将Register.PackageEnum.r_B 改成 了 Register.PackageEnum.r_D  再截图造成的

Answer 28

要求：
1，最理想的调用方式：
PUB  pub = new PUB  
pub.X1.Y(); //调用的时候 把a、b、c包这层隐藏掉，X1是类名，Y()就是X1的方法
//或者
pub.xxx("X1").Y(); //其中X1就是a、b、c包下的一个类，Y()就是X1的方法
2，以最简明扼要的代码实现，贴出相关代码，使观者能理解整个调用流程；
3，不要告诉我用什么模式、什么框架可以实现，要说理论我也能说出一大堆，但是自己去写又有几人能写出来呢
4，以代码最优者给全分【200】，如果都没有达到要求者，每楼层平均分配。
---------------------
1.关于第一点，在前一个帖子中已经写得和你要的调用方式一模一样了，你到底向要哪样
3.设计模式怎么了，经典就是经典，自有它的价值，有人提出来，那你也应该去了解一下，不是天天说不要重复造轮子吗，
抽象工厂模式：我举个例子，和你的这个几乎一模一样：
一个系统数据库有两种实现分别为 Oracl和MySql，：具体使用哪个数据库是卸载配置文件里面的，在系统启动时就确定了用那种数据库，有一个抽象的AbstractDatabaseFactory,为什么抽象满是以为内有一些公用的方法，然后两个实现类，那么对于整个系统来说，完全屏蔽了数据库的差异性，使用的时候该怎么用就怎么用，和你这个一样了。
5.没看出和上一贴有什么不同的，无力吐槽，既然是别处的帖子，那么是否可以给个链接可以瞧瞧，美其名曰学习交流

Answer 29

有类名，再有方法名和参数，直接调用可以吗》？？public static void func(String className, String methodName, Object... objects)
                                                                                   throws Exception {        Class<?>[] clazzs = new Class<?>[objects.length];
        for (int i = 0; i < objects.length; i++) {
            clazzs[i] = objects[i].getClass();
        }        Class<?> clazz = Class.forName(className);
        Object obj = clazz.newInstance();
        Method method = clazz.getMethod(methodName, clazzs);
        method.invoke(obj, objects);
    }

Answer 30

回复 36楼  wufengui1315经典的框架和设计模式是我们拿来用的，但是在使用时我们应该了解它的工作原理。好些大型的软件都使用了类似的机制，我们都在使用，但是有几人能知道其原理呢，我现在把这个需求抽离出来，拿出来300分供大家学习和讨论，当然我也在研究其中的原理和实现技巧。
从你举的例子能看出来你已经了解了我的想法，但是还有一定的区别，兼容各种数据库的系统有很多，如果使用持久层框架如hibernate、mybatis、Apache Cayenn的话就很简单，但是如果不用这些框架的话有几人能写的出来，而且是在开发过程中屏蔽其它数据库。咳。扯远了。你在上贴的代码我也看了，所有的X1、X2....Xn都要实现EntityInterface接口，显然是不是很合适，你可以看看19楼   skyhitnow的代码，已经基本上实现了，只是略有一些瑕疵。最后不管如何，也非常感谢对本帖和上贴的支持和关注。

Answer 31

回复 34 楼  tarenahuangdw使用了枚举对包的进行了封装，挺好的。但是有一点和其它好些代码一样，AbstractEntity接口中不能将所有的X1、X2、X3....Xn里面的方法都在里面进行定义的，具体请参看29楼回复

Answer 32

回复  31楼    u010880076非常抱歉回复的迟了，因为你的代码我研究了较长的时间，根据你的思路我进行了改进，可以满足需求。瑕疵的地方就是包名、类名、和方法名都是通过字符串的形式传递，1是参数太多，2是容易写错，在这个地方可以参考 34 楼 的tarenahuangdw 方法。

Answer 33

工程结构： 各模块类 就贴一个其他都相同
com.pub.a.x1
package com.pub.a;
public class X1 implements com.pub.X1 { public void m1() {
System.out.println("A.X1.m1");
}}
主类。package com.pub;public class PUB<E> {
 //a ,b,c 包中的类 为public  
public E dispatcher(Class clazz ) throws InstantiationException, IllegalAccessException{
//
return  (E) clazz.newInstance();
}


 //a ,b,c 包中的类 为非public
public E dispatcher(String clazz ) throws ClassNotFoundException, InstantiationException, IllegalAccessException{
return  (E) Class.forName(clazz).newInstance();
}

public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
 PUB<X1> f =new PUB<X1>(); 
 f.dispatcher(com.pub.a.X1.class).m1();
 f.dispatcher("com.pub.a.X1").m1();
}}调用方式
 public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
 PUB<X1> f =new PUB<X1>(); 
 f.dispatcher(com.pub.a.X1.class).m1();
 f.dispatcher("com.pub.a.X1").m1();
}
另外一种实现方式。此方式。各模块中的 类必须为public 才能使用 
package com.pub;public class Pub1<E> {

public E dispatcher(E e){
return e;
}



public static void main(String[] args) {
 Pub1<X1> f =new Pub1<X1>(); 
 f.dispatcher(new com.pub.a.X1()).m1();
}
 
}