泛型（14）：混型

柔光的暖阳◎ 2023-05-28 12:52 3阅读 0赞

术语混型随时间的推移好像拥有了无数的含义，但是其最基本的概念就是混合多个类的能力，以产生一个可以表示混型中所有类型的类。这往往是你最后的手段，它将使组装多个类变得简单易行。

混型的价值之一是它们可以将特性和行为一致地应用于多个类之上。如果想在混型类中修改某些东西，作为一种意外的好处，这些修改将会应用于混型所应用的所有类型之上。正由于此，混型有一点面向方面编程的（AOP）的味道，而方面经常被建议用来解决混型问题。

### 一、与接口混合 ###

在C++中，使用多重继承的最大理由，就是为了使用混型。但是，对于混型来说，更有趣、更优雅的方式是使用参数化类型，因为混型就是继承自其类型参数的类。在C++中，可以很容易的创建混型，因为C++能够记住其模版参数的类型。

遗憾的是，java泛型不允许这样。擦除会忘记基类类型，因此泛型类不能直接继承自一个泛型参数。一种更常见的推荐解决方案是使用接口来产生混型效果，就像下面这样：

import java.util.Date;
    
    /**
     * 时间戳
     */
    interface TimeStamped {
    	long getStamp();
    }
    
    class TimeStampedImp implements TimeStamped {
    
    	private final long timeStamp;
    
    	public TimeStampedImp() {
    		timeStamp = new Date().getTime();
    	}
    
    	@Override
    	public long getStamp() {
    		return timeStamp;
    	}
    }
    
    /**
     * 序列号
     */
    interface SerialNumbered {
    	long geterialNumber();
    }
    
    class SerialNumberedImp implements SerialNumbered {
    
    	private static long counter = 1;
    	private final long serialNumber = counter++;
    
    	@Override
    	public long geterialNumber() {
    		return serialNumber;
    	}
    }
    
    /**
     * 基本信息
     */
    interface Basic {
    	public void set(String val);
    
    	public String get();
    }
    
    class BasicImp implements Basic {
    	private String value;
    
    	@Override
    	public void set(String val) {
    		value = val;
    	}
    
    	@Override
    	public String get() {
    		return value;
    	}
    }
    
    /**
     * 混合
     */
    class Mixin extends BasicImp implements TimeStamped, SerialNumbered {
    
    	private TimeStamped timeStamp = new TimeStampedImp();
    	private SerialNumberedImp serialNumber = new SerialNumberedImp();
    
    	@Override
    	public long geterialNumber() {
    		return serialNumber.geterialNumber();
    	}
    
    	@Override
    	public long getStamp() {
    		return timeStamp.getStamp();
    	}
    }
    
    public class Mixins {
    	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.getStamp() + " " + mixin1.geterialNumber());
    		System.out.println(mixin2.get() + " " + mixin2.getStamp() + " " + mixin2.geterialNumber());
    	}
    }

Mixin类基本上是在使用代理，因此每个混入类型都要求在Mixin中有一个相应的域，而你必须在Mixin中编写所有必需的方法，将方法调用转发给恰当的对象。这个示例使用了非常简单的类，但是当使用更复杂的混型时，代码数量会急速增加。

### 二、使用装饰器模式 ###

当你观察混型的使用方式时，就会发现混型概念好像与装饰器设计模式关系很近。装饰器经常用于满足各种可能的组合，而直接子类化会产生过多的类，因此是不实际的。

装饰器模式使用分层对象来动态透明地向单个对象中添加责任。装饰器指定包装在最初的对象周围的所有对象都具有相同的基本接口。某些事物是可装饰的，可以通过将其他类包装在这个可装饰对象的周围，来将功能分层。这使得对装饰器的使用是透明的——无论对象是否被装饰，你都拥有一个可以向对象发送的公共消息集。装饰类也可以添加新方法，但是正如你所见，这将是受限的。

装饰器是通过使用组合和形式化结构（可装饰物/装饰器层次结构）来实现的，而混型是基于继承的。因此可以将基于参数化类型的混型当做是一种泛型装饰器机制，这种机制不需要装饰器设计模式的继承结构。

前面的示例可以被改写为使用装饰器：

