Java技术之反射

最新推荐文章于 2024-05-06 21:32:45 发布

Tony_zxlu

最新推荐文章于 2024-05-06 21:32:45 发布

阅读量383

点赞数

分类专栏： JAVA技术文章标签：面向对象编程编程语言 java 反射技术

本文链接：https://blog.csdn.net/huofenghuang188/article/details/44804121

版权

JAVA技术专栏收录该内容

9 篇文章 0 订阅

订阅专栏

反射的基石——>Class类

1、java中的类是用来描述一类事物的共性，该类事物有什么属性，没有什么属性，至于这个属性的值是什么，则是由这个类的实例对象来确定的，不同的实例对象有不同的属性值。java中所有的类也是一类事物，有其共性，都有所属的包，类名，属性的访问权限，字段，方法等信息。我们对此进行抽象提取用于描述类的共性内容，这就出现了一个特有的类Class类。这个类是反射的基石，它用来表示java中对象的class阶段，Class对象封装了一个java类中定义的成员变量、成员方法、构造方法、类名、包名等。

<span style="font-size:18px;">Person p1 = new Person("zhangsan");
Person p2 = new Person("lisi");
  
/*Class x1 = Vector类在内存里的字节码
  Class x2 = Date类在内存里的字节码*/
Class x1 = Vector.class;
Class x2 = Date.class;</span>

2、Class类代表Java类，它的各个实例对象又分别对应什么呢？
对应各个类在内存中的字节码，例如，Person类的字节码，ArrayList类的字节码，等等。
一个类被类加载器加载到内存中，占用一片存储空间，这个空间里面的内容就是类的字节码，不同的类的字节码是不同的，所以它们在内存中的内容是不同的，这一个个的空间可分别用一个个的对象来表示，这些对象显然具有相同类型，这个类型就是Class。

3、获取Class对象的三种方式和区别：

<span style="font-size:18px;">// 1. 根据给定的类名来获得  用于类加载
String classname = "cn.itcast.reflect.Person"; // 来自配置文件
Class clazz = Class.forName(classname); // 此对象代表Person.class

// 2. 如果拿到了对象，不知道是什么类型   用于获得对象的类型
Object obj = new Person();
Class clazz1 = obj.getClass(); // 获得对象具体的类型

// 3. 如果是明确地获得某个类的Class对象  主要用于传参
Class clazz2 = Person.class; 
// 在java中所有的类型都会对应一个Class对象 int Integer
Class intClazz = int.class;
Class intarrClazz = int[].class;
Class voidClazz = void.class;</span>

4、9个预定义的Class对象：

public boolean isPrimitive()判定指定的 Class 对象是否表示一个基本类型。
有九种预定义的 Class 对象，表示八个基本类型和 void。这些类对象由 Java 虚拟机创建，与其表示的基本类型同名，即 boolean、byte、char、short、int、long、float 和 double。

<span style="font-size:18px;">int.class == Integer.TYPE
void.class == Void.TYPE</span>

5、总之，只要是在源程序中出现的类型，都有各自的Class实例对象，例如，int[]，void…

理解反射

1、反射就是把Java类中的各种成分映射成相应的java类。
例如，一个Java类中用一个Class类的对象来表示，一个类中的组成部分：成员变量，方法，构造方法，包等等信息也用一个个的Java类来表示，就像汽车是一个类，汽车中的发动机，变速箱等等也是一个个的类。表示java类的Class类显然要提供一系列的方法，来获得其中的变量，方法，构造方法，修饰符，包等信息，这些信息就是用相应类的实例对象来表示，它们是Field、Method、Contructor、Package等等。
2、一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示，通过调用Class类的方法可以得到这些实例对象后，得到这些实例对象后有什么用呢？怎么用呢？这正是学习和应用反射的要点。

Constructor类

由Class类中这些方法得到Constructor对象：

一个类有多个构造方法，用什么方式可以区分清楚想得到其中的哪个方法呢？根据参数的个数和类型：

Constructor类代表某个类中的一个构造方法
得到某个类中所有公共的构造函数：

Constructor [] constructors= Class.forName("java.lang.String").getConstructors();

得到某一个构造函数

Constructor constructor = Class.forName(“java.lang.String”).getConstructor(StringBuffer.class);

Constructor对象上会有什么方法呢？得到名字，得到所属于的类，产生实例对象。
创建实例对象：
1、

通常方法：String str = new String(new StringBuffer("abc"));
反射方法: Constructor constructor = Class.forName(“java.lang.String”).getConstructor(StringBuffer.class);
String str = (String) constructor.newInstance(new StringBuffer("abc"));

2、Class对象中有一个便利的方法创建实例对象：
T newInstance()
创建此 Class 对象所表示的类的一个新实例。

String obj = (String)Class.forName("java.lang.String").newInstance();

