Java基础笔记

快来打我* 2022-04-24 02:48 69阅读 0赞

**1****、基本数据类型：**

简单数据类型（4类8种）：

整数：字节型（byte）、短整型（short）、整型（int）、长整型（long）

浮点型：浮点型（float）、双精度型（double）

字符型：char

布尔型：bollean

char类型使用Unicode编码，Unicode前128个（0-127）保留ASCII编码；

float值赋值必须加f/F，否则当成double类型，而double可加可不加d/D;

**2****、类型转换**

1、自动类型转换（小->大）：

1）类型兼容（如都为数值型）2）目标类型大于源类型；例:

byte a = 128;  // 编译出错,int型128超出byte的范围
    float b = 1.5; // 编译出错，浮点数默认为double类型，float必须加f/F
    short i = 1 +1.1; // 编译出错，表达式自动提升类型为double T
    byte c = 3;    // 编译正确

同时注意如int型范围为\-2^31 ~ 2^31-1，当你使用超出这个范围的整数时必须在末尾添加l/L。例:

long a = 10000000000; //编译出错: The literal 10000000000 of type int is out of range
    long b = 10000000000L; //编译正确

还有一个地方需要注意的是：char型其本身是unsigned型，同时具有两个字节，其数值范围是0 ~ 2^16-1，因为，这直接导致**byte****型不能自动类型提升到char，char和short直接也不会发生自动类型提升（因为负数的问题）**，同时，byte当然可以直接提升到short型。

2、强制类型转换（大->小）

范围大的数值类型赋给范围小的类型时需要强制类型转换，可能丢失精度！例：

byte a = (byte)128;   // int型128超出byte的范围，需要手动转为byte类型，但是会丢失精度。此时a的值为-128
    short i = (short)(1 +1.1);   //表达式运算是自动提升类型为double，需要对结果进行强制类型转换

**3****、包装器、拆箱装箱**

每一个基本类型对应一个类，如int与Integer类，叫做“包装器”，或者叫对象包装器。Java有8种基本类型，有9个包装器，分别为：Intger、Long、Short、Byte、Double、Float、Character、Boolean以及Void。前6个类都派生于一个公共的超类Number。

装箱：Java SE5出现。装箱自动将基本数据类型转换为对应包装器对象。

Integer a=10;//相当于：Integer a=Integer.valueOf(10);

通过反编译class文件后，我们知道装箱实际上是通过valueOf()方法实现的，该方法返回一个Integer对象。  
拆箱：拆箱（unboxed），与装箱是正好相反的操作。自动将包装器对象转换为对应的基本数据类型。

Integer i=new Integer(5);
    int b=i;//拆箱：自动将Integer类对象变成int类数据类型，再赋给int类变量b
    int b=i.intValue(); //手动用intValue方法以int的形式返回Integer对象的值

4、== 与 equals

(1)、“==“操作符用于比较它左右的操作对象是否相同。

当==符号比较基本数据类型时，比较的是它们的值。

当==符号计较对象时，比较的是它们的是否指向同一个区域（即是否有相同的引用）。

当==操作符的两边，一个操作数是基本数据类型，另一个是对象时，则会将对象进行拆箱，从而变成两个基本数据类型进行值的比较。

(2)、“equals”则是Object类的一个方法，在Object类中，equals()用来比较两个对象的引用是否相等，即是否指向同一个对象。Integer等包装器中重写了equals()方法，用于比较值（指向对象的内容）。

Object中equals()源码：

public boolean equals(Object obj) {
            return (this == obj);
    }

Integer中equals()源码（如果值Integer对象则比较值）：

public boolean equals(Object obj) {
            if (obj instanceof Integer) 
                return value == ((Integer)obj).intValue();
            }
            return false;
    }

这里必须注意的是自动装箱时 Integer i = 127；与Integer i = 128;的区别，自动装箱的实现是通过调用Integer.valueOf()方法返回一个Integer对象，看其源码：

