JAVA 基础（三十九）反射机制

最新推荐文章于 2024-08-16 14:06:47 发布

我是传奇丶丶

最新推荐文章于 2024-08-16 14:06:47 发布

阅读量93

点赞数

分类专栏： JAVA基础

本文链接：https://blog.csdn.net/qq_35494622/article/details/104259603

版权

JAVA基础专栏收录该内容

45 篇文章 0 订阅

订阅专栏

【定义】

JAVA反射机制是在运行状态中，对于任意一个类(class文件),都能够知道这个类的所有属性
和方法。
对于任意一个对象，都能够调用它任意一个方法和属性；
这种动态获取信息以及动态调用对象的方法的功能称为java语言的反射机制

简单来讲就是动态获取类中信息，就是java反射，可以理解为解剖

【应用场景】

比如说现在我们有一个已经写好的应用软件，已经可以独立运行了。

软件如果要进行功能扩展，那么这个软件就要对外提供一个接口

Inter ,当我们的软件想要实现这个扩展功能的时候，就需要实现这个Inter 接口，

class Demo implement Inter{}

然后，软件内部就调用这个对象Inter in = new Demo();

但是要注意，我们这个软件已经是独立运行了，这个Demo对象是后面才创建的，所以说我们的

软件并不能new这个对象，因为这个是我们之前已经写好的。

这个时候就需要通过反射机制来实现了。

在开发的时候除了对外开放接口的同时，我们还要获取日后产生功能性的类文件，
所以要对外提供一个配置文件，然后解析这个配置文件。而日后要扩展功能的时候，
你的类就要符合软件提供的接口，然后把子类名称告诉我这个软件就可以了。
如果想要对指定名称的字节码文件（class文件）进行加载并获取其中的内容并调用，就要用到
反射技术。所以，软件中就要提前写好这个反射机制

【配置文件】

应用软件去读取配置文件的信息，配置文件中装都是一些不确定的参数变量，应用软件就根据读取到的
这些变量去做相应的处理。

比如说：
Tomcat的有一个配置文件，server.xml,里面有一些配置信息，
port="8080"
protocal="HTTP/1.1"
Tomcat 就会把这些配置信息加载到程序中，如果是类名，那么就会根据类名去加载Class文件，这样就能
拿到这个类中的属性、字段、方法等。

在java中我们经常把事物的共性不断抽取，封装成类，
比如说

Person{
private String name;
private String age;

}

java中运行的字节码文件class文件，来源于原文件，编译器对源文件进行编译，就把

里面的英文等变成二进制的字节码文件。

比如说：

class Demo{

private int num=4;

Demo(){};

}

class Test{

private int num=4;

Test(){};

}

编译器把两个类都编译成了字节码文件，然后把他们的共性抽取，封装成了
Class类。

class Class{
提供获取字节码文件中的内容。
比如：
名称。
字段
构造函数。
一般函数。
}该类就可以获取字节码文件中的所有内容，反射就是依靠该类来完成的

【获取Class对象的三种方式】

public class ReflectDemo {

   /**
   * @param args
   * @throws ClassNotFoundException
   */
   public static void main(String[] args) throws ClassNotFoundException {

       getClassObject_3();

   }
   /*
   * 方式三：
   * 只要通过给定的类的字符串名称就可以获取该类，更为扩展。
   * 可是用Class类中的方法完成。
   * 该方法就是forName.
   * 这种方式只要有名称即可，更为方便，扩展性更强。
   */

   public static void getClassObject_3() throws ClassNotFoundException {

       String className = "cn.itcast.bean.Person";

       Class clazz = Class.forName(className);

       System.out.println(clazz);
   }

   /*
   * 方式二：
   * 2，任何数据类型都具备一个静态的属性.class来获取其对应的Class对象。
   * 相对简单，但是还是要明确用到类中的静态成员。
   * 还是不够扩展。
   *
   */
   public static void getClassObject_2() {

       Class clazz = Person.class;

       Class clazz1 = Person.class;
       System.out.println(clazz==clazz1);
   }

   /*
   * 获取字节码对象的方式：
   * 1，Object类中的getClass()方法的。
   * 想要用这种方式，必须要明确具体的类，并创建对象。
   * 麻烦 .
   *
   */
   public static void getClassObject_1(){

       Person p = new Person();
       Class clazz = p.getClass();

       Person p1 = new Person();
       Class clazz1 = p1.getClass();

       System.out.println(clazz==clazz1);
   }
}

public class Person {

   private int age;
   private String name;

   public Person(String name,int age) {
       super();
       this.age = age;
       this.name = name;

       System.out.println("Person param run..."+this.name+":"+this.age);

   }
   public Person() {
       super();

       System.out.println("person run");


   }

   public void show(){
       System.out.println(name+"...show run..."+age);
   }

   private void privateMethod(){
       System.out.println(" method run ");
   }

   public void paramMethod(String str,int num){
       System.out.println("paramMethod run....."+str+":"+num);

   }
   public static void staticMethod(){
       System.out.println(" static method run......");
   }
}

【获取Class中的构造函数】

public class ReflectDemo2 {

   /**
   * @param args
   * @throws Exception
   * @throws InstantiationException
   * @throws ClassNotFoundException
   */
   public static void main(String[] args) throws ClassNotFoundException, InstantiationException, Exception {

       createNewObject_2();

   }

