0033 Java学习笔记-反射-初步1

先看看通过反射能干嘛

示例：修改对象的private实例变量

package testpack;
import java.lang.reflect.Field;
public class Test1 {
public static void main(String[] args)throws Exception{
Person per=new Person("Java",21);
System.out.println("现在的per对象是："+per);   //[name= Java , age= 21 ]

Class<Person> perClazz=Person.class;           //获取Person类的Class对象

Field fName=perClazz.getDeclaredField("name"); //获取Person类的名为“name”的变量，即使是private修饰
fName.setAccessible(true);                     //取消该变量的访问权限检查
fName.set(per, "C++");                         //将per对象的name变量改为“C++”

Field fAge=perClazz.getDeclaredField("age");
fAge.setAccessible(true);
fAge.set(per, 33);                             //将per对象的age变量改为“33”

System.out.println("private的实例变量被修改了，还是那个per对象："+per); //[name= C++ , age= 33 ]
}
}
class Person{
private int age;
private String name;
public Person(String n,int a){
name=n;
age=a;
}
public String toString(){
return "[name= "+name+" , age= "+age+" ]";
}
}

上面的示例中，虽然age和name被private修饰，但还是被修改了，那这岂不是很不安全，违背了封装的初衷？我也不知道

java.lang.class

有一个类很特别，它是所有类的类，它就是java.lang.class

要使用一个类的时候，类加载器找到并加载这个类，同时返回其Class对象；也就是说只要一个类被加载了，那么就一定存在它的Class对象

如何获得一个类的Class对象？以String类为例

Class.forName("java.lang.String")：用Class类的静态方法forName("包名+类名")来获取

String.class：通过调用一个类的class属性来获取

一般用这种方式

代码更安全。程序在编译阶段就可以检查要访问的Class对象是否存在。？不懂

程序性能更好。因为无须调用方法。

String的实例.getClass()：通过Object类的一个实例方法getClass()方法获取

获取一个类的Class对象后，就可以调用其方法获得该对象和该类的真实信息了

Class主要方法

构造器：以下用“para”代表Class<?>...parameterTypes，这是个数可变的形参列表

Constructor getConstructor(para)：返回该Class对象对应类的、带指定形参的public构造器

Constructor<?>[] getConstructors()：返回对应类的所有public构造器

Constructor getDeclaredConstructor(para)：返回对应类的、带指定形参列表的构造器，不论是什么访问权限

Constructor<?>[] getDeclaredConstructors()：返回对应类的所有构造器，不论访问权限

方法：

Method getMethod(String name,para)：返回对应类的、指定方法名、指定形参列表的public方法

Method[] getMethods()：返回指定类的所有public方法

Method getDeclaredMethod(String name,para)：返回对应类的、指定方法名、指定形参列表的方法，不论访问权限

Method[] getDeclaredMethods()：返回对应类的所有方法，不论访问权限

成员变量

Field getField(String name)：返回对应类的、指定名称的public成员变量

Filed[] getFields()：返回对应类的所有public成员变量

Field getDeclaredField(String name)：返回对应类的、指定名称的成员变量，不论访问权限

Field[] getDeclaredFields()：返回对应类的所有成员变量，不论访问权限

注解

<A extends Annotation> A getAnnotation(Class<A>AnnotationClass)：获取对应类的指定的注解，不存在则返回null

<A extends Annotation> A getDeclaredAnnotation(Class<A>AnnotationClass)：获取

直接修饰

该对应类的、指定的注解，不存在则返回null

Annotation[] getAnnotations()：返回对应类上的所有注解

Annotation[] getDeclaredAnnotations()：返回

直接修饰

该对应类的所有注解

<A extends Annotation> A[] getAnnotationsByType(Class<A>AnnotationClass)：

针对重复注解

功能，返回修饰该对应类的、指定类型的多个注解

<A extends Annotation> A[] getDeclaredAnnotationsByType(Class<A>AnnotationClass)：

针对重复注解

功能，获取

直接修饰

对应类的、指定类型的注解

内部类

Class<?>[] getDeclaredClasses()：返回对应类里包含所有内部类

外部类：

Class<?> getDeclaringClass()：返回对应类的所在的外部类

接口：

Class<?> getInterfaces()：返回对应类所实现的所有接口

父类：

Class<?super T> getSuperclass()：返回对应来的父类的Class对象

修饰符：

int getModifiers()：返回对应类或接口的所有修饰符对应的常量，应使用Modifier工具类的方法解码，才能获得真实的修饰符

所在包：

Package getPackage()：获取对应类所在的包

类名：

String getName()：返回对应类的名称，全局限定名(即包含包名)

String getSimpleName()：返回对应类的名称，不包含包名的类名