public static Integer valueOf(int i) {
            if (i >= IntegerCache.low && i <= IntegerCache.high
                return IntegerCache.cache[i + (-IntegerCache.low)];
            return new Integer(i);
    }

其中IntegerCache.low为-28，IntegerCache.high为127，所以自动装箱时-128到127之间的值直接饮用缓存区中已经定义好的Integer对象，超出范围则创建一个新的对象。例：

Integer a = 127;
       Integer b = 127;
       Integer c = 128;
       Integer d = 128;
       System.out.println(a == b);  //true a,b 为127，自动装箱时都是引用的缓存区中的同一个对
       System.out.println(c == d);  //false c,d 为128，自动装箱是分别创建了两个不同的对象
       System.out.println(a.equals(b)); //true:Integer.equals() 比较的是对象的值
       System.out.println(c.equals(d)); //true:Integer.equals() 比较的是对象的值

5、数组

一维数组

定义：

int[] a = new int[10];  或int a[] = new int[10];//数组大小必须写
    
    int a1[] = new int[10];
    int a2[] = {1,2,4,5,3};
    int a3[] = new int[]{1,2,3};
    int a4[];
    a4 = new int[10];

多维数组：数组的数组

定义（二维）：

int[][] a = new int[10][]; 或 int a[][] = new int[10][];   //第二维数组大小可写可不写
    
    int a5[][] = new int[3][];
    a5[0] = new int[10];
    a5[1] = new int[20];
    a5[2] = new int[30];

6、final

1) final变量：相当于常量 ，一旦赋值便不可更改，final变量为只读常量。

例： public static final int NUM = 10;

注意: final变量通常大写

2) final方法：final方法不可以被子类的方法重写；final方法比非final方法要快，因为在编译的时候已经静态绑定了，不需要在运行时再动态绑定。

例：

class Person{
            public final String getName(){
                    return "personal loan";
            }
    }

3) final类：final类通常功能是完整的，它们不能被继承。Java中有许多类是final的，譬如String, Interger以及其他包装类。

4)final参数：final参数 当方法参数为final类型时，你可以读取使用该参数，但是无法改变该参数的值。 注：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。 final不能用于修饰构造方法。

例：

public void f1(final int i) {
        //i++;    //i是final类型的,值不允许改变的.
        System.out.print(i);
    }

7、static

1）static修饰变量：静态变量，直接使用 类名.变量名 调用。

随着类加载时被完成初始化；类的所有实例共享静态变量（独立于类的实例对象）；JVM也只会为它分配一次内存；

一般在这两种情况下使用静态变量：对象之间共享数据、访问方便。

2）static方法：静态方法，使用 类名.变量名 调用。

没有this，因为不依赖于任何实例对象；不能访问非静态成员变量与非静态成员方法；static方法必须实现，也就是说他不能是抽象方法abstract；

3）static代码块：静态代码块

可以置于类中的任何地方；一个类可以有多个static块；类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次。

4）静态导包：https://www.cnblogs.com/dotgua/p/6354151.html?utm_source=itdadao&utm_medium=referral

注意：static不可以修饰局部变量；static变量在定义时初始化（否则自动初始化）；

8、this

1)this调用本类中的属性，也就是类中的成员变量；

class Student {
         String name; //定义一个成员变量name
         private void SetName(String name) { //定义一个参数(局部变量)name
            this.name=name; //将局部变量的值传递给成员变量
         }
    }

2)this调用本类中的其他方法；

3)this调用本类中的其他构造方法，调用时要放在构造方法的首行；

class Student {
             public Student() { //定义一个方法，名字与类相同故为构造方法
                 this("Zhangsan");
             }
             public Student(String name) { //定义一个带形式参数的构造方法
             }
    }

4)返回类的引用

**return** **this**;  相当于  **return** student;

注意：this代表自身，即当前对象，所以不能出现在静态方法里，因为静态方法代表类与某个具体对象无关。

9、super

1)、访问超类（父类）的构造方法（必须在构造方法第一行调用）；

class B extends A {
            B(){
               super();
                . . .
            }
    }

2)、访问被子类所隐藏的方法、参数

**super****.****方法名****(****參数列表****)**;

**super****.****参数名**;

注意：子类被创建时包含了父类，super即父类；多层继承时super指最近的超类（父类）；

10、类

类文件以.java为后缀的代码文件，在每个类文件中最多只允许出现一个public类，当有public类的时候，类文件的名称必须和public类的名称相同，若不存在public，则类文件的名称可以为任意的名称（不能以数字开头）。

