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<TestBean> 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<TestBean> 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<T> {
// 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<T> {
public abstract void onSuccess(T result);
}
方法泛型
//需要在返回值前加入尖括号标记泛型
private <T> T viewById(int viewId){
return (T)findViewById(viewId);
}
private <T,P> T viewById(P viewId){
return null;
}
泛型的上限
- 声明对象： 类名称<? extends 类> 对象名称
- 定义类：[访问权限][类名称]<泛型标识 extends 类>{}
//声明了clazz这个对象只能是继承于Activity的实例
public void startActivity(Class<? extends Activity> clazz){
Intent intent = new Intent(this, clazz);
startActivity(intent);
}
泛型的下限
- 声明对象： 类名称<? super 类> 对象名称
- 定义类：[访问权限][类名称]<泛型标识 super 类>{}
//下限，包括MainActivity和它的父类BaseActivity
public void startActivity(Class<? super MainActivity> clazz){
Intent intent = new Intent(this, clazz);
startActivity(intent);
}
