JavaSe基础XX21——反射机制_xx21配置-优快云博客

本文深入讲解Java反射机制的核心概念及应用场景，包括动态获取类信息、构造函数、字段和方法等关键知识点。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

*01-反射机制(概述&应用场景)

/*
 * JAVA反射机制是在运行状态中，对于任意一个类 (class文件)，都能够知道这个类的所有属性和方法；
 * 对于任意一个对象，都能够调用它的任意一个方法和属性；
 * 这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 
 * 
 * 
 * 动态获取类中信息，就是java反射 。
 * 可以理解为对类的解剖。
 * 
 * 
 * 要想要对字节码文件进行解剖，必须要有字节码文件对象.
 * 如何获取字节码文件对象呢？
 * 
 */

*02-反射机制(细节&Class对象)

用于描述字节码文件的类名Class。

*03-反射机制(获取Class对象的三种方式)

新建了一个person类：

package cn.itcast.bean;

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......");
	}
}

* 要想要对字节码文件进行解剖，必须要有字节码文件对象.
* 如何获取字节码文件对象呢？

获取字节码对象的方法，方法一共3个。

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

方法二：

方法三、：必须掌握！

----------------------小结-------------------

package cn.itcast.reflect.demo;

import cn.itcast.bean.Person;


/*
 * JAVA反射机制是在运行状态中，对于任意一个类 (class文件)，都能够知道这个类的所有属性和方法；
 * 对于任意一个对象，都能够调用它的任意一个方法和属性；
 * 这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 
 * 
 * 
 * 动态获取类中信息，就是java反射 。
 * 可以理解为对类的解剖。
 * 
 * 
 * 要想要对字节码文件进行解剖，必须要有字节码文件对象.
 * 如何获取字节码文件对象呢？
 * 
 */

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);
	}
}

*04-反射机制(获取Class中的构造函数)

---------------小结---------------------

package cn.itcast.reflect.demo;

import java.io.FileReader;
import java.lang.reflect.Constructor;

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();
		
		
		
		
	}
}

*05-反射机制(获取Class中的字段)

---------小结---------------

package cn.itcast.reflect.demo;

import java.lang.reflect.Field;

public class ReflectDemo3 {

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

	/*
	 * 获取字节码文件中的字段。
	 */
	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);
		
		Object obj = clazz.newInstance();
		
		field.set(obj, 89);
		
		
		Object o = field.get(obj);
		
		System.out.println(o);
		
//		cn.itcast.bean.Person p = new cn.itcast.bean.Person();
//		p.age = 30;
		
	}
	
}

*06-反射机制(获取Class中的方法)

-------------------------------

package cn.itcast.reflect.demo;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

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);
		}
		
		
	}

}

*07-反射机制(反射练习)

-----------------小结--------------------

package cn.itcast.reflect.test;

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

}

package cn.itcast.reflect.test;

public interface PCI {
	
	public void open();
	public void close();

}

package cn.itcast.reflect.test;

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();
		}
	}
}

package cn.itcast.reflect.test;

public class NetCard implements PCI {

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

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

}

package cn.itcast.reflect.test;

import java.io.File;
import java.io.FileInputStream;

import java.util.Properties;


/*
 * 电脑运行。 
 */
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();
		
		
	}

}