在类内部，对于成员变量，如果在定义的时候没有进行显示的赋值初始化，则Java会保证类的每个成员变量都得到恰当的初始化：

1）对于  char、short、byte、int、long、float、double等基本数据类型的变量来说会默认初始化为0（boolean变量默认会被初始化为false）；

2）对于引用类型的变量，会默认初始化为null。

如果没有显示地定义构造器，则编译器会自动创建一个无参构造器，但如果显示地定义了构造器，编译器就不会自动添加构造器。注意，所有的构造器默认为static的。

第一次加载某个类时首先初始化static成员变量与static代码块，且只执行一次，顺序为类中代码的顺序。

11、继承

Java中的类不指出要继承的类便隐式的继承自Object类。

Java只允许单继承

1.子类继承父类的成员变量

1）能够继承父类的public和protected成员变量；不能够继承private成员变量；

2）对于父类的包访问权限成员变量，如果子类和父类在同一个包下，则子类能够继承；否则，子类不能够继承；

3）如果在子类中出现了同名称的成员变量，则会发生隐藏现象，即子类的成员变量会屏蔽掉父类的同名成员变量。如果要在子类中访问父类中同名成员变量，需要使用super关键字来进行引用。

2.子类继承父类的方法

1）能够继承父类的public和protected成员方法；不能够继承private成员方法；

2）对于父类的包访问权限成员方法，如果子类和父类在同一个包下，则子类能够继承；否则，子类不能够继承；

3）对于子类可以继承的父类成员方法，如果在子类中出现了同名称的成员方法，则称为覆盖，即子类的成员方法会覆盖掉父类的同名成员方法。如果要在子类中访问父类中同名成员方法，需要使用super关键字来进行引用。

注意：　子类是不能够继承父类的构造器！所以父类只有参构造器必须使用super调用并传参，如果父类有无参构造器可以不用super调用（系统会自动调用）。

1.  **重写（****Override****）**

1）发生在父子类中，方法签名相同，方法体不同：子类可以重写（覆盖）继承自父类的方法，即方法名和参数列表与父类的方法相同，但方法的实现不同（方法体不同）

2）重写方法被调用时，看对象的类型：当子类对象的重写方法被调用时（无论是通过子类的引用调用还是通过父类的引用调用），运行的是子类的重写后的版本

3）子类在重写父类的方法时，可以通过super关键字调用父类的版本，这样的语法通常用于子类的重写方法在父类方法的基础之上进行功能扩展。

规则：

1）方法名相同、参数列表相同

2）子类方法的返回值可以为父类中返回值的子类型

3）子类方法抛出的异常要小于或等于父类的\----异常之后

4）子类方法不能使用比被重写的方法更严格的访问权限

13、向上转型、向下转型

1）向上转型：子类对象转为父类，父类可以是接口。公式：Father f = new Son();Father是父类或接口

即父类的引用变量引用的是子类的对象，此时这个引用变量表现为所引用的对象（子类）的特征，所以同一个父类变量可以表现出不同的行为特征，即为多态。

注意：向上转型时，子类单独定义的方法会丢失。（当父类对象引用变量引用子类对象时，被引用对象的类型决定了调用谁的成员方法，引用变量类型决定可调用的方法。如果子类中没有覆盖该方法，那么会去父类中寻找。）

2）向下转型：父类对象转为子类。公式：Father f = new Son(); 之后 Son s = (Son)f;

向下转型的前提是父类引用指向的是子类对象（在向下转型之前，必须先向上转型）

向下转型只能转型为本类对象（猫是不能变成狗的）。

**14****、多态**

面向对象三大特性: **封装、继承、多态**

实现多态的技术称为：动态绑定（dynamic binding），是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。

作用：消除类型之间的耦合关系。

实现多态的必要条件：**继承、重写、父类引用指向子类对象**（上转型）

Java中多态的分类：

1)person为父类，student为子类。那么：person p=new student()；

2)fliable为接口，bird为实现接口的类，那么：fliable f=new bird()；

3)fliable为抽象类，bird为继承fliable的类，那么：fliablef=new bird()；

instanceof运算符：instanceof运算符的前一个操作符是一个引用变量，后一个操作数通常是一个类（可以是接口），用于判断前面的对象是否是后面的类，或者其子类、实现类的实例。如果是返回true，否则返回false。

