大数据技术之_31_Java 面试题_01_JavaSE 面试题 + SSM 面试题 + Java 高级面试题 + Java 项目面试题

    public static void main(String[] args) {
        int i = 1;
        i = i++; // i=1
        int j = i++; // j=1  i=2
        int k = i + ++i * i++; // 2 + 3 * 3 = 11
        System.out.println("i=" + i); // i=4
        System.out.println("j=" + j); // j=1
        System.out.println("k=" + k); // 11
    }

package com.atguigu.singleton;

/*
 * 饿汉式：
 *     在类初始化时直接创建实例对象，不管你是否需要这个对象都会创建
 * 
 * （1）构造器私有化
 * （2）自行创建，并且用静态变量保存
 * （3）向外提供这个实例
 * （4）强调这是一个单例，我们可以用 final 修饰
 */
public class Singleton1 {
    public static final Singleton1 INSTANCE = new Singleton1();

    private Singleton1() {
    }
}

package com.atguigu.singleton;

/*
 * 枚举类型：表示该类型的对象是有限的几个
 * 我们可以限定为一个，就成了单例
 */
public enum Singleton2 {
    INSTANCE
}

package com.atguigu.singleton;

import java.io.IOException;
import java.util.Properties;

public class Singleton3 {
    public static final Singleton3 INSTANCE;

    private String info;

