Java-反射剖析

本文介绍了Java反射机制,即在运行状态下可动态获取类的信息和调用对象方法。要解剖类需先获取其字节码文件对象,文中阐述了获取类字节码文件对象的三种方式,包括Object类的getClass()方法、静态属性class和Class类的forName()方法,还提到通过反射获取无参构造方法。

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

     JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法(哪怕是private限定);对于任意一个对象,都能够调用它的任意一个方法和属性“(即使有些属性没有提供Set Get方法);这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
     要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法,所以先要获取到每一个字节码文件对应的Class类型的对象

获取类的字节码(class)文件对象的三种方式
     一:Object类的getClass()方法
     二:静态属性class
     三:Class类中静态方法forName() ----常用

 

 public static Class forName(String className); //className: 这个表示的是一个类对应的全类名(就是需要加上包名)

通过反射获取无参构造方法 

A:获取所有构造方法
	public Constructor<?>[] getConstructors() 获取所有的构造方法不包含私有的
	public Constructor<?>[] getDeclaredConstructors() 获取所有的构造方法 包括私有的
B:获取单个构造方法
	public Constructor<T> getConstructor(Class<?>... parameterTypes) 获取单个的构造方法 不包含私有的
	public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 获取单个的构造方法包含私有的
C:案例演示:	通过反射获取无参构造方法并使用
A:案例演示:	通过反射获取私有构造方法并使用
	// 获取字节码文件对象
	Class clazz = Class.forName("com.click369.Student") ;
	Constructor con = clazz.getDeclaredConstructor(String.class , int.class) ;
	// 值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查。
	con.setAccessible(true) ; 取消语法检查不然会报错 因为私有的外界不能直接访问
	Object obj = con.newInstance("张三" , 23) ;
	System.out.println(obj);
案例演示:通过反射获取所有成员变量
A:获取所有成员变量
	public Field[] getFields() 获取所有的成员变量包含从父类继承过来的
	public Field[] getDeclaredFields() 获取所有的成员变量 包含私有的 也包含从父类继承过来的成员变量
B:获取单个成员变量
	public Field getField(String name)
	public Field getDeclaredField(String name)
C:案例演示:	通过反射获取成员变量并使用
package org.westos.demo;


public class Student {
        //定义成员变量
        public String name;
        private int age;
        public char sex;
        private Student() {
        }
}

-----------------------------------------------------------------------------------------
package org.westos.demo;
import java.lang.reflect.Field;


public class MyTest3 {
    public static void main(String[] args) throws Exception{
        //获取该类的字节码文件对象
        Class aClass = Class.forName("org.westos.demo.Student");
        //获取某个非私有的字段对象
        Field name = aClass.getField("name");
        System.out.println(name.getName());

        //获取私有的字段对象
        Field sex = aClass.getDeclaredField("sex");
        System.out.println(sex);

        ////以前给成员变量设置值
        //Student student = new Student();
        //student.name="zhangsan";
        Object o = aClass.newInstance();
       // Object o1 = aClass.getConstructor().newInstance();
        name.set(o,"zhangsan");
        Student student= (Student) o;
        System.out.println(student.name);
    }
}

 

//通过反射获取无参无返回值成员方法并使用
A:获取所有成员方法
	public Method[] getMethods() //获取所有的公共的成员方法不包含私有的 包含从父类继承过来的过来的公共方法
	public Method[] getDeclaredMethods()//获取自己的所有成员方法 包含私有的
B:获取单个成员方法
	//参数1: 方法名称  参数2:方法行参的class 对象
	public Method getMethod(String name,Class<?>... parameterTypes) //获取单个的方法 不包含私有的
	public Method getDeclaredMethod(String name,Class<?>... parameterTypes) 获取单个方法包括私有的
C:案例演示:	通过反射获取无参无返回值成员方法并使用
package org.westos.demo2;
import com.sun.media.sound.SoftTuning;

public class Student {

    public void test(){
        System.out.println("这是一个空参的方法");
    }

    public void test2(String name,int age) {
        System.out.println("这是一个有参的方法"+name+"==="+age);
    }

    public String show(String name, int age) {
        System.out.println("这是一个有参的方法" + name + "===" + age);

        return name+"哈哈";
    }

    private String show2(String name, int age) {
        System.out.println("这是一个有参的方法" + name + "===" + age);

        return name + "哈哈";
    }
}
----------------------------------------------------------------------------------------
package org.westos.demo2;
import java.lang.reflect.Method;


public class MyTest {
    public static void main(String[] args) throws Exception{
        Class aClass = Class.forName("org.westos.demo2.Student");
        Object obj = aClass.newInstance();

        //获取该类所有的成员方法对象,不包括私有的方法,包括父类继承下来方法
        Method[] methods = aClass.getMethods();
        for (Method method : methods) {
            System.out.println(method.getName());
        }

        System.out.println("-----------------------");
        //获取该类中所有的方法,包括私有的
        Method[] declaredMethods = aClass.getDeclaredMethods();
        for (Method m : declaredMethods) {
            System.out.println(m.getName());
        }
    }
}

 

//案例演示:	通过反射获取带参带返回值成员方法并使用
package org.westos.demo2;
import java.lang.reflect.Method;

