【java学习笔记】反射基础

一.反射

　　反射就是在剖析一个类，了解这个类的构造，创建这个类对应的对象。

Class	代表字节码的类，代表类的类
Field	代表属性的类
Method	代表方法的类
Constructor	代表构造方法的类
Annotation	代表注解的类
Package	代表包的类

二.Class类

2.1 获取Class对象：必须有意义

    ①通过类名.class的方式来获取对应类的字节码对象

import java.util.List;

public class ClassDemo {
    @SuppressWarnings("rawtypes")
    public static void main(String[] args)  {

        // 每一个Class对象对应了一个实际的类，因此要求每一个Class都必须有意义
        // 如果允许随意创建Class对象，就会导致Class对象没有实际对应的类
        // Class clz0 = new Class();
        
        // 通过类名.class的方式来获取一个字节码对象
        // clz表示的就是String的字节码
        Class<String> clz = String.class;
        System.out.println(clz);

        // clz2表示的就是List的字节码
        Class<List> clz2 = List.class;
        System.out.println(clz2);
        
        // clz3表示的就是String[]的字节码
        Class<String[]> clz3 = String[].class;
        System.out.println(clz3);
        
    }
}

    ②通过对象.getClass()方法来获取这个对象对应的实际类的字节码对象

public class ClassDemo {
    @SuppressWarnings("unchecked")
    public static void main(String[] args)  {
        Object str = "abc";
        Class<String> clz = (Class<String>) str.getClass();
        System.out.println(clz);
    }
}

//输出：class java.lang.String

    ③通过Class.forName(类的全路径名)的方法来获取指定类的字节码对象

import java.util.List;

public class ClassDemo {
    @SuppressWarnings("unchecked")
    public static void main(String[] args) throws ClassNotFoundException  {
        Class<String> clz = (Class<String>) Class.forName("java.lang.String");
        System.out.println(clz);
        
        Class<List> clz2 = (Class<List>) Class.forName("java.util.List");
        System.out.println(clz2);
    }
}

//输出：
//class java.lang.String
//interface java.util.List

2.2创建由此类对象表示的类的新实例

2.2.1 newInstance

字节码对象.newInstance();

用处之举例：

    Cat和Dog都实现了Animal接口，利用向上造型，将字符串利用Properties进行更改，可实现任意创建Cat对象或者Dog对象。

public class TestClassDemo {
    @SuppressWarnings("unchecked")
    public static void main(String[] args) throws Exception {

        // 表示获取了Animal类对应的字节码
        //"cn.hdu.reflection.Cat"可以用Properties进去获取
        Class<Animal> clz = (Class<Animal>) Class.forName("cn.hdu.reflection.Cat");
        
        // 要求类中必须有无参构造
        Animal a = clz.newInstance(); //产生对象
        System.out.println(a);

    }

}

interface Animal {
}

class Dog implements Animal {

    @Override
    public String toString() {
        return "Dog";
    }

}

class Cat implements Animal {

    @Override
    public String toString() {
        return "Cat";
    }

}

2.2.2 通过构造方法创建新实例

//只能获取public构造方法
Constructor<?>[] getConstructors()
Constructor<T> getConstructor(类<?>... parameterTypes)  

//不区分是否是public的构造方法
Constructor<?>[] getDeclaredConstructors()  
Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)  
//需要用 Constructor对象.setAccessible(true);进行设置

举例：

import java.lang.reflect.Constructor;

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

        // clz代表String类的字节码
        Class<String> clz = String.class;

        // String(String)
        // 只能获取public修饰的构造方法
        Constructor<String> constructorPublic = clz.getConstructor(String.class);
        String str = constructorPublic.newInstance("abc");
        System.out.println(str);

         // String(byte[], int, int)
        Constructor<String> constructorParameters = clz.getConstructor(byte[].class, int.class, int.class);
        String str2 = constructorParameters.newInstance(new byte[] { 97, 98, 99, 100 }, 1, 3);
        System.out.println(str2);

        // 获取指定的构造方法，不区分是否是public的
        Constructor<String> constructorPrivate = clz.getDeclaredConstructor(char[].class, boolean.class);
        // 暴力破解/暴力拆除
        constructorPrivate.setAccessible(true);
        String str3 = constructorPrivate.newInstance(new char[] { 'a', 'b', 'c' }, true);
        System.out.println(str3);
    }

}

