【Java】反射

//1. Class.forName
      String classAllPath = "ref.Car"; //通过读取配置文件获取
      Class<?> cls1 = Class.forName(classAllPath);
      System.out.println(cls1);
      //2. 类名.class , 应用场景: 用于参数传递
      Class cls2 = Car.class;
      System.out.println(cls2);
      //3. 对象.getClass(), 应用场景，有对象实例
      Car car = new Car();
      Class cls3 = car.getClass();
      System.out.println(cls3);
      //4. 通过类加载器【4 种】来获取到类的 Class 对象
      //(1)先得到类加载器 car
      ClassLoader classLoader = car.getClass().getClassLoader();
      //(2)通过类加载器得到 Class 对象
      Class cls4 = classLoader.loadClass(classAllPath);
      System.out.println(cls4);
      //cls1 , cls2 , cls3 , cls4 其实是同一个对象
      System.out.println(cls1.hashCode());
      System.out.println(cls2.hashCode());
      System.out.println(cls3.hashCode());
      System.out.println(cls4.hashCode());
      //5. 基本数据(int, char,boolean,float,double,byte,long,short) 按如下方式得到 Class 类对象
      Class<Integer> integerClass = int.class;
      Class<Character> characterClass = char.class;
      Class<Boolean> booleanClass = boolean.class;
      System.out.println(integerClass);//int
      //6. 基本数据类型对应的包装类，可以通过 .TYPE 得到 Class 类对象
      Class<Integer> type1 = Integer.TYPE;
      Class<Character> type2 = Character.TYPE; //其它包装类 BOOLEAN, DOUBLE, LONG,BYTE 等待
      System.out.println(type1);
      System.out.println(integerClass.hashCode());//?
      System.out.println(type1.hashCode());//?

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class ReflecAccessMethod {
  
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
//1. 得到 Boss 类对应的 Class 对象
Class<?> bossCls = Class.forName("ref.Boss");
//2. 创建对象
Object o = bossCls.newInstance();
//3. 调用 public 的 hi 方法
//Method hi = bossCls.getMethod("hi", String.class);//OK
//3.1 得到 hi 方法对象
Method hi = bossCls.getDeclaredMethod("hi", String.class);//OK
//3.2 调用
hi.invoke(o, "韩顺平教育~");
//4. 调用 private static 方法
//4.1 得到 say 方法对象
Method say = bossCls.getDeclaredMethod("say", int.class, String.class, char.class);
//4.2 因为 say 方法是 private, 所以需要暴破，原理和前面讲的构造器和属性一样
say.setAccessible(true);
System.out.println(say.invoke(o, 100, "张三", '男'));
//4.3 因为 say 方法是 static 的，还可以这样调用 ，可以传入 null
System.out.println(say.invoke(null, 200, "李四", '女'));
//5. 在反射中，如果方法有返回值，统一返回 Object , 但是他运行类型和方法定义的返回类型一致
Object reVal = say.invoke(null, 300, "王五", '男');
System.out.println("reVal 的运行类型=" + reVal.getClass());//String
//在演示一个返回的案例
Method m1 = bossCls.getDeclaredMethod("m1");
Object reVal2 = m1.invoke(o);
System.out.println("reVal2 的运行类型=" + reVal2.getClass());//Monster
}
}
class Monster {}
class Boss {//类
public int age;
private static String name;
public Boss() {//构造器
}
public Monster m1() {
return new Monster();
}
private static String say(int n, String s, char c) {//静态方法
return n + " " + s + " " + c;
}
public void hi(String s) {//普通 public 方法
System.out.println("hi " + s);
}
}

import java.io.FileOutputStream;
import java.io.PrintStream;
import java.lang.reflect.Field;
public class objectFrame {
  public static void saveObject(Object obj) throws Exception {
    PrintStream ps=new PrintStream(new FileOutputStream("D:\\text.txt",true));
    Class c=obj.getClass();
    String cName=c.getSimpleName();
    ps.println("----------"+cName+"---------------");
    Field[] fields=c.getDeclaredFields();
    for(Field field:fields) {
      String name=field.getName();
      field.setAccessible(true);
      String value=field.get(obj)+"";
      ps.println(name+"="+value);
    }
        ps.close();
  }
}

public class Test {
  public static void main(String[] args) throws Exception {
    Student s1=new Student("某人",15,'男');
    Teacher t1=new Teacher("张老师",9999);
    objectFrame.saveObject(s1);
    objectFrame.saveObject(t1);
  }
}