java中反射

最新推荐文章于 2024-09-07 10:51:32 发布
最新推荐文章于 2024-09-07 10:51:32 发布
阅读量122 收藏
点赞数
分类专栏： Java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40942323/article/details/96330411
版权

java中每个类在编译后都会生成对应的class文件，Java中的所有类，必须被装载到jvm中才能运行，这个装载工作是由jvm中的类装载器完成的。
1.装载：类加载器将编译好的class装载到内存
2.链接：验证：确保被加载类的正确性； 准备：为类的静态变量分配内存，并将其初始化为默认值；解析：把类中的符号引用转换为直接引用；
3.初始化：为类的静态变量赋予正确的初始值；
（说明：装载不是加载，一个应用程序总是由n多个类组成，Java程序启动时，并不是一次把所有的类全部加载后再 运行，它总是先把保证程序运行的基础类一次性加载到jvm中，其它类等到jvm用到的时候再加载，这样的好处是节省了内存的开销，是java动态性的一种体现 ）

java的类加载器
Bootstrap Loader - 负责加载系统类 负责Java核心类的加载
ExtClassLoader - 负责加载扩展类 负责JRE的扩展目录中jar包的加载
AppClassLoader - 负责加载应用类 加载来自java命令的class文件，以及classpath环境变量所指定的jar包和类路径。
在这里java采用了委托模型机制，这个机制简单来讲，就是“类装载器有载入类的需求时，会先请示其Parent使用其搜索路径帮忙载入，如果Parent 找不到,那么才由自己依照自己的搜索路径搜索类”。可见性机制：可见性的原理是子类的加载器可以看见所有的父类加载器加载的类，而父类加载器看不到子类加载器加载的类。单一性机制：根据这个机制，父加载器加载过的类不能被子加载器加载第二次。虽然重写违反委托和单一性机制的类加载器是可能的，但这样做并不可取。

类加载器将class文件加载到方法区中，在堆内存创建唯一的字节码对象也就是class对象。

类的初始化时间

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

获取class对象三种方式：
方式一: 通过Object类中的getObject()方法

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

方式二: 通过 类名.class 获取到字节码文件对象（任意数据类型都具备一个class静态属性,看上去要比第一种方式简单）。

Class c2 = Person.class;

方式三: 通过Class类中的方法（将类名作为字符串传递给Class类中的静态方法forName即可）。

Class c3 = Class.forName("com.xxx.xxx.xxxPerson");(正确的包名位置)

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

public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException {
		//获取Class对象
		Class c = Class.forName("cn.itcast_01_Reflect.Person");//包名.类名
		
		//getConstructors只返回制定参数类型访问权限是public的构造器。
		//Constructor[] cons = c.getConstructors();
		//getDeclaredConstructors() 这个方法会返回制定参数类型的所有构造器，包括public和非public，当然也包括private。
		Constructor[] cons = c.getDeclaredConstructors();
		for (Constructor con : cons) {
			System.out.println(con);
		}
		
		System.out.println("------------------------");
		//获取一个构造方法
		//public Person() 
		Constructor con1 = c.getConstructor(null);
		System.out.println(con1);
		
		//public Person(String name)
		Constructor con2 = c.getConstructor(String.class);
		System.out.println(con2);
		
		//private Person(String name, int age)
		Constructor con3 = c.getDeclaredConstructor(String.class, int.class);
		System.out.println(con3);
		
		//public Person(String name, int age, String address)
		Constructor con4 = c.getDeclaredConstructor(String.class, int.class, String.class);
		System.out.println(con4);
	}

通过反射方式，获取构造方法，创建对象

public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		//1,获取到Class对象
		Class c = Class.forName("cn.itcast_01_Reflect.Person");//包名.类名
		//2,获取指定的构造方法
		//public Person()
		//Constructor con = c.getConstructor(null);
		
		//public Person(String name, int age, String address)
		Constructor con = c.getConstructor(String.class, int.class, String.class);
		
		//3,通过构造方法类中Constructor的方法，创建对象
		//Object obj = con.newInstance(null);
		Object obj = con.newInstance("小明", 22, "哈尔滨");
		
		//显示
		System.out.println(obj);
	}

通过反射方式，获取私有构造方法，创建对象
AccessibleObject 类是 Field、Method 和 Constructor 对象的父类。它提供了将反射的对象标记为在使用时取消默认 Java 语言访问控制检查的能力。

public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		//1,获取到Class对象
		Class c = Class.forName("cn.itcast_01_Reflect.Person");//包名.类名
		
		//2,获取指定的构造方法
		//private Person(String name, int age)
		Constructor con = c.getDeclaredConstructor(String.class, int.class);
		
		//3,暴力反射 
		con.setAccessible(true);//取消 Java 语言访问检查
		
		//4,通过构造方法类中的功能，创建对象
		Object obj = con.newInstance("小明", 23);
		System.out.println(obj);
		
	}

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

