根据实例详解Java中的反射机制

概念：
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
作用：
Java反射机制主要提供了以下功能： 在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。

可以说Java的反射机制是Java中所有框架的基础，要对SSH等框架有一个深刻的理解，必须熟悉掌握Java的反射机制。

下面我们通过具体例子来了解一下Java反射机制的原理及使用

1， 通过对象获取对象所属的包名和类名

在demo2包中定义一个类：

package demo2;
public class ReflectDemo2 {

}

获取包名加类名：

public class ReflectDemo1 {
	public static void main(String[] args) {
		ReflectDemo2 rd=new ReflectDemo2();
		System.out.println(rd.getClass().getName());
	}
}

运行结果：demo2.ReflectDemo2

2，获得Class对象的三种方法：

public class ReflectDemo1 {
	public static void main(String[] args) {
		Class<?> c1 = null;
		Class<?> c2 = null;
		Class<?> c3 = null;
		try {
			c1 = Class.forName("demo2.ReflectDemo2");
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		System.out.println("c1："+c1.getName());

		c2 = new ReflectDemo2().getClass();
		System.out.println("c2："+c2.getName());

		c3 = ReflectDemo2.class;
		System.out.println("c3："+c3.getName());
	}
}

运行结果：

c1：demo2.ReflectDemo2
c2：demo2.ReflectDemo2
c3：demo2.ReflectDemo2

我们可以看到，运行的结果都是一样的，c1通过类Class的静态方法forName()；c2通过实例变量的getClass()方法；c3直接通过对象类的.class文件获得，使用比较普遍的是通过Class的静态方法forName()获取对象。

3， 通过反射机制实例化类的对象
首先创建对象类：

public class User {
	private String username;
	private String password;
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public User(String username, String password) {
		super();
		this.username = username;
		this.password = password;
	}
	public User() {
		super();
		// TODO Auto-generated constructor stub
	}
	@Override
	public String toString() {
		return "User [username=" + username + ", password=" + password + "]";
	}

}

一，使用set方法为实例化对象赋值：

public class ReflectDemo1 {
	public static void main(String[] args) throws ClassNotFoundException {
		Class<?> c1 = Class.forName("demo2.User");
		try {
			User user = (User)c1.newInstance();
			user.setUsername("张三");
			user.setPassword("zhangsan");
			System.out.println(user);
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}

	}
}

运行结果：
User [username=张三, password=zhangsan]

二，使用构造函数方法为实例化对象赋值：

public class ReflectDemo1 {
	public static void main(String[] args) throws ClassNotFoundException {
		Class<?> c1 = Class.forName("demo2.User");
		//取得全部的构造函数
        Constructor<?> cons[] = c1.getConstructors();
        try {
			User user = (User)cons[0].newInstance("李四","123");
			System.out.println(user);
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			e.printStackTrace();
		}
	}
}

运行结果：
User [username=李四, password=123]

4， 获取类的全部属性信息：

public class ReflectDemo2{
	public static void main(String[] args) {
		try {
			Class<?> c1 = Class.forName("demo2.User");
			Field[] field = c1.getDeclaredFields();
			for (int i = 0; i < field.length; i++) {
				int p = field[i].getModifiers();//获取属性的作用域
				String p1 = Modifier.toString(p);
				Class<?> type = field[i].getType();//获取属性的类型
				System.out.println("属性名："+field[i].getName()+"作用域是："+p1+"类型是:"+type.getName());
			}
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}

	}
}

运行结果：
属性名：serialVersionUID作用域是：private static final类型是:long
属性名：username作用域是：private类型是:java.lang.String
属性名：password作用域是：private类型是:java.lang.String

5.获取某个类的全部方法：

public class ReflectDemo2{
	public static void main(String[] args) {
			Class<?> c1;
			try {
				c1 = Class.forName("demo2.User");
				Method method[] = c1.getMethods();
		        for (int i = 0; i < method.length; ++i) {
		            System.out.print(method[i].getName() + " ");
		        }
			} catch (ClassNotFoundException e) {
				e.printStackTrace();
			}
	}
}

运行结果：
toString getUsername setUsername getPassword setPassword wait wait wait hashCode getClass equals notify notifyAll

6， 通过反射机制调用某个类的方法

首先定义要调用的类：

public class User implements Serializable{
	private static final long serialVersionUID = 7331750553985640492L;
	private String username;
	private String password;
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public User(String username, String password) {
		super();
		this.username = username;
		this.password = password;
	}
	public User(String username) {
		this.username = username;
	}
	public User() {
		super();
		// TODO Auto-generated constructor stub
	}
	@Override
	public String toString() {
		return "User [username=" + username + ", password=" + password + "]";
	}
	public void test1(){
		System.out.println("无参方法");
	}
	public void test2(String name){
		System.out.println("带参数的方法，名字为："+name);
	}
}

通过反射机制调用User类中的方法：

public class ReflectDemo2{
	public static void main(String[] args) throws Exception {
			Class<?> c1 = Class.forName("demo2.User");
			//调用User类中的无参方法
			Method method = c1.getMethod("test1");
			method.invoke(c1.newInstance());
			//调用User类中的带参数的方法
			method = c1.getMethod("test2",String.class);
			method.invoke(c1.newInstance(),"阿木侠");
	}
}

运行结果：
无参方法
带参数的方法，名字为：阿木侠

7，操作某个类的属性，对某个类的变量动态赋值：

public class ReflectDemo2{
	public static void main(String[] args) throws Exception {
			Class<?> c1 = Class.forName("demo2.User");
			Object obj = c1.newInstance();
			Field field = c1.getDeclaredField("username");
	        field.setAccessible(true);
	        field.set(obj, "这里对User类中的username进行赋值啦");
	        System.out.println(field.get(obj));
	}
}

运行结果：
这里对User类中的username进行赋值啦

8， 通过Java的反射机制取得数组的信息，修改数组的信息

public class Test {
	 public static void main(String[] args) throws Exception {
	        int[] arr = { 1, 2, 3, 4, 5 };
	        Class<?> demo = arr.getClass().getComponentType();
	        System.out.println("数组类型： " + demo.getName());
	        System.out.println("数组长度  " + Array.getLength(arr));
	        System.out.println("数组的第一个元素: " + Array.get(arr, 0));
	        Array.set(arr, 0, 6);
	        System.out.println("修改之后数组第一个元素为： " + Array.get(arr, 0));
	    }
}

运行结果：
数组类型： int
数组长度  5
数组的第一个元素: 1
修改之后数组第一个元素为： 6

9， 工厂模式中Java反射机制的应用
在不使用反射机制的普通工厂类中，我们每次添加子类时都要对工厂类进行修改，很不方便，而利用反射机制实现工厂模式，可以在不修改工厂类的情况下添加任意多个子类，例如：
定义People接口：

public interface People {
	public abstract void read();
}

用学生和工人实现这个接口：

public class Worker implements People{

