【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);

     }
 }

类名.class

②通过对象.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

对象.getClass()

③通过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

Class.forName(类的全路径名)

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";
     }

 }

AnimalCatDog

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);
     }

 }

getConstructor

在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);
     }

 }

getMethod

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));
     }
 }

getField

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));

     }

 }