Java学习笔记之注解、泛型与反射
尚硅谷JAVA学习视频整理笔记
注解
注解概述
- JDK 5.0开始，JAVA增加了对元数据（MetaData)的支持，也就是Annotation（注解）
- Annotation其实就是代码里的特殊标记，这些标记可以在编译，类加载，运行时被读取，并执行相应的处理。通过使用Annotation，程序员可以在不改变原有逻辑的情况下，在源文件中嵌入一些补充信息。代码分析工具、开发工具和部署工具可以通过这些补充信息进行验证和部署。
- Annotation可以像修饰符一样被使用，可用于修饰包，类，构造器，方法，成员变量，参数，局部变量的声明，这些信息被保存在Annotation的"name=value"对中。
- 在JavaSE中，注解的使用目的比较简单，例如标记过时的功能， 忽略警告等。在JavaEE/Android中注解占据了更重要的角色，例如 用来配置应用程序的任何切面，代替JavaEE旧版中所遗留的繁冗 代码和XML配置等
- 框架=注解+反射+设计模式
注解的使用示例
- 示例一：生成文档相关的注解
- @author 标明开发该类模块的作者，多个作者之间使用,分割
- @version 标明该类模块的版本
- @param 对方法中某参数的说明，如果没有参数就不能写
- @return 对方法返回值的说明，如果方法的返回值类型是void就不能写
- …
- 示例二：在编译时进行格式检查
- @Override: 限定重写父类方法, 该注解只能用于方法
- @Deprecated: 用于表示所修饰的元素(类, 方法等)已过时。通常是因为所修饰的结构危险或存在更好的选择
- @SuppressWarnings: 抑制编译器警告
- 示例三：跟踪代码依赖性，实现替代配置文件功能
- @WebServlet:Servlet3.0提供了注解(annotation),使得不再需要在web.xml文件中进行Servlet的部署
- 需要在web.xml中打开对注解的扫描
- @WebServlet:Servlet3.0提供了注解(annotation),使得不再需要在web.xml文件中进行Servlet的部署
自定义注解
- 定义新的Annotation类型使用@interface关键字
- 自定义注解自动继承了java.lang.annotation.Annotation接口
- Annotation 的成员变量在 Annotation 定义中以无参数方法的形式来声明。其 方法名和返回值定义了该成员的名字和类型。我们称为配置参数。类型只能 是八种基本数据类型、String类型、Class类型、enum类型、Annotation类型、 以上所有类型的数组。
- 可以在定义 Annotation 的成员变量时为其指定初始值, 指定成员变量的初始 值可使用 default 关键字
- 如果只有一个参数成员，建议使用参数名为value
- 如果定义的注解含有配置参数，那么使用时必须指定参数值，除非它有默认 值。格式是“参数名 = 参数值”，如果只有一个参数成员，且名称为value， 可以省略“value=”
- 没有成员定义的 Annotation 称为标记; 包含成员变量的 Annotation 称为元数 据 Annotation
注意：自定义注解必须配上注解的信息处理流程（使用反射）才有意义
案例：创建自定义注解，并选择注解类型
public @interface MyAnnotation {
String value();
}
JDK中的元注解
- 元注解：对现有的注解进行解释说明的注解
- JDK5.0提供了4个标准的meta-annotation类型，分别是
-
Retention：指定所修饰的Annotation的生命周期
- SOURCE\CALSS(默认行为)\RUNTIOME
- 只有声明为RUNTIME时，程序可以通过反射获取该注释
-
Target：用于修饰 Annotation 定义, 用于指定被修饰的 Annotation 能用于 修饰哪些程序元素。 @Target 也包含一个名为 value 的成员变量。
- CONSTRUCTOR:用于描述构造器
- FIELD:用于描述域
- LOCAL_VARIABLE:用于描述局部变量
- METHOD:用于描述方法
- PACKAGE:用于描述包
- PARAMETER:用于描述参数
- TYPE:用于描述类、接口（包括注解类型）或enum声明
-
Documented：表示所修饰的注解在被javadoc工具提取成文档
-
Inherited：被它修饰的注解将具有继承性。如果某个类使用了被@Inherited修饰的注解，则其子类将自动具有该注解
-
@Retention和@Target多用于自定义注解中
通过反射获取注解
将在反射中详细讲述
JDK8中注解的新特性
- 可重复注解：可以让注解重复使用
- 使用：
- 1.在MyAnnotation上声明@Repeatable，成员值为MyAnnotation.class
- 2.MyAnnotation的Target和Retention和MyAnnotation相同
- 类型注解：关于元注解@Target的类型参数ElementType枚举值多了两个，JAVA1.8之后，注解可以应用在任何地方
- ElementType.TYPE_PARAMETER 表示该注解能写在类型变量的声明语 句中（如：泛型声明）。
- ElementType.TYPE_USE 表示该注解能写在使用类型的任何语句中。
泛型
泛型概述
- 所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类 型或者是某个方法的返回值及参数类型。这个类型参数将在使用时（例如， 继承或实现这个接口，用这个类型声明变量、创建对象时）确定（即传入实 际的类型参数，也称为类型实参）
- 从JDK1.5以后，Java引入了“参数化类型（Parameterized type）”的概念， 允许我们在创建集合时再指定集合元素的类型，正如：List，这表明 该List只能保存字符串类型的对象。
- JDK1.5改写了集合框架中的全部接口和类，为这些接口、类增加了泛型支持， 从而可以在声明集合变量、创建集合对象时传入类型实参
设计背景
- 集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的 对象，所以在JDK1.5之前只能把元素类型设计为Object，JDK1.5之后使用泛型来 解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于 这个元素如何保存，如何管理等是确定的，因此此时把元素的类型设计成一个 参数，这个类型参数叫做泛型。Collection，List，ArrayList 这个就 是类型参数，即泛型。
为什么要使用泛型
- 解决元素存储的安全性问题，好比商品、药品标签，不会弄错。
- 解决获取数据元素时，需要类型强制转换的问题
- Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生 ClassCastException异常。同时，代码更加简洁、健壮。
集合中使用泛型
- 1.集合接口或集合类在jdk5.0时都修改为带泛型的结构
- 2.在实例化集合类时，可以指明具体的泛型类型
- 3.指明完以后，在集合类或接口中凡是定义类或接口时，内部结构（比如：方法、构造器、属性等）使用到类的泛型的位置，都指定位实例化的泛型类型
- 4.注意点：泛型的类型必须是类，不能是基本数据类型。需要用到基本数据类型的时候，必须使用包装类
- 5.如果实例化时，没有指明泛型的类型，默认类型为java.lang.Object类
在Map中遍历使用
Map<String,Integer> map = new HashMap<String,Integer>();
map.put("Tom1",34);
map.put("Tom2",44);
map.put("Tom3",33);
map.put("Tom4",32);
//添加失败
//map.put(33, "Tom");
Set<Entry<String,Integer>> entrySet = map.entrySet();
//泛型的嵌套
Iterator<Entry<String,Integer>> iterator = entrySet.iterator();
while(iterator.hasNext()){
Entry<String,Integer> entry = iterator.next(); System.out.println(entry.getKey() + "--->" + entry.getValue());
}
自定义泛型结构
包括泛型类、泛型接口;泛型方法
泛型类与泛型接口的区别，就是类与接口的区别
自定义泛型类
泛型类：order
public class Order<T> {
String orderName;
int orderId;
T orderT;
//类的内部结构就可以使用类的泛型
public Order() {
}
public Order(String orderName, int orderId, T orderT) {
this.orderName = orderName;
this.orderId = orderId;
this.orderT = orderT;
}
public String getOrderName() {
return orderName;
}
public void setOrderName(String orderName) {
this.orderName = orderName;
}
public int getOrderId() {
return orderId;
}
public void setOrderId(int orderId) {
this.orderId = orderId;
}
public T getOrderT() {
return orderT;
}
public void setOrderT(T orderT) {
this.orderT = orderT;
}
}
使用泛型类：
@Test
public void test1(){
//如果定义了泛型类，实例化时没有指明类的泛型，则认为此泛型类型为Object类型
//如果定义了类视带泛型的，建议在实例化时要指明类的泛型
//建议：实例化时指明类的泛型
Order<String> order1 = new Order<String>("orderAA",22,"order:orderAA");
order1.setOrderT("AA:hello");
}
还可以通过继承泛型类的同时，指定类的泛型。若没有指定类的泛型，那该子类依然是泛型类
注意
- 1.泛型不同的引用不能相互赋值
- 2.泛型类的构造器如下：public GenericClass(){}。 而下面是错误的：public GenericClass(){}
- 3.泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价 于Object。泛型要使用一路都用。要不用，一路都不要用。
- 4.泛型的指定中不能使用基本数据类型，可以使用包装类替换。
- 5.在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态 属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法 中不能使用类的泛型
- 6.子类除了指定或保留父类的泛型，还可以增加自 己的泛型
自定义泛型方法
方法，也可以被泛型化，不管此时定义在其中的类是不是泛型类。在泛型 方法中可以定义泛型参数，此时，参数的类型就是传入数据的类型。
格式：[访问权限] <泛型> 返回类型 方法名([泛型标识 参数名称]) 抛出的异常
案例：
//泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系
//泛型方法所属的类是不是泛型类都没有关系
//泛型方法，可以声明为静态的，原因：泛型参数是在调用方法时确定的，并非实例化类时确定
public <E> List<E> copyFromArrayToList(E[] arr){
ArrayList<E> list = new ArrayList<>();
for(E e:arr){
list.add(e);
}
return list;
}
测试
//测试泛型方法
@Test
public void test2(){
Order<String> order = new Order<>();
Integer[] arr = new Integer[]{1,2,3,4,5};
//泛型方法在调用时，指明泛型的类型
List<Integer> list = order.copyFromArrayToList(arr);
System.out.println(list);
}
通配符的使用
- 通配符：? 如：List<?>是List,List等各种泛型List的父类
- 读取List<?>的对象list中的元素时，永远是安全的，因为不管list的真实类型 是什么，它包含的都是Object
- 写入list中的元素时，不行。因为我们不知道c的元素类型，我们不能向其中 添加对象
- 唯一的例外是null，它是所有类型的成员。
- 案例：
List<?> list = null;
list = new ArrayList<String>();
list = new ArrayList<Double>();
// list.add(3);//编译不通过,不知道元素类型，不能添加对象
list.add(null);//null是所有类型的成员
List<String> l1 = new ArrayList<String>();
List<Integer> l2 = new ArrayList<Integer>();
l1.add("java");
l2.add(15);
注意点：
1.编译错误：不能用在泛型方法声明上，返回值类型前面<>不能使用?
2.编译错误：不能用在泛型类的声明上
3.编译错误：不能用在创建对象上，右边属于创建集合对象
有限制条件的通配符的使用
- <?> 允许所有泛型的引用调用
- 通配符指定上限:上限extends：使用时指定的类型必须是继承某个类，或者实现某个接口，即<=
- 通配符指定下限:下限super：使用时指定的类型不能小于操作的类，即>=
- 举例：
- <? extends Number> (无穷小 , Number] 只允许泛型为Number及Number子类的引用调用 * ? extends A: * G<? extends A> 可以作为G和G的父类，其中，B是A的子类
- <? super Number> [Number , 无穷大) 只允许泛型为Number及Number父类的引用调用 * ? super A: * G<? super A> 可以作为G和G的父类，其中，B是A的父类
- <? extends Comparable> 只允许泛型为实现Comparable接口的实现类的引用调用
案例
//Student继承自Person类
List<? extends Person> list1 = null;
List<? super PErson> list2 =null;
List<Student> list3 = null;
List<Person> list4 = null;
List<Object> list5 = null;
//? extends A:
//G<? extends A> 可以作为G<A>和G<B>的父类，其中，B是A的子类
list1 = list3;
list1 = list4;
//list1 = list5; 编译不通过
//? super A:
//G<? super A> 可以作为G<A>和G<B>的父类，其中，B是A的父类
//list2 = list3; 编译不通过
list2 = list4;
list2 = list5;
反射
反射概述
动态语言：是一类在运行时可以改变其机构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或其他结构上的变化。也就是在运行时代码可以根据某些条件改变自身结构，例如Object-C、C#,JavaScript,PHP,Python
静态语言：运行时结构不可变的语言就是静态语言，如Java，C
java不是动态语言，但java可以称之为“准动态语言”。即Java有一定的动 态性，我们可以利用反射机制、字节码操作获得类似动态语言的特性。
反射概念
- 反射（Reflection）被视为动态语言的关键，反射机制运行程序在执行期间借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法
- 加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射
反射机制提供的功能
- 在运行时判断任意一个对象所属的类
- 在运行时构造任意一个类的对象
- 在运行时判断任意一个类所具有的成员变量和方法
- 在运行是获取泛型信息
- 在运行时调用任意一个对象的成员变量和方法
- 在运行时处理注解
- 生成动态代理
反射主要的API
- java.lang.Class:代表一个类
- java.lang.reflect.Method:代表类的方法
- java.lang.reflect.Field:代表类的成员变量
- java.lang.reflect.Constructor:代表类的构造器
- …
案例：创建实体类Person
public class Person {
private int id;
private String name;
int age;
public void show(){
System.out.println("Hello world");
}
public String getResp(String str){
return "Hello "+str;
}
public Person() {
}
private Person(int id){
this.id =id;
}
public Person(int id, String name) {
this.id = id;
this.name = name;
}
@Override
public String toString() {
return "Person{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
'}';
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
创建反射测试
//反射之前，对于Person的操作
@Test
public void test1(){
//1.创建Person类的对象
Person p1 = new Person(1,"Jack");
//2.通过对象，调用其内部的属性方法
p1.age=20;
System.out.println(p1.toString());
p1.show();//输出Hello world
//在person类外部，不可以通过Person类的对象调用其私有的方法，属性，构造器
//比如 name,getResp（） 以及私有构造器
}
//反射之后，对于Person的操作
@Test
public void test2() throws Exception {
Class clazz = Person.class;
//通过反射，创建Person类的对象
Constructor cons = clazz.getConstructor(int.class,String.class);
Object obj = cons.newInstance(2,"Rick");
System.out.println(obj.toString());
Person p = (Person) obj;
//通过反射，获得对象指定的属性、方法
//调用属性
Field age = clazz.getDeclaredField("age");
age.set(p,22);
System.out.println(p.toString());
//调用方法
Method show=clazz.getDeclaredMethod("show");
show.invoke(p);
//通过反射，获得对象私有的属性、方法、构造器
//调用私有的构造方法
Constructor cons1 = clazz.getDeclaredConstructor(int.class);
cons1.setAccessible(true);
Person p1 = (Person) cons1.newInstance(3);
System.out.println(p1);//输出：Person{id=3, name='null', age=0}
//调用私有的属性
Field name = clazz.getDeclaredField("name");
name.setAccessible(true);
name.set(p1,"Motty");
System.out.println(p1);//输出：Person{id=3, name='Motty', age=0}
//调用私有的方法
Method getResp = clazz.getDeclaredMethod("getResp",String.class);
getResp.setAccessible(true);
String resp = (String) getResp.invoke(p1,"java");
System.out.println(resp);//输出：Hello java
}
关于java.lang.Class类的理解
-
1.类的加载过程
- 程序经过javac.exe命令以后，会生成一个或多个字节码文件（.class结尾）。
- 接着我们使用java.exe命令对某个字节码文件进行解释运行。相当于将某个字节码文件加载到内存中。此过程就称为类的加载。加载到内存中的类，就称为运行时类，此运行时类，就作为Class的一个实例
-
2.也就是说，class的实例就对应着一个运行时类
-
3.加载到内存中的运行时类，会缓存一定的时间。在此时间之内，我们可以通过不同的方式类获取此运行时类
-
4.获取的实例是同一个
-
5.可以获取Class对象的类型
- class:外部类，成员（成员内部类，静态内部类），局部内部类，匿名内部类
- interface：接口
- []：数组
- enum：枚举
- annotation：注解@interface
- primitive type：基本数据类型
- void
-
实例：
//获取class的实例的方式
@Test
public void test3() throws ClassNotFoundException {
//方式一：调用运行时类的属性：.class
Class<Person> class1 = Person.class;
System.out.println(class1);//输出：class reflect.Person
//方式二：通过运行时类的对象,调用getClass()
Person p1 = new Person();
Class clazz2 = p1.getClass();
System.out.println(clazz2);//输出：class reflect.Person
//方式三：调用Class的静态方法：forName(String classPath)(常用）
Class clazz3 = Class.forName("reflect.Person");
System.out.println(clazz3);//输出：class reflect.Person
//方式四：使用类加载器ClassLoader(了解)
ClassLoader classLoader = ReflectionTest.class.getClassLoader();
Class clazz4 = classLoader.loadClass("reflect.Person");
System.out.println(clazz4);//输出：class reflect.Person
//Class的类型
Class c1 = Object.class;
Class c2 = Comparable.class;
Class c3 = String[].class;
Class c4 = int[][].class;
Class c5 = ElementType.class;
Class c6 = Override.class;
Class c7 = int.class;
Class c8 = void.class;
Class c9 = Class.class
}
反射的使用
创建运行时类的对象
-
1.调用Class对象的newInstance()方法
Class<Person> clazz = Class.forName("reflect.Person"); /** * newInstance():调用 * 要想此方法正常的创建运行时类的对象，要求： * 1.运行时类必须提供空参的构造器 * 2.空参的构造器的访问权限得够。通常，设置为public * * 在javabean中要求提供一个public的空参构造器，原因： * 1.便于通过反射，创建运行时类的对象 * 2.便于子类继承此运行时类时，默认调用super()时，保证父类有此构造器 */ Person obj = clazz.newInstance(); System.out.println(obj); -
2.没有无参构造器时，可以通过Class类的getDeclaredConstructor(Class … prarmeterTypes)取得本类的指定形参类型的构造器，想构造器的形参中传递一个对象数组进去，里面包含了构造器所需的各个参数，通过Constructor实例化对象
Class<Person> clazz = Class.forName("reflect.Person") Constructor cons = clazz.getDeclaredConstructor(int.class); cons1.setAccessible(true); Person p1 = (Person) cons1.newInstance(3);
获取运行时类的完整结构
实现的全部接口，所继承的父类，全部的构造器，全部的方法，全部的Field
- 1.准备完整的工具类等
创建父类Creature
public class Creature<T> implements Serializable {
private char gender;
public double weight;
private void breath(){
System.out.println("呼吸");
}
public void eat(){
System.out.println("吃饭");
}
}
创建自定义接口MyInterface
public interface MyInterface {
void info();
}
创建自定义注解MyAnnotation
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
String value() default "hello";
}
继承父类Creature的Person子类
@MyAnnotation(value = "hello")
public class Person extends Creature<String> implements Comparable<String>,MyInterface{
private String name;
int age;
public int id;
public Person(){}
private Person(String name){
this.name =name;
}
Person(String name,int age){
this.name =name;
this.age =age;
}
@MyAnnotation(value = "world")
private String show(String info){
System.out.println("你好,"+info);
return info;
}
public String display(String intst){
return intst;
}
@Override
public int compareTo(String o) {
return 0;
}
@Override
public void info() {
System.out.println("人类");
}
}
- 2.获取运行时类的属性结构及其内部结构（了解）
Class clazz =Class.forName("reflact.Person");
//获取属性结构
//getFields():获取当前类及其父类中声明为public访问权限的属性
Field[] fields = clazz.getFields();
for(Field f :fields){
System.out.println(f);//输出：public int cn.aixuxi.reflact.Person.id public double cn.aixuxi.reflact.Creature.weight
}
System.out.println();
//getDeclaredFields():获取当前运行时类中声明的所有属性（不包括父类中声明的属性）
Field[] declaredFields = clazz.getDeclaredFields();
for (Field f:declaredFields){
System.out.println(f);
}
//获取权限修饰符、数据类型、变量名
Field[] declaredFields1 = clazz.getDeclaredFields();
for (Field f:declaredFields1){
//获取权限修饰符
int modifier=f.getModifiers();
System.out.println(Modifier.toString(modifier));
//获取数据类型
Class type = f.getType();
System.out.println(type);
//获取变量名
String fname =f.getName();
System.out.println(fname);
}
- 3.获取运行时类的方法结构及其内部结构（了解）
Class clazz =Class.forName("reflact.Person");
//getMethods():获取当前运行时类及其所有父类中声明为public权限的方法
Method[] methods = clazz.getMethods();
for (Method m :methods){
System.out.println(m);
}
System.out.println("====================");
//getDeclaredMethods():获取当前运行时类声明的所有方法（不包括父类中声明的方法）
Method[] declaredMethods = clazz.getDeclaredMethods();
for (Method m:declaredMethods){
System.out.println(m);
}
//获取方法权限修饰符、返回值类型、方法名(参数类型1 形参名1,........) throws xxxxxx{}
Method[] declaredMethods1 = clazz.getDeclaredMethods();
for (Method m:declaredMethods1){
//1.获得方法的注解
Annotation[] annos = m.getAnnotations();
for (Annotation a:annos){
System.out.println(a);
}
//2.获得每一个方法的权限修饰符
System.out.println(Modifier.toString(m.getModifiers()));
//3.获得返回值类型
System.out.println(m.getReturnType().getName());
//4.获得方法名
System.out.println(m.getName());
System.out.println("(");
//5.获得形参列表
Class[] parameterTypes = m.getParameterTypes();
if(!(parameterTypes ==null && parameterTypes.length ==0)) {
for (int i=0;i<parameterTypes.length;i++){
System.out.println(parameterTypes[i].getName()+"args_"+i);
}
}
System.out.println(")");
//6.获得抛出的异常
Class<?>[] exceptionTypes = m.getExceptionTypes();
if (!(exceptionTypes==null && exceptionTypes.length==0)){
System.out.println("throws");
for (int i = 0; i <exceptionTypes.length ; i++) {
if (i == exceptionTypes.length-1){
System.out.println(exceptionTypes[i].getName());
break;
}
System.out.println(exceptionTypes[i].getName()+",");
}
}
}
- 4.获取运行时类的构造器
Class clazz =Class.forName("reflact.Person");
//getConstructors():获取当前运行时类声明为public的构造器
Constructor[] constructors = clazz.getConstructors();
for(Constructor c:constructors){
System.out.println(c);
}
//getDeclaredConstructors():获取当前运行时类中声明的所有的构造器
Constructor[] declaredConstructors=clazz.getDeclaredConstructors();
for (Constructor c:declaredConstructors){
System.out.println(c);
}
- 5.获取运行时类的完整结构
Class clazz =Class.forName("reflact.Person");
//获取运行时类的父类
Class superClass = clazz.getSuperclass();
System.out.println(superClass);
//获取运行时类的带泛型的父类
Type genericSuperclass = clazz.getGenericSuperclass();
System.out.println(genericSuperclass);
//获取运行时类的带泛型的父类的泛型
ParameterizedType type = (ParameterizedType) genericSuperclass;
//获取泛型类型
Type[] actualTypeArguments = type.getActualTypeArguments();
for(Type t:actualTypeArguments){
System.out.println(t.getTypeName());
}
//获取运行时类实现的接口
Class[] interfaces = clazz.getInterfaces();
for (Class c:interfaces){
System.out.println(c);
}
//获取运行时类的父类实现的接口
Class[] interfaces1 = clazz.getSuperclass().getInterfaces();
for (Class c:interfaces1){
System.out.println(c);
}
//获取运行时类所在的包
Package aPackage = clazz.getPackage();
System.out.println(aPackage);
//获取运行时类的注解
Annotation[] annotations = clazz.getAnnotations();
for (Annotation a:annotations){
System.out.println(a);//输出@reflact.MyAnnotation(value=hello)
}
调用运行时类的指定结构
调用运行时类的属性、方法、构造器
-
1.调用运行时类的属性
-
方式一：只能获取运行时类中声明为public的属性，不建议使用
//调用运行时类中指定的属性 Class clazz =Class.forName("reflact.Person"); //创建运行时类的对象 Person p = (Person)clazz.newInstance(); //获取指定的属性:要求运行时类中声明为public Field id = clazz.getField("id"); /** * 设置当前属性的值 * set():参数1：指明设置哪个属性的对象 参数2：将此属性值设为多少 */ id.set(p,1001); /** * 获取当前属性的值 * get():参数1：获取哪个对象的当前属性值 */ int pid = (int) id.get(p); System.out.println(pid); -
方式二：重要，建议掌握
//调用运行时类中指定的属性 Class clazz =Class.forName("reflact.Person"); //创建运行时类的对象 Person p = (Person)clazz.newInstance(); //getDeclaredField(String name):获取运行时类指定的变量名的属性 Field name = clazz.getDeclaredField("name"); //保证当前属性时可访问的 name.setAccessible(true); //获取设置指定对象的此属性值 name.set(p,"Tom"); System.out.println(name.get(p));
-
-
2.调用运行时类指定的方法
//操作运行时类的指定方法 Class clazz =Class.forName("reflact.Person"); //创建运行时类的对象 Person p = (Person)clazz.newInstance(); /**获取指定的方法 * getDeclaredMethod():参数1：指明获取的方法名称 参数2：指明获取的方法的形参列表 */ Method show = clazz.getDeclaredMethod("show", String.class); //保证当前方法是可访问的 show.setAccessible(true); /** * 调用方法 * invoke():参数1：方法的调用者 参数2：给方法形参赋值的实参 * invoke()的返回值即视为对应类中调用方法的方绘制 */ Object object=show.invoke(p,"JAVA");//输出：你好,JAVA System.out.println(object); System.out.println("============="); //调用静态方法 Method showDesc = clazz.getDeclaredMethod("showDesc"); showDesc.setAccessible(true); //如果调用的运行时类中的方法没有返回值，则此invoke()返回null Object invoke = showDesc.invoke(Person.class); System.out.println(invoke);//null -
3.调用运行时类的指定构造器
Class clazz =Class.forName("reflact.Person"); //private Person(String name) /**获取指定的构造器 * getDeclaredConstructor():参数：指明构造器的参数列表 */ Constructor constructor = clazz.getDeclaredConstructor(String.class); //保证此构造器是可以访问的 constructor.setAccessible(true); //调用此构造器创建运行时类的对象 Person p = (Person) constructor.newInstance("Tom"); System.out.println(p);
扫一扫
353
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
