注解与反射
注解
检查、约束
注解是有功能的
元注解
@MyAnnotation
public class Demo02 {
@MyAnnotation
public void taet() {
}
}
// 定义一个注解
// Target 表示我们的注解可以用在哪些地方
@Target(value = {ElementType.METHOD,ElementType.ANNOTATION_TYPE.TYPE})
// Retention 表示我们的注解可以用在什么地方还有效
@Retention(value = RetentionPolicy.RUNTIME)
// Documented 表示是否将我们注解生成在Javadoc文件中
@Documented
// Inherited 子类可以继承父类注解
@Inherited
@interface MyAnnotation{
}
自定义注解
/**
* 没有顺序
*/
public class Demo03 {
// 注解可以显示赋值 如果没有默认值 必须给注解赋值
@MyAnnotation2(name = "liyjie", schools = {"中北大学", "山西大学"})
public void test1(){
}
@MyAnnotation3("Liyujie")
public void test2(){
}
}
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation2{
// 注解的参数:参数类型 + 参数名();
// 默认值 default
String name() default "";
int age() default 0;
int id() default -1; // 如果默认值为-1 代表不存在
String[] schools() ;
}
// 默认值只有一个时 可以偷懒 参数名为value那么在上面就不需要写 value
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation3{
String value();
}
反射机制
优点缺点
public class Demo03 {
public static void main(String[] args) throws ClassNotFoundException {
Person person = new Student();
System.out.println("这个人是:" + person.name);
// 第一种方式 通过对象获得
Class c1 = person.getClass();
// 第二种方式 forname获得
Class c2 = Class.forName("nuc.richard.reflection.Student");
// 第三种方式 通过类名.class获得
Class c3 = Student.class;
// 第四种方式 基本内置类型的包装类都有一个Type属性
Class c4 = Integer.TYPE;
Class c5 = c1.getSuperclass();
System.out.println(c1.hashCode());
System.out.println(c2.hashCode());
System.out.println(c3.hashCode());
System.out.println(c4);
System.out.println(c5);
}
}
class Person {
String name;
public Person(String name) {
this.name = name;
}
public Person() {
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
'}';
}
}
class Student extends Person {
public Student() {
this.name = "学生";
}
}
class Teacher extends Person {
public Teacher() {
this.name = "教师";
}
}
// 所有类型的Class
public class Demo04 {
public static void main(String[] args) {
Class c1 = Object.class; // 类
Class c2 = Comparable.class; // 接口
Class c3 = String[].class; // 一维数组
Class c4 = int[][].class; // 二维接口
Class c5 = Override.class; // 注解
Class c6 = ElementType.class; // 枚举
Class c7 = Integer.class; // 基本数据类型
Class c8 = void.class; // void
Class c9 = Class.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);
// 只要元素类型与维度一样,就是同一个class
int[] a = new int[10];
int[] b = new int[100];
System.out.println(a.getClass().hashCode());
System.out.println(b.getClass().hashCode());
}
}
例子:
public class Demo05 {
public static void main(String[] args) {
A a = new A();
System.out.println(A.m);
/*
1. 加载到内存 ,会产生一个类对应的Class对象
2. 链接, 链接结束后 m = 0
3. 初始化
<clinit>(){
System.out.println("A类静态代码块初始化");
m = 300;
m = 100
}
*/
}
}
class A{
static int m = 100;
static{
System.out.println("A类静态代码块初始化");
m = 300;
}
public A() {
System.out.println("A类的无参构造初始化");
}
}
// 测试类什么时候会初始化
public class Demo06 {
static {
System.out.println("main类被加载");
}
public static void main(String[] args) throws ClassNotFoundException {
// 1. 主动引用
//Son son = new Son();
// 2. 反射也会产生主动引用 不会导致子类的初始化
//Class.forName("nuc.richard.reflection.Son");
// 通过子类调用父类的东西 不会产生类的引用的方法
//System.out.println(Son.b);
// 通过数组
//Son[] array = new Son[5];
// 常量也不会产生类的加载
System.out.println(Son.M);
}
}
class Father {
static int b = 2;
static {
System.out.println("父类被加载");
}
}
class Son extends Father {
static {
System.out.println("子类被加载");
m = 300;
}
static int m = 100;
static final int M = 1;
}
类加载器的作用
public class Demo07 {
public static void main(String[] args) throws ClassNotFoundException {
// 获取系统类的加载器
ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
System.out.println(systemClassLoader);
// 获取系统类加载器的父类加载器--->扩展类加载器
ClassLoader parent = systemClassLoader.getParent();
System.out.println(parent);
// 获取扩展类加载器的父类--->根加载器(c/c++)
ClassLoader parent1 = parent.getParent();
System.out.println(parent1);
// 测试当前类是那个加载器
ClassLoader classLoader = Class.forName("nuc.richard.reflection.Demo07").getClassLoader();
System.out.println(classLoader);
// 测试jdk内部类是谁加载的
classLoader = Class.forName("java.lang.Object").getClassLoader();
System.out.println(classLoader);
// 如何获得系统类加载器可以加载路径
System.out.println(System.clearProperty("java.class.path"));
//C:\Program Files\Java\jdk1.8.0_131\jre\lib\charsets.jar;
// C:\Program Files\Java\jdk1.8.0_131\jre\lib\deploy.jar;
// C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\access-bridge-64.jar;
// C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\cldrdata.jar;
// C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\dnsns.jar;
// C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\jaccess.jar;
// C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\jfxrt.jar;
// C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\localedata.jar;
// C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\nashorn.jar;
// C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\sunec.jar;
// C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\sunjce_provider.jar;
// C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\sunmscapi.jar;
// C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\sunpkcs11.jar;
// C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\zipfs.jar;
// C:\Program Files\Java\jdk1.8.0_131\jre\lib\javaws.jar;
// C:\Program Files\Java\jdk1.8.0_131\jre\lib\jce.jar;
// C:\Program Files\Java\jdk1.8.0_131\jre\lib\jfr.jar;
// C:\Program Files\Java\jdk1.8.0_131\jre\lib\jfxswt.jar;
// C:\Program Files\Java\jdk1.8.0_131\jre\lib\jsse.jar;
// C:\Program Files\Java\jdk1.8.0_131\jre\lib\management-agent.jar;
// C:\Program Files\Java\jdk1.8.0_131\jre\lib\plugin.jar;
// C:\Program Files\Java\jdk1.8.0_131\jre\lib\resources.jar;
// C:\Program Files\Java\jdk1.8.0_131\jre\lib\rt.jar;
// D:\lyj\JAVA2\注解和反射\out\production\注解和反射;
// D:\lyj\idea\IntelliJ IDEA 2020.3\lib\idea_rt.jar
}
}
获取类的名字、的方法 以及方法属性 (指定)
public class Demo08 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
Class c1 = Class.forName("nuc.richard.reflection.User");
User user = new User();
c1 = user.getClass();
// 获得类的名字
System.out.println(c1.getName()); // 包名 + 类名
// 获得简易类的名字
System.out.println(c1.getSimpleName()); // 类名
// 获得类的属性
System.out.println("-----------------------------");
Field[] fields = null; // 只能找到public属性
fields = c1.getDeclaredFields();
for (Field field : fields) {
System.out.println(field);
}
// 获得类的指定属性
Field name = c1.getDeclaredField("name");
System.out.println(name);
// 获得类的方法
System.out.println("------------------------------");
Method[] methods = c1.getMethods();// 本类及其父类的全部public方法
for (Method method : methods) {
System.out.println("666:" + method);
}
methods = c1.getDeclaredMethods();
for (Method method : methods) { // 本类的所有方法
System.out.println(method);
}
// 获得指定方法
// 重载
Method getName = c1.getMethod("getName", null);
Method setName = c1.getMethod("setName", String.class);
System.out.println(getName);
System.out.println(setName);
// 获得构造器
System.out.println("-----------------------------");
Constructor[] constructors = c1.getConstructors();
for (Constructor constructor : constructors) {
System.out.println(constructor);
}
constructors = c1.getDeclaredConstructors();
for (Constructor constructor : constructors) {
System.out.println(constructor);
}
// 获得指定构造器
Constructor declaredConstructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
System.out.println("指定:" + declaredConstructor);
}
}
操作方法中的属性
public class Demo09 {
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
// 获得Class对象
Class c1 = Class.forName("nuc.richard.reflection.User");
// 构造一个class对象
// User user = (User) c1.newInstance(); // 本质调用无参
//System.out.println(user);
// // 通过构造器创造对象
// Constructor constructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
// User user2 = (User)constructor.newInstance("李宇杰", 001, 20);
// System.out.println(user2);
//
// User user3 = (User) c1.newInstance();
// Method setName = c1.getDeclaredMethod("setName", String.class);
// // invoke 激活的意思
// // (对象, "对象方法值")
// setName.invoke(user3, "richaf");
// System.out.println(user3.getName());
User user4 = (User) c1.newInstance();
Field name = c1.getDeclaredField("name");
// 不能直接操作私有属性,我们需要关闭程序的安全检测,属性或方法的setAccessible(true) 但是会降低程序的效率
name.setAccessible(true); // 关闭权限
name.set(user4,"licahde");
System.out.println(user4.getName());
}
}
性能分析
// 分析性能问题
public class Demo10 {
// 普通方式调用
public static void test01() {
User user = new User();
long starttime = System.currentTimeMillis();
for (int i = 0; i < 1000000000; i++) {
user.getName();
}
long endtime = System.currentTimeMillis();
System.out.println("普通方法执行10亿次:" + (endtime-starttime) + "ms");
}
// 反射方式调用
public static void test02() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
User user = new User();
Class c1 = user.getClass();
Method getName = c1.getDeclaredMethod("getName", null);
long starttime = System.currentTimeMillis();
for (int i = 0; i < 1000000000; i++) {
getName.invoke(user,null);
}
long endtime = System.currentTimeMillis();
System.out.println("反射方法执行10亿次:" + (endtime-starttime) + "ms");
}
// 反射方式调用 关闭检测
public static void test03() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
User user = new User();
Class c1 = user.getClass();
Method getName = c1.getDeclaredMethod("getName", null);
getName.setAccessible(true);
long starttime = System.currentTimeMillis();
for (int i = 0; i < 1000000000; i++) {
getName.invoke(user,null);
}
long endtime = System.currentTimeMillis();
System.out.println("关闭检测方法执行10亿次:" + (endtime-starttime) + "ms");
}
public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
test01();
test02();
test03();
}
}
反射操作泛型
// 通过反射获取泛型
public class Demo11 {
public void test01(Map<String, User> map, List<User> list) {
System.out.println("test01");
}
public Map<String, User> test02() {
System.out.println("test02");
return null;
}
public static void main(String[] args) throws NoSuchMethodException {
Method method = Demo11.class.getMethod("test01", Map.class, List.class);
Type[] genericParameterTypes = method.getGenericParameterTypes(); // 获得泛型参数类型
for (Type genericParameterType : genericParameterTypes) {
System.out.println("#" + genericParameterType);
// 泛型参数类型 等于 结构化参数类型
if (genericParameterType instanceof ParameterizedType) {
Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
for (Type actualTypeArgument : actualTypeArguments) {
System.out.println(actualTypeArgument);
}
}
}
method = Demo11.class.getMethod("test02", null);
Type genericReturnType = method.getGenericReturnType();
System.out.println("#" + genericReturnType);
// 泛型参数类型 等于 结构化参数类型
if (genericReturnType instanceof ParameterizedType) {
Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
for (Type actualTypeArgument : actualTypeArguments) {
System.out.println(actualTypeArgument);
}
}
}
}
反射操作注解
public class Demo12 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
Class<?> c1 = Class.forName("nuc.richard.reflection.Student02");
// 通过反射获得注解
Annotation[] annotations = c1.getAnnotations();
for (Annotation annotation : annotations) {
System.out.println(annotation);
}
// 获得注解的value值
TableRichard tableRichard = (TableRichard) c1.getAnnotation(TableRichard.class);
System.out.println(tableRichard.value());
// 获得类指定的注解
Field f = c1.getDeclaredField("name");
FieldRichard annotation = f.getAnnotation(FieldRichard.class);
System.out.println(annotation.columnName());
System.out.println(annotation.type());
System.out.println(annotation.length());
}
}
@TableRichard("db_student")
class Student02 {
@FieldRichard(columnName = "db_id",type = "int", length = 10)
private int id;
@FieldRichard(columnName = "db_age",type = "int", length = 10)
private int age;
@FieldRichard(columnName = "db_name",type = "String", length = 5)
private String name;
public Student02() {
}
public Student02(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 "Student02{" +
"id=" + id +
", age=" + age +
", name='" + name + '\'' +
'}';
}
}
// 类名注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface TableRichard{
String value();
}
// 属性注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FieldRichard {
String columnName();
String type();
int length();
}