类加载器深入剖析，2021 最新华为 Java 校招面试题
在 Worker 类的二进制数据中，包含了一个对 Car 类 run()方法的符号引用，它由 run()方法的全名和相关描述符组成。在解析阶段，Java 虚拟机会把这个符号引用替换为一个指针，该指针指向 Car 类的 run()方法在方法区内的内存位置，这个指针就是直接引用。
初始化：
在初始化阶段，Java 虚拟机执行类的初始化语句，为类的静态变量赋予初始值。在程序中，静态变量的初始化有两种途径：
（1）在静态变量的声明处进行初始化；
（2）在静态代码块中进行初始化。
例如在上面的 Sample 例子中 a 被显式的初始化，而变量 b 是在静态代码块中初始化的。
静态变量的声明语句以及静态代码块都被看做类的初始化语句，Java 虚拟机会按照初始化语句在类文件中的先后顺序来依次执行他们。
例子：
class Singleton {
private static Singleton singleton = new Singleton();
public static int counter1;
public static int counter2 = 0;
private Singleton() {
counter1++;
counter2++;
}
public static Singleton getInstance() {
return singleton;
}
}
public class MyTest {
public static void main(String[] args) {
Singleton singleton = Singleton.getInstance();
System.out.println("counter1=" + Singleton.counter1);
System.out.println("counter2=" + Singleton.counter2);
}
}
输出：
_counter1=1
counter2=0_
原因：
准备阶段为静态变量赋值默认值（类型的默认值，不是程序中赋值）此时：singleton = null? counter1=0? counter2=0
初始化阶段，为静态变量按照顺序赋予正确的值：
首先执行 singleton = new singleton();会执行构造器，因此 counter1=1，counter2 = 1
然后执行 counter1 和 counter2 的赋值语句，因此 counter1=1?counter2 = 0；
初始化步骤：
（1）假如这个类还没有被加载和连接，那就先进行加载和连接。
（2）假如类存在直接的父类，并且这个父类还没有被初始化，那就向初始化直接的父类
（3）假如类中存在初始化语句，那就依次执行这些初始化语句。
例子：
public class FinalTest {
public static final int x = 8 / 2;
static {
System.out.println("FinalTest static block");
}
}
class Test {
public static void main(String[] args) {
System.out.println(FinalTest.x);
}
}
输出：
4
原因：?常量在编译期间就会调入类的常量池中 ，所以直接引用 final 类型的变量，类并没有被初始化?
public class FinalTest2 {
public static final int y = new Rand
om().nextInt(100);
static {
System.out.println("FinalTest2 static block");
}
}
class Test2 {
public static void main(String[] args) {
System.out.println(FinalTest2.y);
}
}
输出：
why? ?????
原因：x 在编译时就可以确定，y 只有在运行时才能确定
当 JAVA 虚拟机初始化一个类时，要求它的所有父类都已经被初始化，但是这条规则并不适用于接口
1）在初始化一个类时，并不会先初始化它所实现的接口
2）在初始化一个接口时，并不会先初始化它的父接口
因此，一个父接口并不会因为它的子接口或者实现类的初始化而初始化。只有当程序首次使用特定接口的静态变量时，才会导致该接口的初始化。
class Parent {
static int a = 3;
static {
System.out.println("Parent static block");
}
}
class Child extends Parent {
static int b = 4;
static {
System.out.println("Child static block");
}
}
public class Test1 {
static {
System.out.println("Test1 static block");
}
public static void main(String[] args) {
System.out.println(Child.b);
}
}
输出：
如果将 main 函数调用换成：
输出：
程序对子类的“主动使用”会导致父类被初始化；但是父类的“主动”使用并不会导致子类初始化（不可能说生成一个 bjectO 类的对象就导致系统中所有的子类都会被初始化）
只有当程序访问的静态变量或者静态方法确实在当前类或当前接口中定义时，才可以认为是对类或接口的主动使用。
调用 ClassLoader 类的 loadClass 方法加载一个类，并不是对类的主动使用，不会导致类的初始化
例子：
public class ClassLoaderTest {
public static void main(String[] args) {
ClassLoader loader = ClassLoader.getSystemClassLoader();
try {
Class<?> aClass1 = loader.loadClass("com.zy.jvm.FinalTest");
System.out.println("=======================");
aClass1 = Class.forName("com.zy.jvm.FinalTest");
}
catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
FinalTest 是之前定义的一个类：
public class FinalTest2 {
public static final int y = new Random().nextInt(100);
static {
System.out.println("FinalTest2 static block");
}
}
}
输出为：
若有一个类加载器能成功加载 Sample 类，那么这个类加载器被称为定义类加载器，所有能成功返回 Class 对象的引用的类加载器都被称为初始类加载器。（即定义类加载器及其所有子类加载器都被称为初始类加载器）
父亲委托机制的优点是能够提高软件系统的安全性。因为在此机制下，用户自定义的类加载器不可能加载应该由父类加载器加载的可靠类，从而防止不可靠甚至恶意的代码代替由父加载器加载的可靠代码。例如 java,lang.Object 类总是由根类加载器加载，其他任何用户自定义的类加载器都不可能加载含有恶意代码的 java.lang.Object 类。
命名空间：
每个类加载器都有自己的命名空间，命名空间由该加载器及所有父类加载器所加载的类组成。在同一个命名空间，不会出现类的完整名字（包括类的包名）相同的两个类；在不同的命名空间中，有可能会出现类的完整名字相同的两个类。
扩展：是否属于一个类，由包名和加载器决定。
自定义类加载器：
要创建用户自己的类加载器，只需要扩展 java.lang.ClassLoader 类，然后覆盖它的 findClass(String name)方法即可。
public class MyClassLoader extends ClassLoader{
private String name; //类加载器的名字
private String path = "d:\"; //加载类的路径
private final String fileType = ".class"; //class 文件的扩展名
public MyClassLoader(String name) {
super(); //让系统类加载器称为该类加载器的父类加载器
this.name = name;
}
public MyClassLoader(ClassLoader parent, String name) {
super(parent); //显式指定该类加载器的父类加载器
this.name = name;
}
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
byte[] date = loadClassDate(name);
return this.defineClass(name, date, 0, date.length);
}
private byte[] loadClassDate(String name) {
byte[] date = null;
name = name.replace(".", "\");
try (InputStream is = new FileInputStream(new File(path + name + fileType));
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream()){
int ch = 0;
while (-1 != (ch = is.read())) {
byteArrayOutputStream.write(ch);
}
date = byteArrayOutputStream.toByteArray();
}
catch (FileNotFoundException e) {
e.printStackTrace();
}
catch (IOException e) {
e.printStackTrace();
}
return date;
}
public String getPath() {
return path;
}
public void setPath(String path) {
this.path = path;
}
@Override
public String toString() {
return "MyClassLoader{" +
"name='" + name + ''' +
'}';
}
}
class MyClassLoaderTest {
public static void main(String[] args) {
MyClassLoader classLoader1 = new MyClassLoader("loader1");
classLoader1.setPath("d:\myapp\serverlib\");
MyClassLoader classLoader2 = new MyClassLoader(classLoader1, "loader2");
classLoader2.setPath("d:\myapp\clientlib\");
MyClassLoader classLoader3 = new MyClassLoader(null, "loader3");
classLoader3.setPath("d:\myapp\otherlib\");
还未添加个人签名 2021.03.18 加入
还未添加个人简介
评论