Java的几个特性

前言

本文主要介绍java语言的三个特性：类型协变和逆变，动态代理和静态代理，注解。

协变和逆变

借用Treant的博文，逆变与协变用来描述类型转换（type transformation）后的继承关系，其定义：

• 如果A、B表示类型，f(⋅)表示类型转换，≤表示继承关系（比如，A≤B表示A是由B派生出来的子类）；
• f(⋅)是逆变（contravariant）的，当A≤B时，有f(B)≤f(A)成立；
• f(⋅)是协变（covariant）的，当A≤B时， 有f(A)≤f(B)成立；
• f(⋅)是不变（invariant）的，当A≤B时上述两个式子均不成立，即f(A)与f(B)相互之间没有继承关系。

通俗地讲，逆变使得转换后类型变宽（父类转子类），协变使得转换后类型变窄（子类转父类）。
在Java中，数组是协变的：

Number[] numbers = new Integer[10];  // right
Integer[] integers = new Number[10]; // wrong

泛型则是不变的

List<Object> numbers = new ArrayList<Integer>();  // wrong
List<Integer> numbers = new ArrayList<Object>();  // wrong
List<Integer> numbers = new ArrayList<Integer>();  // right

但是泛型可以通过通配符号？来实现协变和逆变。
泛型协变

List<? extends Object> numbers = new ArrayList<Integer>();  // right

泛型逆变

List<? super Integer> numbers = new ArrayList<Object>();  // right

换句话说，extends确定了泛型的上界，而super确定了泛型的下界。
而在方法的参数和返回值上，传入的参数应该是参数的子类或者本身，而返回的参数应该是父类或者本身。

static Number method(Number num) {
    return 1;
}
Object result = method(new Integer(2)); //correct
Number result = method(new Object()); //error
Integer result = method(new Integer(2)); //error
在Java 1.4中，子类覆盖（override）父类方法时，形参与返回值的类型必须与父类保持一致：

class Super {
    Number method(Number n) { ... }
}
class Sub extends Super {
    @Override 
    Number method(Number n) { ... }
}
从Java 1.5开始，子类覆盖父类方法时允许协变返回更为具体的类型：

class Super {
    Number method(Number n) { ... }
}
class Sub extends Super {
    @Override 
    Integer method(Number n) { ... }
}

代理

先看如下代码

public interface IFruit {
	void eat();
}
public class Apple implements IFruit {
	@Override
	public void eat() {
		System.out.println("You are eating Apple!");
	}
}
public class Orange implements IFruit {
	@Override
	public void eat() {
		System.out.println("You are eating Orange!");
	}
}

有个IFruit接口，分别有两个类实现了IFruit接口，有一天产品经理过来和你说需求变更了，现在需要在每个IFruit的实现类的eat方法打印一句话。如果只有两个类，这难不倒你，尽管忘代码里添加就可以了，但是如果有一百甚至一千个这样的类呢？这就需要用到代理了。

静态代理

我们可以新建一个这样的代理类

public class StaticProxy implements IFruit {
	private IFruit mOrig ;
    
	public StaticProxy(IFruit orig) {
		mOrig = orig ;
	}
	
	@Override
	public void eat() {
		mOrig.eat();
		System.out.println("add one line!");
	}
}

然后再调用Proxy类的eat()方法，同样能达到目的。问题又来了，如果我不仅修改IFruit，还修改其他的接口比如IAnimal、IRobot等接口，而且这样的接口也同样有成百上千个呢？这就需要用到java的动态代理了

动态代理

java动态代理需要实现InvocationHandler接口，原来类的所有方法的调用前都会调用DynamicProxy.invoke方法。

public class DynamicProxy implements InvocationHandler {
	
	private Object mOrig ;
	
	public DynamicProxy(Object orig) {
		mOrig = orig ;
	}
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		Object result = method.invoke(mOrig, args);
		System.out.println("add one line!");
		return result;
	}
}
public class MainTest {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Apple apple = new Apple();
		((IFruit)dynamicProxy(apple)).eat();
		staticProxy(apple).eat();
	}
	
	private static IFruit staticProxy(IFruit fruit) {
		return new StaticProxy(fruit);
	}
	private static Object dynamicProxy(Object fruit) {
		return Proxy.newProxyInstance(
				fruit.getClass().getClassLoader(), 
				fruit.getClass().getInterfaces(), 
				new DynamicProxy(fruit)
				);
	}
}

在invoke方法中，我们可以执行原来的方法(eat)，当然也能加入自己的代码逻辑。通过代码我们可以看到，动态代理类无需实现IFruit接口，这样的好处是可以节省很多的代码。

小结

动态代理和静态代理功能上并无差别。动态代理只是做了进一步的封装。使用代理模式可以增强原来方法的功能，通过代理类的Proxy方法可以轻松修改原来的代码逻辑，结合反射可以达到更改某些系统API的目的，Android插件开发中，DroidPlugin可以说是把这种思想运用到了极致。

注解

Java中的注解(Annotation)，也称元数据，JDK1.5引入，主要用来对类、变量、方法、方法参数等进行注释说明。
Java中主要有如下四个类型的注解

• @Documented 表示该注解可以包含在javadoc中
• @Retention 标明注解的声明周期（源码、class文件、运行时）
• @Target 注解可以使用在哪些地方（方法、类、变量等）
• @Inherited – 是否允许子类继承该注解
  注解除了对变量、方法等进行说明，还能结合反射完成更强大的功能。

Android中经常使用findViewById来查找一些控件，Butternife可以通过注解的方式注入代码使得View和id自动绑定，类似代码如下

public class MainActivity extends AppCompatActivity {
    @Bind(R.id.text_view)
    private TextView tv ;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        InjectHelper.inject(this);
        tv.setText("hello boys!");
    }
}

我们也可以通过使用注解和反射的方式完成类似buffernife的功能。

第一步

先新建一个注解

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Bind {
    int value();
}

Target本身也是一个注解，是用来标明我们新建的注解可以使用在哪些地方的。而Retention这个注解是用来标明注解的生命周期，声明成RetentionPolicy.RUNTIME则表用该注解在运行时也会一直保留。

第二步

通过反射获取对应值

public class InjectHelper {
	public static void  inject(Activity acitvity) {
		try {
			Field[] fields = acitvity.getClass().getDeclaredFields();
			for (Field field : fields) {
				Bind bind = field.getAnnotation(Bind.class);
				if (bind != null) {
					int id = bind.value();
					View v = acitvity.findViewById(id);
					field.setAccessible(true);
					field.set(acitvity, v);
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		} 
	}
}

这样就完成了相应注入操作，也能达到和butternife相应的功能。但是代码中用到了反射，效率会比butternife慢，因为butternife是在编译时期生成相应代码的，运行时性能几乎不会有影响。

参考

• Java中的逆变与协变
• 第六节：协变和逆变
• Difference between <? super T> and <? extends T> in Java
• Java 注解
• Annotation