尚硅谷—面试—第一季（SE）

（视频：https://www.bilibili.com/video/BV1Eb411P7bP）

目录

一.Java SE：

---

一.Java SE：

             1）如下代码运行结果：（4，1，11）

    @Test
    void contextLoads() {

        int i = 1;
        i = i++;
        int j = i++;
        int k = i + ++i * i++;

        System.out.println(i);
        System.out.println(j);
        System.out.println(k);

    }

             2）手写单例模式：
                      a：饿汉式：
                            - 1.直接实例化 饿汉式：（简洁直观）
                            - 2.枚举式：（最简洁）
                            - 3.静态代码块 饿汉式：（适合复杂实例化）

public class EHanSingleton {

    private EHanSingleton() {
    }

    private static final EHanSingleton eHanSingleton = new EHanSingleton();

    public static EHanSingleton geteHanSingleton() {
        return eHanSingleton;
    }
}

                      b：懒汉式：
                            - 1.线程不安全：（适用于单线程）
                            - 2.线程安全：（适用于多线程）
                            - 3.静态内部类形式：（适用于多线程）（静态内部类，不会随着外部类的初始化而初始化）

public class LanHanSingleton {

    private LanHanSingleton() {
    }

    private static LanHanSingleton lanHanSingleton = null;

    public static LanHanSingleton getLanHanSingleton() {
        if (lanHanSingleton == null) {
            synchronized (LanHanSingleton.class) {
                lanHanSingleton = new LanHanSingleton();
            }
        }
        return lanHanSingleton;
    }

}

             3）类的初始化 和 实例初始化：
                      a：运行如下代码：

public class Son extends Father {

    private int i = test();

    private static int j = method();

    static {
        System.out.println("6");
    }

    Son() {
        System.out.println("7");
    }

    {
        System.out.println("8");
    }

    @Override
    public int test() {
        System.out.println("9");
        return 1;
    }

    public static int method() {
        System.out.println("10");
        return 1;
    }

}

public class Father {

    private int i = test();

    private static int j = method();

    static {
        System.out.println("1");
    }

    Father() {
        System.out.println("2");
    }

    {
        System.out.println("3");
    }

    public int test() {
        System.out.println("4");
        return 1;
    }

    public static int method() {
        System.out.println("5");
        return 1;
    }

}

public class Test_01 {
    public static void main(String[] args) {
        Son son1 = new Son();
        System.out.println("-----------------");
        Son son2 = new Son();
        /**
         * 5
         * 1
         * 10
         * 6
         * 9
         * 3
         * 2
         * 9
         * 8
         * 7
         * -----------------
         * 9
         * 3
         * 2
         * 9
         * 8
         * 7
         */
    }
}

                      b：讲解：
                            - 1.类初始化过程：
                                   1.一个类创建实例，需要先加载并初始化该类。（main 方法类先初始化）
                                   2.一个子类初始化，需要先初始化父类。
                                   3.静态变量 和 静态代码 从上到下执行，并且只执行一次。
                            - 2.实例初始化过程：
                                   1.依次执行：非静态实例变量显示赋值代码、非静态代码块、对应构造器。
                                   2.构造器代码最后执行。
                                   3.构造器方法，先执行 Super() 方法，先初始化父类，再回来执行。
                            - 3.方法的重写
                                   1.哪些方法，不可以被重写。
                                          final 修饰的方法、static 修饰的方法、构造方法，private 等子类不可见的方法。
                                   2.对象的多态性：
                                          如果子类 重写了父类的方法，通过子类对象调用的一定是重写过的代码。
                                          非静态方法，默认的调用对象是 this。



             4）：方法的参数传递机制：

public class CanshuCDTest {

    public static void main(String[] args) {
        int i = 1;
        String str = "hello";
        Integer num = 200;
        int[] arr = {1, 2, 3, 4, 5};
        MyData myData = new MyData();

        change(i, str, num, arr, myData);

        System.out.println(i);
        System.out.println(str);
        System.out.println(num);
        System.out.println(Arrays.toString(arr));
        System.out.println(myData.a);
    }

    private static void change(int j, String s, Integer n, int[] a, MyData m) {
        j += 1;
        s += "world";
        n += 1;
        a[0] += 1;
        m.a += 1;
    }

}

class MyData {
    int a = 10;
}

                      a：String、包装类等对象的不可变性：
                      b：方法参数传递机制：
                            - 1.形参是基本数据类型：传递数据值。
                            - 2.实参是引用数据类型：传递地址值。（注：特殊的类型：String、包装类等对象不可变性）



             5）递归与迭代：


             6）成员变量 与 局部变量：

public class Exam5 {

    public static int s;
    int i;
    int j;

    {
        int i = 1;
        i++;
        j++;
        s++;
    }

    public void test(int j) {
        j++;
        i++;
        s++;
    }

    public static void main(String[] args) {
        Exam5 obj1 = new Exam5();
        Exam5 obj2 = new Exam5();
        obj1.test(10);
        obj1.test(20);
        obj2.test(30);

        System.out.println(obj1.i + " , " + obj1.j + " , " + obj1.s);
        System.out.println(obj2.i + " , " + obj2.j + " , " + obj2.s);

    }
}

                      a：考点：
                            - 1.就近原则：
                            - 2.变量的分类：
                                       成员变量：类变量（静态变量）、实例变量。
                                       局部变量：
                            - 3.非静态代码块的执行：每次创建实力对象，都会执行
                            - 4.方法的调用规则：调用一次执行一次。

                      b：局部变量 与 成员变量的区别：
                            - 1.声明的位置：
                                     局部变量：方法体中、形参、代码块中
                                     成员变量：类中方法外。（类变量、实例变量）
                            - 2.修饰符：
                                     局部变量：final
                                     成员变量：public、protected、private、final、static、volatile、transient。
                            - 3.存储的位置：
                                     局部变量：栈
                                     实例变量：堆
                                     类变量：方法区

二：SSM 面试题

             3）
                      a：？
                            - 1.
                            - 2.