import java.util.Date;
    
    class Basic {
    	private String value;
    
    	public void set(String val) {
    		value = val;
    	}
    
    	public String get() {
    		return value;
    	}
    }
    
    class Decorator extends Basic {
    	protected Basic basic;
    
    	public Decorator(Basic basic) {
    		this.basic = basic;
    	}
    
    	public void set(String val) {
    		basic.set(val);
    	}
    
    	public String get() {
    		return basic.get();
    	}
    }
    
    class TimeStamped extends Decorator {
    
    	private final long timeStamp;
    
    	public TimeStamped(Basic basic) {
    		super(basic);
    		timeStamp = new Date().getTime();
    	}
    
    	public long getStamp() {
    		return timeStamp;
    	}
    }
    
    class SerialNumbered extends Decorator {
    
    	private static long counter = 1;
    	private final long serialNumber = counter++;
    
    	public SerialNumbered(Basic basic) {
    		super(basic);
    	}
    
    	public long getSerialNumber() {
    		return serialNumber;
    	}
    }
    
    public class Decoration {
    	public static void main(String[] args) {
    		TimeStamped t = new TimeStamped(new Basic());
    		TimeStamped t2 = new TimeStamped(new SerialNumbered(new Basic()));
    //		t2.getSerialNumber();
    		SerialNumbered s = new SerialNumbered(new Basic());
    		SerialNumbered s2 = new SerialNumbered(new TimeStamped(new Basic()));
    //		s2.getStamp();
    	}
    }

产生自泛型的类包含所有感兴趣的方法，但是由使用装饰器所产生的对象类型是最后被装饰的类型。也就是说，尽管可以添加多个层，但是最后一层才是实际的类型，因此只有最后一层的方法是可视的，而混型的类型是所有被混合到一起的类型。因此对于装饰器来说，其明显的缺陷是它只能有效地工作于装饰中的一层（最后一层），而混型方法显然会更自然一些。因此装饰器只是对由混型提出的问题的一种局限的解决方案。

### 三、与动态代理混合 ###

可以使用动态代理来创建一种比装饰器更贴近混型模型的机制。通过使用动态代理，所产生的类的动态类型将会是已经混入的组合类型。

由于动态代理的限制，每个被混入的类都必须是某个接口的实现：

import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    import java.util.HashMap;
    import java.util.Map;
    
    import com.buba.util.TwoTuple;
    import static com.buba.util.Tuple.tuple;
    
    class MixinProxy implements InvocationHandler {
    
    	Map<String, Object> delegatesByMethod;
    
    	public MixinProxy(TwoTuple<Object, Class<?>>... pairs) {
    		delegatesByMethod = new HashMap<>();
    		for (TwoTuple<Object, Class<?>> pair : pairs) {
    			for (Method method : pair.second.getMethods()) {
    				String methodName = method.getName();
    				if (!delegatesByMethod.containsKey(methodName)) {
    					delegatesByMethod.put(methodName, pair.first);
    				}
    			}
    		}
    	}
    
    	@Override
    	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    		String methodName = method.getName();
    		Object delegate = delegatesByMethod.get(methodName);
    		return method.invoke(delegate, args);
    	}
    
    	@SuppressWarnings({ "rawtypes", "unchecked" })
    	public static Object newInstance(TwoTuple... pairs) {
    		Class[] interfaces = new Class[pairs.length];
    		for (int i = 0; i < pairs.length; i++) {
    			interfaces[i] = (Class) pairs[i].second;
    		}
    		ClassLoader cl = pairs[0].first.getClass().getClassLoader();
    		return Proxy.newProxyInstance(cl, interfaces, new MixinProxy(pairs));
    	}
    
    }
    
    public class DynamicProxyMixin {
    	public static void main(String[] args) {
    		Object mixin = MixinProxy.newInstance(tuple(new BasicImp(), Basic.class),
    				tuple(new TimeStampedImp(), TimeStamped.class), tuple(new SerialNumberedImp(), 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.geterialNumber());
    	}
    }

因为只有动态类型而不是非静态类型才包含所有的混入类型，因此这仍旧不如C++的方式好，因为可以在具有这些类型的对象上调用方法之前，你被强制要求必须先将这些对象向下转型到恰当的类型。但是，它明显地更接近于真正的混型。

为了让java支持混型，人们已经做了大量的工作朝着这个目标努力，包括创建了至少一种附加语言（jam语言），它是专门用来支持混型的。

**如果本文对您有很大的帮助，还请点赞关注一下。**