黑马JAVA P189 反射获取Constructor、Field、Method对象
package com.itheima.d3_reflect_constructor;
public class Student {
private String name;
private int age;
private Student() {
System.out.println("无参数构造器执行！");
}
public Student(String name, int age) {
System.out.println("有参数构造器执行！");
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
package com.itheima.d3_reflect_constructor;
import org.junit.Test;
import java.lang.reflect.Constructor;
public class TestStudent02 {
//1.调用无参数构造器得到一个类的对象返回
@Test
public void getDeclaredConstructor() throws Exception{
//a.第一步：获取类对象
Class c = Student.class;
//b.定位单个构造器对象（按照参数定位无参数构造器
Constructor cons = c.getDeclaredConstructor();
System.out.println(cons.getName() + "====>" + cons.getParameterCount());
//如果遇到了私有的构造器，可以暴力反射
cons.setAccessible(true); //权限被打开
Student s = (Student) cons.newInstance();
System.out.println(s);
System.out.println("-------");
//c.定位某个有参构造器
Constructor cons1 = c.getDeclaredConstructor(String.class, int.class);
System.out.println(cons1.getName() + "====>" + cons1.getParameterCount());
Student s1 = (Student) cons1.newInstance("孙悟空",1000);
System.out.println(s1);
}
//2.调用有参数构造器得到一个类的对象返回
}
package com.itheima.d4_reflect_field;
public class Student {
private String name;
private int age;
public static String schoolName;
public static final String COUNTTRY = "中国";
Student() {
System.out.println("无参数构造器执行！");
}
public Student(String name, int age) {
System.out.println("有参数构造器执行！");
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
package com.itheima.d4_reflect_field;
import org.junit.Test;
import java.lang.reflect.Field;
/**
* 目标：反射_获取Field成员变量对象。
* 反射的第一步是先得到Class类对象。
*
* 1.Field getField(String name);
* 根据成员变量名获取对应Field对象，只能获得public修饰
* 2.Field getDeclaredField(string name);
* 根据成员变量名获得对应Field对象，只要申明了就可以得到
* 3.Field[] getFields();
* 获取所有的成员变量对应的Field对象，只能获得public的
* 4.Field[] getDeclaredFields();
* 获得所有的成员变量对应的Field对象，只要申明了就可以得到
*
* 小结：
* 获取全部成员变量：getDeclaredFields
* 获取某个成员变量：getDeclaredField
*/
public class FieldDemo01 {
/**
* 1.获取全部的成员变量。
* Field[] getDeclaredFields();
* 获取所有的成员变量对应的Field对象，只要申明了就可以得到
*/
@Test
public void getDeclaredFields() {
//a.定位Class对象
Class c = Student.class;
//b.定位全部成员变量
Field[] fields = c.getDeclaredFields();
//c.遍历一下
for (Field field : fields) {
System.out.println(field.getName() + "===>" + field.getType());
}
}
/**
* 2.获取某个成员变量对象 Field getDeclaredField(String name);
*/
@Test
public void getDeclaredField() throws Exception {
//a.定位Class对象
Class c = Student.class;
//b.根据名称定位某个 成员变量
Field f = c.getDeclaredField("age");
System.out.println(f.getName() + "===>" + f.getType());
}
}
package com.itheima.d4_reflect_field;
import org.junit.Test;
import java.lang.reflect.Field;
/**
* 目标：反射获取成员变量：取值和赋值
*
* Field的方法：给成员变量赋值和取值
* void set(Object obj,Object value):给对象注入某个成员变量 数据
* Object get(Objcet obj):获取对象的成员变量的值。
* void setAccessible(true):暴力反射，设置为可以直接访问私有类型的属性。
* Class getType(); 获取属性的类型，返回Class对象。
* String getName(); 获取属性的名称。
*/
public class FieldDemo02 {
@Test
public void setField() throws Exception{
//a.反射第一步，获取类对象
Class c = Student.class;
//b.提取某个成员变量
Field ageF = c.getDeclaredField("age");
ageF.setAccessible(true); // 暴力打开权限
//c.赋值
Student s = new Student();
ageF.set(s , 18); // s.setAge(18);
System.out.println(s);
//d.取值
int age = (int) ageF.get(s);
System.out.println(age);
}
}
package com.itheima.d5_reflect_method;
public class Dog {
private String name;
public Dog(){
}
public Dog(String name) {
this.name = name;
}
public void run(){
System.out.println("狗跑的贼快~~");
}
private void eat(){
System.out.println("狗吃骨头");
}
private String eat(String name){
System.out.println("狗吃"+ name);
return "吃的很开心！";
}
public static void inAddr(){
System.out.println("在黑马学习Java！");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
package com.itheima.d5_reflect_method;
import org.junit.Test;
import java.lang.reflect.Method;
/**
* 反射获取类的Method方法对象：
* 1.Method getMethod(String name, Class...args);
* 根据方法名和参数类型获得对应的方法对象，只能获得public的
* 2.Method getDeclaredMethod(String name, Class...args);
* 根据方法名和参数类型获得对应的方法对象，包括private的
* 3.Method[] getMethods();
* 获得类中的所有成员方法对象，返回数组，只能获得public修饰的且包含父类的
* 4.Method[] getDeclaredMethods();
* 获取类中的所有成员方法对象，返回数组，只获得本类申明的方法。
*
* Method 的方法执行：
* Object invoke(Object obj, Object...args)
* 参数一：触发的是哪个对象的方法执行。
* 参数二：args:调用方法时传递的实际参数
*/
public class MethodDemo01 {
/**
* 1.获得类中的所有成员方法对象
*/
@Test
public void getDeclaredMethods(){
// //a.获取类对象
// Class c = Dog.class;
// //b.提取全部方法：包括私有的
// Method[] methods = c.getDeclaredMethods();
// //c.遍历全部方法
// for (Method method : methods) {
// System.out.println(method.getName() + "返回值类型" + method.getReturnType() + "参数个数" + method.getParameterCount());
// }
}
/**
* 2.获取某个方法对象
*/
@Test
public void getDeclardMethod() throws Exception{
//a.获取类对象
Class c = Dog.class;
//b.提取单个方法对象
Method m = c.getDeclaredMethod("eat");
Method m2 = c.getDeclaredMethod("eat",String.class);
//暴力打开权限了
m.setAccessible(true);
m2.setAccessible(true);
//c.触发方法的执行
Dog d = new Dog();
//注意：方法如果是没有结果回来的，那么返回的是null.
Object result = m.invoke(d);
System.out.println(result);
Object result2 = m2.invoke(d,"骨头");
System.out.println(result2);
}
}
