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