Java基础(九)--反射
什么是反射？
在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性
这种动态获取的信息以及动态调用对象的方法的功能称为反射机制。
反射的前提：
需要获取代表每个类的java.lang.class对象，对于HotSpot来说，这个class对象保存在在方法区，作为这个类的各种数据的访问入口
获取class对象的方式：
public static void main(String[] args) throws Exception{
//第一种，通过对象获取class对象
A a = new A();
Class aClass = a.getClass();
System.out.println(aClass.getName());
//第二种，通过类直接获取class对象
Class aClass1 = A.class;
System.out.println(aClass == aClass1);
//第三种，通过类的全限定名获取class对象(包名+类名)
Class aClass2 = Class.forName("com.it.exception.A");
System.out.println(aClass == aClass2);
}
PS: 一般使用第三种方式来获取
构造函数相关方法：
public class A {
public A(int i) {
System.out.println("A Constructor " + i);
}
public A() {
System.out.println("A Constructor No Parameter");
}
protected A(String name) {
System.out.println("A Constructor " + name);
}
private A(int i, String name) {
System.out.println("A Constructor " + i + " name " + name);
}
}
public static void main(String[] args) throws Exception{
Class aClass = Class.forName("com.it.exception.A");
//返回所有public构造函数
Constructor[] constructors1 = aClass.getConstructors();
for (Constructor constructor : constructors1) {
System.out.println(constructor);
}
System.out.println("----getConstructors---------");
//返回具体某种参数类型的public构造函数，参数也可以是null，表示无参构造器
Constructor constructor = aClass.getConstructor(int.class);
System.out.println(constructor);
System.out.println("----get int Constructors---------");
//返回所有构造函数，无论什么修饰符修饰
Constructor[] constructors2 = aClass.getDeclaredConstructors();
for (Constructor constructor1 : constructors2) {
System.out.println(constructor1);
}
System.out.println("----getDeclaredConstructors---------");
//返回具体某种参数类型的构造函数，无论什么修饰符修饰
Constructor constructor2 = aClass.getDeclaredConstructor(String.class);
System.out.println(constructor2);
System.out.println("----String getDeclaredConstructor---------");
}
结果：
public com.it.exception.A() public com.it.exception.A(int) ----getConstructors--------- public com.it.exception.A(int) ----get int Constructors--------- private com.it.exception.A(int,java.lang.String) protected com.it.exception.A(java.lang.String) public com.it.exception.A() public com.it.exception.A(int) ----getDeclaredConstructors--------- protected com.it.exception.A(java.lang.String)
getEnclosingConstructor：
public class Outter {
public void destination(String s) {
class Inner1 {
private String label;
public Inner1() {
System.out.println("abc");
}
public Inner1(String whereTo) {
this.label = whereTo;
}
}
Class aClass = new Inner1().getClass();
//获取局部或匿名内部类在定义时所在的构造器
System.out.println(aClass.getEnclosingConstructor());
}
public static void main(String[] args) {
Outter outter = new Outter();
outter.destination("aaa");
}
}
这里实验类局部内部类一直得到的是null，大家可以试一下
调用构造器：
constructor.newInstance(); //默认无参构造器
字段相关方法：
public class A {
private int id;
private String name;
public int sex;
}
public static void main(String[] args) throws Exception{
Class aClass = Class.forName("com.it.exception.A");
//获取所有public字段
Field[] fields = aClass.getFields();
for (Field field : fields) {
System.out.println(field);
}
//获取某个具体字段，这个字段必须是public修饰，否则会报错
Field field = aClass.getField("sex");
System.out.println(field);
//获取所有字段,无论修饰符
Field[] fields1 = aClass.getDeclaredFields();
for (Field field1 : fields1) {
System.out.println(field1);
}
//获取某个具体字段
Field field1 = aClass.getDeclaredField("id");
System.out.println(field1);
}
结果：
public int com.it.exception.A.sex public int com.it.exception.A.sex private int com.it.exception.A.id private java.lang.String com.it.exception.A.name public int com.it.exception.A.sex private int com.it.exception.A.id
其余操作：
public static void main(String[] args) throws Exception{
Class aClass = Class.forName("com.it.exception.A");
Field field = aClass.getDeclaredField("name");
Object object = aClass.getDeclaredConstructor(null).newInstance();
field.setAccessible(true); //设置为true，private字段可以修改，私有字段必须设置为true，否则set字段会发生异常
field.set(object, "sam");//设置具体字段value
A a = (A)object;
System.out.println(a.toString());
}
结果：
A(id=0, name=sam, sex=0)
方法相关操作：
public class A {
private int id;
private String name;
public int sex;
public void add() {
System.out.println("add()");
}
private void del() {
System.out.println("del()");
}
public static void update() {
System.out.println("static update()");
}
}
public static void main(String[] args) throws Exception{
Class aClass = Class.forName("com.it.exception.A");
Method[] methods = aClass.getMethods();
//获取所有public字段
for (Method method : methods) {
System.out.println(method);
}
//获取某个具体方法，这个method必须是public修饰，否则会报错
Method method = aClass.getMethod("add", null);
System.out.println(method);
//获取所有字段,无论修饰符
Method[] methods1 = aClass.getDeclaredMethods();
for (Method method1 : methods1) {
System.out.println(method1);
}
//获取某个具体字段
Method method1 = aClass.getDeclaredMethod("del", null);
System.out.println(method1);
}
结果：已经省略默认继承object的相关方法
public void com.it.exception.A.add() public static void com.it.exception.A.update() public void com.it.exception.A.add() public void com.it.exception.A.add() public static void com.it.exception.A.update() private void com.it.exception.A.del() private void com.it.exception.A.del()
其余操作：
private int del(int i) {
System.out.println("del(): " + i);
return i + 3;
}
public static void main(String[] args) throws Exception{
Class aClass = Class.forName("com.it.exception.A");
Object object = aClass.getDeclaredConstructor(null).newInstance();
Method method = aClass.getDeclaredMethod("del", int.class);
method.setAccessible(true);
Object object1 = method.invoke(object, 20);
System.out.println(object1);
}
结果：
del(): 20 23
其他：
public class A extends B implements C{
@Override
public void f() throws IOException {
System.out.println("f()");
}
}
public static void main(String[] args) throws Exception{
Class aClass = Class.forName("com.it.exception.A");
System.out.println(aClass.getSuperclass());// 获取父类Class对象
System.out.println(aClass.getClassLoader());// 获取类的加载器
System.out.println(aClass.getInterfaces()[0]);// 获取类的接口数组列表
A[] as = new A[1];
System.out.println(as.getClass().getComponentType());// 获取该数组的Class对象
System.out.println(aClass.getPackage().getName());// 获取包
}
结果：
class com.it.exception.B sun.misc.Launcher$AppClassLoader@18b4aac2 interface com.it.exception.C class com.it.exception.A com.it.exception
通过反射越过泛型检查
public static void main(String[] args) throws Exception{
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
// List<String> list = Arrays.asList("a", "b");
Class aClass = list.getClass();
Method method = aClass.getMethod("add", Object.class);
method.invoke(list, 20);
System.out.println(list);
// list.forEach(s -> {
// System.out.println(s);
// });
}
结果：List<String> list = Arrays.asList("a", "b");然后执行invoke()会报错的，也不要使用foreach也会报错(ClassCastException)
