java面试(十八)--（1）什么时候类必须初始化，什么情况类不会初始化（2）java类加载机制导图（3）回溯法

1.什么时候类必须初始化，什么情况类不会初始化

虚拟机规范严格规定了有且只有五种情况必须立即对类进行“初始化”：

1. 使用new关键字实例化对象的时候、读取或设置一个类的静态字段的时候，已经调用一个类的静态方法的时候。
2. 使用java.lang.reflect包的方法对类进行反射调用的时候，如果类没有初始化，则需要先触发其初始化。
3. 当初始化一个类的时候，如果发现其父类没有被初始化就会先初始化它的父类。
4. 当虚拟机启动的时候，用户需要指定一个要执行的主类（就是包含main()方法的那个类），虚拟机会先初始化这个类；
5. 使用Jdk1.7动态语言支持的时候的一些情况。

除了这五种之外，其他的所有引用类的方式都不会触发初始化，称为被动引用。下面是被动引用的三个例子：

1. 通过子类引用父类的的静态字段，不会导致子类初始化。
2. 通过数组定义来引用类，不会触发此类的初始化。

public class NotInitialization {  
    public static void main(String[] args) {  
        SuperClass[] sca = new SuperClass[10];  
    }    
} 

3.常量在编译阶段会存入调用类的常量池中，本质上没有直接引用到定义常量的类，因此不会触发定义常量的类的初始化。

public class ConstClass {  
    static {  
        System.out.println("ConstClass init!");  
    }  
    public static final int value = 123;  
}  
public class NotInitialization{  
    public static void main(String[] args) {  
        int x = ConstClass.value;  
    }  
}  

上述代码运行之后，也没有输出“ConstClass init！

补充一个小的知识点:
Java提供的事件处理模型是一种人机交互模型。它有三个基本要素：

1. 事件源（Event Source）：即事件发生的场所，就是指各个组件，如按钮等，点击按钮其实就是组件上发生的一个事件；
2. 事件（Event）：事件封装了组件上发生的事情，比如按钮单击、按钮松开等等；
3. 事件监听器（Event Listener）：负责监听事件源上发生的特定类型的事件，当事件到来时还必须负责处理相应的事件；

2.java类加载机制导图

3.回溯法

请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则该路径不能再进入该格子。 例如 a b c e s f c s a d e e 矩阵中包含一条字符串"bcced"的路径，但是矩阵中不包含"abcb"路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入该格子。

示例代码:

public class TestHasPath {
    boolean hasPath(char[] matrix, int rows, int cols, char[] str){
   
	}
}

实现代码(思路分析):

/*
 * 请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。
 * 路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。
 * 如果一条路径经过了矩阵中的某一个格子，则该路径不能再进入该格子
 *
 * 思路：回溯法：首先任意一个点都有可能成为起点，所以要获得任意一点的坐标(位于第几行，第几列)
 * 其次要有一个数组记录这个点是否被访问过，同时要有一个指针来记录字符串中字符的位置。
 * 当某个点成为合法的起点时，即这个点与字符串中第一个字符相等，则可以继续朝上下左右搜索下一个点；
 * 如果这个点不能成为合法的起点，则恢复现场(这个点没有被访问过且字符串指针后退)
 */
public class TestHasPath {
    /**
     *
     * @param matrix 矩阵全部字符
     * @param rows   总行数
     * @param cols   总列数
     * @param str    查询路径(顺序)
     * @return
     */
    public boolean hasPath(char[] matrix, int rows, int cols, char[] str) {
        //判断是否合法
        if(matrix.length <= 0 || rows < 0 || cols < 0 || str.length <= 0) {
            return false;
        }
        //记录数组中被访问的点,默认值为false
        boolean visited[] = new boolean[rows * cols];
        //检查字符串中(str) 指针指向的字符
        int [] index = {0};

        for(int i = 0;i < rows;i ++) {
            for(int j = 0;j < cols;j ++) {
                if(isPath(matrix, rows, cols, i, j, str, visited, index)) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     *
     * @param matrix    矩阵全部字符
     * @param rows      总行数
     * @param cols      总列数
     * @param row       当前行数
     * @param col       当前列数
     * @param str       查询路径(顺序)
     * @param visited   记录点是否被访问
     * @param index     指针指向检查字符的位置
     * @return
     */
    public boolean isPath(char[] matrix, int rows, int cols, int row, int col, char[] str, boolean visited[], int [] index) {

        if(index[0] == str.length) {
            return true;
        }

        boolean flag = false;
        //当前点折算到原数组的位置是：row * cols + col
        if(row >= 0 && row < rows && col >= 0 && col < cols
                && !visited[row * cols + col] && matrix[row * cols + col] == str[index[0]]) {
            index[0] ++;   //指针右移
            visited[row * cols + col] = true;

            //第一个点是合法的起点之后开始回溯:上下左右进行搜索
            flag = isPath(matrix, rows, cols, row - 1, col, str, visited, index) ||
                    isPath(matrix, rows, cols, row + 1, col, str, visited, index) ||
                    isPath(matrix, rows, cols, row, col - 1, str, visited, index) ||
                    isPath(matrix, rows, cols, row, col + 1, str, visited, index);
            if(!flag) {       //恢复现场
                index[0] --;
                visited[row * cols + col] = false;
            }
        }
        return flag;
    }

    public static void main(String[] args) {
        String str = "ABCEHJIGSFCSLOPQADEEMNOEADIDEJFMVCEIFGGS";
        char[] matrix = str.toCharArray();
        String str2 = "SGGFIECVAASABCEEJIGOEM";
        char[] c = str2.toCharArray();
        System.out.println(new TestHasPath().hasPath(matrix, 5, 8, c));
    }
}