Java基础之—反射

最新推荐文章于 2024-08-31 22:04:49 发布

qq_1622479435

最新推荐文章于 2024-08-31 22:04:49 发布

阅读量190

点赞数

分类专栏： java技术 Java Java入门文章标签： Java Java入门

Java 同时被 3 个专栏收录

97 篇文章

订阅专栏

Java入门

95 篇文章

订阅专栏

java技术

92 篇文章

订阅专栏

1）类的加载

当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过加载，连接，初始化三步来实现对这个类进行初始化。

加载：就是指将class文件读入内存，并为之创建一个Class对象。任何类被使用时系统都会建立一个Class对象。

连接：

验证是否有正确的内部结构，并和其他类协调一致

准备负责为类的静态成员分配内存，并设置默认初始化值

解析将类的二进制数据中的符号引用替换为直接引用

初始化：就是我们以前讲过的初始化步骤

2）类初始化时机

创建类的实例
访问类的静态变量，或者为静态变量赋值
调用类的静态方法
使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
初始化某个类的子类
直接使用java.exe命令来运行某个主类

3）类加载器

负责将.class文件加载到内在中，并为之生成对应的Class对象。虽然我们不需要关心类加载机制，但是了解这个机制我们就能更好的理解程序的运行。我刚整理了一套2018最新的0基础入门和进阶教程，无私分享，加Java学习q-u-n ：六七八，二四一，五六三即可获取，内附：开发工具和安装包，以及系统学习路线图

类加载器的组成

Bootstrap ClassLoader 根类加载器

Extension ClassLoader 扩展类加载器

Sysetm ClassLoader 系统类加载器

4）获取Class文件对象的三种方式

Person类：

package cn.itcast_01;
public class Person {
   private String name;
   int age;
   public String address;
   public Person() {
   }
   private Person(String name) {
       this.name = name;
   }
   Person(String name, int age) {
       this.name = name;
       this.age = age;
   }
   public Person(String name, int age, String address) {
       this.name = name;
       this.age = age;
       this.address = address;
   }
   public void show() {
       System.out.println("show");
   }
   public void method(String s) {
       System.out.println("method " + s);
   }
   public String getString(String s, int i) {
       return s + "---" + i;
   }
   private void function() {
       System.out.println("function");
   }
   @Override
   public String toString() {
       return "Person [name=" + name + ", age=" + age + ", address=" + address
               + "]";
   }
}

测试类：

package cn.itcast_01;
/*
* 反射：就是通过class文件对象，去使用该文件中的成员变量，构造方法，成员方法。
* 
* Person p = new Person();
* p.使用
* 
* 要想这样使用，首先你必须得到class文件对象，其实也就是得到Class类的对象。
* Class类：
*         成员变量    Field
*         构造方法    Constructor
*         成员方法    Method
* 
* 获取class文件对象的方式：
* A:Object类的getClass()方法
* B:数据类型的静态属性class
* C:Class类中的静态方法
*         public static Class forName(String className)
* 
* 一般我们到底使用谁呢?
*         A:自己玩    任选一种，第二种比较方便
*         B:开发    第三种
*             为什么呢?因为第三种是一个字符串，而不是一个具体的类名。这样我们就可以把这样的字符串配置到配置文件中。
*/
public class ReflectDemo {
   public static void main(String[] args) throws ClassNotFoundException {
       // 方式1
       Person p = new Person();
       Class c = p.getClass();
       Person p2 = new Person();
       Class c2 = p2.getClass();
       System.out.println(p == p2);// false
       System.out.println(c == c2);// true
       // 方式2
       Class c3 = Person.class;
       // int.class;
       // String.class;
       System.out.println(c == c3);
       // 方式3
       // ClassNotFoundException
       Class c4 = Class.forName("cn.itcast_01.Person");
       System.out.println(c == c4);
   }
}

2、反射

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

要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法，所以先要获取到每一个字节码文件对应的Class类型的对象。

1）通过反射获取构造方法并使用

获取构造方法

getConstructors

getDeclaredConstructors

创建对象

newInstance()

