这篇我们分享和总结Java高新技术中反射内容，这是Java的重点掌握部分。
一、Class类
1、概述
<span style="font-size:14px;">/**
（1）定义
Class是Java程序中各个Java类的总称；它是反射的基石，通过Class类来使用反射。
（2）Class和class的区别
a、class：Java中的类用于描述一类事物的共性，该类事物有什么属性，没有什么属性，至于这个属性的值是什么，则由此类的实例对象确定，不同的实例对象有不同的属性值。
b、Class：指的是Java程序中的各个Java类是属于同一类事物，都是Java程序的类，这些类称为Class。例如人对应的是Person类，Java类对应的就是Class。
（3）属性
类名，类的访问属性，类所属包名，字段名称列表，方法名称列表等。
*/</span>2、对象创建和作用
/**
Class：其代表的是一份字节码，是通过JVM编译过，计算机能够识别的字节码即0和1二进制组成的字节码。
得到各字节码对应的实例对象(Class类型)的方式有3种：
（1）类名.class：如System.class，String.class等等。
（2）对象.class：如new Date().getClass()或者d.getClass()。（Date d = new Date()）。
（3）Class.forName(“类名”)：如Class.forName(”java.lang.String”)。
注意事项：
forName()是静态方法，是反射中使用的一种方式获取字节码的实例对象。
每个类的字节码对象只有唯一的一个，如任何字符串对象，对应唯一的String.clas字节码。
*/3、9个预定义的Class
/**
（1）八种基本类型（byte、short、int、long、float、double、char、boolean）的字节码对象和一种返回值为void类型的void.class。
（2）Integer.TYPE是Integer类的一个常量，它代表此包装类型包装的基本类型的字节码，所以和int.class是相等的。
基本数据类型的字节码都可以用与之对应的包装类中的TYPE常量表示。
数组类型的Class实例对象，可以用Class.isArray()方法判断是否为数组类型的。
*/4、方法
/**
（1）static Class forName(String className)
返回与给定字符串名的类或接口的相关联的Class对象。
（2）Class getClass()
返回的是Object运行时的类，即返回Class对象即字节码对象
（3）Constructor getConstructor()
返回Constructor对象，它反映此Class对象所表示的类的指定公共构造方法。
（4）Field getField(String name)
返回一个Field对象，它表示此Class对象所代表的类或接口的指定公共成员字段。
（5）Field[] getFields()
返回包含某些Field对象的数组，表示所代表类中的成员字段。
（6）Method getMethod(String name,Class… parameterTypes)
返回一个Method对象，它表示的是此Class对象所代表的类的指定公共成员方法。
（7）Method[] getMehtods()
返回一个包含某些Method对象的数组，是所代表的的类中的公共成员方法。
（8）String getName()
以String形式返回此Class对象所表示的实体名称。
（9）String getSuperclass()
返回此Class所表示的类的超类的名称
（10）boolean isArray()
判定此Class对象是否表示一个数组
（11）boolean isPrimitive()
判断指定的Class对象是否是一个基本类型。
（12）T newInstance()
创建此Class对象所表示的类的一个新实例。
*/public static void fuction()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(cls1 == cls3);//true
//判断是否为基本类型：isPrimitive()
System.out.println(cls1.isPrimitive());//false
System.out.println(int.class == Integer.class);//false
//Integer.TYPE代表包装类对应的基本数据类型的字节码
System.out.println(int.class == Integer.TYPE);//true
System.out.println(int[].class.isPrimitive());//false
//判断是否为数组类型的
System.out.println(int[].class.isArray());//true
} 二、反射
1、概述
/**
（1）定义
把Java类中的各种成分映射成相应的Java类。
如Class中的每一个方法返回的都是一种类（型），即Method对所有方法抽取成了这个类Method，它的每一个对象（如变量methodObj1）代表了一个方法。
（2）一个类中的组成成分
成员变量、方法、构造函数、包等信息，也用一个个java类来表示（如汽车是一个类，其中的发动机，变速箱等也是对应的一个个类），表示Java类的Class类显然要提供一系列的方法来获取其中的变量、方法、构造函数、修饰符、包等信息，这些信息就是用相应的类的实例对象来表示，他们是Field、Method、Contructor、Package等。
（3）一个类中的每个成员都可用相应的反射API类的一个实例对象来表示，通过调用Class类的方法可得到这些实例对象。
*/2、反射中的各个类
（1）Constructor类
/**
（1）Constructor类
a、概述
Constructor代表某个类的构造方法。
b、获取构造方法
1）如何得到某个类的所有构造方法：如得到String类的所有构造方法
Constructor[] cons = Class.forName(“java.lang.String”).getConstructors()。
c、获取某一个构造方法
Constructor con =String.class.getConstructor(StringBuffer.class);
（2）创建实例对象
a、通常方式：String str = new String(new StringBuffer (”abc”));
b、反射方式：String str = (String)con.newInstance(new StringBuffer(“abc”));
调用获得的方法时要用到上面相同类型的实例对象，即两个StringBuffer()要对应相等。
NewInstance()：构造出一个实例对象，每调用一次就构造一个对象。
注意：上面的两个地方①②都要用到StringBuffer，这必须是一致的。第①个是指定要带StringBuffer参数类型的构造方法，即所需使用的是含StringBuffer类型的构造方法。第②个是用这个构造方法创建对象，要传入的参数类型是StringBuffer。
（3）Class.newInstance()
创建一个对象，不带参数的构造方法。
*/示例：
Constructor constructor1 =
String.class.getConstructor(StringBuffer.class);
String str2 =
(String)constructor1.newInstance(new StringBuffer("abc"));
System.out.println(str2);
//Class.newInstrance创建不带参数的构造方法
String str3 =
(String)Class.forName("java.lang.String").newInstance();
System.out.println("str3:"+str3); （2）Field类
1）概述
/**
Field类代表成员变量（字段）的反射。
*/public class ReflectPoint {
private int x;
public int y;
public String toString(){
return str1+";" + str2 + ";" + str3;
}
}
public class FieldTest(){
ReflectPoint pt1 = new ReflectPoint(3,5);
//fieldX和fieldY并不是对象身上的变量，而是类上的
//要用它去取某个对象上的对应的值，传入什么对象，就取相应对象的值。
Field fieldY = pt1.getClass().getField("y");
System.out.println(fieldY.get(pt1));
//获取私有的成员变量
Field fieldX = pt1.getClass().getDeclaredField("x");
fieldX.setAccessible(true);
System.out.println(fieldX.get(pt1));
}2）获取成员变量
/**
2、获取成员变量
如上例子所示：
1）获取公有的成员变量：
a、getField(String name)和get(变量)
2）获取私有的成员变量：暴力反射
a、getDeclared(String name)
b、setAccessible(boolean b)，将b设为true即可
c、get(变量)
*///替换字符
private static void changeStringValue(Object obj) throws Exception {
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);
}
}
} （3）Method类
/**
1、概述：Method类代表某个类中的一个成员方法。
调用某个对象身上的方法，要先得到方法，再针对某个对象调用。
2、专家模式：谁调用这个数据，就是谁在调用它的专家。
如人关门：
调用者：是门调用管的动作，对象是门，因为门知道如何执行关的动作，通过门轴之类的细节实现。
指挥者：是人在指挥门做关的动作，只是给门发出了关的信号，让门执行。
总结：变量使用方法，是方法本身知道如何实现执行的过程，也就是“方法对象”调用方法，才执行了方法的每个细节的。
3、获取某个类中的某个方法：（如String str = ”abc”）
1）通常方式：str.charAt(1)
2）反射方式：
Method charAtMethod =
Class.forName(“java.lang.String”).getMethod(“charAt”,int.class);
charAtMethod.invoke(str,1);
说明：如果传递给Method对象的invoke()方法的第一个参数为null，说明Method对象对应的是一个静态方法。
4、用反射方式执行某个main方法：
首先要明确为何要用反射：在写源程序时，并不知道使用者传入的类名是什么，但是虽然传入的类名不知道，而知道的是这个类中的方法有main这个方法，所以可以通过反射的方式，通过使用者传入的类名（可定义字符串型变量作为传入类名的入口，通过这个变量代表类名），内部通过传入的类名获取其main方法，然后执行相应的内容。
*///Method类演示
private static void methodTest(String [] args) throws Exception {
String str1 = "abc";
//一般方法：
System.out.println(str1.charAt(1));
//反射方法 ：
Method methodCharAt =
Class.forName("java.lang.String").getMethod("charAt",int.class);
System.out.println(methodCharAt.invoke(str1,1));
//用反射方式执行某个main方法
//一般方式：
Test.main(new String[]{"111","222","333"});
System.out.println("-------");
//反射方式：
String startingClassName = args[0];
Method methodMain =
Class.forName(startingClassName).getMethod("main",String[].class);
//方案一：强制转换为超类Object，不用拆包
methodMain.invoke(null,(Object)new String[]{"111","222","333"});
//方案二：将数组打包，编译器拆包后就是一个String[]类型的整体
methodMain.invoke(null,new Object[]{new String[]{"111","222","333"}});
}
//定义一个测试类
class Test{
public static void main(String [] args){
for(String arg : args){
System.out.println(arg);
}
}
} （4）数组的反射
1、数组字节码的名字：有[和数组对应类型的缩写，如int[]数组的名称为：[I
2、基本数据类型的一维数组不能转换为Object数组，如：
int[] a = new int[3]；Object[] obj= a;这样是不成立的。
3、如何得到某个数组中的某个元素的类型：
例：int a = newint[3]；Object[] obj= new Object[]{”ABC”,1}；
无法得到某个数组的具体类型，只能得到其中某个元素的类型，如
Obj[0].getClass().getName()得到的是java.lang.String，若通过b.getClass().getName()，结果是：[Ljava.lang.Object。
*/public static void arrayTest()throws Exception {
int[] a1 = new int[]{1,2,3};
int[] a2 = new int[4];
int[][] a3 = new int[2][3];
Integer[] ai = new Integer[3];
String[] a4 = new String[]{"a","b","c"};
System.out.println(a1.getClass() == a2.getClass());
System.out.println((Object)a1.getClass() == (Object)a3.getClass());
System.out.println(a3[0].getClass() == a1.getClass());
System.out.println(a3[0].getClass().getSuperclass().getName());
System.out.println(a1.getClass().equals(a3.getClass()));
System.out.println(a1.getClass().equals(a4.getClass()));
System.out.println(a1.getClass().getName());
System.out.println("----:" + a1.getClass());
System.out.println(a1.getClass().getSuperclass().getName());
System.out.println(a2.getClass().getSuperclass().getName());
Object obj1 = a1;
Object obj2 = a2;
//int基本数据类型不是Object的
//Object[] obj3 = a1;
Object[] obj4 = a3;
Object[] obj5 = a4;
System.out.println(a1);
System.out.println(a4);
System.out.println(Arrays.asList(a1));
System.out.println(Arrays.asList(a4));
System.out.println("-------");
int[] a = new int[3];
Object[] obj = new Object[]{"abc",new Integer(1)};
System.out.println(a.getClass().getName());
System.out.println(obj.getClass().getName());
System.out.println(obj[0].getClass().getName());
} （4）数组的反射
示例：import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
public class ReflectTest2 {
public static void main(String [] args){
Collection cons = new HashSet();
ReflectPoint pt1 = new ReflectPoint(3,3);
ReflectPoint pt2 = new ReflectPoint(5,5);
ReflectPoint pt3 = new ReflectPoint(3,3);
cons.add(pt1);
cons.add(pt2);
cons.add(pt3);
cons.add(pt1);
cons.remove(pt1);
System.out.println(cons.size());
}
}
public class ReflectPoint {
private int x;
public int y;
public String str1 = "ball";
public String str2 = "basketball";
public String str3 = "itcast";
public ReflectPoint(int x, int y) {
super();
this.x = x;
this.y = y;
}
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + x;
result = prime * result + y;
//System.out.println("demo...");//测试
return result;
}
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
ReflectPoint other = (ReflectPoint) obj;
if (x != other.x)
return false;
if (y != other.y)
return false;
return true;
}
public String toString(){
return str1+";" + str2 + ";" + str3;
}
}
覆写hashCode()方法的意义：只有存入的是具有hashCode算法的集合的，覆写hashCode()方法才有价值。
哈希算法详细介绍
/**
1、哈希算法的由来：
若在一个集合中查找是否含有某个对象，通常是一个个的去比较，找到后还要进行equals的比较，对象特别多时，效率很低，通过哈希算法，将集合分为若干个区域，每个对象算出一个哈希值，可将哈希值分组（一般模32为一组），每组对应某个存储区域，依一个对象的哈希码即可确定此对象对应区域，从而减少每个对象的比较，只需在指定区域查找即可，从而提高从集合中查找元素的效率。
*/
哈希算法的注意事项：
/**
1）若同类两对象用equals()方法比较的结果相同时，他们的哈希码也必须是相等的，但反过来就不成立了，如”BB”和”Aa”两字符串用equals()比较式不相等的，但是他们的哈希值是相等的。
2）当一个对象被存储进HashSet集合中，就不能再修改参与计算哈希值的字段，否则对象被修改后的哈希值与最初被存入的HashSet集合中的哈希值就不同了。在这种情况下，即使contains()方法是用对象的当前引用作为参数去HashSet集合中检索对象，也将返回找不到对象的结果，这也导致无法从HashSet集合中单独删除当前对象，从而造成内存泄露。
简单说，之前存入的对象和修改后的对象，是具有不同的哈希值，被认为是不同的两个对象，这样的对象不再使用，又不移除，而越来越多，就会导致内存泄露。
补充：
内存泄露：某些对象不再使用了，占用着内存空间，并未被释放，就会导致内存泄露；也就是说当程序不断增加对象，修改对象，删除对象，日积月累，内存就会用光了，就导致内存溢出。
3）对象在调用方法时，对象会先进行一次自身hashCode()方法的调用，再进行操作方法。
*/3、反射的作用
反射的作用：实现框架。/**
1、框架
通过反射调用Java类的一种方式。
如房地产商造房子用户住，门窗和空调等等内部都是由用户自己安装，房子就是框架，用户需使用此框架，安好门窗等放入到房地产商提供的框架中。
框架和工具类的区别：工具类被用户类调用，而框架是调用用户提供的类。
2、框架机器要解决的核心问题
我们在写框架（造房子的过程）的时候，调用的类（安装的门窗等）还未出现，那么，框架无法知道要被调用的类名，所以在程序中无法直接new其某个类的实例对象，而要用反射来做。
3、简单框架程序的步骤
1）右击项目File命名一个配置文件如：config.properties,然后写入配置信息。如键值对：className=java.util.ArrayList，等号右边的配置键，右边是值。
2）代码实现，加载此文件：
①将文件读取到读取流中，要写出配置文件的绝对路径。
如：InputStream is=new FileInputStream(“配置文件”);
②用Properties类的load()方法将流中的数据存入集合。
③关闭流：关闭的是读取流，因为流中的数据已经加载进内存。
3）通过getProperty()方法获取className，即配置的值，也就是某个类名。
4）用反射的方式，创建对象newInstance()。
5）执行程序主体功能
二、类加载器
1、简述：类加载器是将.class的文件加载进内存，也可将普通文件中的信息加载进内存。
2、文件的加载问题：
1）eclipse会将源程序中的所有.java文件编译成.class文件，然后放到classPath指定的目录中去。并且会将非.java文件原封不动的复制到.class指定的目录中去。在运行的时候，执行的是.class文件。
2）将配置文件放到.class文件目录中一同打包，类加载器就会一同加载。
3、资源文件的加载：是使用类加载器。
1）由类加载器ClassLoader来加载进内存，即用getClassLoader()方法获取类加载器，然后用类加载器的getResourceAsStream(String name)方法，将配置文件（资源文件）加载进内存。利用类加载器来加载配置文件，需把配置文件放置的包名一起写上。这种方式只有读取功能。
2）Class类也提供getResourceAsStream方法来加载资源文件，其实它内部就是调用了ClassLoader的方法。这时，配置文件是相对类文件的当前目录的，也就是说用这种方法，配置文件前面可以省略包名。
如：类名.class.getResourceAsStream(“资源文件名”)
4、配置文件的路径问题：
1）用绝对路径，通过getRealPath()方法运算出来具体的目录，而不是内部编码出来的。
一般先得到用户自定义的总目录，在加上自己内部的路径。可以通过getRealPath()方法获取文件路径。对配置文件修改是需要要储存到配置文件中，那么就要得到它的绝对路径才行，因此，配置文件要放到程序的内部。
2）name的路径问题：
①如果配置文件和classPath目录没关系，就必须写上绝对路径，
②如果配置文件和classPath目录有关系，即在classPath目录中或在其子目录中（一般是资源文件夹resource），那么就得写相对路径，因为它自己了解自己属于哪个包，是相对于当前包而言的。
*///需求：配置文件内容：className=java.util.ArrayList
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Properties;
public class ReflectTest2 {
public static void main(String [] args)throws Exception{
//读取系统文件到读取流中
//方式一：
//InputStream ips = new FileInputStream("config.propert");
/*getRealPath()--得到完整的路径//如：金山词霸/内部
* 一定要用完整的路径，但完整的路径不是硬编码出来的，而是运算出来的。*/
//方式二：
//InputStream ips = ReflectTest2.class.getClassLoader().getResourceAsStream("cn/itcast/text1/config.propert");
//方式三：
//第一种：配置文件（资源文件）在当前包中
InputStream ips = ReflectTest2.class.getResourceAsStream("resourse/config.propert");
//第二种：配置文件（资源文件）不在当前包中，和此包没太大关系
//InputStream ips = ReflectTest2.class.getClassLoader().getResourceAsStream("cn/itcast/test2/resourse/config.properties");
//加载文件中的键值对
Properties props = new Properties();
props.load(ips);
//关闭资源，即ips调用的那个系统资源
//注意：关闭的是ips操作的流，加载进内存后，就不再需要流资源了，需要关闭
ips.close();
//定义变量，将文件中的类名赋值给变量
String className = props.getProperty("className");
//通过变量，创建给定类的对象
Collection cons =
(Collection)Class.forName(className).newInstance();
//将元素添加到集合中
/*Collection cons = new HashSet();*/
ReflectPoint pt1 = new ReflectPoint(3,3);
ReflectPoint pt2 = new ReflectPoint(5,5);
ReflectPoint pt3 = new ReflectPoint(3,3);
cons.add(pt1);
cons.add(pt2);
cons.add(pt3);
cons.add(pt1);
//移除元素
cons.remove(pt1);
System.out.println(cons.size());
}
} <span style="font-size:14px;">
</span> 伙伴们，这篇就到这里了，十分感谢伙伴们的陪伴，谢谢，黑马再会。
扫一扫
615
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