is方法

boolean isAnnotation：是不是注解类型

boolean isAnnotationPresent(Class<? extends Annotation> annotationClass)：对应类是否使用了Annotation修饰

boolean isAnonymousClass()：对应类是否是一个匿名类

boolean isArray()：对应类是否是一个数组

boolean isEnum()：对应类是否是一个枚举

boolean isInterface()：对应类是否是一个接口

boolean isInstance(Object obj)：判断该obj是不是对应类的实例，可以完全替代instanceof

相关方法示例：以Strin类为例

package testpack;

import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class Test1  {
public static void main(String[] args)throws Exception{
Class clazz=String.class;

System.out.println("---------------------------------下面是String的成员变量部分---------------------------------");
System.out.println("-----------所有的public成员变量-----------");
Field[] pfs=clazz.getFields();
for (Field f:pfs) {
System.out.println(f);
}
System.out.println("-----------所有成员变量-----------");
Field[] fs=clazz.getDeclaredFields();
for (Field f:fs) {
System.out.println(f);
}

System.out.println("---------------------------------下面是String的构造器部分---------------------------------");
System.out.println("String的无参构造："+clazz.getConstructor(null));
System.out.println("String以byte[]为参数的构造器："+clazz.getConstructor(byte[].class));
System.out.println("String以StringBuffer为参数的构造器："+clazz.getConstructor(StringBuffer.class));
System.out.println("---------------所有构造器-----------------");
Constructor[] cs=clazz.getDeclaredConstructors();
for(Constructor c:cs){
System.out.println(c);
}

System.out.println("---------------------------------下面是String的方法部分---------------------------------");
System.out.println("String的名为intern的无参方法："+clazz.getMethod("intern",null));
System.out.println("String的名为valueOf的参数为int的方法："+clazz.getMethod("valueOf",int.class));
System.out.println("--------------所有方法--------------------");
Method[] ms=clazz.getDeclaredMethods();
for (Method m:ms) {
System.out.println(m);
}
System.out.println();

System.out.println("---------------------------------下面是String的注解部分---------------------------------");
System.out.println("---------下面是String的所有注解---------------");
Annotation[] as=clazz.getAnnotations();
for (Annotation a:as) {
System.out.println(a);                      //没有输出：因为String类没有注解(但String类内部的一些元素有注解)
}
System.out.println("---------------------------------下面是String的所有内部类---------------------------------");
Class[] css=clazz.getDeclaredClasses();
for (Class c:css) {
System.out.println(c);
}
System.out.println("---------------------------------下面是String实现的所有接口---------------------------------");
Class[] is=clazz.getInterfaces();
for (Class i:is) {
System.out.println(i);
}
System.out.println("---------------------------------其他---------------------------------");
System.out.println("String的直接父类："+clazz.getSuperclass());
System.out.println("String的修饰符："+clazz.getModifiers());
System.out.println("String所在的包："+clazz.getPackage());
System.out.println("String的全局限定名："+clazz.getName());
System.out.println("String的类名："+clazz.getSimpleName());
}
}

关于参数的反射：since1.8

构造方法和方法中包含形参列表，Java1.8增加了Parameter类来描述参数

上面Class对象关于构造器和方法的返回值分别是：Constructor和Method，这两个类是Executable类的子类

Executable的主要方法有：

boolean isVarArgs()：是否包含可变数量的形参

int getModifiers()：获取修饰符

int getParameterCount()：获取形参数量

Parameter[] getParameters()：获取所有形参

Parameter的主要方法

int getModifiers()：获取形参的修饰符

String getName()：获取形参名

Type getParameterizedType()：获取带泛型的形参类型

Class<?> getType()：获取形参类型

boolean isNamePresent()：所在类的class文件中是否包含了形参名信息；

一般情况下，编译的时候都不包含形参名，除非加上“-parameters”选项

boolean isVarArgs()：该参数是否为个数可变的形参

见示例：

package testpack;

import java.lang.reflect.Constructor;
import java.lang.reflect.Parameter;

public class Test1  {
public static void main(String[] args)throws Exception{
Class clazz=String.class;
Constructor c=clazz.getConstructor(byte[].class,int.class,int.class);
System.out.println("该构造器的形参个数："+c.getParameterCount());
Parameter[] ps=c.getParameters();
for (Parameter p:ps) {
System.out.println("该参数是："+p);
System.out.println("该参数的修饰符："+p.getModifiers());
System.out.println("该参数的形参名："+p.getName());
System.out.println("形参类型："+p.getType());
System.out.println("是否有形参名信息："+p.isNamePresent());
System.out.println("是否是个数可变的形参："+p.isVarArgs());
System.out.println("--------------------------");
}
}
}