public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, SecurityException {
		//获取Class对象
		Class c = Class.forName("cn.itcast_01_Reflect.Person");
		
		//获取成员变量
		//多个变量
		//Field[] fields = c.getFields();
		Field[] fields =  c.getDeclaredFields();
		for (Field field : fields) {
			System.out.println(field);
		}
		System.out.println("-----------------");
		//一个变量
		//public int age;
		Field ageField = c.getField("age");
		System.out.println(ageField);
		
		//private String address
		Field addressField = c.getDeclaredField("address");
		System.out.println(addressField);
	}

通过反射，创建对象，获取指定的成员变量，进行赋值与获取值操作

public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchFieldException {
		//1,获取Class对象
		Class c = Class.forName("cn.itcast_01_Reflect.Person");
		//2，获取构造方法
		//public Person(String name) 
		Constructor con = c.getConstructor(String.class);
		//3，通过构造方法，创建对象
		Object obj = con.newInstance("小明");
		//4，获取指定的成员变量
		//public String name;
		Field nameField = c.getField("name");
		//public int age;
		Field ageField = c.getField("age");
		//private String address;
		Field addressField = c.getDeclaredField("address");
		addressField.setAccessible(true); //取消 Java 语言访问检查
		
		//5，通过方法，给指定对象的指定成员变量赋值或者获取值
		System.out.println("name = "+ nameField.get(obj));
		System.out.println("age = "+ ageField.get(obj));
		System.out.println("address = "+ addressField.get(obj));
		
		//赋值
		ageField.set(obj, 23);
		addressField.set(obj, "凯利广场");
		
		System.out.println("------------------------");
		System.out.println("name = "+ nameField.get(obj));
		System.out.println("age = "+ ageField.get(obj));
		System.out.println("address = "+ addressField.get(obj));
	}

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

public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException {
		//获取Class对象
		Class c = Class.forName("cn.itcast_01_Reflect.Person");
		
		//获取多个方法
		//Method[] methods = c.getMethods();
		Method[] methods = c.getDeclaredMethods();
		for (Method method : methods) {
			System.out.println(method);
		}
		
		System.out.println("-----------------------");
		//获取一个方法：
		//public void method1()
		Method method = c.getMethod("method1", null);
		System.out.println(method);
		//public String method4(String name){
		method = c.getMethod("method4", String.class);
		System.out.println(method);
		//私有方法
		//private void method5()
		method = c.getDeclaredMethod("method5", null);
		System.out.println(method);
	}

通过反射，创建对象，调用指定的方法

public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		//1， 获取Class对象
		Class c = Class.forName("cn.itcast_01_Reflect.Person");
		//2,获取构造方法
		//public Person(String name, int age, String address){
		Constructor con = c.getConstructor(String.class, int.class, String.class);
		//3，通过构造方法，创建对象
		Object obj = con.newInstance("小明", 23, "哈尔滨");
		//4，获取指定的方法
		//public void method1()  没有返回值没有参数的方法
		//Method m1 = c.getMethod("method1", null);
		
		//public String method4(String name)
		Method m4 = c.getMethod("method4", String.class);
		
		//5，执行找到的方法
		//m1.invoke(obj, null);
		
		Object result = m4.invoke(obj, "itcast");
		System.out.println("result = " + result);
	}

通过反射，创建对象，调用指定的private 方法

public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		//1， 获取Class对象
		Class c = Class.forName("cn.itcast_01_Reflect.Person");
		//2,获取构造方法
		//public Person(String name, int age, String address){
		Constructor con = c.getConstructor(String.class, int.class, String.class);
		//3，通过构造方法，创建对象
		Object obj = con.newInstance("小明", 23, "哈尔滨");
		//4，获取指定的方法
		//private void method5(){
		Method m5 = c.getDeclaredMethod("method5", null);
		//5,开启暴力访问
		m5.setAccessible(true);
		//6，执行找到的方法
		m5.invoke(obj, null);
	}

反射中的泛型擦除

public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		ArrayList<Integer> list = new ArrayList<Integer>();
		//添加元素到集合
		list.add(new Integer(30));
		list.add(new Integer("12345"));
		list.add(123);
		//list.add("哈哈");//因为有泛型类型的约束
		System.out.println(list);
		
		//通过反射技术，实现添加任意类型的元素
		//1, 获取字节码文件对象
		//Class c = list.getClass();
		//Class c = ArrayList.class;
		Class c = Class.forName("java.util.ArrayList");
		
		//2, 找到add()方法
		// public boolean add(E e)
		Method addMethod = c.getMethod("add", Object.class);
		
		//3，  执行add()方法
		addMethod.invoke(list, "哈哈");// list.add("哈哈");
		System.out.println(list);
	}
