1. 技术文章
  2. 11-java学习笔记-反射

11-java学习笔记-反射

由 强颜欢笑 提交于 2020-04-06 08:03:08
1.反射的应用场景

一、概述

反射技术：

Java反射机制是在运行状态中，对于任意一个类，都能够知道这个类中的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

二、应用场景

一个已经可以使用的应用程序，因为程序已经做好可以运行使用，不能再进行代码的加入了。而当后期我们新的功能加入程序时，该怎么做呢？就如我们的电脑一样，后期我们可能会鼠标、键盘等，所以电脑给我们预留了usb接口，只要符合这个接口规则的设备，电脑就可以通过加载驱动等操作来使用。

那这个程序能用了，如何使用后期出现的功能类呢？

常用的作法，会提供一个配置文件，来供以后实现此程序的类来扩展功能。对外提供配置文件，让后期出现的子类直接将类名字配置到配置文件中即可。该应用程序直接读取配置文件中的内容。并查找和给定名称相同的类文件。进行如下操作：

1）加载这个类。

2）创建该类的对象。

3）调用该类中的内容。

应用程序使用的类不确定时，可以通过提供配置文件，让使用者将具体的子类存储到配置文件中。然后该程序通过反射技术，对指定的类进行内容的获取。

好处：反射技术大大提高了程序的扩展性。


2. 反射的基石-Class类
对比提问： Person类代表人，它的实例对象就是张三，李四这样一个个具体的人，
Java程序中的各个Java类属于同一类事物，描述这类事物的Java类名就是 Class。

对比提问：众多的人用一个什么类表示？众多的Java类用一个什么类表示？

人          Person
Java类   Class.
 
Class类代表Java类，它的各个实例对象又分别对应什么呢？
      对应各个类在内存中的字节码，例如，Person类的字节码，ArrayList类的字节码，等等。
      一个类被类加载器加载到内存中，占用一片存储空间，这个空间里面的内容就是类的字节码，     不同的类的字节码是不同的，所以它们在内存中的内容是不同的，这一个个的空间可分别用一个个的对象来 表示，这些对象显然具有相同的类型，这个类型是什么呢？
如何得到各个字节码对应的实例对象（ Class类型）
     1. 类名.class，
               System.class
               Person.class
     2. 对象.getClass()
               new Date().getClass()
     3. Class.forName("类名")//类名可以是一个变量，动态获取
               Class.forName("java.util.Date");
九个预定义Class实例对象：
      java中有八个基本类型(int ,byte,long,float,double,short,char,boolean,)和void

     参看Class.isPrimitive()方法的帮助
     Int.class == Integer.TYPE 
数组类型的Class实例对象
     Class.isArray()
