闲话
今天去打了第三针疫苗，我感觉我又被强化了
一、注解
1、注解的含义
Java 注解（Annotation）又称 Java 标注，是 JDK5.0 引入的一种注释机制
2、注解的三大分类
-
内置注解
例如：
@Override - 检查该方法是否是重写方法
@Deprecated - 标记过时方法，如果使用该方法，会报编译警告
@SuppressWarnings - 指示编译器忽略注解中的声明的警告 -
元注解：负责注解其他注解
@Target：描述此注解可以被使用在什么地方，比如说是类上还是方法上
@Retention：描述此注解的有效范围，用来描述注解的生命周期
（SOURCE<CLASS<RUNTIME，默认RUNTIME级别）
@DOCUMENT：表示该注解是否将会保存在Javadoc中
@Inherited：说明子类可以继承父类中的该注解 -
自定义注解
使用@interface自定义注解，自动继承了java.lang.annotation.Annotation接口
注解参数的定义格式：参数类型 + 参数名();
注解只有一个参数时，参数名默认使用value，这样使用参数时，就可以默认不写参数名，直接写值
注解可以显示赋值，如果没有默认值的情况下，就必须给注解赋值
如果注解的默认值为-1，那么代表此注解不存在
自定义注解如下
package com.decade.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
// 注解可以显式赋值，如果不赋值，那就使用默认值，没有默认值的必须显式赋值
@MyAnnotation(name = "十年", age = 24)
public class CustomAnnotation {
@MyValue(name = "db_name", type = "java.lang.String", desc = "名字")
private String name;
public CustomAnnotation() {
}
public CustomAnnotation(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "CustomAnnotation{"
+ "name='" + name + '\''
+ '}';
}
public void test() {
}
}
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation {
String name() default "";
// 如果默认值为-1，则代表此注解不存在
int age() default -1;
String[] hobbies() default {"音乐", "篮球"};
}
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyValue {
String name();
String desc();
String type();
}
二、反射
1、反射机制
JAVA反射机制是在运行状态中，对于任意一个实体类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制
reflection是Java被视为动态语言的关键，反射机制允许程序在执行期借助于reflection API取得任何类的内部信息，并且能直接操作任意对象的内部属性和方法
Class cla = Class.forName("java.lang.String");
正常方式：引入需要的包名------->通过new实例化对象----->通过实例化对象，调用对象的方法
反射方式：实例化对象------->getClass()方法----->得到完整的"包类"名称
2、获取反射对象
反射相关的主要API：java.lang.Class类，可以理解为用来描述类的类
一个类在一个内存中只有一个Class对象
一个类被加载后，整个类都会被封装在Class对象中
package com.decade.reflection;
public class ReflectionDemo01 {
public static void main(String[] args) throws ClassNotFoundException {
//通过反射获取类的Class对象
Class c1 = Class.forName("com.decade.reflection.testReflection");
System.out.println(c1);
Class c2 = Class.forName("com.decade.reflection.testReflection");
Class c3 = Class.forName("com.decade.reflection.testReflection");
//一个类在一个内存中只有一个Class对象
//一个类被加载后，整个类都会被封装在Class对象中
System.out.println(c2.hashCode());
System.out.println(c3.hashCode());
}
}
class testReflection {
private String name;
private String email;
private int age;
public testReflection() {
}
public testReflection(String name, String email, int age) {
this.name = name;
this.email = email;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "testReflection{"
+ "name='" + name + '\''
+ ", email='" + email + '\''
+ ", age=" + age
+ '}';
}
}
3、获得Class类的几种方式
- 若已知具体的类，可以通过类的class的属性获取，该方法最安全可靠，程序性能最高
Class cla = Person.class; - 若已知某个类的实例，可以使用该实例的getClass()方法获取Class对象
Class cla = person.getClass(); - 如果知道一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException
Class cla = Class.forName("java.lang.String")； - 内置基本数据类型可以直接用 类名 .Type
- 可以用ClassLoader
package com.decade.reflection;
public class ReflectionDemo02 {
public static void main(String[] args) throws ClassNotFoundException {
Person person = new Student();
System.out.println("这个人是：" + person.name);
//通过对象获得
Class c1 = person.getClass();
System.out.println(c1);
//通过forName获得
Class<?> c2 = Class.forName("com.decade.reflection.Student");
System.out.println(c2.hashCode());
//通过类名.class获得
Class c3 = Student.class;
System.out.println(c3.hashCode());
//基本数据类型的包装类都有一个Type属性
Class c4 = Integer.TYPE;
System.out.println(c4);
//获得父类型
Class c5 = c1.getSuperclass();
System.out.println(c5);
}
}
class Person {
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 = "老师";
}
}
运行结果如下
4、所有类型的class对象
注意：只要类型和维度一样，通过对象获取到的Class就是同一个
package com.decade.reflection;
import java.lang.annotation.ElementType;
public class ReflectionDemo03 {
public static void main(String[] args) {
// 类
Class c1 = Object.class;
// 接口
Class c2 = Comparable.class;
// 一维数组
Class c3 = int[].class;
// 二维数组
Class c4 = int[][].class;
// 注解
Class c5 = Override.class;
// 枚举类
Class c6 = ElementType.class;
// 基本数据类型
Class c7 = Integer.class;
// void
Class c8 = void.class;
// Class
Class c9 = Class.class;
System.out.println(c1);
System.out.println(c2);
System.out.println(c3);
System.out.println(c4);
System.out.println(c5);
System.out.println(c6);
System.out.println(c7);
System.out.println(c8);
System.out.println(c9);
System.out.println("========================");
// 只要类型和维度一样，通过对象获取到的Class就是同一个
int[] array1 = new int[10];
int[] array2 = new int[100];
System.out.println(array1.getClass().hashCode());
System.out.println(array2.getClass().hashCode());
}
}
运行结果如下
5、类加载内存分析
简单了解一下Java内存
1）堆：
存放new出来的对象和数组
可以被所有线程共享，不会存放别的对象引用
2）栈：
存放基本变量类型（包含这个基本类型的具体数值）
引用对象的变量（会存放这个引用在堆里面的具体地址）
3）方法区（特殊的堆）
可以被所有的线程共享
包含了所有的class和static变量
6、类的加载过程：加载—>链接（验证、准备、解析）—>初始化
- 加载：查找和导入Class文件
- 链接：其中解析步骤是可以选择的 （a）检查：检查载入的class文件数据的正确性 （b）准备：给类的静态变量分配存储空间 （c）解析：将符号引用转成直接引用
- 初始化：对静态变量，静态代码块执行初始化工作
7、分析类的初始化
问：什么时候才会发生类的初始化？
类的主动引用（一定会发生类的初始化）：
1）当虚拟机启动，先初始化main方法所在的类
2）new一个类的对象
3）调用类的静态成员（除final常量）和静态方法
4）使用java.lang.reflection包对的方法对类进行反射调用
5）当初始化一个类，如果其父类没有初始化，那么则会先初始化它的父类
类的被动引用（不会发生类的初始化）：
1）当访问一个静态域时，只有真正声明这个域的类才会被初始化，例如通过子类引用父类的静态变量，子类不会初始化
2）通过数组定义类引用，不会触发此类的初始化
3）引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了）
8、获取类的完整结构
如何获取类中属性、构造器以及方法呢，我们可以对着下面的例子做一个简单的了解
package com.decade.reflection;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class ReflectionDemo04 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
Class c1 = Class.forName("com.decade.reflection.People");
// 获取类的名字 + 包名
System.out.println(c1.getName());
// 获取类名
System.out.println(c1.getSimpleName());
System.out.println("=====获取属性========");
// 获取本类和父类中的属性,只能找到public类型的
Field[] fields = c1.getFields();
for (Field field : fields) {
System.out.println(field);
}
System.out.println("=====获取全部属性========");
// 能获取本类全部属性
Field[] fields2 = c1.getDeclaredFields();
for (Field field : fields2) {
System.out.println(field);
}
System.out.println("=====指定属性========");
// 获取本类指定属性
Field sex = c1.getDeclaredField("sex");
System.out.println("sex=" + sex);
// 获取本类和父类中指定属性,public修饰
Field name = c1.getField("name");
System.out.println("sex=" + name);
System.out.println("=====获取方法========");
// 获得类的方法，包括本类和父类的。仅能获得public修饰的
Method[] methods = c1.getMethods();
for (Method method : methods) {
System.out.println(method.getName());
}
System.out.println("=====获取所有方法========");
// 获得类的方法，仅包括本类的。获得public和private修饰的
Method[] declaredMethods = c1.getDeclaredMethods();
for (Method declaredMethod : declaredMethods) {
System.out.println(declaredMethod.getName());
}
System.out.println("=====获取指定方法========");
// 获得指定方法，如果方法没有入参，第二个参数填null
Method setAge = c1.getMethod("setAge", int.class);
System.out.println(setAge);
System.out.println("=====获取所有构造器========");
// 返回本类所有构造函数
Constructor[] declaredConstructors = c1.getDeclaredConstructors();
for (Constructor declaredConstructor : declaredConstructors) {
System.out.println(declaredConstructor.getName());
}
System.out.println("=====获取构造器========");
// 返回public修饰的构造函数
Constructor[] constructors = c1.getConstructors();
for (Constructor constructor : constructors) {
System.out.println(constructor.getName());
}
System.out.println("=====获取指定构造器========");
// 获取指定的构造器
Constructor declaredConstructor = c1.getDeclaredConstructor(String.class, int.class, String.class);
System.out.println(declaredConstructor.getName());
}
}
class Person {
public String name;
public Person() {
}
public Person(String name) {
this.name = name;
}
@Override
public String toString() {
return "Person{"
+ "name='" + name + '\''
+ '}';
}
}
class People extends Person {
public int age;
private String sex;
private People(int age, String sex) {
this.age = age;
this.sex = sex;
}
public People(String name, int age, String sex) {
super(name);
this.age = age;
this.sex = sex;
}
private void test() {
System.out.println("私有方法");
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
@Override
public String toString() {
return "People{" +
"name='" + name + '\'' +
", age=" + age +
", sex='" + sex + '\'' +
'}';
}
}
9、如何动态创建对象执行方法（通过反射获取类的方法、字段、构造器）
-
如何通过反射创建类的对象：调用Class对象的new Instance()方法
使用此方式，类必须要有无参构造，其次，类的构造器的访问权限需要足够 -
如果没有无参构造，我们也可以按照下面的步骤创建类的对象：
1）通过class类的getDeclareConstructor(Class…ParameterTypes)取得本类的指定形参类型的构造器
2）向构造器传递一个对象数组进去，里面包含了构造器中所需的各个参数
3）通过constructor实例化对象 -
调用指定的方法：
1）通过Class类的getMethod(String name, Class… ParameterTypes)或getDeclaredMethod(String name, Class… ParameterTypes)取得一个method对象，并设置此方法操作时所需的参数类型
2）之后使用Object.invoke(对象， 参数)进行调用，并向其中传递方法需要的参数 -
操作指定的属性：需要设置Accessible为true，关闭程序的安全检测
注意：Method、Filed和Constructor都有setAccessible()方法
package com.decade.reflection;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class ReflectionDemo05 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException,
InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchFieldException {
Class<?> c1 = Class.forName("com.decade.reflection.User");
// 通过反射调用普通方法，此处是调用了类的无参构造
User user = (User) c1.newInstance();
Method setName = c1.getDeclaredMethod("setName", String.class);
// 通过invoke进行方法调用
setName.invoke(user, "十年");
System.out.println(user.getName());
System.out.println("=======================");
// 通过反射操作属性
User user2 = (User) c1.newInstance();
Field name = c1.getDeclaredField("name");
Field sex = c1.getDeclaredField("sex");
System.out.println(user.getName());
// 要操作私有属性，需要设置Accessible为true，关闭程序的安全检测
name.setAccessible(true);
name.set(user2, "十年Decade");
sex.set(user2, "男");
System.out.println(user2.getName());
System.out.println(user2.getSex());
}
}
class User {
private String name;
public String sex;
public User() {
}
public User(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\''
+ ", sex='" + sex + '\''
+ '}';
}
}
运行结果如下
10、通过反射操作注解
首先我们新建两个自定义注解，将它们添加到类和属性上
package com.decade.reflection;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
// 注解可以显式赋值，如果不赋值，那就使用默认值，没有默认值的必须显式赋值
@MyAnnotation(name = "十年", age = 24)
public class CustomAnnotation2 {
@MyValue(name = "db_name", type = "java.lang.String", desc = "名字")
private String name;
public CustomAnnotation2() {
}
public CustomAnnotation2(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "CustomAnnotation{"
+ "name='" + name + '\''
+ '}';
}
public void test() {
}
}
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation {
String name() default "";
// 如果默认值为-1，则代表此注解不存在
int age() default -1;
String[] hobbies() default {"音乐", "篮球"};
}
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyValue {
String name();
String desc();
String type();
}
然后我们创建一个测试类
package com.decade.reflection;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
public class reflectionDemo06 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
Class<?> c1 = Class.forName("com.decade.reflection.CustomAnnotation2");
// 通过反射获取注解
Annotation[] annotations = c1.getAnnotations();
for (Annotation annotation : annotations) {
System.out.println(annotation);
}
System.out.println("================================");
// 获取注解的属性值
MyAnnotation annotation = c1.getAnnotation(MyAnnotation.class);
String name = annotation.name();
System.out.println(name);
System.out.println("================================");
// 获取类中指定的注解
Field nameField = c1.getDeclaredField("name");
MyValue annotation1 = nameField.getAnnotation(MyValue.class);
System.out.println(annotation1.desc());
System.out.println(annotation1.name());
System.out.println(annotation1.type());
}
}
控制台输出结果如下
如有错误，欢迎指正
278
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
