九、反射
1、反射功能
- 在运行时获取任意一个对象所属的类型信息，包括修饰符、泛型、父类、实现的接口、注解等；
- 在运行时构造任意一个类的对象；
- 在运行时获取任意一个类所具有的构造方法、成员变量和方法；
- 在运行时访问任意一个对象的成员变量和方法；
2、研究案例
package com;
public class Person {
String id; //非公有成员变量
public String name; //公有成员变量
private int age; //私有成员变量
public Person(){ //公有构造方法
}
private Person(String name,String id){//私有构造方法
this.id = id;
this.name = name;
}
public void show(){ // 公有成员方法
System.out.println(name+":"+age);
}
public void setAge(int num){ //公有成员方法
if(num<100 && num>=9){
age=num;
} else {
System.out.println("不合理");
}
}
private int getAge(){ //私有成员方法
return age;
}
}
案例中构造方法、成员变量与方法有包含私有与公有
3、获取Class实例的三种方法
public static void main(String[] args) throws ClassNotFoundException {
//1、对象.getClass(),通过对象的getClass()函数
Person p =new Person("one");
Class person1 = p.getClass();
//2、类名.class，通过类的class属性
Class person2 = Person.class;
//3、Class.forName()，通过路径字符串
Class person3 = Class.forName("com.Person");
System.out.println(person1);//class com.Person
System.out.println(person2);//class com.Person
System.out.println(person3);//class com.Person
System.out.println((person1==person2 )+"," + (person1 ==person3));//true,true
}
通过这三种方式获取到的 Class 对象是同一个，即 Java 运行时，每一个类只会生成一个 Class 对象。
4、获取类的成员变量的四种方式
需要先import java.lang.reflect.Field;
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
Class person2 = Person.class;
// 1.根据名字获取类中定义的成员变量，不包括继承父类的成员，可以为公有变量和私有变量
// public Field getDeclaredField(String name)
Field filed00 = person2.getDeclaredField("id"); //java.lang.String com.Person.id
Field filed01 = person2.getDeclaredField("name");//public java.lang.String com.Person.name
Field filed02 = person2.getDeclaredField("age");//private int com.Person.age
// 2.根据名字获取类中定义的公有成员变量，包括继承父类的成员
// public Field getField(String name)
Field filed10 = person2.getField("name");//public java.lang.String com.Person.name
// Field filed11 = person2.getField("id");//不可以获取，非公有变量，age为私有也不可以获取
// 3.获取类所有成员变量，返回Field[]类型，不含继承父类的成员
// public Field[] getDeclaredFields()
Field[] filed3 =person2.getDeclaredFields();
for (Field field:filed3){ //Field[]列表，内部都是Field对象
System.out.println(field);
}
/* 输出结果，，列表长度为3
java.lang.String com.Person.id
public java.lang.String com.Person.name
private int com.Person.age
*/
// 4.获取类所有公有成员变量，返回Field[]类型
// public Field[] getFields()
Field[] filed4 =person2.getFields();
for (Field field:filed4){ //Field[]列表，内部都是Field对象
System.out.println(field);
}
/* 输出结果，列表长度为1
public java.lang.String com.Person.name
*/
}
5、获取类的成员方法的四种方式
需要先import java.lang.reflect.Method;
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
Class person2 = Person.class;
// 1.根据名字获取类中定义的成员方法，不包括继承父类的成员方法
// public Method getDeclaredMethod(String name,Class<?>... parameterTypes)
Method filed00 = person2.getDeclaredMethod("setAge",int.class); //public void com.Person.setAge(int)
Method filed01 = person2.getDeclaredMethod("show");//public void com.Person.show()
Method filed02 = person2.getDeclaredMethod("getAge");//private int com.Person.getAge()
// 2.根据名字获取类中定义的公有成员方法，包括继承父类的成员方法
// public Method getMethod(String name,Class<?>... parameterTypes)
Method filed10 = person2.getMethod("setAge",int.class);//public void com.Person.setAge(int)
Method filed11 = person2.getMethod("show");//public void com.Person.show()
// Field filed12 = person2.getMethod("getAge");//不可以获取，getAge为私有不可以获取
// 3.获取类中声明的所有成员方法，返回Method[]类型，不含继承父类的成员
// public Method[] getDeclaredMethods()
Method[] method3 =person2.getDeclaredMethods();
for (Method method:method3){
System.out.println(method);
}
/* 输出结果，因为是在com.Person写的主函数，所以包含了主函数
public void com.Person.show()
private int com.Person.getAge()
public void com.Person.setAge(int)
public static void com.Person.main(java.lang.String[]) throws java.lang.ClassNotFoundException,java.lang.NoSuchFieldException,java.lang.NoSuchMethodException
*/
// 4.获取类中声明的所有公有成员方法，返回Method[]类型
// public Method[] getMethods()
Method[] method4 =person2.getMethods();
for (Method method:method4){
System.out.println(method);
}
/* 输出结果，除了类自身公有方法，还获取到了很多 Object 类中的公有方法
public void com.Person.show()
public void com.Person.setAge(int)
public static void com.Person.main(java.lang.String[]) throws java.lang.ClassNotFoundException,java.lang.NoSuchFieldException,java.lang.NoSuchMethodException
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
public final void java.lang.Object.wait() throws java.lang.InterruptedException
public boolean java.lang.Object.equals(java.lang.Object)
public java.lang.String java.lang.Object.toString()
public native int java.lang.Object.hashCode()
public final native java.lang.Class java.lang.Object.getClass()
public final native void java.lang.Object.notify()
public final native void java.lang.Object.notifyAll()
*/
}
注意：Object 是所有 Java 类的父类，所有对象都默认实现了 Object 类的方法，因此getMethods()方法不仅获取到了类自身的公有方法，还会获取到了很多 Object 类中的公有方法，getDeclaredMethods无法获取到父类中的方法。
6、获取类的构造方法的四种方式
首先import java.lang.reflect.Constructor;
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
Class person2 = Person.class;
// 1.根据参数类型列表获取类中定义的构造方法
// public Constructor<T> getDeclaredConstructor(Class<?>… parameterTypes)
Constructor cons00 = person2.getDeclaredConstructor(String.class,String.class); //private com.Person(java.lang.String,java.lang.String)
Constructor cons01 = person2.getDeclaredConstructor();//public com.Person()
// 2.根据参数类型列表获取类中定义的公有构造方法
// public Constructor<T> getConstructor(Class<?>… parameterTypes)
// Constructor cons10 = person2.getConstructor(String.class,String.class); //不可以获取，该构造方法为私有
Constructor cons11 = person2.getConstructor();//public com.Person()
// 3.获取类中声明的所有构造方法，返回Constructor[]类型
// public Constructor<?>[] getDeclaredConstructors()
Constructor[] cons3 =person2.getDeclaredConstructors();
for (Constructor cons:cons3){
System.out.println(cons);
}
/* 输出结果
public com.Person()
private com.Person(java.lang.String,java.lang.String)
*/
// 4.获取类中声明的所有公有构造方法，返回Constructor[]类型
// public Constructor<?>[] getConstructors()
Constructor[] cons4 =person2.getConstructors();
for (Constructor cons:cons4){
System.out.println(cons);
}
/* 输出结果
public com.Person()
*/
}
7、反射应用：创建对象，设置对象属性
常规创建对象：Person p =new Person("one");
常规方式无法设置的情况下才能使用反射
案例：反射获取类的构造方法，构造对象，通过反射访问成员变量和成员方法
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
//1、获取Person类的Class对象
Class personClass = Person.class;
//2.获取构造方法，传入所需参数的类名，多个参数，用','分隔
Constructor personCons = personClass.getDeclaredConstructor(String.class,String.class);
personCons.setAccessible(true); //私有构造方法需要该代码，公有构造方法不需要
// Constructor.newInstance(Object... initargs)可以调用类的任何构造方法，但是需要throws InvocationTargetException异常
Object person = personCons.newInstance("ricardo","001");
// Class.newInstance()只能调用类的无参数的非私有构造方法,需要throws构造方法的异常
Object person1 = personClass.newInstance();
Person p = (Person)personCons.newInstance("rico","002");//实例化对象
//3.获取成员变量并设置成员变量值
Field personField = personClass.getDeclaredField("age");
personField.setAccessible(true); //私有成员变量需要该代码，公有成员变量不需要
personField.set(person,10); //设置person对象的成员变量的age值
Field personField2 = personClass.getDeclaredField("name");
//personField2.setAccessible(true); //公有成员变量不需要
personField2.set(person,"rrr"); //设置person对象的成员变量的name值
//4.获取成员方法，并传入参数
Method personMethod1 = personClass.getDeclaredMethod("getAge");//无参数输入的方法
personMethod1.setAccessible(true);//私有成员方法需要该代码，公有成员方法不需要
Object personAge = personMethod1.invoke(person); //获取年龄,10，返回值为10
Method personMethod2 = personClass.getDeclaredMethod("setAge",int.class);//无参数输入的方法
// personMethod2.setAccessible(true);//公有成员方法不需要
Object personAge2 = personMethod2.invoke(person,12); //设置年龄，使其变为10,无返回值，personAge2为null
Person p1= (Person)person; //将person这一object实例化
System.out.println(p1.age);//12
System.out.println(p1.id);//001
}
注意：如果需要将object实例化，需要采用像Person p1= (Person)person;的语句
反射允许访问私有成员，打破了封装，可能破坏可移植性，避免常规情况下的使用
十、注解
1、定义
- 编译前：为编译器提供编译检查的依据，辅助检查代码错误或抑制检查异常。
- 编译中或发布时：给编译器提供信息生成代码或给其他工具提供信息生成文档等。
- 运行时：在运行过程中提供信息给解释器，辅助程序执行
@注解类型名
2、Override
加在方法前，表示重写父类的方法，如果重写有错误，则报错
class PersonBase{
String id;
public String name ="base";
private int age;
public PersonBase(){
}
private PersonBase(String name,String id){
this.id = id;
this.name = name;
}
public void show(){
System.out.println(name+":"+age);
}
public void setAge(int num){
if(num<100 && num>=9){
age=num;
} else {
System.out.println("不合理");
}
}
private int getAge(){
return age;
}
}
public class Person extends PersonBase{
public String name;
public Person(){ }
@Override
public void show(){ //重写父类方法
super.show(); //base:0
System.out.println(name);//null
System.out.println(super.name);//base
}
//public void show(String str) 由于@存在，会提示其重写失败
public static void main(String[] args) {
Person person = new Person();
person.show();
}
}
3、自定义注解
@interface自定义注解时，自动继承了java.lang.annotation.Annotation接口
public @interface MyTestAnnotation {
注解属性 [default 默认值]
}
4、元注解
注解其他注解，4个标准的meta-annotation类型：
- @Target：Annotation所修饰的对象范围
（1）CONSTRUCTOR:用于描述构造器
（2）FIELD:用于描述域
（3）LOCAL_VARIABLE:用于描述局部变量
（4）METHOD:用于描述方法
（5）PACKAGE:用于描述包
（6）PARAMETER:用于描述参数
（7）TYPE:用于描述类、接口(包括注解类型) 或enum声明 - @Retention：Annotation被保留的时间长短
- @Documented
- @Inherited
案例：
@Target(ElementType.TYPE)
public @interface Table {
}
@Target(ElementType.FIELD)
public @interface NoDBColumn {
}