L X D.
关注
专栏目录
Java中反射
12-22
- Java反射机制还支持动态代理，通过`java.lang.reflect.Proxy` 类可以创建一个代理对象，该对象在运行时代表另一个对象。 8. 异常处理： - 使用反射操作时，需要注意处理可能抛出的异常，如`...
详解java中反射机制（含数组参数）
08-29
Java 中的反射机制（含数组参数） Java 中的反射机制是一种强大的工具，可以在运行时获取类的内部信息，包括modifiers、superclass、interfaces、fields 和 methods 的所有信息，并可以在运行时改变 fields 的内容...
Java 中的反射
ShadowySpirits的博客
07-06 1141
反射(Reflection)是Java 程序开发语言的特征之一，它允许运行中的 Java 程序获取自身的信息，并且可以操作类或对象的内部属性。  简而言之，通过反射，我们可以在运行时获得程序或程序集中每一个类型的成员和成员的信息。 程序中一般的对象的类型都是在编译期就确定下来的，而Java反射机制可以动态地创建对象并调用其属性，这样的对象的类型在编译期是未知的。所以我们可以通过反射机制直接创建...
JAVA中的反射
菜鸡，轻喷
02-24 475
反射1.获取Class对象的三种方式1.1实例展示2.创建实例，判断是否为某个类的实例2.1实例演示3.ClassLoader4.获取方法4.1获取构造方法4.2获取方法Method4.2.1获取到方法后，进行操作方法4.2.2获取父类的(私有)方法4.2.3获取描述字段 --- Field 1.获取Class对象的三种方式 名称 解释 通过类名获取 类名.class 通过对象获取 对象名.getClass() 通过全类名获取 Class.forName(全类名) 1.1实例展示
Java中的反射
最新发布
m0_50345460的博客
09-07 961
字节码文件：就是通过java文件编译之后的class文件（是在硬盘上真实存在的，用眼睛能看到的）理解：集合中的泛型只在java文件中存在，当编译成class文件之后，就没泛型了。字节码文件对象：当class文件加载到内存之后，虚拟机自动创建出来的对象。字节码文件对象，这个对象在内存中是唯一的。需求：利用反射根据文件中不同的类名和方法名，创建不同的对象并调用方法。如果当前获取到的是私有的，必须要临时修改访问权限，否则无法使用。，把要创建的对象信息和方法写在配置文件中。如何获取class字节码文件的对象。
Java中反射的一个简单使用
09-01
Java反射机制是Java语言提供的一种强大的能力，它允许我们在运行时动态地获取类的信息并进行操作，包括类的属性、方法、构造器等。在实际开发中，虽然反射的使用频率不高，但它是理解许多高级Java框架（如Spring、...
关于Java中反射机制的深入讲解
08-27
在面试中，了解和掌握Java反射机制是非常重要的，它能体现出开发者对Java语言特性的理解深度和问题解决能力。理解反射的工作原理和使用场景，能够帮助开发者在遇到需要动态操作对象或者类的情况时，做出更灵活、高效...
java中的反射
weixin_57321519的博客
06-08 202
反射的核心是在程序运行时动态的加载类并获取类的信息一般情况下，我们使用某个类时必定知道它是什么类，是用来做什么的。于是我们直接对这个类进行实例化，之后使用这个类对象进行操作。而反射则是一开始并不知道我要初始化的类对象是什么反射就是在运行时才知道要操作的类是什么，并且可以在运行时获取类的完整构造，并调用对应的方法。反射的实现1、class.forName（“全类名”）：将字节码文件加载进内存，然后返回给class对象2、类名.class：通过类名获取class对象-----》一般知道类名称才使用3、对象.ge
java中反射的实际应用
07-11
Java中反射的实际应用非常广泛，下列举几个常见的应用场景1. 框架和库的开发：很框架和库都使用了反射来实现动态加载和扩展功能。例如，Spring框架中的依赖注、AOP等功能都通过反射来实的。 2. 序列化和反序列化：反射可以用于将对象转化为字节流或者将字节流还原成对象。这在网络传输、持久化存储等场景中非常常见，例如Java中的ObjectInputStream和ObjectOutputStream就使用了反射。 3. 动态代理：反射可以用于生成代理对象，通过代理对象可以在目标对象的方法前后添加额外的逻辑。这在AOP编程、RPC框架等场景中非常有用。 4. 单元测试：反射可以用于测试私有方法或属性，通过反射可以绕过访问修饰符的限制，从而在单元测试中调用私有方法或修改私有属性的值。 5. 配置文件解析：反射可以用于解析配置文件，根据配置文件中的类名创建对象，并调用对应的方法或设置属性值。 总之，反射提供了一种在运行时检查和操作类、方法、属性等结构的能力，使得Java程序具备更高的灵活性和动态性。但是在使用反射时需要注意性能开销和安全性，过度使用反射可能会影响程序的性能和可维护性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值