java混型实现：实例代码剖析

混型

混合了多个类的能力以产生一个可以表示混型中所有类型的类（组装多个类）；类似参数修改，这些修改会应用于混型所应用的所有类型之上；

解决办法：

方式1.     接口混合：也就是java中的多重继承；

//接口TimeStamped；

interfaceTimeStamped{

    long getStamp();

}

//接口TimeStamped的实现；

classTimeStampedImp implements TimeStamped

{

    private final long timeStamp;

    public TimeStampedImp(){

     timeStamp=new Date().getTime();

    }

    public long getStamp(){

     return timeStamp;

    }

}

//接口SerialNumbered

interfaceSerialNumbered

{

    long getSerialNumber();

}

//接口SerialNumbered的实现

classSerialNumberedImp implements SerialNumbered

{

    private static long counter=1;

    private final long serialNumber=counter++;

    public long getSerialNumber(){returnserialNumber;}

}

//接口Basic

interfaceBasic

{

    public void set(String val);

    public String get();

}

//接口Basic实现

classBasicImp implements Basic

{

    private String value;

    public void set(String val){value=val;}

    public String get(){return value;}

}

开始基于接口的多重继承：继承BasicImp类，实现TimeStamped，SerialNumbered。

class Mixinextends BasicImp implements TimeStamped,SerialNumbered

{

    private TimeStamped timeStap=newTimeStampedImp();

    private SerialNumbered SerialNumber=newSerialNumberedImp();

    public long getStamp(){returntimeStap.getStamp();}

    public long getSerialNumber(){returnSerialNumber.getSerialNumber();}

 

    public static void main(String[] args){

    Mixin mixin1=new Mixin(),mixin2=new Mixin();

    mixin1.set("test string 1");

    mixin2.set("test string 2");

    System.out.println(mixin1.get()+""+mixin1.getSerialNumber()+" "+mixin1.getStamp());

   

    }

 

}

方式2.     动态绑定：

import java.lang.reflect.*;

import java.util.*;

 

 

//定义要组合的接口：TimeStamped

interface TimeStamped{

    longgetStamp();

}

//接口的实现：TimeStampedImp类

class TimeStampedImp implementsTimeStamped

{

    privatefinal long timeStamp;

    publicTimeStampedImp(){

      timeStamp=new Date().getTime();

    }

    publiclong getStamp(){

      return timeStamp;

    }

}

 

 

//定义要组合的接口：SerialNumbered

interface SerialNumbered

{

    longgetSerialNumber();

}

 

//接口的实现：SerialNumberedImp类

class SerialNumberedImp implementsSerialNumbered

{

    privatestatic long counter=1;

    privatefinal long serialNumber=counter++;

    publiclong getSerialNumber(){return serialNumber;}

}

 

 

//定义要组合的接口：Basic

interface Basic

{

    publicvoid set(String val);

    publicString get();

}

//接口的实现：BasicImp类

class BasicImp implements Basic

{

    privateString value;

    publicvoid set(String val){value=val;}

    publicString get(){return value;}

}

 

 //泛型

class TwoTuple<A,B>{

public final A first;

public final B second;

/*constructure*/

public TwoTuple(A a,B b){

 first=a;

 second=b;

}

public String toString(){

  return "-->"+first+second;

  }

}

/*使用泛型方法 method*/

class Tuple{

  public static <A,B> TwoTuple<A,B> tuple(A a,B b){

    return new TwoTuple<A,B>(a,b);

  }

 

}

//动态代理：MixinProxy类用以实现InvocationHandler。

class MixinProxy implementsInvocationHandler

{

    Map<String,Object>delegatesByMethod;

    publicMixinProxy(TwoTuple<Object,Class<?>>...pairs){//构造函数MixinProxy（可变长度参数pairs来初始化delegatesByMethod。这里delegatesByMethod是一个Map里面存放的是存放方式：<方法名，方法拥有者的对象>）

      delegatesByMethod=newHashMap<String,Object>();

      for(TwoTuple<Object,Class<?>>pair:pairs){这里的pairs是类似一个泛型class TwoTuple<A,B>[]（数组），这个泛型内部first变量存放对象，second存放的是对象的接口；

             for(Method method:pair.second.getMethods()){//取出对象内的方法

                 StringmethodName=method.getName();//把方法赋给临时变量methodName;

                          if(!delegatesByMethod.containsKey(methodName)){//如果这个方法名字没有存放delegatesByMethod中，那么就把他按照对象索引的位置的方式放入；

                          delegatesByMethod.put(methodName,pair.first);

                          }

            }

      }

    }

    publicObject invoke(Object proxy,Method method,Object[] args)throws Throwable{

      String methodName=method.getName();//取出方法名字；

      Object delegate=delegatesByMethod.get(methodName);//到Map中取出方法名字对应的对象；

      return method.invoke(delegate,args);//代入对象，参数；

      }

 

      @SuppressWarnings("unchecked")

//此函数主要为Proxy.newProxyInstance（）这个静态函数服务，一起来看看他的前处理过程：

      public static ObjectnewInstance(TwoTuple...pairs){

       Class[] interfaces=new Class[pairs.length];//新建Class类数组，内部存放对象的接口；

       for(int i=0;i<pairs.length;i++){

         interfaces[i]=(Class)pairs[i].second;//和上述一样，pairs是类似一个泛型class TwoTuple<A,B>[]（数组），内部的second内部存放的是对象的interface(实现的接口)

       }

       ClassLoadercl=pairs[0].first.getClass().getClassLoader();//first是对象，。GetClassLoader（）是为了得到类加载器；Proxy.newProxyInstance（）函数要用；

       returnProxy.newProxyInstance(cl,interfaces,new MixinProxy(pairs));//带入相应参数

      }

}

 

public class DynamicProxyMixin

{

    publicstatic void main(String[] args){

//调用静态方法Proxy.newProxyInstance（）用以返回动态代理的Object对象；

//静态方法Tuple.tuple()用以返回确定的泛型类型；

       Object mixin=MixinProxy.newInstance(

           Tuple.tuple(newBasicImp(),Basic.class),Tuple.tuple(new TimeStampedImp(),TimeStamped.class),

              Tuple.tuple(newSerialNumberedImp(),SerialNumbered.class));

       Basic b=(Basic)mixin;

       TimeStamped t=(TimeStamped)mixin;

       SerialNumbered s=(SerialNumbered)mixin;

       b.set("Hello");

       System.out.println(b.get());

       System.out.println(t.getStamp());

       System.out.println(s.getSerialNumber());

    }

}