con.newInstance(“zhangsan", 20);

例子：

package cn.itcast_02;
import java.lang.reflect.Constructor;
import cn.itcast_01.Person;
/*
* 通过反射获取构造方法并使用。
*/
public class ReflectDemo {
   public static void main(String[] args) throws Exception {
       // 获取字节码文件对象
       Class c = Class.forName("cn.itcast_01.Person");
       // 获取构造方法
       // public Constructor[] getConstructors():所有公共构造方法
       // public Constructor[] getDeclaredConstructors():所有构造方法
       // Constructor[] cons = c.getDeclaredConstructors();
       // for (Constructor con : cons) {
       // System.out.println(con);
       // }
       // 获取单个构造方法
       // public Constructor<T> getConstructor(Class<?>... parameterTypes)
       // 参数表示的是：你要获取的构造方法的构造参数个数及数据类型的class字节码文件对象
       Constructor con = c.getConstructor();// 返回的是构造方法对象
       // Person p = new Person();
       // System.out.println(p);
       // public T newInstance(Object... initargs)
       // 使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例。
       Object obj = con.newInstance();
       System.out.println(obj);
       
       // Person p = (Person)obj;
       // p.show();
   }
}

2）通过反射获取成员变量并使用

获取所有成员

getFields
getDeclaredFields

获取单个成员

getField

getDeclaredField

修改成员的值

set(Object obj,Object value) ：将指定对象变量上此 Field 对象表示的字段设置为指定的新值。

例子：

package cn.itcast_03;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
/*
* 通过发生获取成员变量并使用
*/
public class ReflectDemo {
   public static void main(String[] args) throws Exception {
       // 获取字节码文件对象
       Class c = Class.forName("cn.itcast_01.Person");
       // 获取所有的成员变量
       // Field[] fields = c.getFields();
       // Field[] fields = c.getDeclaredFields();
       // for (Field field : fields) {
       // System.out.println(field);
       // }
       /*
        * Person p = new Person(); p.address = "北京"; System.out.println(p);
        */
       // 通过无参构造方法创建对象
       Constructor con = c.getConstructor();
       Object obj = con.newInstance();
       System.out.println(obj);
       // 获取单个的成员变量
       // 获取address并对其赋值
       Field addressField = c.getField("address");
       // public void set(Object obj,Object value)
       // 将指定对象变量上此 Field 对象表示的字段设置为指定的新值。
       addressField.set(obj, "北京"); // 给obj对象的addressField字段设置值为"北京"
       System.out.println(obj);
       // 获取name并对其赋值
       // NoSuchFieldException
       Field nameField = c.getDeclaredField("name");
       // IllegalAccessException
       nameField.setAccessible(true);
       nameField.set(obj, "林青霞");
       System.out.println(obj);
       // 获取age并对其赋值
       Field ageField = c.getDeclaredField("age");
       ageField.setAccessible(true);
       ageField.set(obj, 27);
       System.out.println(obj);
   }
}

3）通过反射获取成员方法并使用

获取所有方法

getMethods

getDeclaredMethods

获取单个方法

getMethod

getDeclaredMethod

暴力访问

method.setAccessible(true);

例子：

package cn.itcast_04;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
public class ReflectDemo {
   public static void main(String[] args) throws Exception {
       // 获取字节码文件对象
       Class c = Class.forName("cn.itcast_01.Person");
       // 获取所有的方法
       // Method[] methods = c.getMethods(); // 获取自己的包括父亲的公共方法
       // Method[] methods = c.getDeclaredMethods(); // 获取自己的所有的方法
       // for (Method method : methods) {
       // System.out.println(method);
       // }
       Constructor con = c.getConstructor();
       Object obj = con.newInstance();
       /*
        * Person p = new Person(); p.show();
        */
       // 获取单个方法并使用
       // public void show()
       // public Method getMethod(String name,Class<?>... parameterTypes)
       // 第一个参数表示的方法名，第二个参数表示的是方法的参数的class类型
       Method m1 = c.getMethod("show");
       // obj.m1(); // 错误
       // public Object invoke(Object obj,Object... args)
       // 返回值是Object接收,第一个参数表示对象是谁，第二参数表示调用该方法的实际参数
       m1.invoke(obj); // 调用obj对象的m1方法
       System.out.println("----------");
       // public void method(String s)
       Method m2 = c.getMethod("method", String.class);
       m2.invoke(obj, "hello");
       System.out.println("----------");
       // public String getString(String s, int i)
       Method m3 = c.getMethod("getString", String.class, int.class);
       Object objString = m3.invoke(obj, "hello", 100);
       System.out.println(objString);
       // String s = (String)m3.invoke(obj, "hello",100);
       // System.out.println(s);
       System.out.println("----------");
       // private void function()
       Method m4 = c.getDeclaredMethod("function");
       m4.setAccessible(true);
       m4.invoke(obj);
   }
}

测试类：

package cn.itcast.test;
public class ToolDemo {
   public static void main(String[] args) throws NoSuchFieldException,
           SecurityException, IllegalArgumentException, IllegalAccessException {
       Person p = new Person();
       Tool t = new Tool();
       t.setProperty(p, "name", "林青霞");
       t.setProperty(p, "age", 27);
       System.out.println(p);
       System.out.println("-----------");
       Dog d = new Dog();
       t.setProperty(d, "sex", '男');
       t.setProperty(d, "price", 12.34f);
       System.out.println(d);
   }
}
class Dog {
   char sex;
   float price;
   @Override
   public String toString() {
       return sex + "---" + price;
   }
}
class Person {
   private String name;
   public int age;
   @Override
   public String toString() {
       return name + "---" + age;
   }
}