【Java SE】SE“细节”知识大总结

向右看齐 2023-09-28 15:39 117阅读 0赞

**目录**

1.初识JAVA

1.1环境配置时JDK、JRE、JVM之间是什么关系？

1.2Java代码运行过程

1.3一个简单Java程序的解释

1.4什么叫“一次编译，到处运行”？

1.5注释常见错误

1.6标识符

1.7关键字

2.数据类型

2.1基本数据类型

2.2.引用型数据类型

2.3.不同数据类型解析

要注意以下这些不同点：

整形（int）：

长整形（long）：

短整型（short）：

字节型（byte）:(可以为类比char)

问答：

单精度浮点型（float）：

双精度浮点型（double）:

字符型（char）:

布尔类型（boolean）:

2.4类型转换

自动类型转换(隐式)：

强制类型转换(显式):

字符串类型（String）：

3.运算符常见易错点

3.1 + - \* /

3.2 x=x+1与x+=1

编辑

3.3 > < >= <= == !=

3.4 && 和 ||

3.5 无符号右移

3.6条件运算符（三目运算符）经典面试题

4.逻辑控制（猜数字游戏）

5.方法重载

5.1形参与实参的关系，如何开辟空间？

6.数组

6.1数组的三种访问方式

6.2数组名作为参数传参，以及内存布局

6.3 对于数组，Java带来的一些便捷(import java.util.Arrays;)

6.3.1 数组拷贝(Arrays.copyOf)

6.3.2字符串形式返回数组(Arrays.toString)

6.3.3数组排序（Arrays.sort）

6.3.4指定范围的数组拷贝(Arrays.copyOfRange)

6.3.5数组比较（Arrays.equals）

6.4二维数组

有以下三种定义方式：（未定义默认初始化为0，引用类型为:NULL）

三种不同的遍历方式：

对二维数组遍历的解释：

不规则二维数组:

7.类和对象（一个例子轻松理解~）

7.1this

7.2构造

7.2.1 构造重载

8.static修饰的静态变量

8.1类变量和类方法

8.2代码块

9.内部类

9.1实例内部类

9.2静态内部类

9.3局部内部类

10.封装、继承、多态

11.抽象类（abstract）

12.接口

12.1制作一个简单的比较器

13.浅拷贝和深拷贝

14.Object类

15.String类

15.1字符串常量池

15.2面试题：请解释String类中三种实例化对象的区别

15.3.1 字符串比较是否相同(equals())

15.3.2字符串比较大小(compareTo())

15.3.3忽略大小写比较是否相同（equalsIgnoreCase()）

15.3.4KMP算法查找字符或字符串(indexOf())

15.3.5将其他类型相互转化(其他类型.valueOf())

15.3.6小写转大写（toUpperCase()）

15.3.7大写转小写(toLowerCase())

15.3.8字符串转字符数组（toCharArray()）

15.3.9字符串切割（split()）

15.3.10字符串替代（replaceFirst()）

15.3.11拿到字符串中的每一个字符(charAt())

16.异常处理

16.1try-catch-finally（捕获并处理）

16.2自定义异常

--------------------

高老爷子保佑！！！

![36475b3902aa45f6bdfb51e414948e38.png][]

--------------------

# 1.初识JAVA #

## 1.1环境配置时JDK、JRE、JVM之间是什么关系？ ##

![e130f0c1a3824d1da4badf75ace0da65.png][]

![62a8070ad6284798ae920b57c2033d31.png][]

--------------------

## 1.2Java代码运行过程 ##

> 在之前的文章有写过~下面给出链接