总之，只要是在源程序中出现的类型，都有各自的Class实例对象，例如，int[]，void…
class ReflectTest
{
     public static void main(String[] args) throws Exception
     {
          String str1 = "abc";
          Class cls1 = str1.getClass();
          Class cls2 = String.class;
          Class cls3 = Class.forName("java.lang.String");

          System.out.println(cls1==cls2); //true
          System.out.println(cls2==cls3); //true

          //判定指定的 Class 对象是否表示一个基本类型。
          System.out.println(cls1.isPrimitive()); //false

          System.out.println(int.class == Integer.class);//false
          System.out.println(int.class == Integer.TYPE); //true

          System.out.println(int[].class.isPrimitive()); //false

          //判定此 Class 对象是否表示一个数组类。
          System.out.println(int[].class.isArray()); //true

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

import java.lang.reflect.*;
得到某个类所有的构造方法：
Constructor [] constructors= Class.forName("java.lang.String").getConstructors();
得到某一个构造方法：
        
     Constructor constructor =
          Class.forName(“java.lang.String”).getConstructor(StringBuffer.class);
          //获得方法时要用到类型
创建实例对象：
     通常方式： String str = new String(new StringBuffer("abc"));
     反射方式： String str = (String)constructor.newInstance(new StringBuffer("abc"));
     //调用获得的方法时要用到上面相同类型的实例对象
Class.newInstance()方法：
     例子：String obj = (String)Class.forName("java.lang.String").newInstance();
     该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象。
     该方法内部的具体代码是怎样写的呢？用到了缓存机制来保存默认构造方法的实例对象。
5.Field类

Field类代表某个类中的一个成员变量
问题：得到的Field对象是对应到类上面的成员变量，还是对应到对象上的成员变量？
          类只有一个，而该类的实例对象有多个，如果是与对象关联，哪关联的是哪个对象呢？
          所以字段fieldX 代表的是x的定义，而不是具体的x变量。
示例：
     ReflectPoint point = new ReflectPoint(1,7);
     Field y = Class.forName("cn.itcast.corejava.ReflectPoint").getField("y");
     System.out.println(y.get(point));
     //Field x = Class.forName("cn.itcast.corejava.ReflectPoint").getField("x");
     Field x = Class.forName("cn.itcast.corejava.ReflectPoint").getDeclaredField("x");
     x.setAccessible(true);
     System.out.println(x.get(point));
import java.lang.reflect.*;

class ReflectPoint
{
     private int x;
     public int y;

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

class FieldDemo
{
     public static void main(String[] args) throws Exception
     {
          ReflectPoint pt1 = new ReflectPoint(3,5);

          //Field fieldX = pt1.getClass().getField("x");
          Field fieldX = pt1.getClass().getDeclaredField("x");
          //暴力反射
          fieldX.setAccessible(true);

          Field fieldY = pt1.getClass().getField("y");
          //fieldY的值是多少?
          System.out.println(fieldX.get(pt1));
          System.out.println(fieldY.get(pt1));
     }
}
作业：将任意一个对象中的所有String类型的成员变量所对应的字符串内容中的"b"改成"a"。
import java.lang.reflect.*;

class ReflectPoint
{
     private int x;
     public int y;
     public String str1 = "ball";
     public String str2 = "basketball";
     public String str3 = "apple";

     public ReflectPoint(int x,int y)
     {
          super();
          this.x = x;
          this.y = y;
     }
     @Override
     public String toString()
     {
          return str1 + ":" + str2 + ":" + str3;
     }
}

class FieldTest
{
     public static void main(String[] args) throws Exception
     {
          ReflectPoint pt1 = new ReflectPoint(3,5);

          Field[] fields = pt1.getClass().getFields();
          for(Field field : fields)
          {
               //同一个字节码用==
               //if(field.getType().equals(String.class))
               if(field.getType() == String.class)    
               {    
                    String oldValue = (String)field.get(pt1);
                    String newValue = oldValue.replace('b', 'a');
                    field.set(pt1, newValue);
               }
          }

          System.out.println(pt1);
     }
}
6.Method类
Method类代表某个类中的一个成员方法
得到类中的某一个方法：
     例子：         
     Method charAt =
                    Class.forName("java.lang.String").getMethod("charAt", int.class);
      //参数 方法名称和参数列表
调用方法：
     通常方式： System.out.println(str.charAt(1));
     反射方式： System.out.println(charAt.invoke(str, 1));
               如果传递给Method对象的invoke()方法的第一个参数为null，这有着什么样的意义呢？
               说明该Method对象对应的是一个静态方法！
（可变参数）
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})    
                   形式。
7.用反射方式执行某个类中的main方法

目标：
     写一个程序，这个程序能够根据用户提供的类名，去执行该类中的main方法。
     用普通方式调完后，大家要明白为什么要用反射方式去调啊？
     写程序的时候并不知道调用那个类
问题：
启动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的语法解释，因此会出现参数类型不对的问题。
解决办法：
mainMethod.invoke(null,new Object[]{new String[]{"xxx"}});
mainMethod.invoke(null,(Object)new String[]{"xxx"});
编译器会作特殊处理，编译时不把参数当作数组看待，也就不会数组打散成若干个参数了
import java.lang.reflect.*;
class ReflectDemo
{
     public static void main(String[] args) throws Exception
     {
          String startingClassName = args[0];

          //TestArguments.main(new String[]{"111","222"});
          Method mainMethod = Class.forName(startingClassName).getMethod("main", String[].class);
          //JDK1.5为了兼容
          mainMethod.invoke(null,(Object)new String[]{"111","222","333"});
          //mainMethod.invoke(null,new Object[] {new String[]{"111","222","333"}} );
    
     }
}
class ArgumentsTest
{
     public static void main(String[] args) throws Exception
     {
          for(String a:args)
          {
               System.out.println(a);
          } 
          System.out.println("u got me");
     }
}
java ReflectDemo ArgumentsTest
8.数组的反射

具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象。
代表数组的Class实例对象的getSuperClass()方法返回的父类为Object类对应的Class。
基本类型的一维数组可以被当作Object类型使用，不能当作Object[]类型使用；
非基本类型的一维数组，既可以当做Object类型使用，又可以当做Object[]类型使用。
Arrays.asList()方法处理int[]和String[]时的差异。
Array工具类用于完成对数组的反射操作。
思考题：怎么得到数组中的元素类型？
Object[] a = new Object[]{"a",1};
a[0].getClass().getName();
import java.lang.reflect.*;
import java.util.*;

class ArrayReflectDemo
{
     public static void main(String[] args)
     {
          int[] a1 = new int[]{1,2,3};
          int[] a2 = new int[4];
          int[][] a3 = new int[2][3];
          String[] a4 = new String[]{"a","b","c"};

          //sop(a1.getClass() == a2.getClass());
          //sop(a1.getClass() == a3.getClass());
          //sop(a1.getClass() == a4.getClass());

          // [I
          sop(a1.getClass().getName());
         
          //父类Object
          sop(a1.getClass().getSuperclass().getName());

          //父类是Object
          sop(a4.getClass().getSuperclass().getName());

          Object aObj1 = a1;
          Object aObj2 = a4;
         
          //int类型不是Object类型
          //Object[] aobj3 = a1;
          Object[] aobj4 = a3;
          Object[] aobj5 = a4;

          //[I@28169674
          sop(a1);
          //[Ljava.lang.String;@62efae3b
          sop(a4);

          sop(Arrays.asList(a1));
          sop(Arrays.asList(a4));
     }
     public static void sop(Object obj)
     {
          System.out.println(obj);
     }
}
9.反射的作用：实现框架功能
框架与框架要解决的核心问题
     我做房子卖给用户住，由用户自己安装门窗和空调，我做的房子就是框架，用户需要使用我的框架，把门窗插入进我提供的框架中。框架与工具类有区别，工具类被用户的类调用，而框架则是调用用户提供的类。
框架要解决的核心问题
     我在写框架（房子）时，你这个用户可能还在上小学，还不会写程序呢？
我写的框架程序怎样能调用到你以后写的类（门窗）呢？
     因为在写程序时无法知道要被调用的类名，所以，在程序中无法直接new 某个类的实例对象了，
而要用反射方式来做。
综合案例
     先直接用new  语句创建ArrayList和HashSet的实例对象，演示用eclipse自动生成 ReflectPoint类的equals和hashcode方法，比较两个集合的运行结果差异。
     然后改为采用配置文件加反射的方式创建ArrayList和HashSet的实例对象，比较观察运行结果差异。
     引入了elipse对资源文件的管理方式的讲解。
//config.properties文件
className=java.util.ArrayList
//需要有回车 
import java.util.*;
import java.io.*;

public class ReflectTest2
{
     public static void main(String[] args) throws Exception
     {
          InputStream     ips = new FileInputStream("config.properties");
          Properties props = new Properties();
          props.load(ips);
          ips.close();

          String className = props.getProperty("className");

          Collection collections
               = (Collection)Class.forName(className).newInstance();

          //Collection collections = new HashSet();
          ReflectPoint pt1 = new ReflectPoint(3,3);
          ReflectPoint pt2 = new ReflectPoint(5,5);
          ReflectPoint pt3 = new ReflectPoint(3,3);

          collections.add(pt1);
          collections.add(pt2);
          collections.add(pt3);
          collections.add(pt1);

          //pt1.y = 7
          System.out.println(collections.size());
     }
}

class ReflectPoint
{
     private int x;
     public int y;
     public String str1 = "ball";
     public String str2 = "basketball";
     public String str3 = "apple";

     public ReflectPoint(int x,int y)
     {
          super();
          this.x = x;
          this.y = y;
     }
     @Override
     public String toString()
     {
          return str1 + ":" + str2 + ":" + str3;
     }
}
标签
string
反射机制
对象数组
object
数组
易学教程内所有资源均来自网络或用户发布的内容，如有违反法律规定的内容欢迎反馈！
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!