第一：先认识Class类

类也是一种实例，类的实例创建有三种方式。

类的实例对象创建的方式有两种。以下的代码详细的介绍：

packagecom.company;import java.util.*;public classMain {public static voidmain(String[] args) {//类的实例创建有两种方式

Vae xs = newVae();

xs.music();//每个类都是一个实例的对象，Vae类是一个Class类的对象，其实例表达方式有3种//第1种，类的class

Class c1 = Vae.class;//第2种，类的实例的getClass

Class c2 =xs.getClass();//第3种，类的名字，这种是最常用的方式，我们在写Java反射的时候会经常使用

Class c3 = null;try{

c3= Class.forName("com.company.Vae");

}catch(ClassNotFoundException e) {

e.printStackTrace();

}

System.out.println(c1==c2);

System.out.println(c2==c3);//类的实例的第2种创建方式

try{

Vae xs2=(Vae) c1.newInstance();

xs2.music();

}catch(InstantiationException e) {

e.printStackTrace();

}catch(IllegalAccessException e) {

e.printStackTrace();

}

}

}classVae{public voidmusic(){

System.out.println("许嵩是最佳歌手");

}

}

这段代码的输出结果是：

下面来整理一下代码，首先，类的实例的创建的两种方法：

//第一种，最常见的new

Vae xs = newVae();//第二种，newInstance()方式，这种方式必须加try catch，否则会报错

try{

Vae xs2=(Vae) c1.newInstance();

xs2.music();

}catch(InstantiationException e) {

e.printStackTrace();

}catch(IllegalAccessException e) {

e.printStackTrace();

}

其次，类实例的创建方法，其实就是获取这个类的类型，有三种：

//第1种，类的class

Class c1 = Vae.class;//第2种，类的实例的getClass

Class c2 =xs.getClass();//第3种，类的名字，这种是最常用的方式，我们在写Java反射的时候会经常使用

Class c3 = null;try{

c3= Class.forName("com.company.Vae");

}catch(ClassNotFoundException e) {

e.printStackTrace();

}

第三种的确是最常见的，而且c1，c2，c3是一样的，输出==的时候结果是true。

这些就是Class类的全部知识。先记住。接下来讲解Java的动态加载和静态加载。很快，就可以触及到反射了。

第二：Java的静态加载和动态加载

加载分为静态加载和动态加载。

什么是静态加载呢？你写的代码在编译的时候，就是静态加载。凡是编译不能通过的代码，都是属于静态加载的。例如类创建对象的new关键字。

什么是动态加载呢？动态加载就是在代码运行的时候才加载的，C#里面有一个类型是dynamic，而在Java里面就是利用的我们上面讲的Class.forName

我先来举个例子，解释一下上面两句话：

