一、注解
1.1什么是注解
Annotation 是从JDK5.0开始引入的新技术 。
- 作用:
(1)不是程序本身 , 可以对程序作出解释.(这一点和注释(comment)没什么区别)
(2)可以被其他程序(比如:编译器等)读取. - 使用范围:
(1)可以附加在package , class , method , field 等上面 , 相当于给他们添加了额外的辅助信息
(2)我们可以通过反射机制实现对这些元数据的访问
1.1.1注解的源码定义格式
查看注解的源代码,注解定义格式
1.2内置注解
-
@Override
定义在 java.lang.Override 中 , 此注释只适用于修辞方法 , 表示一个方法声明打算重写超类中的另一个方法声明. -
@Deprecated
定义在java.lang.Deprecated中 , 此注释可以用于修辞方法 , 属性 , 类 ,
表示不鼓励程序员使用这样的元素 , 通常是因为它很危险或者存在更好的选择 . -
@SuppressWarnings(镇压警告)
定义在java.lang.SuppressWarnings中,用来抑制编译时的警告信息.
与前两个注释有所不同,你需要添加一个参数才能正确使用,这些参数都是已经定义好了的,我们
选择性的使用就好了 .
@SuppressWarnings(“all”)
@SuppressWarnings(“unchecked”)
@SuppressWarnings(value={“unchecked”,“deprecation”})
等等 …
1.3元注解
元注解的作用就是负责注解其他注解 , Java定义了4个标准的meta-annotation类型,他们被用来提供对其他annotation类型作说明 .
- Java定义了4个标准的元注解:( @Target , @Retention , @Documented , @Inherited )
(1)@Target : 用于描述注解的使用范围(即:被描述的注解可以用在什么地方)
(2)@Retention : 表示需要在什么级别保存该注释信息 , 用于描述注解的生命周期 (SOURCE(源码中有效) < CLASS(在Class文件中仍然有效) < RUNTIME(运行时还有效))
(3)@Document:说明该注解将被包含在javadoc中
(4)@Inherited:说明子类可以继承父类中的该注解
1.4自定义注解
package JavaSE注解反射;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* @author Pengwei Qu
* @Date 2024/8/24 14:08
*/
public class MyAnnotation02 {
public static void main(String[] args) {
}
//定义一个测试方法
@MyAnnotation(name = "QPW")
public static void test(){
System.out.println("这是测试方法");
}
/*自定义注解*/
/*格式:
元注解
* @interface 注解名{参数类型1 参数名1();参数类型2 参数名() defaulr 默认值;参数类型3 数组();
}*/
@Target(ElementType.METHOD)//元注解用来限定其使用的对象Method:方法
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation{
String name();
String[] arr() default {"Chian","Beijing"};//设置了默认值,当给方法加MyAnnotation注解时,arr数组可以不用手动写值
}
@MyAnnotation2("测试")
public static void test01(){
System.out.println("第二个测试方法");
}
@Target(ElementType.METHOD)//元注解用来限定其使用的对象Method:方法
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation2{
String value();//当注解只有一个参数值时,一般用value()来,使用该注解的方法参数可以不用写成:参数名=“”,
// 直接输入参数值即可
}
}
二、反射 Reflection
//1. 创建一个实体类
class User{
private int id;
private int age;
private String name;
public User() {
}
public User(int id, int age, String name) {
this.id = id;
this.age = age;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", age=" + age +
", name='" + name + '\'' +
'}';
}
}
2.1反射机制概述
2.1.1动态语言/静态语言
- 动态语言:
是一类在运行时可以改变其结构的语言:例如新的函数、对象、甚至代码可以被引进,已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。 - 主要动态语言:Object-C、C#、JavaScript、PHP、Python等。
//体现动态语言的代码
function test() {
var x = "var a=3;var b=5;alert(a+b)";
//x只是一个字符串
//调用下面的方法,其功能时执行x,运行时执行x,使得x的结果变成类:8
eval(x);
}
- 静态语言
与动态语言相对应的,运行时结构不可变的语言就是静态语言。如Java、C、C++。
Java不是动态语言,但Java可以称之为“准动态语言”。即Java有一定的动态性,我们可以利用反射机制获得类似动态语言的特性。Java的动态性让编程的时候更加灵活!
2.2理解Class类并获取Class实例
Reflection(反射)是Java被视为动态语言的关键,反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息,并能直接操作任意对象的内部属性及方法。
Class c = Class.forName("java.lang.String")
加载完类之后,在堆内存的方法区中就产生了一个Class类型的对象(一个类只有一个Class对象),这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子,透过这个镜子看到类的结构,所以,我们形象的称之为:反射
2.2.1反射相关的API
//测试各种类型获得Class对象的方式
public class Test3 {
public static void main(String[] args) throws ClassNotFoundException {
Person person = new Student();
System.out.println("这个人是:"+person.name);
//获得class办法一:通过对象获得
Class clazz1 = person.getClass();
//获得class办法二:通过字符串获得(包名+类名)
Class clazz2 = Class.forName("com.reflection.Student");
//获得class办法三:通过类的静态成员class获得
Class clazz3 = Person.class;
//获得class办法四:只针对内置的基本数据类型
Class clazz4 = Integer.TYPE;
//获得父类类型
Class clazz5 = clazz2.getSuperclass();
System.out.println(clazz1);
System.out.println(clazz2);
System.out.println(clazz3);
System.out.println(clazz4);
System.out.println(clazz5);
}
}
class Person {
public String name;
public Person() {
}
public Person(String name) {
this.name = name;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
'}';
}
}
class Student extends Person{
public Student(){
this.name = "学生";
}
}
class Teacher extends Person{
public Teacher(){
this.name = "老师";
}
}
2.3类加载与ClassLoder
2.4创建运行时类的对象
通过反射获取运行时类的完整结构
Field(字段)、Method、Constructor、Superclass、Interface、Annotation(注解)
实现的全部接口
所继承的父类
全部的构造器
全部的方法
全部的Field
注解
。。。
package JavaSE_Reflection;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/**
* @author Pengwei Qu
* @Date 2024/8/24 15:50
*/
public class Reflection03 {
//获取类对象中的内容
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
//01获取Class对象
Class aClass = Class.forName("JavaSE_Reflection.User");
//02获取类的属性
Field[] fields = aClass.getFields();//只能找到public类型的属性
for (Field field : fields) {
System.out.println(field);
}
System.out.println("------------------getDeclaredFields--------------");
Field[] declaredFields = aClass.getDeclaredFields();//可以获取所有类型的属性
for (Field declaredField : declaredFields) {
System.out.println(declaredField);
}
//03获取指定属性
Field id = aClass.getDeclaredField("id");
//04获取方法
System.out.println("========================================================");
Method[] methods = aClass.getMethods();//获取本类和父类的所有public方法
for (Method method : methods) {
System.out.println(method);
}
System.out.println("------------------------getDeclaredMethods()---------------------------------");
Method[] declaredMethods = aClass.getDeclaredMethods();//只获取本类所有的方法
for (Method declaredMethod : declaredMethods) {
System.out.println(declaredMethod);
}
//获取指定方法
Method getAge = aClass.getDeclaredMethod("getAge", null);
Method setAge = aClass.getDeclaredMethod("setAge", int.class);//参数类型时int类型
System.out.println("获取指定的方法"+getAge);
System.out.println("获取指定的方法"+setAge);
System.out.println("============================构造器============================");
//05获取构造器
Constructor[] constructors = aClass.getConstructors();//获取public类型的构造器
for (Constructor constructor : constructors) {
System.out.println(constructor);
}
Constructor[] declaredConstructors = aClass.getDeclaredConstructors();
}
}
2.5动态创建对象
2.5.1通过Class对象的newInstance创建对象
- 创建类的对象:调用Class对象的newInstance()方法
类必须有一个无参数的构造器。
类的构造器的访问权限需要足够
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
//01获取Class对象
Class c1 = Class.forName("JavaSE_Reflection.User");
//02通过newInstance()创建对象,但是前提保证User类中存在无参构造
User user01 = (User) c1.newInstance();
System.out.println(user01);
/*有时我们自己定义的类,会定义有参构造,会把无参构造给覆盖,无法使用newInstance创建对象*/
//03通过获取指定有参构造创建对象
//先获取有参构造
Constructor constructor = c1.getDeclaredConstructor(int.class, int.class, String.class);
User user = (User) constructor.newInstance(001, 23, "Jack");
System.out.println(user);
}
2.5.2操作方法,属性
- 反射调用方法
//01获取Class对象
Class c1 = Class.forName("JavaSE_Reflection.User");
//02通过newInstance()创建对象,但是前提保证User类中存在无参构造
User user01 = (User) c1.newInstance();
//03通过反射调用普通方法
Method setName = c1.getDeclaredMethod("setName", String.class);//获取方法对象
/*invok(对象,"方法的值”):激活的意思*/
setName.invoke(user01,"Jack");
System.out.println(user01.getName());
- 对属性赋值报错:由于属性定义的时私有的不能直接赋值,赋值之前需要使用
name.setAccessible(true);
//04操作属性
Class c1 = Class.forName("JavaSE_Reflection.User");
User user02 = (User) c1.newInstance();
//获取属性
Field name = c1.getDeclaredField("name");
//赋值操作
name.set(user02,"Tom");
System.out.println(user02.getName());
Exception in thread “main” java.lang.IllegalAccessException: Class JavaSE_Reflection.Reflection05 can not access a member of class JavaSE_Reflection.User with modifiers “private”
2.6获取泛型信息
Java采用泛型擦除的机制来引入泛型 , Java中的泛型仅仅是给编译器javac使用的,确保数据的安全性和免去强制类型转换问题 , 但是 , 一旦编译完成 , 所有和泛型有关的类型全部擦除为了通过反射操作这些类型 , Java新增了 ParameterizedType ,GenericArrayType , TypeVariable 和 WildcardType 几种类型来代表不能被归一到
Class类中的类型但是又和原始类型齐名的类型.
ParameterizedType : 表示一种参数化类型,比如Collection
GenericArrayType : 表示一种元素类型是参数化类型或者类型变量的数组类型
TypeVariable : 是各种类型变量的公共父接口
WildcardType : 代表一种通配符类型表达式
2.7反射读取注解
package JavaSE_Reflection;
import java.lang.annotation.*;
import java.lang.reflect.Field;
/**
* @author Pengwei Qu
* @Date 2024/8/24 20:01
*/
//反射操作注解
public class Reflection06 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
//01通过反射获取Class对象
Class c1 = Class.forName("JavaSE_Reflection.Student2");
//02通过反射获取注解
Annotation[] annotations = c1.getAnnotations();
for (Annotation annotation : annotations) {
System.out.println("获取到的注解:"+annotation);
//得到的只是最外层类的注解:
//获取到的注解:@JavaSE_Reflection.AnnotationTable(value=db_Student)
}
//03获取注解value的值
AnnotationTable annotationTable = (AnnotationTable)c1.getAnnotation(AnnotationTable.class);
String value = annotationTable.value();
System.out.println(value);
//04获取类指定的注解
Field declaredField = c1.getDeclaredField("name");
AnnotationField annotation = declaredField.getAnnotation(AnnotationField.class);
System.out.println(annotation.ColumnName());
System.out.println(annotation.Type());
System.out.println(annotation.length());
}
}
@AnnotationTable("db_Student")
class Student2{
@AnnotationField(ColumnName = "db_id",Type = "int",length = 10)
private String name;
@AnnotationField(ColumnName = "db_id",Type = "int",length = 10)
private int age;
@AnnotationField(ColumnName = "db_id",Type = "int",length = 10)
private String Sex;
public Student2(String name, int age, String sex) {
this.name = name;
this.age = age;
Sex = sex;
}
public Student2() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getSex() {
return Sex;
}
public void setSex(String sex) {
Sex = sex;
}
}
//01自定义类注解
@Target(ElementType.TYPE)//作用于类上
@Retention(RetentionPolicy.RUNTIME)
@interface AnnotationTable {
String value();
}
//02属性的注解
@Target(ElementType.FIELD)//作用于属性上
@Retention(RetentionPolicy.RUNTIME)
@interface AnnotationField{
String ColumnName();//列名
String Type();//类型
int length();
}