反射、注解、和泛型简要笔记

1.反射

作用：能够做一般做不到的事情。使用场景：插件式换肤，插件式开发 apk(没有安装插件)

创建对象

image

很多系统的类，都被系统隐藏了，或者说只有系统可以直接new，此时可以通过反射来创建对象。

• 方式一: 使用[类名].class.newInstance()

    try {
        TestBean testBean = TestBean.class.newInstance();
        testBean.sayName();
        } catch (InstantiationException e) {

        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

仅适用于TestBean含公有的无参构造器，代码才可以正常跑起来。如果TestBean的无参构造器是私有的，那么sayName()方法将无法调用，会报出 java.lang.IllegalAccessException。如果TestBean没有无参构造器，会报java.lang.InstantiationException:has no zero argument constructor。

• 方式二: 使用[类名].class.getDeclaredConstructor([参数类型])

try {
    //获取构造函数    
    Constructor constructor = TestBean.class.getDeclaredConstructor(String.class);
    //如果是私有构造器，必须设置可访问
    constructor.setAccessible(true);
    TestBean testBean = constructor.newInstance("莫少侠");
    testBean.sayName();
} catch (Exception e) {
    e.printStackTrace();
}

获取构造器有两个方法getDeclaredConstructor(...)和getConstructor(...)，区别是后者只从类中公有的构造器中找，而前者是从类里面所有的构造器中找匹配的构造器，所以推荐使用前者(获取方法和属性也类似)。如果构造器是私有的，必须记得setAccessible(true)。

注意

如果代码中拿不到类，换句话说没有办法通过[xxx].class的方式拿到class。那还可以通过
Class.forName("[全类名]") 获取class对象。所有的反射功能都是基于我们的字节码(class),一个类的class在内存中应该只有一份，而且class其实也是一个Class的对象。

    Class testBeanClass1 = TestBean.class;
    Class testBeanClazz = Class.forName("com.moshaoxia.chapter4.reflection.TestBean");

方法调用

class.getDeclaredConstructor("[方法名]",[参数类型])

try {
    Constructor constructor = TestBean.class.getDeclaredConstructor(String.class);
    constructor.setAccessible(true);
    TestBean testBean = constructor.newInstance("莫少侠");
    //获取的方法是sayName()
    Method sayName = TestBean.class.getDeclaredMethod("sayName");
    //获取的方法是sayName(String name)
    Method sayName2 = TestBean.class.getDeclaredMethod("sayName",String.class);
    //如果方法是私有的需要设置可访问，公有方法可不设置
    sayName.setAccessible(true);
    sayName.invoke(testBean);
    //invoke的第一个参数是调用该方法的对象
    //从第二个参数起就是这个方法要传入的参数
    sayName2.invoke(testBean,"666");
} catch (Exception e) {
    e.printStackTrace();
    }

获取属性

class.getDeclaredFiled([属性名])

TestBean testBean = new TestBean("莫少侠");
try {
    Field nameField = TestBean.class.getDeclaredField("name");
    nameField.setAccessible(true);
    //通过get从指定的对象获取属性，一般需要做强转。
    //如果要获取的Field是静态的，get里面的参数可以传null，因为不依赖任何对象了
    String name = (String) nameField.get(testBean);
    Log.i(TAG, " onCreate(): " +name);
} catch (Exception e) {
    e.printStackTrace();
}

获取拿不到类的静态属性示例

try {
            Class activityThreadClazz = Class.forName("android.app.ActivityThread");
            Field activityThreadClazzField = activityThreadClazz.getDeclaredField("sCurrentActivityThread");
            activityThreadClazzField.setAccessible(true);
            Object currentActivityThread = activityThreadClazzField.get(null);
            Log.i(TAG, " onCreate(): "+currentActivityThread.toString());
        } catch (Exception e) {
            e.printStackTrace();
        }

public class TestBean {

    private static final String TAG ="TestBean";
    private String name = "Tony";

    public TestBean(){}
    public TestBean(String name){
        this.name = name;
    }

    public String getName() {
        return name;
    }

    private void sayName(){
        Log.i(TAG, " sayName(): "+name);
    }
    public void sayName(String name){
        Log.i(TAG, " sayName(): "+name);
    }
}

2. 注解

注解只是一个标识（标记），自身没有具体的功能逻辑代码。常和反射搭配使用，但两者没有任何关系，是不同的东西。
butterknife 主要通过注解实现，但在new对象的时候用了反射。

声明一个注解

//上面必须有两个标识,Target 标识着放在哪里，哪里可以使用。Retention 标识着什么时候起作用。
//FIELD作用于属性,TYPE作用于类上,METHOD作用于方法上
@Target(ElementType.FIELD)
//RUNTIME 运行时(程序运行中),CLASS 代表的是编译时(打包的时候),SOURCE 编程阶段(例如Override)
@Retention(RetentionPolicy.RUNTIME)
public @interface ViewById {//@interface 代表一个注解
    int value(); //给注解要传的值
}

• @interface 代表是一个注解
• Target 标识着放在哪里，哪里可以使用。常用的有三个。
  • FIELD作用于属性
  • TYPE作用于类上
  • METHOD作用于方法上
• Retention 标识着什么时候起作用。
  • RUNTIME 运行时(程序运行中)
  • CLASS 代表的是编译时(打包的时候)
  • SOURCE 编程阶段(例如Override)

通过反射和注解去 findViewById

public class ViewUtils {

    public static void inject(Activity activity){
        //1、获取所有的属性(用了反射)
        Field[] fields = activity.getClass().getDeclaredFields();
        //2、过滤关于VIewByID的属性
        for (Field field : fields) {
            ViewById viewById = field.getAnnotation(ViewById.class);
            if(viewById != null) {
                //3、findViewById
                View view = activity.findViewById(viewById.value());
                //4、反射注入
                field.setAccessible(true);
                try {
                    //把view赋值给这个field
                    field.set(activity,view);
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";

    @ViewById(value = R.id.tv)
    private TextView mTextView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ViewUtils.inject(this);
        mTextView.setText("莫少侠");
    }
}    

3.泛型

泛型给代码立了个规范，起到一定的约束作用。

类泛型

在类里面任何地方出现的，代表的是同一类型.

public class ArrayList {
    
//    private T[] TItems = new T[10]; //泛型是不可以直接new的
    private Object[] items = new Object[10];
    public void add(T t){
        items[0] = t;
    }
}

public abstract class HttpCallBack {
    public abstract void onSuccess(T result);
}

方法泛型

//需要在返回值前加入尖括号标记泛型
    private  T viewById(int viewId){
        return (T)findViewById(viewId);
    }
    
    private  T viewById(P viewId){
        return null;
    }

泛型的上限

• 声明对象： 类名称 对象名称
• 定义类：[访问权限][类名称]<泛型标识 extends 类>{}

    //声明了clazz这个对象只能是继承于Activity的实例
    public void startActivity(Class clazz){
        Intent intent = new Intent(this, clazz);
        startActivity(intent);
    }

泛型的下限

• 声明对象： 类名称 对象名称
• 定义类：[访问权限][类名称]<泛型标识 super 类>{}

//下限，包括MainActivity和它的父类BaseActivity
public void startActivity(Class clazz){
        Intent intent = new Intent(this, clazz);
        startActivity(intent);
    }

Thanks

红橙架构进阶之旅页