importjava.util.Scanner;public classMain {public static voidmain(String[] args) {

Scanner scan=newScanner(System.in);

Start(scan.nextLine());

}public static voidStart(String name)

{if("Vae".equals(name)){

Vae xs=newVae();

xs.music();

}else{

System.out.println("我是出口");

}

}

这是我在idea里面写的代码，编译的时候，报错，说没有Vae这个类。这就说明了在new Vae的对象的时候，编译是不通过的，因为在编译的时候就已经开始加载了。这说明了，new 类的对象是属于静态加载的。

现在我们写一个Vae类出来：

public classVae {public voidmusic() {

System.out.println("许嵩是最佳歌手");

}

}

然后我们把Vae类名传递过去。运行，输入 Vae

结果如下：

非常完美。那么现在问题来了。很严重的问题。我现在不想用Vae类了，使用Vae类只能输出许嵩是最佳歌手。这个是许嵩的专属类。

我还想去输入其它歌手怎么办？例如我想添加一个shuyunquan类，去输出蜀云泉是一名歌手。那么我们要做两件事：

1.新写一个shuyunquan类

2.在Main类的Start方法中，必须新加一个if语句去判断我的输入是否等于shuyunquan

第一步是毫无疑问必须要写的，但是第二步！！！假如我们已经发布了代码，你怎么改？假如我想再增加10名歌手，你怎么改？

一个一个的在Start方法里面加？

这是一个很愚蠢的行为。这个时候我们需要使用我们第一步中学到的Class类的知识。

我改动了Main类中的Start方法，如下：

importjava.util.Scanner;public classMain {public static voidmain(String[] args) {

Scanner scan=newScanner(System.in);

Start(scan.nextLine());

}public static voidStart(String name)

{try{

Class c=Class.forName(name);

singer s=(singer)c.newInstance();

s.music();

}catch(ClassNotFoundException e) {

e.printStackTrace();

}catch(IllegalAccessException e) {

e.printStackTrace();

}catch(InstantiationException e) {

e.printStackTrace();

}

}

}

可以看到，我使用Class.forName方法获取了我输入的类类型。然后使用newInstance方法new出了一个类的实例对象。但是newInstance方法是必须要加强制类型转换的怎么办？

因为我输入的都是歌手类。所以我写了一个接口，定义为singer:

interfacesinger {public voidmusic();

}

然后给我的Vae类实现这个接口：

public class Vae implementssinger {public voidmusic() {

System.out.println("许嵩是最佳歌手");

}

}

现在，如果我想再加10个，20个歌手进来，都是完全没有问题的。我只需要写出我需要的歌手类。然后继承这个接口。再然后，我直接输入就可以了。

完全不需要修改我的Main类中的Start方法。这一点和QQ的在线更新啊，其它软件的升级功能啊，貌似都是这样实现的。

第三：Java获取类的方法名，方法返回值类型，方法的参数类型

在第一我们学到了Java如何去获取类类型，在第二我们使用了类类型去完成了Java的动态加载。这一次，我们学习下，Java如何去获取方法的详细信息。

importjava.lang.reflect.Method;public classMain {public static voidmain(String[] args) {

Vae xs=newVae();//getMethods()是获取所有的public方法，包括父类继承的，系统写的。getDeclaredMethods()是获取所有自己写的方法，public和private都获取。我喜欢getDeclaredMethods()//Method [] methods=xs.getClass().getMethods();

Method [] methods=xs.getClass().getDeclaredMethods();for(Method temp:methods) {//获取方法的返回值类型

Class returnType=temp.getReturnType();

System.out.print("方法名"+temp.getName()+" 返回值类型"+returnType);///获取方法名//System.out.println(temp.getName());

///获取参数数组

Class [] params=temp.getParameterTypes();for(Class param:params) {

System.out.print(" 方法的参数"+param.getSimpleName()+"，");

}

System.out.println();

}

}

}

第一亮点：import java.lang.reflect.Method  我们已经引用了Java反射

第二亮点：getMethods()和getDeclaredMethods()这两个方法的区别。

getMethods()是获取所有的public方法，包括父类继承的，系统写的。getDeclaredMethods()是获取所有自己写的方法，public和private都获取。

我特意传进去的我写的Vae类，我们来看看我的Vae类：

public class Vae implementssinger {public voidmusic() {

System.out.println("许嵩是最佳歌手");

}public int test(inta,String b) {return 1;

}

}

里面有两个方法，参数，返回值一目了然。我们执行上面的代码，结果如下：

完美！自己手动写写吧。

第四：Java获取类的成员变量的名称，类型 。获取构造函数的名称，参数类型。

由于第四和第三步是差不多的。所以我直接贴出代码和结果了

//获取成员变量

Field [] fs=xs.getClass().getFields(); //只能获取public

Field [] fs1=xs.getClass().getDeclaredFields(); //获取所有

for(Field field:fs1) {//成员变量的类型

Class fieldType=field.getType();

String typeName=fieldType.getName();//成员变量的名称

String fileName=field.getName();

System.out.println("变量名:"+fileName+" 变量类型"+typeName);

}//获取构造函数信息

Constructor [] cs=xs.getClass().getConstructors(); //获取public的构造函数

Constructor [] cs1=xs.getClass().getDeclaredConstructors(); //获取所有的构造函数，包括public和private

for(Constructor constructor:cs) {

System.out.print("构造函数名称是：" + constructor.getName() + " 构造函数的参数有:");

Class[] paramTypes=constructor.getParameterTypes();for(Class class1:paramTypes){

System.out.print(class1.getName()+",");

}

System.out.println();

}

就这么多，还是以我的Vae类为例子

public class Vae implementssinger {public int age=32;public String name="许嵩";private String love="写歌";public voidmusic() {

System.out.println("许嵩是最佳歌手");

}public int test(inta,String b) {return 1;

}

}

结果：

自己敲一敲代码，记一记就完事了。下面开始讲反射。

第五：方法的反射

终于，我们开始方法的反射了。先看代码：

packagecom.company;importjava.lang.reflect.Method;public classMain {public static voidmain(String[] args) {

Class c=Vae.class;

Vae xs=newVae();//方法的反射

try{

Method s=c.getMethod("music", int.class, int.class);//invoke方法就是反射的方法，Object是接收的返回值，如果是void方法，返回值是null

Object object=s.invoke(xs,2,3);

System.out.println(object);//有返回值的方法

Method s1=c.getMethod("music", String.class, String.class);

object=s1.invoke(xs,"许嵩","蜀云泉");

System.out.println(object);//没有参数的方法

Method s2=c.getMethod("music");

object=s2.invoke(xs);

System.out.println(object);

}catch(Exception e) {

e.printStackTrace();

}

}

}classVae{public void music(int a,intb){

System.out.println(a+b);

}publicString music(String a,String b){return a+b;

}public void music(){ System.out.println("没有参数的空方法");}

}

看看输出的结果：

现在来讲解一下方法的反射。Invoke方法是重点，现在写到这里应该是有两个疑问的？

第一：我既然实例化了Vae类的对象，我为什么不直接xs.music()，反而要反射的去做。这不是麻烦吗？

存疑，这个我暂时没想通。

第二：在反射方法的时候，我怎么知道参数怎么填写？有几个？什么类型的？

这个疑问在想出来的时候就已经想到答案了，答案就是第四步，我们可以输出方法的名称和参数类型，个数还有方法的返回值类型。其实。。。这也完全没有必要，因为你的那些类都是继承了接口的，你只需要看看接口有哪些方法，就可以了。所以这个问题完全不是问题。

其它的在代码的注释里面，已经写的很清楚了。

还有一个反射去绕过泛型的例子待补充。我在网上搜了一下，貌似都说反射这个技能比较消耗资源，在普通情况下，是不建议使用的。反射大量应用的场景应该是写框架的时候。

我再找找看看有没有反射的最佳实践吧。反正我学习到这里，只觉得第二步是有意思的。