Java反射——java.lang.Class和类的加载

反射的基础: java.lang.Class

Class类的实例对象，用于记录类描述信息。

源码说：represent classes and interfaces in a running Java application

Class类没有公共的构造方法，无法通过new运算符实例化；只能通过对象的getClass方法，或是通过Class.forName(…)来获得实例。


static ClassforName(String className)throws ClassNotFoundException	使用参数className来指定具体的类，来获得相关的类描述对象，该方法有可能抛出类加载异常（ClassNotFoundException），必须捕捉
Class getSuperclass()	获得当前类描述对象的父类的描述对象
String getName()	返回当前类描述对象的类名称

获取Class对象的三种方式：

public class _T11获取Class {

	// Class：类描述对象

	// （源码说：represent classes and interfaces in a running Java application）

	public static void main(String[] args) {

		Class<?> _class;

		// ***1*对象.getClass()

		String str = "";

		_class = str.getClass();

		System.out.println(_class + "-----对象名.getClass()");

		// ***2*类.class

		_class = String.class;

		System.out.println(_class + "-----类名.class");

		// ***3*Class.forName("")

		try {

			_class = Class.forName("java.lang.String");

			System.out.println(_class + "-----Class.forName(...)");

		} catch (ClassNotFoundException e) {

			e.printStackTrace();

		}

	}

}

class java.lang.String-----对象名.getClass()

class java.lang.String-----类名.class

class java.lang.String-----Class.forName(...)

.getSuperclass()

_class.getSuperclass()：获得父类的描述对象

以下示例，打印StringBuffer的父类、父类的父类……

public class _T12getSuperclass {

	public static void main(String[] args) {

		System.out.println("-----.getSuperclass()获得父类的描述对象-----");

		try {

			Class _class = Class.forName("java.lang.StringBuffer");

			// 循环打印父类信息，直到没有父类

			while (_class != null) {

				System.out.println(_class);

				// getSuperclass()：获得父类的描述对象

				_class = _class.getSuperclass();

			}

		} catch (ClassNotFoundException cnfe) {

			cnfe.printStackTrace();

		}

	}

}

-----.getSuperclass()获得父类的描述对象-----

class java.lang.StringBuffer

class java.lang.AbstractStringBuilder

class java.lang.Object

类的加载

Java程序运行在Java虚拟机进程中，同一个JVM的所有线程、所有变量都处于同一个进程里。

当系统出现以下几种情况时，JVM进程将被终止：

|--程序正常结束。

|--程序运行到System.exit()或Runtime.getRuntime().exit()代码。

|--程序执行过程中遇到未捕获的异常或错误。

|--强制结束JVM进程。

类加载，是指将类的.class文件读入内存，并为之创建一个java.lang.Class对象。

class Tester {

	static {

		System.out.println("静态初始化块...");

	}

	public Tester() {

		System.out.println("构造方法...");

	}

}

public class _T21TestClassLoader {

	public static void main(String[] args) throws ClassNotFoundException {

		ClassLoader _cLoader = ClassLoader.getSystemClassLoader();

		System.out.println("=====loadClass()：加载类，但不做初始化=====");

		String _包类名 = "Tester";

		Class<?> loadClass = _cLoader.loadClass(_包类名);

		System.out.println("加载即得Class：" + loadClass);

		// -----------------------------------------------------

		System.out.println("=====Class.forName()：初始化(静态代码块执行)=====");

		Class.forName(_包类名);

	}

}

=loadClass()：加载类，但不做初始化=

加载即得Class：class Tester

=Class.forName()：初始化=

静态初始化块...

static变量的初始化

使用static final的变量（常量），如果值可以在编译期确定，则类不需要初始化。

// static final修饰的变量，被用于“常量”，更类似于“宏定义”。

// 当其在编译器能确定时，不需要初始化类，使用“宏变量”替换的形式进行编译；

// 当其不能在编译期确定时，需要初始化类；

// 如果未加final，不是“宏定义”，需要初始化类。

class StaticField {

	static {

		System.out.println("---此代码不执行---");

	}

	static final String compileConstant = "static final变量，编译时能确定，类不做初始化，使用'宏替换'的形式编译";

}

class StaticField2 {

	static {

		System.out.println("【2：此代码执行，表示初始化过了】");

	}

	static final String compileConstant = "static final变量，编译时不能确定时，运行时才确定。"

			+ System.getProperty("os.name");

}

class StaticField3 {

	static {

		System.out.println("【3：此代码执行，因为就不是final】static{}变量不是final，编译时能确定，变量");

	}

	static String compileConstant = "非final的static变量";

}

public class _T22宏定义常量 {

	public static void main(String[] args) {

		System.out.println("\t" + StaticField.compileConstant);

		System.out.println("\t" + StaticField2.compileConstant);

		System.out.println("\t" + StaticField3.compileConstant);

	}

}

运行结果：

	static final变量，编译时能确定，类不做初始化，使用'宏替换'的形式编译

【2：此代码执行，表示初始化过了】

	static final变量，编译时不能确定时，运行时才确定。Windows 10

【3：此代码执行，因为就不是final】static{}变量不是final，编译时能确定，变量

	非final的static变量

巴特西

Java反射——java.lang.Class和类的加载

反射的基础: java.lang.Class

.getSuperclass()

类的加载

static变量的初始化

最新文章

热门文章