public class MyTest2 {
    public static void main(String[] args) throws Exception{
        Class aClass = Class.forName("org.westos.demo2.Student");
        Object obj = aClass.newInstance();
        //获取单个的非私有方法的对象
        Method test = aClass.getMethod("test");
        System.out.println(test);

        ////以前要调用一个方法
        //Student student = new Student();
        //student.test();
        test.invoke(obj);

        System.out.println("--------------------");
        //获取一个有参数的方法对象
        Method test2 = aClass.getMethod("test2", String.class, int.class);
        test2.invoke(obj,"abc",100);

        //获取一个有参数,有返回值的方法对象,并调用该方法执行
        Method show = aClass.getMethod("show", String.class, int.class);
        Object result = show.invoke(obj, "张三", 19);
        String str= (String) result;
        System.out.println(str);
         System.out.println("--------------------");
        Class aClass = Class.forName("org.westos.demo2.Student");
        Object obj = aClass.newInstance();
        //获取一个私有的方法对象
        Method show2 = aClass.getDeclaredMethod("show2", String.class, int.class);
        show2.setAccessible(true);//取消语法检测
        show2.invoke(obj, "王五", 25);
    }
}
案例演示:	通过反射运行配置文件内容
案例演示:       通过反射越过泛型检查
案例演示         通过反射写一个通用的设置某个对象的某个属性为指定的值
A:案例演示
	public void setProperty(Object obj, String propertyName, Object value){},
	此方法可将obj对象中名为propertyName的属性的值设置为value。
通过用户的增删改查引出中介
动态代理的概述和实现
A:动态代理概述
	代理:本来应该自己做的事情,却请了别人来做,被请的人就是代理对象。
	举例:春季回家买票让人代买
	动态代理:在程序运行过程中产生的这个对象
	而程序运行过程中产生对象其实就是我们刚才反射讲解的内容,所以,动态代理其实就是通过反射来生成一个代理
	
	在Java中java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口,
	通过使用这个类和接口就可以生成动态代理对象。JDK提供的代理只能针对接口做代理。
	我们有更强大的代理cglib,Proxy类中的方法创建动态代理类对象
		public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
	最终会调用InvocationHandler的方法
		InvocationHandler Object invoke(Object proxy,Method method,Object[] args)
B:案例演示:	动态代理的实现
我们可以通过Proxy类中的静态方法获取一个代理对象:
- 
- public static Object newProxyInstance(ClassLoader loader,  Class<?>[] interfaces,  InvocationHandler h)
loader: 			类加载器
interfaces:			接口对应的一个Class数组
InvocationHandler:	这个其实就是要代理对象所做的事情的一个类的封装

注意:JDK给我们提供的动态代理,只能对接口进行代理.
A: JDK1.5的新特性: 自动拆装箱 , 泛型 , 增强for , 静态导入 , 可变参数 , 枚举
B:枚举概述:	就是一个类只能存在几个固定的对象,那么这个就是枚举.我们就可以使用这些对象可以表示一些固定的值.
			举例:一周只有7天,一年只有12个月等。
C:案例演示:	自己实现枚举类
JDK5新特性(通过enum实现枚举类)
A:案例演示:	通过enum实现枚举类
JDK5新特性(枚举的注意事项)
A:案例演示
	定义枚举类要用关键字enum
	所有枚举类都是Enum的子类
	枚举类的第一行上必须是枚举项,最后一个枚举项后的分号是可以省略的,但是如果枚举类有其他的东西,这个分号就不能省略。建议不要省略
	枚举类可以有构造器,但必须是private的,它默认的也是private的。枚举项的用法比较特殊:枚举(“”);
	枚举类也可以有抽象方法,但是枚举项必须重写该方法
	枚举在switch语句中的使用
A:枚举类的常见方法
	int ordinal()  返回枚举项的序号
	int compareTo(E o) 比较两个枚举项的 返回的是两个枚举项序号的 差值
	String name() 获取枚举项的名称
	String toString()获取枚举项的名称
	<T> T valueOf(Class<T> type,String name) 用来获取指定的枚举项  参数1:枚举类对应的字节码对象 参数2 枚举项的名称
	values()  获取所有的枚举项
	此方法虽然在JDK文档中查找不到,但每个枚举类都具有该方法,它遍历枚举类的所有枚举值非常方便
B:案例演示:	枚举类的常见方法

public static void main(String[] args) {
	
	// 测试
	Direction front = Direction.FRONT ;
	Direction behind = Direction.BEHIND;
	Direction left = Direction.LEFT ;
	Direction right = Direction.RIGHT ;
	
	System.out.println(front.ordinal());
	System.out.println(behind.ordinal());
	System.out.println(left.ordinal());
	System.out.println(right.ordinal());
	
	System.out.println("----------------------------------");

	System.out.println(front.compareTo(right));
	
	System.out.println("----------------------------------");
	
	System.out.println(front.name());
	
	System.out.println("----------------------------------");
	
	System.out.println(front.toString());
	System.out.println(front);
	
	System.out.println("----------------------------------");
	
	// <T> T valueOf(Class<T> type,String name):	用来获取指定的枚举项
	// type: 表示的是对应的枚举的字节码文件对象
	// name: 就是枚举项的名称
	Direction direction = Direction.valueOf(Direction.class, "RIGHT") ;
	System.out.println(direction);
	
	System.out.println("----------------------------------");
	
	Direction[] directions = Direction.values() ;
	
	for(Direction d : directions){
		System.out.println(d);
	}

}
JDK7新特性(JDK7的六个新特性回顾和讲解)
A:二进制字面量
	JDK7开始,终于可以用二进制来表示整数(byte,short,int和long)。
	使用二进制字面量的好处是,可以使代码更容易被理解。语法非常简单,只要在二进制数值前面加 0b或者0B
	int x = 0b110110
B:数字字面量可以出现下划线
	为了增强对数值的阅读性,如我们经常把数据用逗号分隔一样。JDK7提供了_对数据分隔。
	举例:
		int x = 100_1000;
	注意事项:
		不能出现在进制标识和数值之间
		不能出现在数值开头和结尾
		不能出现在小数点旁边
C:switch 语句可以用字符串
D:泛型简化
E:异常的多个catch合并

 

 

 

 

 

 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值