系列文章目录
https://editor.csdn.net/md/?articleId=131757340
参考
可以参考的笔记: https://blog.csdn.net/ProGram_Java521/article/details/127733167
学习视频:
https://www.bilibili.com/video/BV1PY411e7J6?p=192&vd_source=585eef59d366645f5bf03840b1010547
https://www.bilibili.com/video/BV1p4411P7V3/?spm_id_from=333.337.search-card.all.click
【1】注解
1. 什么是注解
–对程序作出解释。@注释名”在代码中存在的,还可以添加一些参数值
注解在哪里使用?–可以附加在package,class,method,field等上面,相当于给他们添加了额外的辅助信息,我们可以通过反射机制实现对这些元数据的访问
2. 内置注解
@Override @Deprecated等
3. 元注解
负责注解其他的注解。通过4个元注解说明其他注解的作用域、作用方式等。
@Target :描述作用范围
@Retention :描述注解的生命周期(源码、类、runtime运行时)
@Document :包含再javadoc中
@Ingerited :自雷可以继承父类中的注解
4.自定义注解
设置作用域、返回类型等可以借助元注解
【2】反射–基本概念
一、反射的基本概念
1. 为什么要用反射?
1)java程序中的两种对象类型,编译时类型 和 运行时类型。如果出现编译时类型和运行时类型不一致,要怎么解决?
2)如果已知运行时类型,可以用instanceof 直接判断。
3)无法预知运行时类型,只能依靠运行时的信息获取对象和类的真实信息 --由此引入反射机制。
2. 什么是反射?
在代码运行过程中,允许程序借助Reflection API取得类的任何内部信息、操作类的属性和方法。
作用:操作字节码
正常方式: 引入包类 --》new 实例化对象 --》 取得实例化对象
反射方式: 实例化对象 --》getClass()方法 --》得到完整的“包类”名称
3. 用和不用反射的区别?
不用反射,出了类之后,private属性和方法不能使用–类的封装性
使用反射:可以访问私有方法属性
4.开发中什么场景下用反射?
1)一般业务开发,对使用对象已知和确定,基本可以不用反射
2)对于框架的开发,体现动态性,考虑使用反射。
5.反射优点和缺点:
优点:自适应 灵活 动态获取
缺点:性能较差。
二、反射的使用
1. 获取反射对象的4种方式
CLass.forName(“完整包名”)
对象.getClass()
任何类型.class
ClassLoader.getSystemClassLoader().loadClass(“完整包名”)
基本数据类型 Integer.TYPE
2.哪些类型哟class对象?
class
interface
数组
enum
annotation 注解
基本数据类型
void
三、类加载过程
1.加载过程
·过程1:类的装载(Loading)
把class文件读入内存,并创建一个java.lamg.Class对象,由类加载器完成
·过程2:链接(linking)
验证(verify):确保类加载嘻嘻符合JVM规范。比如,cafebabe
准备(prepare):给static变量分配内存并且设置初始值。这里的内存都在方法区中分配
解析(Resolve):虚拟机常量池内的符号引用(常量名)替换为直接引用(引用地址)
·过程3:初始化(initialization)
执行类构造器方法。
2. 补充:java 内存分析
堆:存new的对象和数组,可以被所有线程共享
栈:存基本变量类型、引用类型的变量(存引用在堆里的具体地址)
方法区:所有class和static变量,被所有线程共享
3. 类加载器 + 类的双亲委派机制
4. 怎么获取类运行过程中的各种对象(方法、参数、构造器等)
常用的API 接口
5. 用class对象能怎么用?
动态创建对象:
1)newInstance 对无参构造函数创建对象
2)getDeclaredConstructor 先获取构造器,在用构造器创建对象。
3)执行方法 getMethod,用invoke进行调用的激活
4)私有属性 方法可以用setAccessible(true); // 关掉权限检测文章来源:https://www.toymoban.com/news/detail-603118.html
6.应用:反射的动态性:
文章来源地址https://www.toymoban.com/news/detail-603118.html
package com.common.inject;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
class ReflectTest {
// 举例1:反射的动态性--类
public <T> T getInstance(String className) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
Class c1 = Class.forName(className);
Constructor con = c1.getDeclaredConstructor();
con.setAccessible(true);
return (T) con.newInstance();
}
// 举例2:反射的动态性--方法
public static Object invoke(String className, String methodName) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
// 1.创建雷鸣对应的运行时的类对象
Class c1 = Class.forName(className);
Constructor con = c1.getDeclaredConstructor();
con.setAccessible(true);
Object o = con.newInstance();
//2. 获取运行时类中的方法
Method method = c1.getDeclaredMethod(methodName);
method.setAccessible(true);
return method.invoke(o);
}
public static void main(String[] args) throws ClassNotFoundException, InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException {
String className ="com.common.inject.LearnInject";
String methodName = "del";
System.out.println(invoke(className, methodName));
}
}
public class LearnInject {
private int id;
public LearnInject() {
}
public LearnInject(int id, String name) {
this.id = id;
this.name = name;
}
public int add(int a, int b) {
return a + b;
}
private String del() {
return "This is del method";
}
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {
Class c1 = Class.forName("com.common.inject.LearnInject");
Class c0 = ClassLoader.getSystemClassLoader()
.loadClass("com.common.inject.LearnInject");
System.out.println(c1 == c0);
// 创建实例对象:构造器
// LearnInject l1 = (LearnInject)c1.newInstance();
// System.out.println(l1);
Constructor constructor = c1.getDeclaredConstructor(int.class, String.class);
LearnInject l2 = (LearnInject)constructor.newInstance(1, "one");
System.out.println(l2.toString());
System.out.println(l2.add(1, 2));
// 通过反射调用方法
LearnInject l3 = (LearnInject) c1.newInstance();
Method add = c1.getDeclaredMethod("add",int.class,int.class);
int invoke = (int) add.invoke(l3, 1, 2);
System.out.println(invoke);
Field id = c1.getDeclaredField("id");
id.setAccessible(true); // 关掉权限检测
id.set(l3, 10);
System.out.println(l3.id);
// Class c1 = Class.forName("com.common.inject.LearnInject");
// System.out.println(c1);
// System.out.println(c1.hashCode());
//
// System.out.println(c1);
// // 获取类运行过程中的对象
// System.out.println(c1.getName());
// System.out.println(c1.getClassLoader());
// System.out.println(c1.getField("name")); // getField获取public
// System.out.println(c1.getDeclaredField("id")); // getDeclaredField获取所有的变量
//
//
// Method[] methods = c1.getMethods(); // getMethods 获取本类和父类的所有public方法
// for (Method method : methods) {
// System.out.println("getMethods:" + method);
// }
//
//
// methods = c1.getDeclaredMethods(); // getDeclaredMethods 获取本类的所有方法
// for (Method method : methods) {
// System.out.println("getDeclaredMethods:" + method);
// }
//
// System.out.println(c1.getMethod("add", int.class, int.class));
//
// LearnInject learnInject = new LearnInject();
// Class c2 = learnInject.getClass();
// System.out.println(c2);
//
// System.out.println(c2.hashCode());
//
// Class c3 = LearnInject.class;
// System.out.println(c3);
// System.out.println(c3.hashCode());
//
// // 内置基本类型可以用类名.Type
// Class<Integer> type = Integer.TYPE;
// System.out.println(type.hashCode());
//
// Integer val = new Integer(1);
// System.out.println(val.getClass().hashCode());
}
}
到了这里,关于java学习(二):反射的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!