java se基础高级之反射

反射的概念

Java 反射机制在程序运行时，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性。这种 动态的获取信息 以及 动态调用对象的方法 的功能称为 java 的反射机制。
反射机制很重要的一点就是“运行时”，其使得我们可以在程序运行时加载、探索以及使用编译期间完全未知的 .class 文件。
换句话说，Java 程序可以加载一个运行时才得知名称的 .class 文件，然后获悉其完整构造，并生成其对象实体、或对其 fields（变量）设值、或调用其 methods（方法

反射的好处: 通过反射技术可以获取到字节码文件对象,使用这个字节码文件对象就可以获取到一个类的所有信息,包括私有【构造方法对象,成员变量对象,成员方法对象,访问权限修饰符对象...】。
之前的做法:
Student s = new Student();
学习反射之后的做法: 可以不需要显示地出现学生类就能够创建学生类的对象,并且可以动态创建对象,动态赋值,动态调用方法

反射能够获取的相关对象

• Class 类对象
• Constructor 构造方法对象
• Method 成员方法对象
• Field 成员变量对象
• Modifier 访问权限修饰符对象
• Array 数组对象

 创建反射字节码文件对象的三种方式

1.Class clazz = Class.forName("com.ashin.bean.Book");
该方法要注意的是会抛出一个ClassNotFoundException因为输入的字符串代表的类可能不存在。推荐这种方法

2.使用对象的getClass（）来反向获取
Book book = new Book();
Class clazz = book.getClass();
必须得先生成对象

3.类字面常量
Class clazz = Book.class;
必须导入该类所在的包

通过反射获取构造方法对象

• Constructor<?>[] getConstructors() 获取到所有公有修饰的构造方法对象数组
• Constructor<?>[] getDeclaredConstructors() 获取所有构造方法对象数组,包括私有
• Constructor<T> getConstructor(Class<?>... parameterTypes) 获取单个公有修饰构造方法对象
• Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 获取所有单个修饰的构造方法对象,包括私有

例子

public class ReflectDemo01 {
public static void main(String[] args) throws ClassNotFoundException, FileNotFoundException, IOException {
Student s1 = new Student("张三", 18, "北京西路", 1.80);
Student s2 = new Student("张三", 18, "北京西路", 1.80);
Class<? extends Student> c1 = s1.getClass();
Class<? extends Student> c2 = s2.getClass();

System.out.println(s1 == s2);
System.out.println(c1 == c2);

//    Class<Integer> c3 = int.class;
Class<Student> c3 = Student.class;
System.out.println(c1 == c3);

Properties properties = new Properties();
properties.load(new FileReader("config/classinfo.properties"));
String classPath = properties.getProperty("className");
Class<?> c4 = Class.forName(classPath);
System.out.println(c1 == c4);

}
}

通过反射获取成员变量对象

• Field[] getFields() 获取所有公有的成员变量对象,包括父类的公有成员
• Field[] getDeclaredFields() 获取所有本类的成员,包括私有
• Field getDeclaredField(String name) 获取公有的成员属性,包括父类
• Field getField(String name) 获取所有本类属性,包括私有

public class ReflectDemo01 {
public static void main(String[] args) throws Exception {
Class<?> c = Class.forName("com.sxt.reflectdemo03.Student");
// 通过字节码文件对象获取成员变量对象
Field[] fields = c.getFields();
for (Field field : fields) {
System.out.println(field);
}

System.out.println("===============");
Field[] declaredFields = c.getDeclaredFields();
for (Field field : declaredFields) {
System.out.println(field);
}

System.out.println("===============");
Field nameField = c.getField("name");
System.out.println(nameField);

//    Field heightField = c.getField("height");
//    System.out.println(heightField);

Field heightField = c.getDeclaredField("height");
System.out.println(heightField);
}
}

通过反射获取成员方法对象,并且调用

原来方式：

Student s = new Student();
s.method();

• Method[] getMethods() 获取所有公有修饰的成员方法对象,包括父类公有方法
• Method[] getDeclaredMethods() 获取本类所有成员方法对象,包括私有方法
• Method getMethod(String name, Class<?>... parameterTypes)
• Method getDeclaredMethod(String name, Class<?>... parameterTypes)

public class ReflectDemo01 {
public static void main(String[] args) throws Exception {
Class<?> c = Class.forName("com.sxt.reflectdemo04.Student");
Object instance = c.getConstructor().newInstance();

// 通过字节码文件对象获取成员方法对象
Method[] methods = c.getMethods();
for (Method method : methods) {
System.out.println(method);
}

System.out.println("=================");
Method[] declaredMethods = c.getDeclaredMethods();
for (Method method : declaredMethods) {
System.out.println(method);
}

System.out.println("==================");
// 获取method方法
// Method getMethod(String name, Class<?>... parameterTypes)
Method method = c.getMethod("method");
System.out.println(method);

Object invoke = method.invoke(instance);
System.out.println(invoke);
System.out.println("==================");
// 获取setName方法并且赋值
Method setNameMethod = c.getMethod("setName", String.class);
setNameMethod.invoke(instance, "隔壁老周");

// 获取getName方法
Method getNameMethod = c.getMethod("getName");
Object result = getNameMethod.invoke(instance);
System.out.println(result);

// 获取add方法并且调用
Method addMethod = c.getMethod("add", int.class, int.class);
Object result3 = addMethod.invoke(instance, 10, 20);
System.out.println(result3);

// 获取私有方法并且调用
Method showMethod = c.getDeclaredMethod("show");
showMethod.setAccessible(true);
showMethod.invoke(instance);
}
}

通过反射获取数组Array对象并且赋值

public class ReflectDemo01 {
public static void main(String[] args) throws Exception {
Class<?> c = Class.forName("com.sxt.reflectdemo05.Demo");

Object instance = c.getConstructor().newInstance();

Field arrField = c.getDeclaredField("arr");

Object arr = arrField.get(instance);

//    if (arr instanceof int[]) {
//    int[] array = (int[]) arr;
//    System.out.println(Arrays.toString(array));
//    }
//    int i = Array.getInt(arr, 0);
//    System.out.println(i);
//    Object obj = Array.get(arr, 0);
//    System.out.println(obj);
//    System.out.println(Array.get(arr, 1));
//    System.out.println(Array.get(arr, 2));
////    System.out.println(Array.get(arr, 3));
//    int length = Array.getLength(arr);
//    System.out.println(length);

for (int i = 0; i < Array.getLength(arr); i++) {
System.out.println(Array.get(arr, i));
}

Array.set(arr, 2, 100);
System.out.println(Array.get(arr, 2));

// 通过反射创建数组
Object arrObj = Array.newInstance(String.class, 5);
for (int i = 0; i < Array.getLength(arrObj); i++) {
System.out.println(Array.get(arrObj, i));
}

Object arrobj2 = Array.newInstance(int.class, 2, 3);
//    Object oneDimensson1 = Array.newInstance(int.class, 1);
//    Object oneDimensson2 = Array.newInstance(int.class, 2);
//    
//    Array.set(arrobj2, 0, oneDimensson1);
//    Array.set(arrobj2, 1, oneDimensson2);

if (arrobj2 instanceof int[][]) {
int[][] array = (int[][]) arrobj2;
System.out.println(array);
}
}
}

class Demo {

int[] arr = new int[3];

public Demo() {
arr[0] = 10;
arr[1] = 20;
}

}