**15****、重载(Overload)**

在同一个类中使用相同的方法名，参数不同（数量、类型）。返回类型可以相同也可以不同。

必须改变参数列表；可以改变返回类型；可以改变访问修饰符；声明新的或更广的异常检查；

**16****、抽象类**

1）当类中包含抽象方法时必须使用abstract修饰该类，即为抽象类

2）抽象方法使用abstract修饰，只有声明，而没有具体的实现

3）抽象类不能使用new创建实例对象，但是可以定义引用变量（可以用来指向子类的对象）

4）抽象类中的抽象方法必须在子类中实现(如果子类不实现必须使用abstract修饰该子类)

5）抽象类可以包含非抽象方法

[public] abstract class A {
        abstract void fun();
    }
    
    class B extends A {
        void fun() { . . . }
    }

**17****、接口（interface）**

接口是对行为的抽象。

1）接口中所有方法只能是public abstract类型（否则自动隐式的定义）

2）接口中所有变量只能是public static final（否则自动隐式的定义）

3）一个类（可以是抽象类）可以遵循多个接口，使用implements关键字，接口名使用逗号隔开

4）类中必须实现所遵循的接口中的所有方法

5）接口不能实例化，但是可以定义一个变量：可以是空指针，或指向一个实现此接口的对象（类似向上转型，用于接口回调）

例：

interface fly{
        public static final int i = 1;
        public abstract void fly();
    }
    
    interface run{
        void run();
    }
    
    class bird implements fly,run {
    
        public void fly() {
           System.out.println("Bird fly ...");
        }
    
        public void run() {
           System.out.println("Bird run ...");
        }
    
    }

**关于抽象类与接口：**[https://www.cnblogs.com/dolphin0520/p/3811437.html][https_www.cnblogs.com_dolphin0520_p_3811437.html]

18、访问控制修饰符

Java中的访问修饰符有：public、protected、default、private

修饰方法/变量：

1)private：表示私有的，仅限本类中访问（封装性）

2)protected：表示受保护的，本类、子类、同包类

3)default：表示不写修饰符（并不是一个真正的修饰符），本类、同包类

4)public：表示公共的，本类、子类、同包、不同包

修饰类：

用于类的访问控制修饰符只有public

1)public（访问控制符），将一个类声明为公共类，他可以被任何对象访问，一个程序的主类必须是公共类。

2)abstract，将一个类声明为抽象类，没有实现的方法，需要子类提供方法实现。

3)final，将一个类声明为最终（即非继承类），表示他不能被其他类继承。

4)friendly，默认的修饰符，只有在相同包中的对象才能使用这样的类。

19、异常

非检查异常(unckecked exception): Error和RuntimeException以及他们的子类。编译时不会发现这类异常，不必须使用代码进行异常处理，此类异常应该去修正代码避免。如：除0异常(ArithmeticException)、数组越界(ArrayIndexOutOfBoundsException)等。

检查异常(checked exception): 除Error和RuntimeException外的异常。编译时强制程序进行异常预处理(使用try-catch捕获处理 或 使用throws子句声明跑出)，否则编译不通过。此类异常通常由运行环境导致，如SQLException、IOException、ClassNotFundException等。

注意：Error并不算是异常而是错误

Throwable类及其子类

异常的冒泡：异常的冒泡是为了在当前发生异常的方法或者这个方法的caller中找到最近的异常处理程序。由于下图例子中没有使用任何异常处理机制，因此异常最终由main方法抛给JRE，导致程序终止。

异常最先发生的地方，叫做异常抛出点。异常处理的任务就是将执行控制流从异常发生的地方转移到能够处理这种异常的地方去。

异常处理语法：

1使用try-catch-finally语句块