在String源码中是默认的，非public

2.3 获取方法

//public
Method getMethod(String name, 类<?>... parameterTypes)  
Method[] getMethods()  //获取所有公有方法（包含了父类的方法也包含Object类） 

//非public
Method getDeclaredMethod(String name, 类<?>... parameterTypes) 
Method[] getDeclaredMethods() //获取所有的成员方法，包括私有的(不包括继承的)
//m.setAccessible(true);

//使用所指定的方法:Method的对象.invoke(Object obj, Object... args);

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class ClassGetMethodDemo {

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

        Class<String> clz = String.class;

        // 表示String(String)
        Constructor<String> c = clz.getConstructor(String.class);
        String str = c.newInstance("abcdefg");

        // 获取charAt(int)
        // 只能获取public修饰的方法
        Method m = clz.getMethod("charAt", int.class);
        // 执行方法对象
        // 相当于char ch = str.charAt(3);
        char ch = (char) m.invoke(str, 3);
        System.out.println(ch);

        // 获取指定的方法
        Method m2 = clz.getDeclaredMethod("lastIndexOfSupplementary", int.class, int.class);
        m2.setAccessible(true);
        int i = (int) m2.invoke(str, 2, 3);
        System.out.println(i);    
    }

}

2.4 获取属性

//public
Field getField(String name)  
Field[] getFields()  

//非public
Field getDeclaredField(String name)  
Field[] getDeclaredFields()  
//f.setAccessible(true);

//Field类
获取：Object get(Object obj) 
设置：void set(Object obj, Object value)  
        void setChar(Object obj, char c) 
        void setDouble(Object obj, double d) 
        void setInt(Object obj, int i) 
        ... ...

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

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

        Class<String> clz = String.class;

        // 表示String(String)
        Constructor<String> c = clz.getConstructor(String.class);
        String str = c.newInstance("abcdefg");

        // 获取类中指定的属性
        Field f = clz.getDeclaredField("hash");
        f.setAccessible(true);
        System.out.println(f.get(str));
        // 设置属性的值
        f.set(str, 125);
        // 获取属性的值
        System.out.println(f.get(str));
    }
}

2.5 获取注解

<A extends Annotation>A getAnnotation(类<A> annotationClass)  
Annotation[] getAnnotations()  

<A extends Annotation>A getDeclaredAnnotation(类<A> annotationClass)  
Annotation[] getDeclaredAnnotations()  

2.6 Class类其它常用方法

import java.lang.reflect.TypeVariable;
import java.util.ArrayList;
import java.util.List;

public class ClassDemo {

    @SuppressWarnings("rawtypes")
    public static void main(String[] args) {

        Class<String> clz = String.class;

        // 获取这个类实现的所有的接口
        Class[] ins = clz.getInterfaces();
        for (Class c : ins) {
            System.out.println(c);
        }

        // 获取父类
        Class superc = clz.getSuperclass();
        System.out.println(superc);

        // 获取类的全路径名
        System.out.println(clz.getName());
        // 获取类的简称
        System.out.println(clz.getSimpleName());

        // 获取所在的包
        System.out.println(clz.getPackage());

        List<String> list = new ArrayList<>();
        Class lclz = list.getClass();
        TypeVariable[] ts = lclz.getTypeParameters();
        for (TypeVariable typeVariable : ts) {
            System.out.println(typeVariable);
        }

        // 判断是否是一个枚举
        System.out.println(clz.isAnnotation());
        // 判断是否是一个基本类型
        System.out.println(clz.isPrimitive());

        // 判断参数是否是指定类型的实例的
        Object str = "abc";
        System.out.println(clz.isInstance(str));
        System.out.println(str instanceof String);

        // 判断两个类之间是否有继承关系
        System.out.println(Object.class.isAssignableFrom(String.class));

    }

}