该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象。（javabean要求有一个默认的构造函数）
该方法内部的具体代码是怎样写的呢？用到了缓存机制来保存默认构造方法的实例对象。

Filed类

Field类代表某个类中的一个成员变量

假如有一个ReflectPoint类：

public class ReflectPoint {
	private int x;
	public int y;

	public ReflectPoint(int x, int y) {
		super();
		this.x = x;
		this.y = y;
	}

	public void setX(int x) {
		this.x = x;
	}

	public int getX() {
		return x;
	}

	public void setY(int y) {
		this.y = y;
	}

	public int getY() {
		return y;
	}
}

反射字段：

 //成员字段的反射
  ReflectPoint pt1 = new ReflectPoint(3, 5);
  Field filedY = pt1.getClass().getField("y");
  System.out.println(filedY);
  System.out.println(filedY.get(pt1));
  
  //私有字段的暴力反射
  Field fieldX = pt1.getClass().getDeclaredField("x");//可以得到私有字段但还不能用它的方法
  System.out.println(fieldX);
  fieldX.setAccessible(true);//经过暴力反射，强行使用它的方法
  System.out.println(fieldX.get(pt1));

练习：将任意一个对象中的所有String类型的成员变量所对应的字符串内容中的"b"改成"a"。
实现该功能的代码如下：

private static void changeStringValue(Object obj) throws IllegalArgumentException, IllegalAccessException {
  Field[] fields = obj.getClass().getFields();
  
  for(Field field : fields){
   if(field.getType() == String.class){
    String oldValue = (String) field.get(obj);
    String newValue = oldValue.replace('b', 'a');   
    field.set(obj, newValue);
   }
  }  
 }

Method类

Method类代表某个类中的一个成员方法

1、大家应通过思考和推理的方式来学习反射中的API，例如，Class.getMethod方法用于得到一个方法，该方法要接受什么参数呢？显然要一个方法名，而一个同名的方法有多个重载形式，用什么方式可以区分清楚想得到重载方法系列中的哪个方法呢？根据参数的个数和类型，例如，Class.getMethod(name,Class... args)中的args参数就代表所要获取的那个方法的各个参数的类型的列表。
再强调一遍参数类型用什么来表示啊？用Class对象！
得到Method对象的几个方法：

2、得到类中的某一个方法：

Method charAt = Class.forName("java.lang.String").getMethod("charAt", int.class);

3、调用方法：

通常方式：System.out.println(str.charAt(1));
反射方式： System.out.println(charAt.invoke(str, 1));

注意：如果传递给Method对象的invoke()方法的第一个参数为null时说明此方法为静态方法。
4、jdk1.4和jdk1.5的invoke方法的区别：（可变参数的出现）
Jdk1.5：public Object invoke(Object obj,Object... args)
Jdk1.4：public Object invoke(Object obj,Object[] args)，即按jdk1.4的语法，需要将一个数组作为参数传递给invoke方法时，数组中的每个元素分别对应被调用方法中的一个参数，所以，调用charAt方法的代码也可以用Jdk1.4改写为 charAt.invoke(“str”, new Object[]{1})形式。

用反射方式执行某个类中的main()方法：

main()虽属于Method范畴内的，但由于其特殊性，与一般的函数有一定的区别：
1、问题的出现：
启动Java程序的main方法的参数是一个字符串数组，即public static void main(String[] args)，通过反射方式来调用这个main方法时，如何为invoke方法传递参数呢？按jdk1.5的语法，整个数组是一个参数，而按jdk1.4的语法，数组中的每个元素对应一个参数，当把一个字符串数组作为参数传递给invoke方法时，javac会到底按照哪种语法进行处理呢？jdk1.5肯定要兼容jdk1.4的语法，会按jdk1.4的语法进行处理，即把数组打散成为若干个单独的参数。所以，在给main方法传递参数时，不能使用代码mainMethod.invoke(null,new String[]{“xxx”})，javac只把它当作jdk1.4的语法进行理解，而不把它当作jdk1.5的语法解释，因此会出现参数类型不对的问题。

2、解决的方法：
mainMethod.invoke(null,new Object[]{new String[]{"xxx"}});
mainMethod.invoke(null,(Object)new String[]{"xxx"}); ，编译器会作特殊处理，编译时不把参数当作数组看待，也就不会数组打散成若干个参数了
Class clazz = Class.forName(arg[0]);//运行时将类名作为参数传递进去，开发中一般写在配置文件中并读取
Method mMain = clazz.getMethod("main", String[].class);
mMain.invoke(null,new Object[]{new String[]{"aaa","bbb"}});
mMain.invoke(null,(Object)new String[]{"aaa","bbb"});

<span style="font-size:18px;">class TestArrayArguments {
 public static void main(String [] args)
 {
  for(String arg:args)
  {
   System.out.println("----------" + arg + "----------");
  }
 }
}</span>

数组的反射：

