注解与反射（3）--类的加载与获得

最新推荐文章于 2024-08-28 03:46:55 发布

zxy7857

最新推荐文章于 2024-08-28 03:46:55 发布

阅读量80

点赞数 1

文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/zxyccm/article/details/122845854

版权

类的加载

加载：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时的数据结构，然后生成一个代表这个类的java.lang.Class对象（故只能获取，不能创建）
链接：将java类的二进制代码合并到JVM的运行状态之中的过程
- 验证：确保加载的类的信息符合JVM标准，没有安全方面的问题
- 准备：正式为类变量（static）分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配
- 解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程
初始化：
- 执行类构造器()方法的过程。类构造器()方法是由编译器自动收集类中的所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器）
- 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化
- 虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步

package Annotation;

public class Test5 {

	public static void main(String[] args) {
		A a = new A();
		System.out.println(A.m);
	}
}

class A{
	static {
		
		System.out.println("A类静态代码块初始化");
		
		m = 300;
		
	}
	
	static int m = 100;
	
	public A() {
		
		System.out.println("A类的无参构造函数初始化");
	}
}

输出：
A类静态代码块初始化
A类的无参构造函数初始化
100
 
过程：
1.加载到内存，会产生一个类对应的class对象
2.连接，链接结束后m = 0
3.初始化
    <clinit>(){
    			System.out.println("A类静态代码块初始化");
    			m = 300;
    			m = 100;
	}
	m = 100;

类的初始化

什么时候会发生类的初始化？

类的主动引用（一定会发生类的初始化）
- 当虚拟机启动，先初始化main方法所在的类
- new一个对象
- 调用类的静态成员（除了final常量）和静态方法
- 使用java.lang.reflect包的方法对类进行反射调用
- 当初始化一个类，如果其父类没有被初始化，则会先初始化它的父类
类的被动引用（不会发生类的初始化）
- 当访问一个静态域时，只有真正声明这个域的类才会被初始化。如：当通过子类调用父类的静态变量，不会导致子类初始化
- 通过数组定义类引用，不会触发此类的初始化
- 引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了）

package Annotation;

/* 测试类什么时候会初始化 */
public class Test6 {

	static {
		System.out.println("main类被加载");
	}
	
	public static void main(String[] args) throws ClassNotFoundException {
		
		/* 主动引用 */
		//Son son = new Son();
		
		/* 反射也会产生主动引用 */
		//Class.forName("Annotation.Son");
		
		/* 不会产生类的引用的方法 */
		//System.out.println(Son.b);
		
		//Son[] array  =new Son[5];
		
		System.out.println(Son.M);
	}
	
}

class Father{
	
	static {
		System.out.println("父类被加载");
	}
	
	static int b = 2;
}

class Son extends Father{
	
	static {
		System.out.println("子类被加载");
		m = 300;
	}
	
	static int m = 100;
	static final int M = 1;
	
}

类加载器

类加载器的作用：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口
类缓存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间，不过JVM垃圾回收机制可以回收这些Class对象
JVM规范定义了如下类型的类加载器
- 引导类加载器
- 拓展类加载器
- 系统类加载器

package Annotation;

public class Test7 {

	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("Annotation.Test7").getClassLoader();
		System.out.println(classLoader);
		
		/* 测试JDK内置的类是谁加载的 */
		classLoader = Class.forName("java.lang.Object").getClassLoader();
		System.out.println(classLoader);
		
		/* 如何获得系统类加载器可以加载的路径 */
		System.out.println(System.getProperty("java.class.path"));
	}
	
}

输出：
jdk.internal.loader.ClassLoaders$AppClassLoader@6659c656
jdk.internal.loader.ClassLoaders$PlatformClassLoader@2d363fb3
null
jdk.internal.loader.ClassLoaders$AppClassLoader@6659c656
null
E:\Java\Annotation\bin

创建运行时类的对象

package Annotation;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/* 获取类的信息 */
public class Test8 {

	@SuppressWarnings({ "unchecked", "rawtypes" })
	public static void main(String[] args) throws ClassNotFoundException, 
	NoSuchFieldException, SecurityException, NoSuchMethodException {
		Class c1 = Class.forName("Annotation.User");
		
		User user = new User();
		c1 = user.getClass();
		
		/* 获得类的名字 */
		System.out.println(c1.getName());//获得包名+类名
		System.out.println(c1.getSimpleName());//获得类名
		
		/* 获得类的属性 */
		Field[] fields = c1.getFields();
		fields = c1.getDeclaredFields();
		for(Field field : fields) {
			System.out.println(field);
		}
		
		/* 获得指定属性的值 */
		Field name = c1.getDeclaredField("name");
		System.out.println(name);
		
		/* 获得类的方法 */
		/* 获得本类及其父类的全部public方法 */
		c1.getMethods();
		Method[] methods = c1.getDeclaredMethods();
		for(Method method : methods) {
			System.out.println("正常的："+method);
		}
		
		/* 获得本类所有方法 */
		methods = c1.getDeclaredMethods();
		for(Method method : methods) {
			System.out.println("getDeclaredMethods:"+method);
		}
		
		/* 获得指定方法 */
		Method getName = c1.getMethod("getName", null);
		Method setName = c1.getMethod("setName", String.class);
		System.out.println(getName);
		System.out.println(setName);
		
		/* 获得构造器 */
		Constructor[] constructors = c1.getConstructors();
		for(Constructor constructor : constructors) {
			System.out.println(constructor);
		}
		
		constructors = c1.getDeclaredConstructors();
		for(Constructor constructor : constructors) {
			System.out.println("--"+constructor);
		}
		
		/* 获得指定构造器 */
		Constructor dc = c1.getDeclaredConstructor(String.class, int.class, int.class);
		System.out.println("指定"+dc);
	}
}

输出：
Annotation.User
User
private java.lang.String Annotation.User.name
private int Annotation.User.id
private int Annotation.User.age
private java.lang.String Annotation.User.name
正常的：public void Annotation.User.setId(int)
正常的：public int Annotation.User.getAge()
正常的：public void Annotation.User.setAge(int)
正常的：public java.lang.String Annotation.User.getName()
正常的：public java.lang.String Annotation.User.toString()
正常的：public void Annotation.User.setName(java.lang.String)
正常的：public int Annotation.User.getId()
getDeclaredMethods:public void Annotation.User.setId(int)
getDeclaredMethods:public int Annotation.User.getAge()
getDeclaredMethods:public void Annotation.User.setAge(int)
getDeclaredMethods:public java.lang.String Annotation.User.getName()
getDeclaredMethods:public java.lang.String Annotation.User.toString()
getDeclaredMethods:public void Annotation.User.setName(java.lang.String)
getDeclaredMethods:public int Annotation.User.getId()
public java.lang.String Annotation.User.getName()
public void Annotation.User.setName(java.lang.String)
public Annotation.User(java.lang.String,int,int)
public Annotation.User()
--public Annotation.User(java.lang.String,int,int)
--public Annotation.User()
指定public Annotation.User(java.lang.String,int,int)