java反射简解

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]
        
        //所以证明了上面的观点，也同时很好的证明了反射多神奇
    }
}