[http://t.csdn.cn/lkZ5J][http_t.csdn.cn_lkZ5J]

![427d1eba691c4f2eaef893facaae0632.png][]

--------------------

## 1.3一个简单Java程序的解释 ##

![ab29daa19cef4f269ecfc244b179d5c0.png][]

--------------------

## 1.4什么叫“一次编译，到处运行”？ ##

> *一次编译后产生的**xxx.class字节码文件**，无论你发给谁，只要他的电脑上装有**JDK**，在他的JDK上就能跑，Java命令就能执行！*
> 
>  *苹果电脑 没问题 可以跑*
> 
>  *你是linux也可以*
> 
>  *windows也可以*

![51d1af9e3a814dc796d25f01fbdf0ba1.gif][]

--------------------

## 1.5注释常见错误 ##

> 注释中出现**中文**就会出现以下错误（分情况）

![444ae4d7505e4e7799ad64038992fdb2.png][]

--------------------

## 1.6标识符 ##

> 在程序中由用户给类名、方法名或者变量所取的名字。

**【硬性规则】**

标识符中可以包含：**字母、数字以及 下划线和 $ 符号**等等。注意：标识符**不能以数字开头**，也不能是关键字，且严格区分大小写。

**【软性建议】**

*  类名：每个单词的首字母大写(大驼峰)
 *  方法名：首字母小写，后面每个单词的首字母大写(小驼峰)
 *  变量名：与方法名规则相同

--------------------

## 1.7关键字 ##

>  *观察上述程序可以发现，public、class以及static等颜色会发生变化，将这些具有特殊含义的标识符称为关键字。即：关键字是由Java语言提前定义好的，有特殊含义的标识符，或者保留字。*

*那么，java中都有那些常见的关键字呢？*

![53beb5dcdd4e44d9b662cb58e058836b.png][]

慢慢学 不着急 一步一步来~

![79b430719e2348909f41737a3d7ad4eb.gif][]

--------------------

# 2.数据类型 #

实际上java和C语言类型，有以下这些类型：

--------------------

## 2.1基本数据类型 ##

![553a7ce21bdf4d2f9320bcaf89849d18.png][]

##  ##

--------------------

## 2.2.引用型数据类型 ##

**数组 String 类 接口 枚举**...(后面章节细讲)

--------------------

## 2.3.不同数据类型解析 ##

> 很多地方可以与C语言类比着看，以前写过一篇文章（仅做参考），解释了数据类型，以及内存形式：

[http://t.csdn.cn/QOGH6][http_t.csdn.cn_QOGH6]

### 要注意以下这些不同点： ###

*  ### 整形（int）： ###
 *  大小4个字节【可移植性强：不管你是32位还是64位，int就是4个字节】；
 *  在Java里，int 没有所谓的无符号整形，故int既能表示正数也能表示负数
 *  包装类类型->Integer

在Java中，什么是变量(int举例)

简而言之就是可以改变的量；

问题来了，如下图

![11763ab8e5db42dea692071b0b3dcf0c.png][]

**注 意：Java中局部变量必须要初始化，否则会报错，Java中不存在所谓的如C语言中全局变量（后续类和对象中会细讲）**

### 长整形（long）： ###

*  不管是64位还是32位都只占8个字节，总共64位，去掉符号位63位
 *  最小值：-2^63,最大值：-2^63-1
 *  同样long也就包装类类型->Long
 *  不存在无符号，只有有符号数
 *  long a = 10L;后面的L（或小写l,但不推荐）表示为长整型，没有的话他就是一个整数

### 短整型（short）： ###

*  2个字节 共16位，去掉符号位-> 15位
 *  最小值：-2^15,最大值：2^15-1
 *  不存在无符号，只有有符号数
 *  包装类类型->Short

### 字节型（byte）:(可以为类比char) ###

*  占一个字节
 *  总共8位，去掉符号位-> 7位
 *  大小为-128~127
 *  不存在无符号，只有有符号数
 *  包装类类型->Byte

注意如果你这样赋值：

![db67e0e608574d7c9cc28c6a8dac48e4.png][]

**编译器会自动检查，赋值的字面值常量是不是超出了当前数据类型能够表示的数据范围，以此类推其他数据类型也一样，超出便会报错！**

**注意：**

![4bcda2d6713f415c8cd7d5dae6b5867c.png][]

更改办法：

![2ddd413b983b4ce7ae733244a659ac20.png][]

### 问答： ###

> *但是b的值是128，超出了b，怎么办呢？ 为什么不报错呢？*

*我们来打印看一下它的值：*

![b1f0c46c9b224033ad83334f35e1c1ce.png][]

> \-128？为什么呢？不报错吗？

注意：刚刚说的是**超出字面值常量**！编译前并不知道a+1中的a是127

详情请看（和C语言中的char一样）：

[http://t.csdn.cn/Wecgu][http_t.csdn.cn_Wecgu]

**小的总结：不能直接赋值一个超过这个数据类型的值，编译器会报错!**

### 单精度浮点型（float）： ###

*  ﬂoat 类型在 Java 中占四个字节, 同样遵守 IEEE 754 标准.
 *  由于表示的数据精度范围较小, 一般在工程上用到浮点数都优先考虑 double, 不太推荐使用 ﬂﬂoat. ﬂﬂoat的包装类型为Float。
 *  float精确到小数点后6位

注意：![f6fb9f351b5b49228dcd19e2bd9d0324.png][]

**6.5默认是一个double类型的数据（Java规定），而double占用8个字节，所以会报错；**

更改：![2b687f80e5ce49259c6188102151f821.png][]

### 双精度浮点型（double）: ###

*  double在任何系统下都占8个字节
 *  浮点数与整数在内存中的存储方式不同，不能单纯使用的形式来计算
 *  double的包装类型为Double4. double 类型的内存布局遵守 IEEE 754 标准(和C语言一样), 尝试使用有限的内存空间表示可能无限的小数, 势必会存在一定的精度误差，因此浮点数是个近似值，并不是精确值。

### 字符型（char）: ###

*  char类型占两个字节(与C语言不一样！)
 *  Java中使用的不是ASCII字符集，而是Unicode字符集
 *  ASCII字符集:只有英文
 *  Unicode字符集：包含很多语言：中文，拉丁文...
 *  不能表示负数
 *  取值范围0~65535(2^16)

### 布尔类型（boolean）: ###

![aefaacd84cf648d2a2c118583bd1d350.png][]

*  boolean类型非常特殊，JVM没有所谓的大小
 *  包装类：Boolean

也不能存在如下写法：

![ee0e9df8e6414c23882f5c673c64ae6b.png][]

--------------------

## 2.4类型转换 ##

### 自动类型转换(隐式)： ###

*  代码不需要经过任何处理，在代码编译时，编译器会自动进行处理。
 *  特点：数据范围小的转为数据范围大的时会自动进行。

int a = 100;
    long b = 10L;
    b = a;//a,b都是整形，a的范围更小，b的范围大，赋值时编译器自动将小范围类型转化为大范围类型
    a = b;//都是整形，但a的范围比b小，Java语法规定为错误，除非强制类型转化

### 强制类型转换(显式): ###

*  当进行操作时，代码需要经过一定的格式处理，不能自动完成。
 *  特点：数据范围大的到数据范围小的。

int a = 10;
    long b = 100L;
    b = a;        // int-->long，数据范围由小到大，隐式转换
    a = (int)b;   // long-->int, 数据范围由大到小，需要强转，否则编译失败

*那么问题来了，下面两个代码正确吗？*

public class test {
    
        public static void main(String[] args){
            //代码1
            byte a = 1;
            byte b = 2;
            byte c = a + b;
            System.out.println(c);
            //代码2
            int i = 10;
            float f = 19.9f;
            i = f;
            
        }
    }

解释如下：

![1811192c1991409a8f558bd9746d82d0.png][] **扩展：两个不一样的数据类型进行运算时候，会把较小的数据类型转化为较大的数据类型参与运算（**CPU 通常是按照 4 个字节为单位从内存中读写数据. 为了硬件上实现方便, 诸如 byte 和 short这种低于 4 个字节的类型, 会先提升成 int, 再参与计算.**）**

### 字符串类型（String）： ###

【后期会重点讲！本章只做了解！】

Java中使用String定义字符串：

public class test{
        public static void main(String[] args){
            String h = "hello ";
            String w = "world";
            System.out.println(h+w);//h+w表示将字符串h与w拼接起来
        }
    }

**特点：String类型和其他数据类型进行拼接的时候，会整体变成字符串类型**

一些情况下，字符串与整形需要相互转化(这就设计到包装类，后面章节重点讲，本小节只做了解！)

1.int转化成String

int num = 10;
    // 方法1
    String str1 = num + "";  
    // 方法2
    String str2 = String.valueOf(num);

2.String转化成int

String str = "100";
    int num = Integer.parseInt(str);

--------------------

# 3.运算符常见易错点 #

本章主要会探究C与Java的不同点

## 3.1 + - \* / ##

> \+ - \* /想必都很了解(类比C语言)，有必要的是聊一聊%，看懂下下面例子对%也就没什么问题
> 
> 你计算的结果是？

public class operator {
        
        public static void main(String[] args){
            System.out.println(10 % 3);
            System.out.println(10 % -3);
            System.out.println(-10 % 3);
            System.out.println(-10 % -3);
        }
    }

> 解析：

![881268ca87d3465dad9d81327c163cb9.png][]

--------------------

## 3.2 x=x+1与x+=1 ##

> 观察以下代码，为什么s1 = s1 + 1;报错了，s1 += 1;却不会报错？

## ![9bdc4c23d73f40f38b5c6ededb9ca605.png][] ##

> 解析：

s1 + 1中，进行了算数运算，1为整形，所以s1会提升为整形，那么(s1+1)也就为整形类型，赋值给s1这个short类型自然会报错，想不让他报错，只需要s1 = (short)(s1 + 1);即可，证明s1+=1;

中的+=自动帮我进行类型转化;

--------------------

## 3.3 > < >= <= == != ##

> 值得注意一点是，这些表达式的结果只能是布尔类型，也就是说，表达式的结果只能为ture或者false（要和C语言区分开），看如下例子，结果是什么？

![ee9216485a0947f78ab4ac3cce205acf.png][]

> 解析：

![e9a261dfa06843d7ab430ba85788e529.png][]

--------------------

## 3.4 && 和 || ##

> 逻辑与（&&）：

![69c3aa23781e4483a8c20217fc4cbc51.png][]

> 逻辑或（||）：

![6ec5a3fc230142e8a5c8b6d9ff825b22.png][]

--------------------

## 3.5 无符号右移 ##

![08a15125e69f4b66ba841d7d6e18eb03.png][]

*存在无符号位左移吗？*

*不存在！*

*因为右边不是符号位！*

--------------------

## 3.6条件运算符（三目运算符）经典面试题 ##

![442736dc33c34df38b10e4c2a4bda12c.png][]

> 解析：

![02cf53132e3543809ec15ec8a230759e.png][]

--------------------

# 4.逻辑控制（猜数字游戏） #

import java.util.Random;
    import java.util.Scanner;
    //猜数字游戏
    public class test{
        public static void main(String[] args){
    
        }
        public static void main1(String[] args){
            //生成随机数
            Random ran = new Random();
            int randNum = ran.nextInt(101);//[0~101)
            //int randNum = ran.nextInt(100)+1;//[1~101)
            while(true){
                System.out.print("请输入数字:");
                Scanner scanner = new Scanner(System.in);
                int input = scanner.nextInt();
                if(input > randNum){
                    System.out.println("猜大了!");
                }
                else if(input < randNum){
                    System.out.println("猜小了!");
                }
                else{
                    System.out.println("恭喜你猜中了!");
                    break;
                }
            }
        }
    }

--------------------

# 5.方法重载 #

> 类比C与语言函数会清楚很多，想象以下榨汁机：

![980b4a08b3dc4d19b375ec528fa629ae.png][]

> **重载** 注意以下几点就好了

*  方法名相同
 *  形参列表不同
 *  返回值不做要求，可以一样，也可以不一样

--------------------

## 5.1形参与实参的关系，如何开辟空间？ ##

**注意一下形参和实参的传递关系即可：**

main方法和你定义的方法会分别在栈区开辟两块不同的空间（栈帧），形参只是实参的一份临时拷贝

对此，博主之前写过一篇文章，详细的介绍了栈帧的创建与销毁，可以通过下方链接看看

**函数栈帧的创建与销毁**

[http://t.csdn.cn/hU5oV][http_t.csdn.cn_hU5oV]

--------------------

# 6.数组 #

和C语言中数组就些许不同啦~

> 三种定义方式，由于JAVA中数组是动态的，所以会在堆区开辟空间存放**数组内容**，在栈区为引用变量开辟空间，**存放数组内容的地址（**未定义默认初始化为0，引用类型为:NULL）

![aee44665f32c42ef934180d8dd294fdf.png][]

> 初始化数组时不能指定数组元素个数，否则报错，相比C语言，此时array1才真的算的上是数组，类型为int\[ \] (doge)

![2d72deaf373346e78e40a17c21c30584.png][]

> 数组名不在仅仅是地址，而是地址的哈希值：也可以理解为地址

![eb50e8edef5f4cf8a23fa050d86885d7.png][]

--------------------

## 6.1数组的三种访问方式 ##

> 第一种

import java.util.Arrays;
    public class Test{
        //数组访问
        public static void main(String[] args){
            int[] array = {1,2,3,4,5,6};
            //1
            int i = 0;
            for(i = 0; i < array.length; i++){
                System.out.print(array[i] + "   ");
            }
        }

> 第二种

import java.util.Arrays;
    public class Test{
        //数组访问
        public static void main(String[] args){
            int[] array = {1,2,3,4,5,6};
            //2
            for(int x : array){
                System.out.print(x + " ");
            }
            System.out.println();
        }

> 第三种

import java.util.Arrays;
    public class Test{
        //数组访问
        public static void main(String[] args){
            int[] array = {1,2,3,4,5};
            //3
            String ret = Arrays.toString(array);
            System.out.println(ret);//以字符串的形式打印
        }

--------------------

## 6.2数组名作为参数传参，以及内存布局 ##

> 以下代码会打印什么？

public class Test{
        public static void fun1(int[] array1){
            array1 = new int[]{4,5,6};
        }
        public static void fun2(int[] array2){
            array2[0] = 100;
        }
        public static void main(String[] args){
            int[] array = {1,2,3};
            fun1(array);
            int i = 0;
            for(i = 0; i < array.length; i++){
                System.out.print(array[i] + " ");
            }
            System.out.println();
            fun2(array);
            for(i = 0; i < array.length; i++){
                System.out.print(array[i] + " ");
            }
        }

> 分析：

1.首先main方法在栈区开辟栈帧，在堆区开辟空间存放 array数组内容，并在栈区存放array地址

![94451372b548498eaa3187eedee93218.png][]

2.调用fun1方法，栈区为fun1开辟空间

![2a1b4d5836d84bef86ff415edfd7f89f.png][]

![a3f65bcd4e174240bef204ad9f564777.png][]

3.出函数销毁

![550e45b19a914cf3bac8815a2dcbfec3.png][]

4.调用fun2函数，并通过地址修改其值

![3d883bdebb764697aa02603e01c97a29.png][]

**其实将过程分析清楚，答案自然就出来，画图很重要！！！**

--------------------

## 6.3 对于数组，Java带来的一些便捷(import java.util.Arrays;) ##

### 6.3.1 数组拷贝(Arrays.copyOf) ###

> Arrays.copyOf(待拷贝的数组,拷贝的长度)

有以下copyOf重载：

![f33152ad48db45e7b42a07cfa5d48766.png][]

> 实例：（**拷贝长度大于被拷贝数组时，相当于扩容，扩容部分自动初始化为0**）

import java.util.Arrays;
    public class Test{
        //数组拷贝
        public static void main(String[] args){
            int[] array = {1,2,3,4,5};
            int[] copy = Arrays.copyOf(array, array.length);
            for(int i = 0; i < copy.length; i++){
                System.out.print(copy[i] + " ");
            }
        }
    }

--------------------

### 6.3.2字符串形式返回数组(Arrays.toString) ###

> Arrays.toString(数组名)

重载：

![85647ccced5c4008a503bf5650680f54.png][]

> 实例：（打印时会自动加上\[ \] ，并且是以字符串形式打印）

import java.util.Arrays;
    public class Test{
        //字符串打印数组实例
        public static void main(String[] args){
            int[]array = new int[]{1,2,3,4,5};
            System.out.println(Arrays.toString(array));
        }

--------------------

### 6.3.3数组排序（Arrays.sort） ###

> Arrays.sort(待排序的数组名);
> 
> Arrays.sort(待排序的数组名, 起始位置下标, 终止位置下标); //前闭后开 \[ x, y )

重载：

![16e3d9da2fde4e38859b33c6234fa681.png][]

> 实例：（升序排序，可以给出起始终止位置，也可以不给(默认排序整个数组)，以下例子只会排序下标1~3的数字，4不会被排序，注意**前闭后开**）

import java.util.Arrays;
    public class Test{
        //排序实例
        public static void main(String[] args){
            int[] array = new int[]{5,3,2,6,1,9};
            Arrays.sort(array,1, 4);
            System.out.println(Arrays.toString(array));
        }

--------------------

### 6.3.4指定范围的数组拷贝(Arrays.copyOfRange) ###

> Arrays.copyOfRange(被拷贝的数组, 起始下标, 终止下标); //前闭后开

重载：

![86852e2e8a05456b99d49dd889aa0470.png][]

> 实例：（凡是from , to一般都是前闭后开）下例打印\[ 1 , 2 , 3 \]

import java.util.Arrays;
    public class Test{
        //指定拷贝
        public static void main(String[] args){
            int[] array = new int[]{1,2,3,4,5};
            int[] arrayCopy = Arrays.copyOfRange(array, 0,3);
            System.out.println(Arrays.toString(arrayCopy));
        }

--------------------

### 6.3.5数组比较（Arrays.equals） ###

> Arrays.equals(数组名1, 数组名2); 返回类型为布尔类型，相等返回true

![f21515cfebcd4a8fb0708c0932f4a6f5.png][]

> 实例：（以下例子打印true）

import java.util.Arrays;
    public class Test{
        public static void main(String[] args){
            int[] array1 = new int[]{1,2,3,4,5};
            int[] array2 = new int[]{1,2,3,4,5};
            boolean flag = Arrays.equals(array1,array2);
            System.out.println(flag);
        }

--------------------

## 6.4二维数组 ##

和C语言中数组就些许不同啦~

--------------------

### 有以下三种定义方式：（未定义默认初始化为0，引用类型为:NULL） ###

public class Test{
        public static void main(String[] args) {
            int[][] array1 = {
       {1,2,3},{1,2,3}};//不可指定[]里的内容，此时行列会根据初始化内容定义,因此也不能{1,2,3,1,2,3}
            int[][] array2 = new int[][]{
       {1,2,3},{4,5,6}};
            int[][] array3 = new int[2][3];
        }

--------------------

### 三种不同的遍历方式： ###

import java.util.Arrays;
    public class Test{
        
        public static void main(String[] args) {
            int[][] array = {
       {1,2,3},{4,5,6}};
            //1
            for(int i = 0; i < array.length; i++){
                for(int j = 0; j < array[i].length; j++){
                    System.out.print(array[i][j] + " ");
                }
            }
            System.out.println();
            //2
            for(int[] tmp : array){
                for(int x : tmp){
                    System.out.print(x + " ");
                }
            }
            System.out.println();
            //3
            System.out.println(Arrays.deepToString(array));
        }

> 如何理解呢？

--------------------

### 对二维数组遍历的解释： ###

![4a948938eb6f4444929dab98aea0fbd4.png][]

--------------------

### 不规则二维数组: ###

> 与C不同，Java中二维数组可以省略列，不能省略行，以下为图解：

![c087dc1495e243f7900df0195ddddbaf.png][]

--------------------

# 7.类和对象（一个例子轻松理解~） #

一个例子带你搞懂类和对象：

> 一、假设我们要创造一个机器人，首先我们要先绘制机器人图纸（这个图纸相当于“**类**”，没有实际的物理空间）。
> 
> 二、根据图纸我们需要建造这么一个机器人（建造出机器人过过程成为——**实例化对象**），那么这个机器人有那些属性呢？
> 
> 三、这个机器人是什么颜色、有多重、多高...这便是这个机器人的**属性**。那么的功能是那些呢？怎么设计他的芯片让他完成一系列任务？
> 
> 四、这个机器人我需要给他设计多个芯片，每个芯片都可以让他完成不同的任务（**行为**）。
> 
> 五、成功造出这个机器人（机器人——**对象**）

代码如下：

class robot{
        //成员属性（字段）
        public String colour;
        public double height;
        public double weight;
        //...
        //成员方法（行为）
        public void fun1(){
            System.out.println("与人沟通");
        }
        public void fun2(){
            System.out.println("做饭");
        }
        public void fun3(){
            System.out.println("洗衣服");
        }
    }
    
    public class Test{
        public static void main(String[] args){
            robot machine1 = new robot();
            machine1.colour = "蓝色";
            machine1.height = 1.88;
            machine1.weight = 300.25;
            machine1.fun1();
        }

图解：

![078ae7c676264a5bbffedb120626cb81.png][]

![3cb569d6ab5a4b0d97078628986ab875.png][]

--------------------

## 7.1this ##

> 1.防止形参与成员变量同名，并且约定俗成，在方法里引用成员变量时，最好都加this
> 
> (存在即合理)

class student{
        public String name;
        public int age;
        public void fun(String name, int age){
            this.name = name;
            this.age = age;
        }
        public void print(){
            System.out.println("name :" + this.name);
            System.out.println("age :" + this.age);
        }
    }
    public class Test{
        public static void main(String[] args){
            student stu = new student();
            stu.fun("jay chou",46);
            stu.print();
        }

> 2.在当前的构造方法里面，通过this()可以调用当前对象的构造方法（**必须放在当前构造方法的第一行！**）

class student{
        public String name;
        public int age;
    
        public student(){
            this("jay chou",46);
        }
        public student(String name, int age){
            this.name = name;
            this.age = age;
            System.out.println("name:" + this.name + "age:" + this.age);
        }
    
        public void fun(String name, int age){
            this.name = name;
            this.age = age;
        }
        public void print(){
            System.out.println("name :" + this.name);
            System.out.println("age :" + this.age);
        }
    }
    public class Test{
        public static void main(String[] args){
            student stu = new student();
        }

--------------------

## 7.2构造 ##

> 一个没有返回类型的方法，对象一旦生成（new），就会调用一次构造方法（实例化对象其实就是开辟空间同时调用构造方法），同时，构造方法不止一个，可以重载，如果没有提供构造方法，编译器会默认给你提供一种合适的构造方法

使用如下：

class student{
        //成员变量
        public String name;
        public int age;
        //构造方法
        public student(String name, int age){//public 可加可不加，后期会讲
            this.name = name;
            this.age = age;
            System.out.println("name:" + this.name + "age:" + this.age);
        }
        //成员方法
        public void fun(String name, int age){
            this.name = name;
            this.age = age;
        }
        public void print(){
            System.out.println("name :" + this.name);
            System.out.println("age :" + this.age);
        }
    }
    public class Test{
        public static void main(String[] args){
            student stu = new student("jay chou",46);
        }

执行过程如下：

![5ec26eafaa5c4564a7049bd65ec8d0cd.png][]

--------------------

### 7.2.1 构造重载 ###

> **7.1this中的例二就是构造重载，向上翻阅即可**

**注意：不可圈式调用（以下为错误调用）**

![f1282d42ad654d4ebab6eb28eedc9e3a.png][]

--------------------

# 8.static修饰的静态变量 #

> 在类里面，static可以修饰成员变量和方法，由于修饰后的意义不同，也被也被称为类变量和类方法；类变量在内存中只有一份，不能定义在普通的方法当中

--------------------

## 8.1类变量和类方法 ##

> 类中的成员变量被static修饰后也称类变量，类方法同；（类变量和类方法的访问最好通过类名去访问，尽管通过对象也可以访问，但是不推荐！）

如下代码：

class Student{
        public String name;
        public int score;
        //类变量
        public static String classes = "火箭6班";
        //类方法
        public static void fun1(){
            System.out.println("类方法");
        }
    }
    public class Test {
        public static void main(String[] args){
            Student stu = new Student();
            System.out.println(Student.classes);
            Student.fun1();
        }
    }

内存布局如下：

![e8566eadf38a4f0da29122848a0e1713.png][]

> 注意：在静态的方法里不要直接去访问非静态的，可以提供对象引用来访问非静态的！（静态方法在没有new这个类的时也是可以访问的，而非静态的在没有new出对象时是不可以直接访问的!）

如下代码：

class Student{
        public String name;
        public int score;
        //类变量
        public static String classes = "火箭6班";
        //类方法
        public static void fun1(){
            name = "jay";//错误
            System.out.println("类方法");
        }
        public void fun2(){
            name = "jay";//正确
        }
    }

class Student{
        public String name;
        public int score;
        //类变量
        public static String classes = "火箭6班";
        //类方法
        public static void fun1(){
            Student stu = new Student();
            stu.name = "jay";           //正确
            System.out.println("类方法");
        }
    }

--------------------

## 8.2代码块 ##

博主单另写了一篇，有兴趣可以看看~

[http://t.csdn.cn/NGixv][http_t.csdn.cn_NGixv]

--------------------

# 9.内部类 #

> 内部类就是将一个类定义在另一个类的内部；内部类有四种，分别为：实例内部类、静态内部类、局部内部类、匿名内部类（匿名后期将接口会细讲）

--------------------

## 9.1实例内部类 ##

*  外部类中的任何成员都可在实例内部类中直接访问
 *  内外成员同名时，优先访问内部，若想访问外部：外部类名.this.成员名
 *  外部类对象创建后才能创建实例内部类对象
 *  外部类中不能直接访问内部类，须先创建内部类对象

> 如下代码：

class OutClass{
        //成员变量
        public int data1 = 1;
        private int data2 = 2;
        public static int data3 =3;//类变量
        //构造方法
        public OutClass(){
            System.out.println("外部类的构造方法！");
        }
        //实例内部类
        class InsideClass{
            //成员变量
            public int data1 = 4;
            private int data2 = 5;
            public static final int date3 = 6;//必须用 final 修饰为常量，必须初始化
            //构造方法
            public InsideClass(){
                System.out.println("实例内部类的构造方法！");
            }
            //成员方法
            public void fun2(){
                System.out.println(OutClass.this.data1);//访问外部
                System.out.println(data2);//优先访问内部
                System.out.println("实例内部类的成员方法");
            }
        }
        //成员方法
        public void fun1(){
            OutClass.InsideClass inside = new InsideClass();//外部类中需要先创建对象内部类对象
            System.out.println(inside.data1);//在外部类中访问内部类成员
            System.out.println(inside.data2);
            System.out.println("外部类的成员方法！");
        }
    
    }
    public class Test{
        public static void main(String[] args){
            OutClass out = new OutClass();
            OutClass.InsideClass inside = out.new InsideClass();//必须建立在外部类对象的前提的下
        }
    }

--------------------

## 9.2静态内部类 ##

*  静态内部中只能访问外部类中的静态变量，不能访问非静态变量，非要访问，需要创建外部类对象
 *  创建静态内部类对象，不需要先创建外部类对象
 *  在外部类未引入静态内部变量对象前，只能访问静态变量

> 如下代码：

class OutClass{
        public int data1 = 1;
        private int data2 = 2;
        public static int data3 = 3;
        public OutClass(){
            System.out.println("外部类的构造方法！");
        }
        static class InsideClass{
            public int data3 = 3;
            private int data4 = 4;
            public static int data5; // 可以不加final修饰，可以不用先初始化
            public InsideClass(){
                System.out.println(OutClass.data3);//只能访问外部静态的变量
                OutClass out = new OutClass();
                out.fun1();//访问外部非静态成员
                System.out.println("静态内部类构造方法！");
            }
            public void fun2(){
                System.out.println("静态内部类成员方法！");
            }
        }
        public void fun1(){
            System.out.println(InsideClass.data5);//没引入内部类对象前只能访问静态变量
            OutClass.InsideClass inside = new OutClass.InsideClass();
            System.out.println(inside.data3);//访问静态内部类
            System.out.println("外部类的成员方法！");
        }
    
    }
    public class Test{
        public static void main(String[] args){
            //创建静态内部类对象时不需要先创建外部类对象
            OutClass.InsideClass inside = new OutClass.InsideClass();
        }
    }

--------------------

## 9.3局部内部类 ##

*  可以直接访问外部类中成员变量
 *  此类极不常用

> 如下代码：

class OutClass{
        public int data1 = 1;
        private int data2 = 2;
        public static int data3 = 3;
        public OutClass(){
            System.out.println("外部类构造方法！");
        }
        public void fun(){
            System.out.println("外部类成员方法！");
            //局部内部类
            class InsideClass{
                public void fun(){
                    System.out.println("外部类成员变量:" + data1);
                }
            }
        }
    
    }
    public class Test{
        public static void main(String[]  args){
            OutClass out = new OutClass();
            out.fun();
        }
    }

--------------------

# 10.封装、继承、多态 #

> 也是经典的一个面试问题：**OOP语言的三大特征**

**这篇博主已经整理好笔记啦~**

[http://t.csdn.cn/KUJrv][http_t.csdn.cn_KUJrv]

--------------------

# 11.抽象类（abstract） #

> 通俗来讲，就是一个abstract修饰的类，他也具有成员变量，构造方法，成员方法，但这个方法必须是抽象类方法（被abstract修饰并且没有具体实现）。

**注意事项：**

*  抽象类不能进行实例化
 *  可以被继承（extends）
 *  若被一个普通类继承，必须对继承的抽象类（有抽象方法）里抽象方法进行重写，否则编译报错
 *  抽象类A，继承抽象类B，则可以不重写B的抽象方法
 *  抽象方法不能被static、final、private修饰

> 例子：音乐生与美术生所能完成的不同任务

abstract class Human{
        public abstract void func();
    }
    class Art extends Human{
        @Override
        public void func(){
            System.out.println("画画~");
        }
    }
    class Music extends Human{
        @Override
        public void func(){
            System.out.println("唱歌~");
        }
    }
    public class Test{
        public static void function(Human human){
            human.func();
        }
        public static void main(String[] args){
            //Human human = new Human();//抽象类不能实例化对象
            Human human1 = new Art();
            Human human2 = new Music();
            function(human1);
            function(human2);
        }
    }

--------------------

# 12.接口 #

> 是一个用interface修饰的接口，成员变量都是默认被public static final修饰的，成员方法都是默认被public abstract修饰的，并且不能有具体实现（JDK8开始，才可以通过default来写具体实现）。

举个例子，就像手机，需要通过usb接口完成交互，通过数据线将接口连接到电脑，可以传输不同类型的数据，如：图片、视频、音乐、软件.....

**注意事项：**

*  可以有静态成员方法，并且都是被public修饰的
 *  不可以实例化
 *  类是通过implements关联接口的
 *  可以引用具体的实现类完成向上转型
 *  不能有静态代码块、实例代码块、构造方法
 *  接口之间可以通过extends继承，并且可以不重写抽象方法

> 例子：

abstract class Animal{
        public String name;
        public int age;
        Animal(String name, int age){
            this.name = name;
            this.age = age;
        }
        public abstract void eat();
    }
    interface IRun{
        int a = 1;
        void run();
    }
    interface IFly{
        void fly();
    }
    class Brid extends Animal implements IRun, IFly{
        Brid(String name, int age){
            super(name,age);
        }
        @Override
        public void eat(){
            System.out.println(name + "正在吃小虫子~");
        }
        @Override
        public void run(){
            System.out.println(name + "正在用两条腿蹦来蹦去~");
        }
        @Override
        public void fly(){
            System.out.println(name + "正在飞翔~");
        }
    }
    class Dog extends Animal implements IRun{
        Dog(String name, int age){
            super(name, age);
        }
        @Override
        public void eat(){
            System.out.println(name + "正在啃骨头~");
        }
        @Override
        public void run(){
            System.out.println(name + "正在用四条腿跑~");
        }
    }
    public class Test{
        public static void func1(Animal animal){
            animal.eat();
        }
        public static void func2(IRun run){
            run.run();
        }
        public static void func3(IFly fly){
            fly.fly();
        }
        public static void main(String[]  args){
            func1(new Brid("小鸟",1));
            func1(new Dog("狗子",2));
            func2(new Brid("小鸟",1));
            func2(new Dog("狗子",2));
            func3(new Brid("小鸟",1));
        }
    }

--------------------

## 12.1制作一个简单的比较器 ##

import java.util.Arrays;
    import java.util.Comparator;
    
    class Student /*implements Comparable<Student>*/ {
        public String name;
        public int age;
        public int score;
    
        public Student(String name, int age, int score) {
            this.name = name;
            this.age = age;
            this.score = score;
        }
    
        @Override
        public String toString() {
            return "Student = {" +
                    name + ", " + age
                    + ", " + score +
                    "} ;";
        }
    }
    //比较器
    class AgeCompare implements Comparator<Student>{
        @Override
        public int compare(Student o1, Student o2) {
            return o1.age - o2.age;
        }
    }
    class ScoreCompare implements Comparator<Student>{
        @Override
        public int compare(Student o1, Student o2){
            return o1.score - o2.score;
        }
    }
    class NameCompare implements Comparator<Student>{
        @Override
        public int compare(Student o1, Student o2){
            return o1.name.compareTo(o2.name);
        }
    }
    public class Test {
        public static void main(String[] args){
            Student[] student = new Student[3];
            student[0] = new Student("张三",19,90);
            student[1] = new Student("李四",17,82);
            student[2] = new Student("王五",18,85);
            System.out.println("排序前:" + Arrays.toString(student));
            Arrays.sort(student,new ScoreCompare());
            System.out.println("排序后:" + Arrays.toString(student));
    
        }

--------------------

# 13.浅拷贝和深拷贝 #

博主整理出文章了哦，快去看看吧~

[http://t.csdn.cn/bu7wd][http_t.csdn.cn_bu7wd]

--------------------

# 14.Object类 #

Java当中，默认Object是所有类的父类，也就意味着Object可以接收所有类的对象

> 如下代码：

import java.util.Objects;
    class A{
    
    }
    class B{
    
    }
    public class Test{
        public static void main(String[] args){
            Object obj1 = new A();
            Object obj2 = new B();
            System.out.println(obj1);
            System.out.println(obj2);
        }
    }

> 同时，Object类中，也有很好的几个方法例如toString，equals, hashcode...（后面数据结构博主会重点讲），以下以equals举例作为了解

import java.util.Objects;
    class Human{
        public String id;
        public Human(String id){
            this.id = id;
        }
        @Override
        public boolean equals(Object obj){
            if(obj == null){//判断参数是否为空
                return false;
            }
            if(this == obj){//判断地址是否相等
                return true;
            }
           Human tmp = (Human)obj;
           return this.id.equals(tmp.id);
        }
    
    }
    public class Test{
        public static void main(String[] args){
            Object o1 = new Human("610");
            Object o2 = new Human("610");
            System.out.println(o1.equals(o2));
        }
    }

--------------------

# 15.String类 #

> string的三种定义方法

public class Test {
        public static void main(String[] args){
    
            String str1 = "hello";
    
            String str2 = new String("world");
    
            char[] s = {'a','b','c'};
            String str3 = new String(s);
    
        }
    }

> 内存布局：(简易图如下，后面讲面试题有更细致的图)

![4c0b4088436b45fab1504410232d4649.png][]

--------------------

## 15.1字符串常量池 ##

> 观察如下代码 s1 == s2 ?

public class Test {
        public static void main(String[] args){
    
            String str1 = "hello";
            String str2 = "hello";
            System.out.println(str1 == str2);
        }
    }

> 内存分析：

![b2ecb2290e934c498a4825cc27775167.png][]

--------------------

## 15.2面试题：请解释String类中三种实例化对象的区别 ##

博主已经整理好博客啦

[http://t.csdn.cn/n1n5z][http_t.csdn.cn_n1n5z]

--------------------

### 15.3.1 字符串比较是否相同(equals()) ###

public class Test {
        public static void main(String[] args){
    
            String str1 = "hello";
            String str2 = "hell";
            System.out.println(str1.equals(str2));
        }
    }

--------------------

### 15.3.2字符串比较大小(compareTo()) ###

public class Test {
        public static void main(String[] args){
            String str1 = "abc";
            String str2 = "jcd";
            System.out.println(str1.compareTo(str2));//返回ASCII码差值
        }
    }

--------------------

### 15.3.3忽略大小写比较是否相同（equalsIgnoreCase()） ###

public class Test {
        public static void main(String[] args){
            String str1 = "abc";
            String str2 = "ABC";
            System.out.println(str1.equalsIgnoreCase(str2));//返回ASCII码差值
        }
    }

--------------------

### 15.3.4KMP算法查找字符或字符串(indexOf()) ###

public class Test {
        public static void main(String[] args){
            String str1 = "abcabcdeabcdef";
            /**
             * 通过KMP算法
             * 从下标3的位置开始查找第一次出现字符'c'的位置，返回下标，
             */
            int index1 = str1.indexOf('c',3);
            System.out.println(index1);
            int index2 = str1.indexOf("abcd");
            System.out.println(index2);
        }
    }

--------------------

### 15.3.5将其他类型相互转化(其他类型.valueOf()) ###

public class Test {
        public static void main(String[] args){
            //double转String
            String str1 = String.valueOf(12.5);
            System.out.println(str1);
            //String转int
            int value =Integer.valueOf("64");
            System.out.println(value);
        }
    }

--------------------

### 15.3.6小写转大写（toUpperCase()） ###

public class Test {
        public static void main(String[] args){
            String str1 = "abc";
            String str2 = str1.toUpperCase();
            System.out.println(str2);
        }
    }

--------------------

### 15.3.7大写转小写(toLowerCase()) ###

public class Test {
        public static void main(String[] args){
            String str1 = "ABC";
            String str2 = str1.toLowerCase();
            System.out.println(str2);
        }
    }

> [LeetCode 125.验证回文串：][LeetCode 125.]给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。

class Solution {
        private boolean legal(char ch){
            if(((ch >= 'a') && (ch <= 'z')) || ((ch >= '0') && (ch <= '9'))){
                return true;
            }
            return false;
        }
        public boolean isPalindrome(String s) {
            s = s.toLowerCase();
            int left = 0;
            int right = s.length() - 1;
            while(left < right){
                while(left < right && !legal(s.charAt(left))){
                    left++;
                }
                while(left < right && !legal(s.charAt(right))){
                    right--;
                }
                if(s.charAt(left) != s.charAt(right)){
                    return false;
                }
                left++;
                right--;
            }
            return true;
        }
    }

--------------------

### 15.3.8字符串转字符数组（toCharArray()） ###

public class Test {
        public static void main(String[] args){
            String str1 = "hello";
            char[] str2 = str1.toCharArray();
            System.out.println(str2);
        }
    }

--------------------

### 15.3.9字符串切割（split()） ###

public class Test {
        public static void main(String[] args){
            String str1 = "hello welcome to China";
            String[] str2 = str1.split(" ");//(" ", 3);3表示切割3组字符串
            for(String x : str2){
                System.out.println(x);
            }
        }
    }

--------------------

### 15.3.10字符串替代（replaceFirst()） ###

> 剑指Offer：将str1中的空格替代为%20

//将str1中的空格替代为%20
    public class Test {
        public static void main(String[] args){
            String str1 = "hello welcome to China";
            for(int i = 0; i < 3; i++){
                str1 = str1.replaceFirst(" ","%20");//每次只会替代一个空格
            }
            System.out.println(str1);
        }
    }

--------------------

### 15.3.11拿到字符串中的每一个字符(charAt()) ###

> 求字符串最后一个单词的长度

public class Test {
        public static void main(String[] args){
            Scanner scanner = new Scanner(System.in);
            String str = scanner.nextLine();
            int i = 0;
            int count = 0;
            for(i = str.length() - 1; i > 0; i--){
                if(str.charAt(i) == ' '){
                    break;
                }
                count++;
            }
            System.out.println(count);
        }
    }

--------------------

# 16.异常处理 #

对异常的处理常常有以下两种处理方式：

> 1.LBYL：事前防御型

在操作前就提前做好一切准备，把可能报异常的地方都列举出来；

*一个有趣的例子，你谈了女朋友，想牵她的手，但是不知道会发生什么，所以你问了一句：“**我可以牵你手吗**？”这便是提前做好准备*

> 2.EAFP：事后认错型

不管会发生什么样的问题，先操作，遇到问题，再解决问题；

*你谈了女朋友，想牵她的手，但是不知道会发生什么，然后你也没问，**直接牵手**，这便是先斩后奏，遇到问题，再说。*

## 16.1try-catch-finally（捕获并处理） ##

> 如下代码：

public class Test{
        public static void main(String[] args){
            int[] array = null;
            try {
                /**
                 * 可能会发生的异常
                 */
                System.out.println(array.length);
            }catch (NullPointerException e){
                /**
                 * 若try中抛出的异常与catch捕获的异常类型一样时，就会进行对异常的处理
                 * 若try中抛出的异常与catch捕获的异常类型不一样时，就会不断对外抛，直到交给JVM中断程序，抛出异常
                 */
                System.out.println("对异常的处理!");
            }finally{
                System.out.println("无论try有没有抛异常，程序都会指向这里");
                /**
                 * 无论有没有finally程序都会执行到这里，那finally有什么意义呢？
                 * 想象一下，如果try里存在return这样的语句，就会结束main方法
                 * 但这里因为有finally，所以无论try里有没有return都会执行指一条语句
                 */
            }
        }
    }

> 面试题：
> 
> throw 和 throws 的区别？

throw关键字，事抛出一个指定的异常对象，将错误信息告知给调用者

throw new XXXException("异常产生的原因");

throws是异常的声明，在方法名（参数列表）之后如下：

修饰符  返回值类型   方法名(参数列表) throws 异常类型1，异常类型2...{
    //...
    }

是当方法中抛出编译时异常时，用户不想处理异常，就用throws来声明异常即可，以提醒方法的调用者处理该异常

> 面试题：
> 
> ﬁnally中的语句一定会执行吗？

一定会执行，就算try里有return语句，照样执行finally；

--------------------

## 16.2自定义异常 ##

> 先自定义一个异常类，继承一个具体异常或者Exception(所有异常的父类)，再实现一个带有String参数的构造方法（抛出错误原因）。

如下代码：（消息发送异常，模拟网络异常）

class NetworkException extends Exception{
        public NetworkException(String message){
            super(message);
        }
    }
    public class Test{
        public static void send (String networdState) throws NetworkException{
            if(networdState.equals("网络异常")){
                throw new NetworkException("网络状况不佳，无法发送消息!");
            }
        }
        public static void main(String[] args){
            //相应处理...发生网络异常
            String networdState = "网络异常";
            try{
                send(networdState);
            }catch(NetworkException e){
                e.printStackTrace();//打印栈区情况
            }
        }
    }

> 运行结果：

![18c87abb0e32441da6dc106a56218640.png][]

[36475b3902aa45f6bdfb51e414948e38.png]: https://img-blog.csdnimg.cn/36475b3902aa45f6bdfb51e414948e38.png
[e130f0c1a3824d1da4badf75ace0da65.png]: https://img-blog.csdnimg.cn/e130f0c1a3824d1da4badf75ace0da65.png
[62a8070ad6284798ae920b57c2033d31.png]: https://img-blog.csdnimg.cn/62a8070ad6284798ae920b57c2033d31.png
[http_t.csdn.cn_lkZ5J]: http://t.csdn.cn/lkZ5J
[427d1eba691c4f2eaef893facaae0632.png]: https://img-blog.csdnimg.cn/427d1eba691c4f2eaef893facaae0632.png
[ab29daa19cef4f269ecfc244b179d5c0.png]: https://img-blog.csdnimg.cn/ab29daa19cef4f269ecfc244b179d5c0.png
[51d1af9e3a814dc796d25f01fbdf0ba1.gif]: https://img-blog.csdnimg.cn/51d1af9e3a814dc796d25f01fbdf0ba1.gif
[444ae4d7505e4e7799ad64038992fdb2.png]: https://img-blog.csdnimg.cn/444ae4d7505e4e7799ad64038992fdb2.png
[53beb5dcdd4e44d9b662cb58e058836b.png]: https://img-blog.csdnimg.cn/53beb5dcdd4e44d9b662cb58e058836b.png
[79b430719e2348909f41737a3d7ad4eb.gif]: https://img-blog.csdnimg.cn/79b430719e2348909f41737a3d7ad4eb.gif
[553a7ce21bdf4d2f9320bcaf89849d18.png]: https://img-blog.csdnimg.cn/553a7ce21bdf4d2f9320bcaf89849d18.png
[http_t.csdn.cn_QOGH6]: http://t.csdn.cn/QOGH6
[11763ab8e5db42dea692071b0b3dcf0c.png]: https://img-blog.csdnimg.cn/11763ab8e5db42dea692071b0b3dcf0c.png
[db67e0e608574d7c9cc28c6a8dac48e4.png]: https://img-blog.csdnimg.cn/db67e0e608574d7c9cc28c6a8dac48e4.png
[4bcda2d6713f415c8cd7d5dae6b5867c.png]: https://img-blog.csdnimg.cn/4bcda2d6713f415c8cd7d5dae6b5867c.png
[2ddd413b983b4ce7ae733244a659ac20.png]: https://img-blog.csdnimg.cn/2ddd413b983b4ce7ae733244a659ac20.png
[b1f0c46c9b224033ad83334f35e1c1ce.png]: https://img-blog.csdnimg.cn/b1f0c46c9b224033ad83334f35e1c1ce.png
[http_t.csdn.cn_Wecgu]: http://t.csdn.cn/Wecgu
[f6fb9f351b5b49228dcd19e2bd9d0324.png]: https://img-blog.csdnimg.cn/f6fb9f351b5b49228dcd19e2bd9d0324.png
[2b687f80e5ce49259c6188102151f821.png]: https://img-blog.csdnimg.cn/2b687f80e5ce49259c6188102151f821.png
[aefaacd84cf648d2a2c118583bd1d350.png]: https://img-blog.csdnimg.cn/aefaacd84cf648d2a2c118583bd1d350.png
[ee0e9df8e6414c23882f5c673c64ae6b.png]: https://img-blog.csdnimg.cn/ee0e9df8e6414c23882f5c673c64ae6b.png
[1811192c1991409a8f558bd9746d82d0.png]: https://img-blog.csdnimg.cn/1811192c1991409a8f558bd9746d82d0.png
[881268ca87d3465dad9d81327c163cb9.png]: https://img-blog.csdnimg.cn/881268ca87d3465dad9d81327c163cb9.png
[9bdc4c23d73f40f38b5c6ededb9ca605.png]: https://img-blog.csdnimg.cn/9bdc4c23d73f40f38b5c6ededb9ca605.png
[ee9216485a0947f78ab4ac3cce205acf.png]: https://img-blog.csdnimg.cn/ee9216485a0947f78ab4ac3cce205acf.png
[e9a261dfa06843d7ab430ba85788e529.png]: https://img-blog.csdnimg.cn/e9a261dfa06843d7ab430ba85788e529.png
[69c3aa23781e4483a8c20217fc4cbc51.png]: https://img-blog.csdnimg.cn/69c3aa23781e4483a8c20217fc4cbc51.png
[6ec5a3fc230142e8a5c8b6d9ff825b22.png]: https://img-blog.csdnimg.cn/6ec5a3fc230142e8a5c8b6d9ff825b22.png
[08a15125e69f4b66ba841d7d6e18eb03.png]: https://img-blog.csdnimg.cn/08a15125e69f4b66ba841d7d6e18eb03.png
[442736dc33c34df38b10e4c2a4bda12c.png]: https://img-blog.csdnimg.cn/442736dc33c34df38b10e4c2a4bda12c.png
[02cf53132e3543809ec15ec8a230759e.png]: https://img-blog.csdnimg.cn/02cf53132e3543809ec15ec8a230759e.png
[980b4a08b3dc4d19b375ec528fa629ae.png]: https://img-blog.csdnimg.cn/980b4a08b3dc4d19b375ec528fa629ae.png
[http_t.csdn.cn_hU5oV]: http://t.csdn.cn/hU5oV
[aee44665f32c42ef934180d8dd294fdf.png]: https://img-blog.csdnimg.cn/aee44665f32c42ef934180d8dd294fdf.png
[2d72deaf373346e78e40a17c21c30584.png]: https://img-blog.csdnimg.cn/2d72deaf373346e78e40a17c21c30584.png
[eb50e8edef5f4cf8a23fa050d86885d7.png]: https://img-blog.csdnimg.cn/eb50e8edef5f4cf8a23fa050d86885d7.png
[94451372b548498eaa3187eedee93218.png]: https://img-blog.csdnimg.cn/94451372b548498eaa3187eedee93218.png
[2a1b4d5836d84bef86ff415edfd7f89f.png]: https://img-blog.csdnimg.cn/2a1b4d5836d84bef86ff415edfd7f89f.png
[a3f65bcd4e174240bef204ad9f564777.png]: https://img-blog.csdnimg.cn/a3f65bcd4e174240bef204ad9f564777.png
[550e45b19a914cf3bac8815a2dcbfec3.png]: https://img-blog.csdnimg.cn/550e45b19a914cf3bac8815a2dcbfec3.png
[3d883bdebb764697aa02603e01c97a29.png]: https://img-blog.csdnimg.cn/3d883bdebb764697aa02603e01c97a29.png
[f33152ad48db45e7b42a07cfa5d48766.png]: https://img-blog.csdnimg.cn/f33152ad48db45e7b42a07cfa5d48766.png
[85647ccced5c4008a503bf5650680f54.png]: https://img-blog.csdnimg.cn/85647ccced5c4008a503bf5650680f54.png
[16e3d9da2fde4e38859b33c6234fa681.png]: https://img-blog.csdnimg.cn/16e3d9da2fde4e38859b33c6234fa681.png
[86852e2e8a05456b99d49dd889aa0470.png]: https://img-blog.csdnimg.cn/86852e2e8a05456b99d49dd889aa0470.png
[f21515cfebcd4a8fb0708c0932f4a6f5.png]: https://img-blog.csdnimg.cn/f21515cfebcd4a8fb0708c0932f4a6f5.png
[4a948938eb6f4444929dab98aea0fbd4.png]: https://img-blog.csdnimg.cn/4a948938eb6f4444929dab98aea0fbd4.png
[c087dc1495e243f7900df0195ddddbaf.png]: https://img-blog.csdnimg.cn/c087dc1495e243f7900df0195ddddbaf.png
[078ae7c676264a5bbffedb120626cb81.png]: https://img-blog.csdnimg.cn/078ae7c676264a5bbffedb120626cb81.png
[3cb569d6ab5a4b0d97078628986ab875.png]: https://img-blog.csdnimg.cn/3cb569d6ab5a4b0d97078628986ab875.png
[5ec26eafaa5c4564a7049bd65ec8d0cd.png]: https://img-blog.csdnimg.cn/5ec26eafaa5c4564a7049bd65ec8d0cd.png
[f1282d42ad654d4ebab6eb28eedc9e3a.png]: https://img-blog.csdnimg.cn/f1282d42ad654d4ebab6eb28eedc9e3a.png
[e8566eadf38a4f0da29122848a0e1713.png]: https://img-blog.csdnimg.cn/e8566eadf38a4f0da29122848a0e1713.png
[http_t.csdn.cn_NGixv]: http://t.csdn.cn/NGixv
[http_t.csdn.cn_KUJrv]: http://t.csdn.cn/KUJrv
[http_t.csdn.cn_bu7wd]: http://t.csdn.cn/bu7wd
[4c0b4088436b45fab1504410232d4649.png]: https://img-blog.csdnimg.cn/4c0b4088436b45fab1504410232d4649.png
[b2ecb2290e934c498a4825cc27775167.png]: https://img-blog.csdnimg.cn/b2ecb2290e934c498a4825cc27775167.png
[http_t.csdn.cn_n1n5z]: http://t.csdn.cn/n1n5z
[LeetCode 125.]: https://leetcode.cn/problems/valid-palindrome/
[18c87abb0e32441da6dc106a56218640.png]: https://img-blog.csdnimg.cn/18c87abb0e32441da6dc106a56218640.png