java反射简解

时间：2022-07-19 09:14:35

1、首先一个问题，什么是类，类是不是对象？

我们总是说我们new一个对象出来

那么我们还没有new的时候，建造的那个java类是不是对象呢？

是

它是java.lang.Class的对象

对于反射我们首先要知道的就是什么是Class类

java.lang.Class到底是什么，有啥用。

首先我们要得到Class，我们有三种可以得到的方法，代码如下，c1，c2，c3就是我们需要的Class

//任何一个类都有一个隐含的成员变量叫做calss

Class c1 = Man.class;

//通过对象的getClass方法获取class

Class c2 = man1.getClass();

//c1和c2表示了Man的类类型，也就是class type

Class c3 = null;

c3 = Class.forName("com.clazz.test.Man");

需要知道的是类的类类型是一样的，都指的是一个，所以c1,c2,c3都是一样的。都是相等的。

那我们现在已经拿到了Class，可以用它来干嘛呢？

我们可以通过类的类类型直接创建一个对象，也就是说，没有new了。

需要注意的是下面的代码中newInstance方法会调用类的无参构造方法

//通过类的类类型创建对象。

Man man2 = (Man) c1.newInstance();

下面是所有的测试代码

package com.clazz.test;

/**

 * Class类的描述测试

 * @author XX

 *

 */

public class ClazzDemo1 {

    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException

    {

        //Man是java.lang.Class的对象

        //任何一个类都是class类的实例对象

        Man man1 = new Man();

        //man1是Man类的实例对象

        //任何一个类都有一个隐含的成员变量叫做calss

        Class c1 = Man.class;

        //通过对象的getClass方法获取class

        Class c2 = man1.getClass();

        //c1和c2表示了Man的类类型，也就是class type

        Class c3 = null;

        c3 = Class.forName("com.clazz.test.Man");

        //通过类的类类型创建对象。

        Man man2 = (Man) c1.newInstance();

    }

}

class Man{

    public Man(){

        System.out.println("创建了这个类");

    }

}

2、静态加载类和动态加载类

new创建对象是静态加载，在编译时刻就需要加载所有可能使用到的类。

通过动态加载类，可以在运行时刻加载使用到的类

也就是我们的c3使用的方法

package com.clazz.test;

public class DynamicLoadClass {

    public static void main(String args[]) throws ClassNotFoundException, InstantiationException, IllegalAccessException

    {

        //静态加载类，直接new出对象，调用方法，一般都是使用这个，但是一旦没有Student类，编译就会报错

        //而且如果需要使用老师对象那么代码需要重新写过很多，要把new对象重新写过，

        Student s1 = new Student();

        s1.speck();

        //通过动态加载类，编译时刻，无论学生还是老师类存不存在，都可以编译通过，只有当运行时刻才进行加载

        //好处是如果你需要新增一个类，直接实现IPeople接口，只要forName的名字正确即可，而且这个名字可以

        //作为一个参数传进来然后进行修改

        Class c1 = Class.forName("com.clazz.test.Student");

        IPeople p1 = (IPeople) c1.newInstance();

        p1.speck();

    }

}
package com.clazz.test;

public class Student implements IPeople{

    public void speck()

    {

        System.out.println("我是学生");

    }

}
package com.clazz.test;

public interface IPeople {

    public void speck();

}

3通过反射拿到一个类的所有的信息

下面这个就是反射最基本的用法，也是反射最神奇的地方

package com.clazz.util;

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

import com.clazz.test.Student;

/**

 * calss类的测试工具类

 * @author XX

 *

 */

public class ClazzUtil {

    public static void main(String args[])

    {

        //通过反射能拿到类的所有方法信息

        printAll(new Student());

    }

    /**

     * 获取这个对象的信息并打印出来

     */

    public static void printAll(Object object)

    {

        Class c = object.getClass();

        //打印该类的名字

        System.out.println("类的名字" + c.getName());

        //打印该类的所有方法（包含从父类继承来的）(不包含私有的方法)

        Method[] ms = c.getMethods();

        for (Method method : ms) {

            System.out.println("方法：" + method.getName() + "          方法的返回值：" + method.getReturnType().getName());

            //获取方法的参数

            Class<?>[] par = method.getParameterTypes();

            for (Class<?> class1 : par) {

                System.out.println("方法的入参：" + class1.getName());

            }

        }

        //打印该类的方法（不包含从父类继承来的）包含私有方法

        Method[] ms2 = c.getDeclaredMethods();

        for (Method method : ms2) {

            System.out.println("方法1：" + method.getName() + "          方法的返回值：" + method.getReturnType().getName());

        }

        //获取成员变量(不包含私有变量)

        Field[] fs = c.getFields();

        for (Field field : fs) {

            System.out.println("成员变量： " + field.getName());

        }

        //获取成员变量（包含私有变量）

        Field[] fs1 = c.getDeclaredFields();

        for (Field field : fs1) {

            System.out.println("成员变量： " + field.getName());

        }

        //获取构造方法

        Constructor[] con = c.getDeclaredConstructors();

        for (Constructor constructor : con) {

            System.out.println("构造方法：" + constructor.getName());

        }

    }

}
package com.clazz.test;

public class Student implements IPeople{

    private int a1;

    public int a12;

    public void speck()

    {

        System.out.println("我是学生");

    }

    private void speck2()

    {

        System.out.println("我是学生");

    }

}

4通过反射调用类的方法

这个是反射的应用，通过反射调用一个类的方法

package com.clazz.test;

import java.lang.reflect.Method;

/**

 * @author XX

 *

 */

public class ReflectMethod {

    public static void main(String args[]) throws Exception

    {

        A a = new A();

        Class c = a.getClass();

        Method m = c.getMethod("add", int.class,int.class);

        System.out.println(m.invoke(a, 1,2));

    }

}

class A{

    public int add(int a,int b)

    {

        return a+b;

    }

    private int minus(int a,int b)

    {

        return a-b;

    }

}

5利用反射解释ArrayList的泛型

package com.clazz.test;

import java.lang.reflect.Method;

import java.util.ArrayList;

public class ArrayListRflect {

    public static void main(String args[]) throws Exception

    {

        /**

         * 下面的代码用于证明，在ArrayList中，泛型只在编译之前有效，编译之后泛型对于list的限制

         * 是无效的。利用反射就能绕过编译这个阶段在ArrayList添加本不属于该泛型的值

         */

        ArrayList<String> list = new ArrayList<String>();

        list.add("哈哈");

        //list.add(1);如果原来这么写，编译会报错的

        //那么怎么在list放个int的1呢？

        //获取list的类类型

        Class c = list.getClass();

        //通过类类型拿到方法

        Method m = c.getMethod("add",Object.class);

        //通过反射调用方法

        m.invoke(list, 1);

        System.out.println(list);

        //结果为：[哈哈, 1]

        //所以证明了上面的观点，也同时很好的证明了反射多神奇

    }

}

相关文章