一、Class类
、概念：Class是Java程序中各个Java类的总称，一个Class对象代表一个Java类的字节码文件它是反射的基石，
Class类 来使用反射。
、Class类中的元素：类名，类的访问属性，类所属包名，字段名称列表，方法名称列表等。
、Class和class的区别
：Java中的类用于描述一类事物的共性，该类事物有什么属性，没有什么属性，至于这个属性的值是什么，
则由此类的实例对象确定，不同的实例对象有不同的属性值。
：指的是Java程序中的各个Java类是属于同一类事物，都是Java程序的类的字节码对象，这些类称为Class。
Person类，Java类对应的就是Class。
、如何获取Class实例对象？
new Class()的方式，因为Class没有这样的构造方法。而是将字节码对象赋值给Class变量。
Class c1 =Person.class。
Person类，它的字节码：首先要将Person的java文件编译为class文件放于硬盘上，即为二进制代码，再将
这些代码加载到内存中，接着用它创建一个个对象。就是把类的字节码加载进内存中，再用此字节码创建一个个
Person、Math、Date等等的类，那么这些字节码就是分别的一个Class对象。即Class c2=Date.class;
、获取各个字节码对应的实例对象的方法
.class，例如，System.class;
.getClass()，例如，new Date().getClass()
类名")，例如，Class.forName("java.util.Date");
、Class.forName(java.lang.String)的作用（面试题）
String.class。得到这个字节码对象有两种情况：
1）此类已经加载进内存：若要得到此类字节码，不需要再加载。
2）此类还未加载进内存：类加载器加载此类后，将字节码缓存起来，forName()方法返回加载进来的字节码。
、九个预定义的Class：
1）包括八种基本类型（byte、short、int、long、float、double、char、boolean）的字节码对象和一种
void类型的void.class。
2）Integer.TYPE是Integer类的一个常量，它代表此包装类型包装的基本类型的字节码，所以和int.class是相等的。
isPrimitive方法判断）的字节码都可以用与之对应的包装类中的TYPE常量表示
Class实例对象，可以用Class.isArray()方法判断是否为数组类型的。
Class实例对象，例如，int[]，void…
、Class类中的常用方法
、static Class forName(String className)
Class对象。
、Class getClass()
Object运行时的类，即返回Class对象即字节码对象
c、Constructor getConstructor()
Constructor对象，它反映此Class对象所表示的类的指定公共构造方法。
d、Field getField(String name)
Field对象，它表示此Class对象所代表的类或接口的指定公共成员字段。
e、Field[] getFields()
Field对象的数组，表示所代表类中的成员字段。
f、Method getMethod(String name,Class… parameterTypes)
Method对象，它表示的是此Class对象所代表的类的指定公共成员方法。
g、Method[] getMehtods()
Method对象的数组，是所代表的的类中的公共成员方法。
h、String getName()
String形式返回此Class对象所表示的实体名称。
i、String getSuperclass()
Class所表示的类的超类的名称
j、boolean isArray()
Class对象是否表示一个数组
k、boolean isPrimitive()
Class对象是否是一个基本类型。
l、T newInstance()
Class对象所表示的类的一个新实例。
二、反射概述
、 反射就是把Java类中的各种成分映射成相应的java类。
Java类中用一个Class类的对象来表示，一个类中的组成部分：成员变量，方法，构造方法，
Java类来表示，就像汽车是一个类，汽车中的发动机，变速箱等等也是一个个的类。
、类的成分：表示java类的Class类显然要提供一系列的方法，来获得其中的变量，方法，构造方法，修饰符，
Field、Method、Contructor、Package等等。
、 一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示，通过调用Class类的方法可以
得到这些实例对象后，再通过这些实例对象使用它们对应成员的功能。
三、Constructor类
、概念：Constructor类代表某个类中的一个构造方法
、得到某个类所有的构造方法：
类名).getConstructors();
、得到某一个构造方法：
类名).getConstructor(Class 参数类型);
注：获得方法时要用到类型
、创建实例对象：
String str = new String(实参);
String str = (String)constructor.newInstance(实参);//实参反射时传入的类的实例对象。
注：调用获得的方法时要用到上面相同类型的实例对象
、直接通过类对应的Class对象创建该类对象：Class类中的newInstance方法
String obj = (String)Class.forName("java.lang.String").newInstance();
该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象。
用到了缓存机制来保存默认构造方法的实例对象。
四、Field类
、概念：Field类代表某个类中的一个成员变量。
、示例：下面是是一个对Point类使用反射获取其成员变量的示例。
/*创建一个Point类*/
public class ReflectPoint {
private int x;
public int y;
public String toString(){
return str1+";" + str2 + ";" + str3;
}
}
/*对Point类使用反射获取其成员变量*/
public class FieldTest(){
ReflectPoint pt1 = new ReflectPoint(3,5);
//fieldY的值是多少？是5,错！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));
}
总结：
、获取成员变量：
如上例子所示：
1）获取公有的成员变量：
和get(变量)
2）获取私有的成员变量：暴力反射
getDeclared(String name)
，将b设为true即可
.get(变量所属对象)
、对字节码的比较用等号。
因为内存中同一类型的字节码文件只有一份。
、练习：下面代码实现了将传入的参数字符串中的字符'b‘替换成字符'a'。
/**
* 将传入的参数字符串中的字符'b‘替换成字符'a'
* @param obj:要被替换的字符串对象
*/
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); //记得替换后设置到对象中
}
}
}
set方法设置到对象中。
五、Method类
、概念：Method类代表某个类中的一个成员方法。
调用某个对象身上的方法，要先得到方法，再针对某个对象调用。
、专家模式：谁拥有这个数据，谁就是根据这个数据实现功能的专家。
如人关门：
调用者：是门调用管的动作，对象是门，因为门知道如何执行关的动作，通过门轴之类的细节实现。
指挥者：是人在指挥门做关的动作，只是给门发出了关的信号，让门执行。
总结：变量使用方法，是方法本身知道如何实现执行的过程，也就是“方法对象”调用方法，才执行
了方法的每个细节的。
、获取某个类中的某个方法：（如String str = ”abc”）
1）通常方式：str.charAt(1)
2）反射方式：
“java.lang.String”).getMethod(“charAt”,int.class);
charAtMethod.invoke(str,1);
Method对象的invoke()方法的第一个参数为null。
六、用反射方式执行某个main方法
反射的作用：
main这个方法，所以可以通过反射的方式，通过使用者传入的类名（可定义字符串型变量作为传入类名的入口，通过这个变量代表类名），内部通过传入的类名获取其main方法，然后执行相应的内容。
main方法的代码演示
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，告诉JVM传入参数是一个对象，不用拆包
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);
}
}
}
七、数组的反射
、具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象(此处比较与值无关)。
、代表数组的Class实例对象的getSuperClass()方法返回的父类为Object类对应的Class。
、基本类型的一维数组可以被当作Object类型使用，不能当作Object[]类型使用；非基本类型的一维数组，
Object类型使用，又可以当做Object[]类型使用。
例如：定义以下四个数组：
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"};
以下四个赋值：
合法
合法
不合法，a1里面元素是基本数据类型，不能当做Object对象
合法，转成Object[]类型数组后，数组中元素是一维数组。
合法
、Arrays.asList()方法处理int[]和String[]时的差异
类型数组作为参数时，因为该类型不属于Object[]类型，也不是其子类，所以JDK1.4版本处理不了。
JDK1.5里面会将传入的int[]型数组当成一个参数处理。
String[]类型的数组时，JDK1.4版本的特性，会将参数当成一个数组处理，进行拆包，取里面
的元素作为参数。
、Array工具类用于完成对数组的反射操作
通过定义一个打印功能演示
/**
* 通过判断传入的对象将其打印，如果是数组，逐个打印其元素；若不是数组，直接打印。
* @param obj 要打印的对象
*/
private static void printObject(Object obj) {
Class clazz = obj.getClass();
if(clazz.isArray()){
int len = Array.getLength(obj);
for(int i=0;i<len;i++){
System.out.println(Array.get(obj, i));
}
}else{
System.out.println(obj);
}
}
八、HashSet和与hashCode的分析
、HashSet的特点：HashSet是一个集合容器，底层是哈希数据结构，元素不能重复，增删快，查询慢。
、HashSet如何保证元素的唯一性？
equals方法判断元素是否相同。
hashCode方法和equals方法。
hashCode算法的集合的，覆写hashCode()方法才有价值。
、哈希算法的由来：
equals的比较，
对象特别多时，效率很低，通过哈希算法，将集合分为若干个区域，每个对象算出一个哈希值，
32为一组），每组对应某个存储区域，依一个对象的哈希码即可确定此对象
对应区域，从而减少每个对象的比较，只需在指定区域查找即可，从而提高从集合中查找元素的效率。
示意图：
、如果不存入是hashCode算法的集合中，那么则不用复写此方法。
、只有类的实例对象要被采用哈希算法进行存入和检索时，这个类才需要按要求复写hashCode()方法，
hashCode()方法，但是为提供一个hashCode()方法也不会
hashCode()和equals()两者一
并被覆盖。
、提示：
1）若同类两对象用equals()方法比较的结果相同时，他们的哈希码也必须是相等的，但反过来就
BB”和”Aa”两字符串用equals()比较式不相等的，但是他们的哈希值是相等的。
2）当一个对象被存储进HashSet集合中，就不能再修改参与计算哈希值的字段，否则对象被修改后
HashSet集合中的哈希值就不同了。在这种情况下，即使contains()
HashSet集合中检索对象，也将返回找不到对象的结果，这
HashSet集合中单独删除当前对象，从而造成内存泄露。
简单说，之前存入的对象和修改后的对象，是具有不同的哈希值，被认为是不同的两个对象，这样的对象
不再使用，又不移除，而越来越多，就会导致内存泄露。
HashSet集合存储元素后，修改了用于计算hashCode值的参数，那么再去访问元素时会发生内存泄漏，
找不到要访问的元素。
内存泄漏：内存中的某个数据不需要再使用了，但是该数据还存在着内存中，没有释放内存空间。
九、反射的作用——>实现框架功能
、框架：通过反射调用位置Java类的一种方式。
如房地产商造房子用户住，门窗和空调等等内部都是由用户自己安装，房子就是框架，用户需使用
此框架，安好门窗等放入到房地产商提供的框架中。
框架和工具类的区别：工具类被用户类调用，而框架是调用用户提供的类。
、框架机器要解决的核心问题：
我们在写框架（造房子的过程）的时候，调用的类（安装的门窗等）还未出现，那么，框架无法知
new其某个类的实例对象，而要用反射来做
、简单框架程序的步骤：
1）右击项目名-->File-->命名，写入键值对：className=java.util.ArrayList，等号右边
的可以自己定义集合的名称，即用户可以对此记事本修改成自己的类名。
2）代码实现，加载此文件：
getRealPath()方法获取路径名，
再加上自己定义的文件夹名。
Properties类的load()方法将流加载经内存，即提取文件中的信息。
③关闭流：关闭的是读取流，因为流中的数据已经加载进内存。
3）通过getProperty()方法获取类名属性，将传入的类名赋值给指定变量。
4）用反射的方式，创建对象newInstance()
5）进行相关的具体操作。
、类加载器：
1）简述：类加载器是将.class的文件加载经内存，也可将普通文件中的信息加载进内存。
2）文件的加载问题：
、eclipse会将源程序中的所有.java文件加载成.class文件，以确保编译，然后放到classPath
.java文件原封不动的复制到.class指定的目录中去。在真正编译的
classPath目录中的文件，即放置.class文件的目录。
、写完程序是要讲配置文件放到.class文件目录中一同打包，这些都是类加载器加载的，资源文
件（配置文件）也同样加载了配置文件。
、框架中的配置文件都要放到classPath指定的文件夹中，原因是它的内部就是用类加载器加载的文件。
3）资源文件的加载：是使用类加载器。
、由类加载器ClassLoader的一个对象加载经内存，即用getClassLoader()方法加载。
getResourseAsStream(String name)在classPath的文件中
逐一查找要加载的文件。
、在.class身上也提供了方法来加载资源文件，其实它内部就是先调用了Loader方法，再加载的
资源文件。
Reflect.class.getResourseAsStream(String name)
、配置文件的路径问题：
getRealPath()方法运算出来具体的目录，而不是内部编码出来的
getRealPath()方法获取
文件路径。对配置文件修改是需要要储存到配置文件中，那么就要得到它的绝对路径才行，因此，
配置文件要放到程序的内部。
name的路径问题：
classPath目录没关系，就必须写上绝对路径，
classPath目录有关系，即在classPath目录中或在其子目录中（一般是
resource），那么就得写相对路径，因为它自己了解自己属于哪个包，是相对于
当前包而言的。
示例：
配置文件内容：
className=java.util.ArrayList
程序示例：
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());
}
}