try{
        //try块中放可能发生异常的代码。
        //如果执行完try且不发生异常，则接着去执行finally块和finally后面的代码（如果有的话）。
        //如果发生异常，则尝试去匹配catch块。
    }catch(SQLException SQLexception){
       //每一个catch块用于捕获并处理一个特定的异常，或者这异常类型的子类。Java7中可以将多个异常声明在一个catch中。
       //catch后面的括号定义了异常类型和异常参数。如果异常与之匹配且是最先匹配到的，则虚拟机将使用这个catch块来处理异常。
       //在catch块中可以使用这个块的异常参数来获取异常的相关信息。异常参数是这个catch块中的局部变量，其它块不能访问。
       //如果当前try块中发生的异常在后续的所有catch中都没捕获到，则先去执行finally，然后到这个方法的外部caller中去匹配异常处理器。
       //如果try中没有发生异常，则所有的catch块将被忽略。
    }catch(Exception exception){
       //...
    }finally{
       //finally块通常是可选的。
      //无论异常是否发生，异常是否匹配被处理，finally都会执行。
      //一个try至少要有一个catch块，否则， 至少要有1个finally块。但是finally不是用来处理异常的，finally不会捕获异常。
     //finally主要做一些清理工作，如流的关闭，数据库连接的关闭等。
    }

try-catch语句可以嵌套使用，异常发生时当内层没有匹配的catch块时转向外层寻找相匹配的catch块

catch块中也可以抛出异常（需在外层进行必要的处理），后面的finally也会执行：首先执行finally块，然后去外围调用者中寻找合适的catch块。

2在方法签名中使用throws 声明交给方法调用者caller去解决

throws是另一种处理异常的方式，throws仅仅是将方法中可能出现的异常向调用者声明，而自己则不具体处理。

而抛出异常方法的调用者必须对相应的异常进行处理。

public void fun() throws ExceptionType1 , ExceptionType2 ,ExceptionTypeN{
         //fun内部可以抛出 ExceptionType1 , ExceptionType2 ,ExceptionTypeN 类的异常，或者他们的子类的异常对象。
    
    }

throw 异常抛出语句：

可以通过throw语句手动显式的抛出一个异常。throw语句的后面必须是一个异常对象。

throw 语句必须写在方法中，执行throw 语句的地方就是一个异常抛出点，它和由JRE自动形成的异常抛出点没有任何差别，所以此类异常不必须进行处理。

例如：

if(user  == null)
        throw new IllegalArgumentException("User对象为空");

自定义异常：

可以自定义一个异常类，需继承自Exception，属于检查异常。也可以继承RuntimeException作为非检查异常。

自定义异常应该带有（非强制）：

一个无参构造函数

一个带有String参数的构造函数，并传递给父类的构造函数。

一个带有String参数和Throwable参数，并都传递给父类构造函数

一个带有Throwable 参数的构造函数，并传递给父类的构造函数。

注意： 
    关于finally：不管如何finally总会执行，用于关闭资源；
    注意catch捕获异常的顺序，更详细的异常在前；
    try-with-resources：try(. . . ;. . .;)… 在括号中声明的资源会在代码最后按声明相反的顺序关闭，替代了在finally中手动关闭；
    注意对异常的向外传递；

20、多线程

现在的操作系统是多任务操作系统，多线程是实现多任务操作系统的方式

进程：是并发执行的程序在执行过程中分配和管理资源的基本单位，是一个动态概念，竟争计算机系统资源的基本单位。每一个进程都有一个自己的地址空 间，即进程空间或（虚空间）。进程空间的大小 只与处理机的位数有关，一个 16 位长处理机的进程空间大小为 216 ，而 32 位处理机的进程空间大小为 232 。进程至少有 5 种基本状态，它们是：初始态，执行态，等待状态，就绪状态，终止状态。

线程：线程是一个执行流程，一个进程可以有多个线程，线程总属于进程，进程中的多个线程共享内存空间。

Java中线程：

使用java.lang.Thread类或者java.lang.Runnable接口编写代码来定义、实例化和启动新线程。
    一个Thread类实例只是一个对象。
    每一个线程都有一个调用栈（没创建一个新的线程都会产生一个新的调用栈）。
    Java程序总从main()方法开始执行，main()方法所在的线程叫做主线程。

线程分为用户线程(User Thread)与守候线程(Daemon Thread)，守护线程服务所有用户线程，当JVM关闭是守护线程关闭，用户也可以设置守护线程。用户线程即用户自定义的线程。

创建线程的四种方式：

1 继承Thread类创建线程
    Thread类实现Runnable接口，重写run()方法实现操作。

class ThreadTest extends Thread {
        public void run() 
            System.out.println("MyThread run()");
        }
    }
             
    ThreadTest myThread = new ThreadTest();
    myThread.start();
    Thread t = new Thread(new ThreadTest());
    t.start();