   public static void createNewObject_2() throws Exception {

//       cn.itcast.bean.Person p = new cn.itcast.bean.Person("小强",39);

       /*
       * 当获取指定名称对应类中的所体现的对象时，
       * 而该对象初始化不使用空参数构造该怎么办呢？
       * 既然是通过指定的构造函数进行对象的初始化，
       * 所以应该先获取到该构造函数。通过字节码文件对象即可完成。
       * 该方法是：getConstructor(paramterTypes);
       *
       */
       String name = "cn.itcast.bean.Person";
       //找寻该名称类文件，并加载进内存，并产生Class对象。
       Class clazz = Class.forName(name);
       //获取到了指定的构造函数对象。
       Constructor constructor = clazz.getConstructor(String.class,int.class);

       //通过该构造器对象的newInstance方法进行对象的初始化。
       Object obj = constructor.newInstance("小明",38);



   }

   public static void createNewObject() throws ClassNotFoundException, InstantiationException, IllegalAccessException{


       //早期：new时候，先根据被new的类的名称找寻该类的字节码文件，并加载进内存，
//       并创建该字节码文件对象，并接着创建该字节文件的对应的Person对象.
//       cn.itcast.bean.Person p = new cn.itcast.bean.Person();

       //现在：
       String name = "cn.itcast.bean.Person";
       //找寻该名称类文件，并加载进内存，并产生Class对象。
       Class clazz = Class.forName(name);
       //如何产生该类的对象呢？
       Object obj = clazz.newInstance();




   }
}

public class ReflectDemo3 {

   /**
   * @param args
   * @throws Exception
   */
   public static void main(String[] args) throws Exception {
       //getFieldDemo1();

       getFieldDemo();

   }

   /*
   * 获取字节码文件中的字段。
   */

public static void getFieldDemo1() throws Exception {

       Class clazz = Class.forName("cn.itcast.bean.Person");

       File field =clazz.getField("age");

       System.out.println(field);//这样会报错，因为getField("age")只能获取共有的

   }

}

所以改成

public static void getFieldDemo1() throws Exception {

       Class clazz = Class.forName("cn.itcast.bean.Person");

       File field =null;

       field=clazz.getDeclaredField("age");

       System.out.println(field);//打印private int cn.itcast.bean.Person.age

   }

}

操作这个字段

   public static void getFieldDemo() throws Exception {

       Class clazz = Class.forName("cn.itcast.bean.Person");

       Field field = null;//clazz.getField("age");//只能获取公有的，

       field = clazz.getDeclaredField("age");//只获取本类，但包含私有。

       //对私有字段的访问取消权限检查。暴力访问。
       field.setAccessible(true);

//为什么要有这个对象呢？
//我们知道在正常操作的时候应该是这样，
//cn.itcast.bean.Person p = new cn.itcast.bean.Person();
//p.age = 30;这样就好理解了，操作属性要有属性所属的对象

       Object obj = clazz.newInstance();

       field.set(obj, 89);


       Object o = field.get(obj);

       System.out.println(o);


   }

}

【获取方法】

public class ReflectDemo4 {

public ReflectDemo4() {
}

   /**
   * @param args
   * @throws Exception
   */
   public static void main(String[] args) throws Exception {

       getMethodDemo_3();

   }

   public static void getMethodDemo_3() throws Exception {

       Class clazz = Class.forName("cn.itcast.bean.Person");

       Method method = clazz.getMethod("paramMethod", String.class,int.class);

       Object obj = clazz.newInstance();

       method.invoke(obj, "小强",89);


   }

   public static void getMethodDemo_2() throws Exception {

       Class clazz = Class.forName("cn.itcast.bean.Person");

       Method method = clazz.getMethod("show", null);//获取空参数一般方法。

//       Object obj = clazz.newInstance();
       Constructor constructor = clazz.getConstructor(String.class,int.class);
       Object obj = constructor.newInstance("小明",37);


       method.invoke(obj, null);



   }

   /*
   * 获取指定Class中的所有公共函数。
   */
   public static void getMethodDemo() throws Exception {

       Class clazz = Class.forName("cn.itcast.bean.Person");

       Method[] methods = clazz.getMethods();//获取的都是公有的方法。
       methods = clazz.getDeclaredMethods();//只获取本类中所有方法，包含私有。
       for(Method method : methods){
           System.out.println(method);
       }


   }

}

【反射练习】

/*
* 电脑运行。
*/
public class ReflectTest {

   /**
   * @param args
   * @throws Exception
   */
   public static void main(String[] args) throws Exception {

       Mainboard mb = new Mainboard();
       mb.run();
       //每次添加一个设备都需要修改代码传递一个新创建的对象
//       mb.usePCI(new SoundCard());
       //能不能不修改代码就可以完成这个动作。
//       不用new来完成，而是只获取其class文件。在内部实现创建对象的动作。

       File configFile = new File("pci.properties");

       Properties prop = new Properties();
       FileInputStream fis = new FileInputStream(configFile);

       prop.load(fis);

       for(int x=0; x<prop.size(); x++){

           String pciName = prop.getProperty("pci"+(x+1));

           Class clazz = Class.forName(pciName);//用Class去加载这个pci子类。

           PCI p = (PCI)clazz.newInstance();

           mb.usePCI(p);
       }

       fis.close();


   }

}

public class Mainboard {

   public void run() {
       System.out.println("main board run....");
   }

   public void usePCI(PCI p) {//PCI p = new SouncCard();
       if (p != null) {
           p.open();
           p.close();
       }
   }
}

public class NetCard implements PCI {

   @Override
   public void open() {
       System.out.println("net open");
   }

   @Override
   public void close() {
       System.out.println("net close");
   }

}

public interface PCI {

   public void open();
   public void close();

}

public class SoundCard implements PCI {
   public void open(){
       System.out.println("sound open");
   }
   public void close(){
       System.out.println("sound close");
   }

}