	public void read() {
		System.out.println("工人爱读书");
	}
}

public class Student implements People {

	public void read() {
		System.out.println("学生爱读书");
	}

}

定义工厂类：

public class FactoryDemo {
	public static People getInstance(String name) throws Exception{
		People p;
		p = (People)Class.forName(name).newInstance();
		return p;

	}
}

测试这个工厂类是否能实现：

public class ReflectDemo2{
	public static void main(String[] args) throws Exception {
			People student = FactoryDemo.getInstance("demo2.Student");
			if(student!=null){
				student.read();
			}
			People worker = FactoryDemo.getInstance("demo2.Worker");
			if(worker!=null){
				worker.read();
			}
	}
}

运行结果：
学生爱读书
工人爱读书

时间： 2024-08-01 08:27:05

根据实例详解Java中的反射机制的相关文章

实例详解Java中ThreadLocal内存泄露_java

案例与分析 问题背景 在 Tomcat 中,下面的代码都在 webapp 内,会导致WebappClassLoader泄漏,无法被回收. public class MyCounter { private int count = 0; public void increment() { count++; } public int getCount() { return count; } } public class MyThreadLocal extends ThreadLocal<MyCount

实例详解Java中如何对方法进行调用_java

方法调用Java支持两种调用方法的方式,根据方法是否返回值来选择. 当程序调用一个方法时,程序的控制权交给了被调用的方法.当被调用方法的返回语句执行或者到达方法体闭括号时候交还控制权给程序. 当方法返回一个值的时候,方法调用通常被当做一个值.例如: int larger = max(30, 40); 如果方法返回值是void,方法调用一定是一条语句.例如,方法println返回void.下面的调用是个语句: System.out.println("Welcome to Java!");

详解Java中的正则表达式

详解Java中的正则表达式,并列出常用的正则表达式语法和一些常用的场景. 判断一个字符串是否是由数字组成: 当不使用正则表达式的时候的实现代码: public class RegexDemo01 { public static void main(String[] args) { String s = "23432324"; char c[] = s.toCharArray();//将字符串转换成字符数组 for (int i = 0; i < c.length; i++) {

Java中的反射机制

反射,reflection,听其名就像照镜子一样,可以看见自己也可以看见别人的每一部分.在java语言中这 是一个很重要的特性.下面是来自sun公司官网关于反射的介绍: Reflection is a feature in the Java programming language. It allows an executing Java program to examine or "introspect" upon itself, and manipulate internal pr

详解Java中的指针、引用及对象的clone

对象|详解 Java语言的一个优点就是取消了指针的概念,但也导致了许多程序员在编程中常常忽略了对象与引用的区别,本文会试图澄清这一概念.并且由于Java不能通过简单的赋值来解决对象复制的问题,在开发过程中,也常常要要应用clone()方法来复制对象.本文会让你了解什么是影子clone与深度clone,认识它们的区别.优点及缺点.看到这个标题,是不是有点困惑:Java语言明确说明取消了指针,因为指针往往是在带来方便的同时也是导致代码不安全的根源,同时也会使程序的变得非常复杂难以理解,滥用指针写成的

实例详解PHP中html word 互转的方法_php实例

下面一段代码给大家介绍php将html转入word中,具体内容如下所示: 这是经过测试的,这种方法有一点不好,html页面代码要写在php中,不过好歹能运行,看程序 <?php class word{ function start(){ ob_start(); echo '<html xmlns:o="urn:schemas-microsoft-com:office:office" xmlns:w="urn:schemas-microsoft-com:office

详解Java中final的用法_java

概念 final 具有"不可改变的"的含义,可以修饰 非抽象类.非抽象成员方法和变量. 用 final 修饰的类不能被继承,没有子类. 用 final 修饰的方法不能被子类的方法覆盖(重写). 用 final 修饰的变量表示常量,只能被赋一次值(声明变量的时候). 注: final 不能用来修饰构造方法,因为"方法覆盖"这一概念仅适用于类的成员方法,而不适用于类的构造方法,父类的构造方法和子类的构造方法之间不存在覆盖的关系,因此用final修饰构造方法没有任何意义.

详解java中动态代理实现机制_java

代理模式是常用的java设计模式,它的特征是代理类与委托类有同样的接口,代理类主要负责为委托类预处理消息.过滤消息.把消息转发给委托类,以及事后处理消息等.代理类与委托类之间通常会存在关联关系,一个代理类的对象与一个委托类的对象关联,代理类的对象本身并不真正实现服务,而是通过调用委托类的对象的相关方法,来提供特定的服务. JAVA各种动态代理实现的比较 接口 interface AddInterface{ int add(int a, int b); } interface SubInterfa

详解Java中synchronized关键字的死锁和内存占用问题_java

先看一段synchronized 的详解: synchronized 是 java语言的关键字,当它用来修饰一个方法或者一个代码块的时候,能够保证在同一时刻最多只有一个线程执行该段代码. 一.当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时,一个时间内只能有一个线程得到执行.另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块. 二.然而,当一个线程访问object的一个synchronized(this)同步代码块时,另一个线程仍然可以