2 实现Runnable接口创建线程

当类已经继承了一个类后无法继承Thread类，只能通过实现Runnable接口。

class MyThread extends OtherClass implements Runnable {
        public void run() { 
            System.out.println("MyThread.run()"); 
        } 
    }

为了启动MyThread，需要首先实例化一个Thread，并传入自己的MyThread实例：

MyThread myThread = new MyThread(); 
    Thread thread = new Thread(myThread); 
    thread.start();

myThread传入Thread后，Thread的run方法会自动调用myThread的run方法。

3 实现Callable接口通过FutureTask包装器来创建Thread线程
    a:创建Callable接口的实现类 ，并实现Call方法 
    b:创建Callable实现类的实现，使用FutureTask类包装Callable对象，该FutureTask对象封装了Callable对象的Call方法的返回值 
    c:使用FutureTask对象作为Thread对象的target创建并启动线程 
    d:调用FutureTask对象的get()来获取子线程执行结束的返回值

4 线程池

//创建线程池executorService
    ExecutorService executorService=Executors.newFixedThreadPool(5);
    //将线程thread注册到线程池中
    executorService.execute(thread);  
    //关闭线程池
    executorService.shutdown();

21、集合

集合与数组区别：

1、数组定长，集合不定长；2、数组存储基本类型和对象，集合存储对象

Java中集合主要由Collection和Map两个接口派生出来

Collection中定义的方法：

Iterator接口为迭代器，iterator()方法的返回值是Iterator<E>，用于遍历结合；
    Iterator接口中hasNext()方法返回boolean表示是否仍有元素可以迭代，next()方法返回写一个元素

例如：

Collection<T> t = new ArrayList<T>();…
       Iterator<T> it = t.iterator();
       T t = it.naxt();

Iterator获取的为集合值，修改itesrator方法返回的结果对原集合无影响

Collection的三个子集合：
    1、Set
    Set与Collection的区别为，Set不允许有重复的值，如果强行add一个已有的值则返回false，且不添加。
    2、List
    List集合代表一个元素有序、可重复的集合，集合中每个元素都有其对应的顺序索引。List集合允许使用重复元素，可以通过索引来访问指定位置的集合元素 。List集合默认按元素的添加顺序设置元素的索引，例如第一个添加的元素索引为0，第二个添加的元素索引为1......
    List作为Collection接口的子接口，可以使用Collection接口里的全部方法。而且由于List是有序集合，因此List集合里增加了一些根据索引来操作集合元素的方法。

方法：

void add(int index, Object element)
    Object get(index)
    int indexOf(Object o)
    int lastIndexOf(Object o)
    Object set(int index, Object element)
    Object[] toArray()
    Java8： 
    void replaceAll(UnaryOperator operator):根据operator指定的计算规则重新设置List集合的所有元素。
    
    void sort(Comparator c):根据Comparator参数对List集合的元素排序。

3、Queue

模拟队列，先进先出（FIFO）

Map集合：

Map用于保存具有映射关系的数据，key-value，key、value可以是任何引用类型的数据；key必须唯一。

Map中所有key可以看做是一个Set（keySet()方法用于返回一个由key组成的Set集合），所有value可以看做是一个list。

例：

public class MapTest {
        public static void main(String[] args){
            Day day1 = new Day(1, 2, 3);
            Day day2 = new Day(2, 3, 4);
            Map<String,Day> map = new HashMap<String,Day>();
            //成对放入key-value对
            map.put("第一个", day1);
            map.put("第二个", day2);
            //判断是否包含指定的key
            System.out.println(map.containsKey("第一个"));
            //判断是否包含指定的value
            System.out.println(map.containsValue(day1));
            //循环遍历
            //1.获得Map中所有key组成的set集合
            Set<String> keySet = map.keySet();
            //2.使用foreach进行遍历
            for (String key : keySet) {
                //根据key获得指定的value
                System.out.println(map.get(key));
            }
            //根据key来移除key-value对
            map.remove("第一个");
            System.out.println(map);
        }
    }

lambda表达式、引用(变量)与对象、集合、多线程、反射、堆栈、单元测试

[https_www.cnblogs.com_dolphin0520_p_3811437.html]: https://www.cnblogs.com/dolphin0520/p/3811437.html