    static {
        try {
            Properties properties = new Properties();
            properties.load(Singleton3.class.getClassLoader().getResourceAsStream("single.properties"));

            INSTANCE = new Singleton3(properties.getProperty("info"));
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    private Singleton3(String info) {
        this.info = info;
    }

    public String getInfo() {
        return info;
    }

    public void setInfo(String info) {
        this.info = info;
    }

    @Override
    public String toString() {
        return "Singleton3 [info=" + info + "]";
    }
}

package com.atguigu.singleton;

/*
 * 懒汉式：
 *     延迟创建这个实例对象
 *  线程不安全（适用于单线程）
 * 
 * （1）构造器私有化
 * （2）用一个静态变量保存这个唯一的实例
 * （3）提供一个静态方法，获取这个实例对象
 */
public class Singleton4 {
    private static Singleton4 instance;

    private Singleton4() {
    }

    public static Singleton4 getInstance() {
        if (instance == null) {
            instance = new Singleton4();
        }
        return instance;
    }
}

package com.atguigu.singleton;

/*
 * 懒汉式：
 *     延迟创建这个实例对象
 *  线程安全（适用于多线程）
 * 
 * （1）构造器私有化
 * （2）用一个静态变量保存这个唯一的实例
 * （3）提供一个静态方法，获取这个实例对象
 */
public class Singleton5 {
    private static Singleton5 instance;

    private Singleton5() {
    }

    public static Singleton5 getInstance() {
        if (instance == null) { // 优化性能
            synchronized (Singleton5.class) { // 线程安全
                if (instance == null) {
                    instance = new Singleton5();
                }
            }
        }
        return instance;
    }
}

package com.atguigu.singleton;

/* 懒汉式：
 *     延迟创建这个实例对象
 *     静态内部类形式（适用于多线程）
 * 
 *     在内部类被加载和初始化时，才创建 INSTANCE 实例对象
 *     静态内部类不会自动随着外部类的加载和初始化而初始化，它是要单独去加载和初始化的。（是最懒的）
 *     因为是在内部类加载和初始化时，创建的，因此是线程安全的
 */
public class Singleton6 {
    private Singleton6() {
    }

    private static class Inner {
        private static final Singleton6 INSTANCE = new Singleton6();
    }

    public static Singleton6 getInstance() {
        return Inner.INSTANCE;
    }
}

一个类要创建实例需要先加载并初始化该类
    main 方法所在的类需要先加载和初始化

一个子类要初始化需要先初始化父类

一个类初始化就是执行 <clinit>() 方法
    <clinit>() 方法由静态类变量显示赋值代码和静态代码块组成
    类变量显示赋值代码 和 静态代码块代码 从上到下顺序执行
    <clinit>() 方法只执行一次

实例初始化就是执行 <init>() 方法
    <init>() 方法可能重载有多个，有几个构造器就有几个 <init> 方法
    <init>() 方法由非静态实例变量显示赋值代码和非静态代码块、对应构造器代码组成

    非静态实例变量显示赋值代码和非静态代码块代码从上到下顺序执行，而对应构造器的代码最后执行

    每次创建实例对象，调用对应构造器，执行的就是对应的 <init> 方法

    <init> 方法的首行是 super() 或 super(实参列表)，即对应父类的 <init> 方法

哪些方法不可以被重写
    final 方法
    静态方法
    private 等子类中不可见方法

对象的多态性
    子类如果重写了父类的方法，通过子类对象调用的一定是子类重写过的代码
    非静态方法默认的调用对象是 this
    this 对象在构造器或者说 <init> 方法中就是正在创建的对象

Override 重写的要求？
    方法名
    形参列表
    返回值类型
    抛出的异常列表
    修饰符

了解《JVM 虚拟机规范》中关于 <clinit> 和 <init> 方法的说明、invokespecial 指令

package com.atguigu.init;

/*
 * 父类的初始化 <clinit>：
 * （1）父类的静态方法 j = method();
 * （2）父类的静态代码块
 * 
 * 
 * 
 * -----------------------------------------
 *  父类的实例化 <init>：
 * （1）super()（最前）
 * （2）i = test();
 * （3）父类的非静态代码块
 * （4）父类的无参构造（最后）
 * 
 * 非静态方法前面其实有一个默认的对象 this
 * this 在构造器（或 <init>）它表示的是正在创建的对象，
 * 因为这里是在创建 Son 对象，所以 test() 执行的是子类重写的代码（面向对象+多态）
 * 
 * 这里 i=test() 执行的是子类重写的 test() 方法
 */
public class Father {
    private int i = test();
    private static int j = method();

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

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

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

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

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

package com.atguigu.init;

/*
 * 子类的初始化 <clinit>：
 * （1）子类的静态方法 j = method();
 * （2）子类的静态代码块
 * 
 * 先初始化父类的静态方法和静态代码块：(5)(1)
 * 再初始化子类的静态方法和静态代码块：(10)(6)
 * -----------------------------------------
 * 子类的实例化  <init>：
 * （1）super()（最前）            (9)(3)(2)
 * （2）i = test();                (9)
 * （3）子类的非静态代码块        (8)
 * （4）子类的无参构造（最后）    (7)
 * 
 * 因为创建了两个 Son 对象，因此实例化方法 <init> 执行了两次
 * 即又出现了一次 (9)(3)(2)(9)(8)(7)
 */
public class Son extends Father {
    private int i = test();
    private static int j = method();

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

    Son() {
        // super(); // 写或不写都在，在子类构造器中一定会调用父类的构造器
        System.out.print("(7)");
    }

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

    public int test() {
        System.out.print("(9)");
        return 1;
    }

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

    public static void main(String[] args) {
        Son s1 = new Son();
        System.out.println();
        Son s2 = new Son();
    }
}

形参是基本数据类型时
    传递数据值

形参是引用数据类型时
    传递地址值，本质也是值
    特殊的类型：String、包装类等对象不可变性

package com.atguigu.passvalue;

import java.util.Arrays;

public class Exam4 {
    public static void main(String[] args) {
        int i = 1;
        String str = "hello"; // 在常量池中（jdk1.8 中，常量池在元空间中；jdk1.7 中，常量池在堆中）
        Integer num = 200; // 值大于 127，对象在堆中
        int[] arr = { 1, 2, 3, 4, 5 }; // 堆中
        MyData my = new MyData(); // 堆中

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

        System.out.println("i = " + i); // i = 1
        System.out.println("str = " + str); // str = hello
        System.out.println("num = " + num); // num = 200
        System.out.println("arr = " + Arrays.toString(arr)); // arr = [2, 2, 3, 4, 5]
        System.out.println("my.a = " + my.a); // my.a = 11
    }

    public static void change(int j, String s, Integer n, int[] a, MyData m) { // 方法在栈中，执行完毕后销毁
        j += 1; // j = 1
        s += "world"; // 产生新的对象
        n += 1; // 产生新的对象
        a[0] += 1; // a[0] = 2
        m.a += 1; // 11
    }
}

class MyData {
    int a = 10;
}

package com.atguigu.step;

import org.junit.Test;

public class TestStep {
    @Test
    public void test() {
        long start = System.currentTimeMillis();
        System.out.println(f(40)); // 165580141
        long end = System.currentTimeMillis();
        System.out.println(end - start); // 308ms
    }

    // 实现 f(n)：求 n 步台阶，一共有几种走法
    public int f(int n) {
        if (n < 1) {
            throw new IllegalArgumentException(n + "不能小于1");
        }
        if (n == 1 || n == 2) {
            return n;
        }
        return f(n - 2) + f(n - 1);
    }
}

package com.atguigu.step;

import org.junit.Test;

public class TestStep2 {
    @Test
    public void test() {
        long start = System.currentTimeMillis();
        System.out.println(loop(40)); // 165580141
        long end = System.currentTimeMillis();
        System.out.println(end - start); // <1ms
    }

    public int loop(int n) {
        if (n < 1) {
            throw new IllegalArgumentException(n + "不能小于1");
        }
        if (n == 1 || n == 2) {
            return n;
        }

        int one = 2; // 初始化 走到第二级台阶的走法
        int two = 1; // 初始化 走到第一级台阶的走法
        int sum = 0;

        for (int i = 3; i <= n; i++) {
            // 最后跨2步 + 最后跨1步的走法
            sum = two + one;
            two = one;
            one = sum;
        }
        return sum;
    }
}

声明的位置
    局部变量：方法体 {} 中，形参，代码块 {} 中
    成员变量：类中方法外
        类变量：有 static 修饰
        实例变量：没有 static 修饰

修饰符
    局部变量：final
    成员变量：public、protected、private、final、static、volatile、transient

值存储的位置
    局部变量：栈
    实例变量：堆
    类变量：方法区

作用域
    局部变量：从声明处开始，到所属的 } 结束
    实例变量：在当前类中 “this.” (有时 this. 可以缺省)，在其他类中 “对象名.” 访问
    类变量：在当前类中 “类名.”(有时类名.可以省略)，在其他类中 “类名.” 或 “对象名.” 访问

生命周期
    局部变量：每一个线程，每一次调用执行都是新的生命周期
    实例变量：随着对象的创建而初始化，随着对象的被回收而消亡，每一个对象的实例变量是独立的
    类变量：随着类的初始化而初始化，随着类的卸载而消亡，该类的所有对象的类变量是共享的

当局部变量与 xx 变量重名时，如何区分：
    局部变量与实例变量重名
        在实例变量前面加 “this.”
    局部变量与类变量重名
        在类变量前面加 “类名.”

package com.atguigu.variable;

public class Exam5 {
    static int s; // 成员变量，类变量
    int i; // 成员变量，实例变量
    int j; // 成员变量，实例变量

    {
        int i = 1; // 非静态代码块中的局部变量 i
        i++; // i = 2
        j++; // j = 1
        s++; // 
    }

    public void test(int j) { // 形参，局部变量 j
        j++; // 
        i++; // i = 1
        s++; // 
    }

    public static void main(String[] args) { // 形参，局部变量 args
        Exam5 obj1 = new Exam5(); // 局部变量 obj1
        Exam5 obj2 = new Exam5(); // 局部变量 obj2
        obj1.test(10);
        obj1.test(20);
        obj2.test(30);

        System.out.println(obj1.i + "," + obj1.j + "," + obj1.s); // 2,1,5
        System.out.println(obj2.i + "," + obj2.j + "," + obj2.s); // 1,1,5
    }
}

事务的属性：
    1.★ propagation：用来设置事务的传播行为
    事务的传播行为：一个方法运行在了一个开启了事务的方法中时，当前方法是使用原来的事务还是开启一个新的事务
        -Propagation.REQUIRED：默认值，使用原来的事务
        -Propagation.REQUIRES_NEW：将原来的事务挂起，开启一个新的事务
    2.★ isolation：用来设置事务的隔离级别
        -Isolation.REPEATABLE_READ：可重复读，MySQL默认的隔离级别
        -Isolation.READ_COMMITTED：读已提交，Oracle默认的隔离级别，开发时通常使用的隔离级别

  <filter>
    <!-- SpringMVC 中如何解决 POST 请求中文乱码问题 -->
    <filter-name>CharacterEncodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
      <!-- POST 请求中文乱码问题 -->
      <param-name>encoding</param-name>
      <param-value>UTF-8</param-value>
    </init-param>
    <init-param>
      <!-- POST 响应中文乱码问题 -->
      <param-name>forceEncoding</param-name>
      <param-value>true</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>CharacterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

购物车：
1. 购物车跟用户的关系?
    a) 一个用户必须对应一个购物车【一个用户不管买多少商品，都会存在属于自己的购物车中。】
    b) 单点登录的开发一定在开发购物车之前。
2. 跟购物车有关的操作有哪些？
    a) 添加购物车
        i.用户未登录状态
            1. 添加到什么地方？未登录将数据保存到什么地方？
                a) Redis ? --> 京东使用
                b) Cookie ? --> 自己开发项目的时候【如果浏览器禁用 cookie，则京东登录不上】
        ii.用户登录状态
            1. Redis 缓存中【读写速度快】
                a) Hash：hset(key,field,value)
                    i. key=user:userId:cart
                    ii. Hset(key,skuId,value);
            2. 存在数据库中【oracle、mysql，保证数据安全性】
    b) 展示购物车
        i.未登录状态展示
            1.直接从 cookie 中取得数据进行展示即可
        ii.登录状态
            1.用户一旦登录：必须显示数据库 【redis】+【cookie】 中的购物车的数据
                a) Cookie 中有三条记录
                b) Redis 中有五条记录
                c) 合并后，真正展示的时候应该是小于或等于八条记录