Java反射笔记

 

　　第一：先认识Class类

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

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

package com.company;
import java.util.*;

public class Main {

    public static void main(String[] args) {

        //类的实例创建有两种方式
        Vae xs = new Vae();
        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();
        }

    }
}

class Vae{
    public void music(){
        System.out.println("许嵩是最佳歌手");
    }
}

这段代码的输出结果是：

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

//第一种，最常见的new
 Vae xs = new Vae();


//第二种，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

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

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        Scanner scan=new Scanner(System.in);
        Start(scan.nextLine());

    }

    public static void  Start(String name)
    {
        if("Vae".equals(name)){
            Vae xs=new Vae();
            xs.music();
        }
        else{
            System.out.println("我是出口");
        }
    }

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

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

public class Vae {
    public void music() {
        System.out.println("许嵩是最佳歌手");
    }
}

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

结果如下：

 

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

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

1.新写一个shuyunquan类

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

 

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

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

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

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

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        Scanner scan=new Scanner(System.in);
        Start(scan.nextLine());

    }

    public static void  Start(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:

interface singer {
    public void music();
}

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

public class Vae implements singer {
    public void music() {
        System.out.println("许嵩是最佳歌手");
    }
}

 

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

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

 

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

 

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

import java.lang.reflect.Method;

public class Main {

    public static void main(String[] args) {

        Vae xs=new Vae();
        //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 implements singer {
    public void music() {
        System.out.println("许嵩是最佳歌手");
    }
    public int test(int a,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 implements singer {

    public int age=32;

    public String name="许嵩";

    private String love="写歌";

    public void music() {
        System.out.println("许嵩是最佳歌手");
    }
    public int test(int a,String b) {
        return 1;
    }
}

结果：

 

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

 

　　第五：方法的反射

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

package com.company;
import java.lang.reflect.Method;

public class Main {

    public static void main(String[] args) {

     Class c=Vae.class;
     Vae xs=new Vae();
     //方法的反射
        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();
        }


    }
}

class Vae{
    public void music(int a,int b){
        System.out.println(a+b);
    }

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

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

}

看看输出的结果：

 

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

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

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

 

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

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

 

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

 

 

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

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