标签：targe lan instance jvm nec master extend rop return
动态语言
静态语言
反射机制在执行期间借助ReflectionAPI
加载完类后，在堆内存的方法去产生一个Class类型的对象——包含完整的类的结构信息
new——通过类来创建对象
class——通过获取class对象获取类、class对象有且只有一个
public class Test01 {
public static void main(String[] args) throws ClassNotFoundException {
//正常创建对象——通过类创建对象
Test t1 = new Test();
Test t2 = new Test();
t1.getAge();
//new创建的不是同一个对象
System.out.println(t1.hashCode());//460141958
System.out.println(t2.hashCode());//1163157884
//反射获取对象——通过对象获取类
Class c1 = Class.forName("com.shelton.reflection.Test");
Class c2 = Class.forName("com.shelton.reflection.Test");
c1.getName();
//Class对象是唯一的
System.out.println(c1.hashCode());//1956725890
System.out.println(c2.hashCode());//1956725890
}
}
//实体类
class Test {
private String name;
private int age;
private String hobby;
public Test() {
}
public Test(String name, int age, String hobby) {
this.name = name;
this.age = age;
this.hobby = hobby;
}
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 getHobby() {
return hobby;
}
public void setHobby(String hobby) {
this.hobby = hobby;
}
@Override
public String toString() {
return super.toString();
}
}
已知具体的类，通过类的class属性获取（最安全，性能最高）
Class c1 = Person.class;
已知某 个类的实例，调用该实例的getClass()方法获取Class对象
Class c1 = person.getClass();
已知类的全名且该类在类路径下，静态的forName()方法获取,并抛出异常
Class c1 = Class.forName("demo01.Student");
内置基本数据类型可以直接用类名.Type
ClassLoader
public class Test02 {
public static void main(String[] args) throws ClassNotFoundException {
//new创建对象
Person p1 = new Student();//多态
System.out.println(p1.name);//学生
//方式1——
Class c1 = Student.class;
System.out.println(c1.hashCode());//460141958
//方式2——通过对象获得
Class c2 = p1.getClass();
System.out.println(c2.hashCode());//460141958
//方式3——通过包名获得
Class c3 = Class.forName("com.shelton.reflection.Student");
System.out.println(c3.hashCode());//460141958
//方式4——基本类型的包状态
Class c4 = Integer.TYPE;
System.out.println(c4);//int
//获取父类
Class c5 = c1.getSuperclass();
System.out.println(c5);//class com.shelton.reflection.Person
}
}
class Person {
String name;
}
class Student extends Person {
public Student() {
this.name = "学生";
}
}
class Teacher extends Person {
public Teacher() {
this.name = "老师";
}
}
public class Test03 {
public static void main(String[] args) {
Class c1 = Object.class;//类
Class c2 = Runnable.class;//接口
Class c3 = String[].class;//一维数组
Class c4 = int[][].class;//二维数组
Class c5 = Target.class;//注解
Class c6 = ElementType.class;//枚举类型
Class c7 = Integer.class;//包装类
Class c8 = void.class;//空类型
Class c9 = Class.class;//类
System.out.println(c1);//class java.lang.Object
System.out.println(c2);//interface java.lang.Runnable
System.out.println(c3);//class [Ljava.lang.String;
System.out.println(c4);//class [[I
System.out.println(c5);//interface java.lang.annotation.Target
System.out.println(c6);//class java.lang.annotation.ElementType
System.out.println(c7);//class java.lang.Integer
System.out.println(c8);//void
System.out.println(c9);//class java.lang.Class
//同一个类只有一个class对象
int[] a = new int[10];
int[] b = new int[100];
System.out.println(a.getClass().hashCode());//325040804
System.out.println(b.getClass().hashCode());//325040804
}
}
加载
连接
初始化
类构造器<clinit>()方法
先初始化父类
虚拟机会保证一个类的
public class Test04 {
public static void main(String[] args) {
//1. Test004 test加载到内存，产生一个Class对象
A test = new A();
System.out.println("调用完类的a值："+ A.a);//静态变量
}
}
class A {
//2. 链接 链接结束后，a = 0
static {
System.out.println("静态代码块初始化");
int a = 300;
}
static int a = 100;//静态变量
//3. new Test004()构造器初始化前，先执行类构造器clinic(由静态域组成)
/*
<clinit>(){
System.out.println("静态代码块初始化");
int a = 300;
static int a = 100;//静态变量
}
*/
public A() {
System.out.println("A类的无参构造");
}
}
/*
静态代码块初始化
A类的无参构造
调用完类的a值：100
*/
类的主动引用——一定发生初始化
new和反射一定会初始化
类的被动引用——不会发生初始化
访问静态域时，只有真正声明这个域的类才会被初始化
数组定义类引用
引用常量
public class Test07 {
static {
System.out.println("Main类被加载");
}
public static void main(String[] args) throws ClassNotFoundException {
//主动引用
//1. new
Son son = new Son();
/*
Main类被加载
父类被加载
子类被加载
*/
//2. 反射
Class c1 = Class.forName("com.shelton.reflection.Son");
/*
Main类被加载
父类被加载
子类被加载
*/
// 被动引用
// 1.子类调用父类的静态变量、方法，子类不会被加载
System.out.println(Son.b);
/*
Main类被加载
父类被加载
2
*/
//2. 数组
Son[] array = new Son[10];
/*
Main类被加载
*/
//3. 静态常量
System.out.println(Son.M);
/*
Main类被加载
1
*/
}
}
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;
}
类加载：将class文件字节码加载到内存中，生成唯一的Class对象，作为方法区类数据的访问入口
类缓存：类加载器加载了某个类后，会维持加载一段时间（缓存），JVM垃圾回收机制可以回收这些Class对象
类加载器的作用
自定义类加载器App--->系统类加载器Syc ---> 扩展类加载器Exc ---引导类加载器Boot(无法获取)
public class Test08 {
public static void main(String[] args) throws ClassNotFoundException {
//1. 加载器类型
//获取系统类的加载器
ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
System.out.println(systemClassLoader);
//获取系统类加载器的父类加载器--->扩展类加载器
ClassLoader parent = systemClassLoader.getParent();
System.out.println(parent);
//获取扩展类加载器的父类加载器--->根加载器
ClassLoader parent1 = parent.getParent();
System.out.println(parent1);
//2. 测试类是哪个加载器加载的
System.out.println("***********测试***********");
//当前类——用户自定义类
ClassLoader classLoader = Class.forName("com.shelton.reflection.Test08").getClassLoader();
System.out.println(classLoader);//APP
//Object类——JDK内置类
ClassLoader classLoader1 = Class.forName("java.lang.Object").getClassLoader();
System.out.println(classLoader1);//null——C++写的无法获取
//3. 获得系统类加载器可以加载的路径
System.out.println(System.getProperty("java.class.path"));
/*
C:\Program Files\Java\jdk1.8.0_212\jre\lib\charsets.jar;
C:\Program Files\Java\jdk1.8.0_212\jre\lib\deploy.jar;
C:\Program Files\Java\jdk1.8.0_212\jre\lib\ext\access-bridge-64.jar;
C:\Program Files\Java\jdk1.8.0_212\jre\lib\ext\cldrdata.jar;
C:\Program Files\Java\jdk1.8.0_212\jre\lib\ext\dnsns.jar;
C:\Program Files\Java\jdk1.8.0_212\jre\lib\ext\jaccess.jar;
C:\Program Files\Java\jdk1.8.0_212\jre\lib\ext\jfxrt.jar;
C:\Program Files\Java\jdk1.8.0_212\jre\lib\ext\localedata.jar;
C:\Program Files\Java\jdk1.8.0_212\jre\lib\ext\nashorn.jar;
C:\Program Files\Java\jdk1.8.0_212\jre\lib\ext\sunec.jar;
C:\Program Files\Java\jdk1.8.0_212\jre\lib\ext\sunjce_provider.jar;
C:\Program Files\Java\jdk1.8.0_212\jre\lib\ext\sunmscapi.jar;
C:\Program Files\Java\jdk1.8.0_212\jre\lib\ext\sunpkcs11.jar;
C:\Program Files\Java\jdk1.8.0_212\jre\lib\ext\zipfs.jar;
C:\Program Files\Java\jdk1.8.0_212\jre\lib\javaws.jar;
C:\Program Files\Java\jdk1.8.0_212\jre\lib\jce.jar;
C:\Program Files\Java\jdk1.8.0_212\jre\lib\jfr.jar;
C:\Program Files\Java\jdk1.8.0_212\jre\lib\jfxswt.jar;
C:\Program Files\Java\jdk1.8.0_212\jre\lib\jsse.jar;
C:\Program Files\Java\jdk1.8.0_212\jre\lib\management-agent.jar;
C:\Program Files\Java\jdk1.8.0_212\jre\lib\plugin.jar;
C:\Program Files\Java\jdk1.8.0_212\jre\lib\resources.jar;
C:\Program Files\Java\jdk1.8.0_212\jre\lib\rt.jar;
D:\Codes\JAVA\JavaSE\Reflection\out\production\Reflection;
C:\Program Files\JetBrains\IntelliJ IDEA 2020.1.1\lib\idea_rt.jar
*/
}
}
双亲委派机制
public class String {
}
通过反射获取运行时类的完整结构
例如有一个实体类User
public class User {
private String name;
private int id;
private int age;
public String hobby;
public User(String name, int id, int age) {
this.name = name;
this.id = id;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
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;
}
@Override
public String toString() {
return "User{" +
"name" + name + ‘\‘‘ +
", id" + id +
", age" + age +
‘}‘;
}
}
getName()
getSimpleName()
User user = new User();
Class c2 = user.getClass();
//获得类的名字——通过对象
System.out.println(c2.getName()); //包名+类名
System.out.println(c2.getSimpleName()); //类名
getFields()
getDeclaredFields()
Class c1 = Class.forName("com.shelton.reflection.User");
//获得类的属性
//只能找到public属性
Field[] fields = c1.getFields();
for (Field field : fields) {
System.out.println(field);
}
//找到全部的属性
Field[] declaredFields = c1.getDeclaredFields();
for (Field declaredField : declaredFields) {
System.out.println(declaredField);
}
//获得指定属性
Field name = c1.getDeclaredField("name");
System.out.println(name);
/*
============getFields()============
public java.lang.String com.shelton.reflection.User.hobby
============getDeclaredFields()============
private java.lang.String com.shelton.reflection.User.name
private int com.shelton.reflection.User.id
private int com.shelton.reflection.User.age
public java.lang.String com.shelton.reflection.User.hobby
============getDeclaredField("name")============
private java.lang.String com.shelton.reflection.User.name
*/
getMethods()
getDeclaredMethods()
Class c1 = Class.forName("com.shelton.reflection.User");
//获得本类及其父类的所有方法
Method[] methods = c1.getMethods();
for (Method method : methods) {
System.out.println(method);
}
//获得本类的所有方法
Method[] declaredMethods = c1.getDeclaredMethods();
for (Field declaredField : declaredFields) {
System.out.println(declaredField);
}
//获得指定方法
//需要这个参数，因为方法有重载，方法名是一样的
Method getName = c1.getMethod("getName", null);
Method setName = c1.getMethod("setName", String.class);
System.out.println(getName);
System.out.println(setName);
/*
============getMethods()============
public java.lang.String com.shelton.reflection.User.toString()
public java.lang.String com.shelton.reflection.User.getName()
public int com.shelton.reflection.User.getId()
public void com.shelton.reflection.User.setName(java.lang.String)
public int com.shelton.reflection.User.getAge()
public void com.shelton.reflection.User.setId(int)
public void com.shelton.reflection.User.setAge(int)
public final void java.lang.Object.wait() throws java.lang.InterruptedException
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
public boolean java.lang.Object.equals(java.lang.Object)
public native int java.lang.Object.hashCode()
public final native java.lang.Class java.lang.Object.getClass()
public final native void java.lang.Object.notify()
public final native void java.lang.Object.notifyAll()
============getDeclaredMethods()============
private java.lang.String com.shelton.reflection.User.name
private int com.shelton.reflection.User.id
private int com.shelton.reflection.User.age
public java.lang.String com.shelton.reflection.User.hobby
============getMethod("getName", null)============
public java.lang.String com.shelton.reflection.User.getName()
public void com.shelton.reflection.User.setName(java.lang.String)
*/
getConstructors()
getDeclaredConstructors()
//获得本类及父类的构造器
Constructor[] constructors = c1.getConstructors();
for (Constructor constructor : constructors) {
System.out.println(constructor);
}
//获得本类的构造器
Constructor[] declaredConstructors = c1.getDeclaredConstructors();
for (Constructor declaredConstructor : declaredConstructors) {
System.out.println(declaredConstructor);
}
//获得指定的构造器
Constructor declaredConstructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
System.out.println(declaredConstructor);
/*
============getConstructors()============
public com.shelton.reflection.User()
public com.shelton.reflection.User(java.lang.String,int,int)
============getDeclaredConstructors============
public com.shelton.reflection.User()
public com.shelton.reflection.User(java.lang.String,int,int)
============getDeclaredConstructor============
public com.shelton.reflection.User(java.lang.String,int,int)
*/
newInstance()方法
类必须有无参构造
类的构造器访问权限必须足够
Class c1 = Class.forName("com.shelton.reflection.User");
//本质是调用无参构造创建对象，因此删除User的无参构造后会报错
User user = (User)c1.newInstance();
System.out.println(user);//User{name123‘, id1, age1}
也可以使用有参构造创建user对象
Class c1 = Class.forName("com.shelton.reflection.User");
//调用User的有参构造器使用
Constructor declaredConstructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
//创建User对象
User user2 = (User)declaredConstructor.newInstance("shelton", 1, 20);
System.out.println(user2);//User{nameshelton‘, id1, age20}
Class c1 = Class.forName("com.shelton.reflection.User");
User user3 = (User)c1.newInstance();
//获取set方法
Method setName = c1.getDeclaredMethod("setName", String.class);
//使用方法
//invoke(对象，方法的值)
setName.invoke(user3,"哈哈");
System.out.println(user3);//User{name哈哈‘, id0, age0}
如果是private属性，则要设置accessible为true
Class c1 = Class.forName("com.shelton.reflection.User");
//创建user对象
User user4 = (User)c1.newInstance();
//获取name属性
Field name = c1.getDeclaredField("name");
//关闭安全检测——因为name属性是private，不能直接操作
name.setAccessible(true);
//赋值
name.set(user4,"嘿嘿");
System.out.println(user4.getName());//嘿嘿
public class Test11 {
//普通方式
public static void Test1 () {
User user = new User();
long startTime = System.currentTimeMillis();
for (int i = 0; i < 1_000_000_000; i++) {
user.getName();
}
long endTime = System.currentTimeMillis();
System.out.println("普通方式运行了："+(endTime-startTime)+"ms");
}
//反射方式
public static void Test2 () throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
Class c1 = Class.forName("com.shelton.reflection.User");
User user = (User)c1.newInstance();
Method getName = c1.getDeclaredMethod("getName",null);
long startTime = System.currentTimeMillis();
for (int i = 0; i < 1_000_000_000; i++) {
getName.invoke(user,null);
}
long endTime = System.currentTimeMillis();
System.out.println("反射方式运行了："+(endTime-startTime)+"ms");
}
//反射方式——关闭检测
public static void Test3 () throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
Class c1 = Class.forName("com.shelton.reflection.User");
User user = (User)c1.newInstance();
Method getName = c1.getDeclaredMethod("getName",null);
getName.setAccessible(true);
long startTime = System.currentTimeMillis();
for (int i = 0; i < 1_000_000_000; i++) {
getName.invoke(user,null);
}
long endTime = System.currentTimeMillis();
System.out.println("反射关闭检测方式运行了："+(endTime-startTime)+"ms");
}
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
Test1();
Test2();
Test3();
}
}
/*
普通方式运行了：5ms
反射方式运行了：2837ms
反射关闭检测方式运行了：2049ms
*/
//通过反射获取泛型
public class Test12 {
public void method01(Map<String,User> map, List<User> list) {
System.out.println("method01");
}
public Map<String,User> method02() {
System.out.println("method02");
return null;
}
public static void main(String[] args) throws NoSuchMethodException {
//获取泛型信息
//1. 获取方法,输入参数，然后生成一个对象
Method method01 = Test12.class.getDeclaredMethod("method01", Map.class, List.class);
//2. 获取泛型类型，返回一个Type类型的数组，生成对象
Type[] genericParameterTypes = method01.getGenericParameterTypes();
//3. 打印输出这个Type类型数组
for (Type genericParameterType : genericParameterTypes) {
System.out.println("泛型信息："+genericParameterType);
//4. 获取泛型的参数
//判断泛型的参数类型 是否为 结构化参数类型
if (genericParameterType instanceof ParameterizedType) {
//是则强转成 结构化参数类型，调用getActualTypeArguments()方法获取参数
Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
for (Type actualTypeArgument : actualTypeArguments) {
System.out.println(" 参数："+actualTypeArgument);
}
}
}
}
}
/* 泛型信息：java.util.Map<java.lang.String, com.shelton.reflection.User>
参数：class java.lang.String
参数：class com.shelton.reflection.User
泛型信息：java.util.List<com.shelton.reflection.User>
参数：class com.shelton.reflection.User
*/
创建注解(类、属性)
//注解——类
@Target(value = ElementType.TYPE)//作用于类
@Retention(value = RetentionPolicy.RUNTIME)//运行时有效
@interface MyClass {
String value() default "";
}
//注解——属性
@Target(value = ElementType.FIELD)//作用于属性
@Retention(RetentionPolicy.RUNTIME)
@interface Myfield {
String columnName() default "null";//字段名
String type() default "null"; //类型
int length() default 0;//长度
}
创建一个实体类Student
//实体类
@MyClass("this is a boy")
class People {
@Myfield(columnName = "boy_id",type = "int",length = 10)
private int id;
@Myfield(columnName = "boy_age",type = "int",length = 10)
private int age;
@Myfield(columnName = "boy_name",type = "varchar",length = 3)
private String name;
public People() {
}
public People(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 "Man{" +
"id=" + id +
", age=" + age +
", name=‘" + name + ‘\‘‘ +
‘}‘;
}
}
通过反射操作注解
public class test13 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
//1. 获取类的注解信息
//获取Man类的class对象
Class c1 = Class.forName("com.shelton.reflection.People");
//通过class对象调用 getAnnotations()方法，获取注解，创建对象
Annotation[] annotations = c1.getAnnotations();
//遍历打印输出
for (Annotation annotation : annotations) {
System.out.println(annotation);
//@com.shelton.reflection.MyClass(value=this is a boy)
}
//2. 获取类注解，value的值
//强转成MyClass类型，获取value参数
MyClass annotation = (MyClass)c1.getAnnotation(MyClass.class);
System.out.println(annotation.value());//this is a boy
//3. 获取指定属性的注解信息
Field name = c1.getDeclaredField("name");
Myfield annotation1 = name.getAnnotation(Myfield.class);
System.out.println(annotation1.columnName());//boy_name
System.out.println(annotation1.type());//varchar
System.out.println(annotation1.length());//3
}
}
标签：targe lan instance jvm nec master extend rop return
原文地址：https://www.cnblogs.com/Sheltonz/p/14117280.html