1、具有相同维数和元素类型的数组属于同一类型，即具有相同的Class实例对象。
2、代表数组的Class实例对象的getSupperClass()方法返回的父类为Object类对应的Class。
3、基本类型的一维数组可以当做Object类型来使用，不能当做Object[]来使用；
非基本类型的一维数组既可以当做Object类型来使用，也可以当做Object[]来使用。

 int[] a1 = new int[3];
 int[] a2 = new int[4];
 int[][] a3 = new int[3][4];
 String[] a4 = new String[3];
 Integer[] a5 = new Integer[3];
 Object[] aObj3 = a5;//可以，非基本类型的一维数组可以当做Object[]类型来使用
 //Object[] aObj4 = a1; //不可以，基本类型的一维数组不能当做Object[]来使用；
 Object aObj1 = a1;//可以，基本类型的一维数组可以当做Object类型来使用
 Object aObj2 = a4;//可以，非基本类型的一维数组能当做Object来使用；
 System.out.println(a1.getClass() == a2.getClass());//true
 //System.out.println(a1.getClass() == a3.getClass()); //不兼容类型
 //System.out.println(a1.getClass() == a4.getClass()); //不兼容类型
 System.out.println(a1.getClass().getName());//[I
 System.out.println(a3.getClass().getName());//[[I
 //代表数组的Class实例对象的getSupperClass()方法返回的父类为Object类对应的Class。
 System.out.println(a1.getClass().getSuperclass().getName());//java.lang.Object
 System.out.println(a4.getClass().getSuperclass().getName());//java.lang.Object

反射的作用（做框架）

1、什么是框架：
比如：我做房子卖给用户住，由用户自己安装门窗和空调，我做的房子就是框架，用户需要使用我的框架，把门窗插入进我提供的框架中。
框架与工具类有区别，工具类被用户的类调用，而框架则是调用用户提供的类。
框架的特点：
框架就是将开发中大量重复的代码集中起来写个通用的程序；
框架是用反射来实现的,框架需要现在的类调用将来写的类；（核心问题）
框架调用未来程序员所写的类，框架不能实现完整的功能，框架只是一些通用的代码；
框架要依赖将来写的类才能运行；
现在写的类要调用将来写的类，我们先针对接口进行调用，将来的类需要实现接口，那么方法就固定了；
但是将来写的类的类名我们无法获知，这时就需要调用者通过配置文件告诉框架具体的类名。
2、框架要解决的核心问题
我再写框架（盖房子）的时候，将来的客户可能还在上小学，还不会写程序，那么我写的框架怎样能调用到你以后写的类（门窗）呢？----------->用反射技术来解决

3、实现一个小框架，通过配置文件获取要调用的类名。

配置文件：config.properties

className=java.util.HashSet//当需要ArrayList时可以改为 className=java.util.HashSet

框架类：ReflecTest2

class ReflecTest2{
 public static void main(String[] args) throws Exception{
 //应该先直接用ArrayList和HashSet，然后才引入从配置文件读，这样便于学员学习。
 Properties props = new Properties();
 //先演示相对路径的问题
 //InputStream ips = new FileInputStream("config.properties");
 /*一个类加载器能加载.class文件，那它当然也能加载classpath环境下的其他文件，既然它有如此能力，它没有理由不 顺带提供这样一个方法。它也只能加载classpath环境下的那些文件。注意：直接使用类加载器时，不能以/打头。*/
 //InputStream ips = ReflectTest2.class.getClassLoader().getResourceAsStream("cn/itcast/javaenhance/config. //properties");
 //Class提供了一个便利方法，用加载当前类的那个类加载器去加载相同包目录下的文件
 //InputStream ips = ReflectTest2.class.getResourceAsStream("config.properties");
 InputStream ips = ReflectTest2.class.getResourceAsStream("/cn/itcast/javaenhance/config.properties");
 props.load(ips);
 ips.close();

 String className = props.getProperty("className");
 Class clazz = Class.forName(className);

 Collection collection = (Collection)clazz.newInstance();
 //Collection collection = new ArrayList();
 ReflectPoint pt1 = new ReflectPoint(3,3);
 ReflectPoint pt2 = new ReflectPoint(5,5);
 ReflectPoint pt3 = new ReflectPoint(3,3);
 collection.add(pt1);
 collection.add(pt2);
 collection.add(pt3);
 collection.add(pt1);
 System.out.println(collection.size());
 }
}

Tony_zxlu

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java技术之反射

反射的基石——>Class类1、java中的类是用来描述一类事物的共性，该类事物有什么属性，没有什么属性，至于这个属性的值是什么，则是由这个类的实例对象来确定的，不同的实例对象有不同的属性值。java中所有的类也是一类事物，有其共性，都有所属的包，类名，属性的访问权限，字段，方法等信息。我们对此进行抽象提取用于描述类的共性内容，这就出现了一个特有的类Class类。这个类是反射的基石，它用来表示
复制链接

扫一扫