# Base ## 安装 [JDK 下载](https:\/\/www.oracle.com\/java\/) [JDK8 下载 ](https:\/\/www.oracle.com\/java\/technologies\/javase\/javase8u211-later-archive-downloads.html) [JDK11 下载](https:\/\/www.oracle.com\/java\/technologies\/javase\/jdk11-archive-downloads.html) [java8 文档](https:\/\/docs.oracle.com\/javase\/8\/docs\/api\/index.html) * Java 2 标准版(J2SE) ：桌面 * Java 2 企业版(J2EE) ：服务器 * Java 2 移动版(J2ME) ：手机 **JDK、JRE、JVM** * JDK ：Java Development Kit (开发工具包) * 2014 jdk8 * 2018 jdk11 * 2021 jdk17 * JRE ：Java Runtime Environment (运行环境) * JVM ：Java Virtual Machine (虚拟机) **JDK 安装** * 下载 JDK * 配置环境变量 `JAVA_HOME` 、`Path` * 验证安装 `java -version` ```java public class Main { public static void main(String[] args) { System.out.println("hello world"); } } ``` ```sh # 检查版本号 java -version javac -version # 编译java文件 javac Demo.java # 查看编译的class文件内容 javap A.class # 执行class文件 java Demo.class # 执行jar包 java -jar xxx.jar # 生成javadoc javadoc -encoding UTF-8 -charset UTF-8 Demo.java ``` ### DOS 命令 * `dir` ：列出当前目录下的文件以及文件夹 * `md` ：创建目录 * `rd` ：删除目录 * `cd` ：进入指定目录 (change directory) * `cd ..` ：退回到上一级目录 * `cd \/` ：退回到根目录 * `del` ：删除文件 * `exit` ：退出 dos 命令行 * `cls` ：清理屏幕 * `ipconfig` ：查看电脑的 ip * 打开应用：`calc mspaint notepad` * JavaSE * JavaWeb * SSM 框架 * Linux * SpringBoot * SpringCloud ## 标识符标识符由 26 个大小写字母、0～9 阿拉伯数字、`_` 和 `＄` 组成。数字不能开头。常量名全部大写。标识符是大小写敏感的。可以用中文命名，但不推荐。不能使用关键字作为变量名或方法名。修饰符不存在先后顺序。 ```java public static final double PI = 3.14159; ``` ### 关键字 ![](http:\/\/qiniu.huangyihui.cn\/202507072158283.png) ## 注释 * 单行注释：`\/\/` * 多行注释：`\/* *\/` * 文档注释：`\/** *\/` 多行注释中不能嵌套多行注释，文档注释也不能嵌套多行注释。 ```java \/** * @author: 张三 * @ClassName: TestController * @Desciption: Test 控制类 * @Date: 2024\/01\/20 21:22 *\/ ``` ## 数据类型 * 基本类型 * 整数类型。数字之间可以使用下划线分隔。操作比较大的数的时候，需注意溢出问题。 * 浮点类型。最好完全避免使用浮点数进行比较。 * 字符类型 * 布尔类型 * 引用类型 * 类、接口、数组 | 基本数据类型 | 内存占用（字节数） | 数据范围 | | ------------ | ------------------ | ------------------------------------------------ | | byte | 1 | -128~127 | | short | 2 | -32768~32767 | | int | 4 | -2147483648~2147483647(10位数，大概21亿多) | | long | 8 | -9223372036854775808~9223372036854775807(19位数) | | float | 4 | 1.401298 E-45 到3.4028235 E+38 | | double | 8 | 4.9000000E-324 到1.797693E+308 | | char | 2 | 0-65535 | | boolean | 1 | true，false | * 位(bit) ：是计算机内部数据储存的最小单位。10010011 是一个八位二进制数。 * 字节(byte) ：是计算机中数据处理的基本单位，习惯用大写 B 来表示。1B (字节) = 8 bit (位) * 1024B = 1KB ```java int num1 = 10; byte num2 = 20; short num3 = 30; long num4 = 40L; \/\/ Long 类型要在数字后面加 L float num5 = 50.1f; \/\/ float 类型要在数字后面加 F double num6 = 3.14159; char ch1 = 'A'; String str1 = "abc"; \/\/ String 不是关键字，是类 boolean flag = true; int money = 10_0000_0000; \/\/ 最好完全避免使用浮点数进行比较 float f = 0.1f; double d = 1.0 \/ 10; System.out.println(f == d); \/\/ false float d1 = 2131314124144f; float d2 = d1 + 1; System.out.println(d1 == d2); \/\/ true \/\/ 操作比较大的数的时候，需注意溢出问题 int money = 10_0000_0000; int year = 20; int total = money * year; \/\/ -1474836480 溢出了 long total2 = money * year; \/\/ -1474836480 默认是 int，转换之前已经存在问题了 long total3 = money * ((long) year); \/\/ 20000000000 ``` ### 类型转换自动类型转换：类型范围小的变量，可以直接赋值给类型范围大的变量。 * byte → short → int → long → float → double * char → int 在表达式中，小范围类型的变量，会自动转换成表达式中较大范围的类型，再参与运算。表达式的最终结果类型由表达式中的`最高类型决定`。 **在表达式中，byte、short、char 是直接转换成 int 类型参与运算的。** 强制类型转换可能造成数据丢失。浮点型强转成整型，直接丢掉小数部分，保留整数部分返回。 ```java \/\/ 类型转换 \/\/ 自动类型转换 byte a = 12; int b = a; System.out.println(a); \/\/ 12 System.out.println(b); \/\/ 12 \/\/ 结果类型由最高类型决定 byte a = 10; int b = 20; long c = 30; long d = a + b + c; System.out.println(d); \/\/ 60 \/\/ char 会转为 int 再进行运算 char a = 'a'; \/\/ 97 int b = a + 10; System.out.println(b); \/\/ 107 System.out.println(((char)98)); \/\/ b \/\/ 强制类型转换可能造成数据丢失 int a = 220; byte b = (byte)a; System.out.println(b); \/\/ -36 这是因为截取了220的二进制表示的后8位 \/\/ 浮点型强转为整型会丢失小数部分 double d = 3.21; int i = (int) d; System.out.println(i); \/\/ 3 \/\/ 面试题 byte b1 = 10; byte b2 = 20; \/\/ byte b3 = b1 + b2; \/\/ 编译错误，Java在进行算术运算时，会自动将byte、short和char类型提升为int类型。 int b3 = b1 + b2; byte b4 = (byte)(b1 + b2); System.out.println(b3); ``` ## 进制 * 二进制：由 0，1 组成，开头用 `0b` 表示 * 八进制：由 0～7 组成，开头用 `0` 表示 * 十进制：由 0～9 组成 * 十六进制：由 0～9，A～F组成，开头用 `0x` 表示 ```java int i = 10; int i2 = 0b10; int i3 = 010; int i4 = 0x10; System.out.println(i); \/\/ 10 System.out.println(i2); \/\/ 2 System.out.println(i3); \/\/ 8 System.out.println(i4); \/\/ 16 ``` 进制转换： * 十进制转二进制：就是除 2 运算 * 除二取余法：将十进制数不断除以2，每次取余数，直至商为0为止，将所得的余数从下向上排列就是二进制结果。 * 二进制转十进制：就是乘 2 运算，每位乘以2的当前位数幂 * 8421转换法：依次把每位是1的结果相加 * 二进制转十六进制：四个二进制位代表一个十六进制位 * 8421转换法：4位最大值是15，依次把4位的结果拼接起来就是二进制转16进制的结果 * 二进制转八进制：三个二进制位代表一个八进制位 * 8421转换法：3位最大值是7，依次把3位的结果拼接起来就是二进制转8进制的结果 * 负数的二进制就是它的取反 `+1` ```java \/\/ java中内置的进制转换 System.out.println(Integer.toBinaryString(-6)); \/\/十进制-->二进制 public static void toBin(int num){ trans(num,1,1); } \/\/十进制-->八进制 public static void toOctal(int num){ trans(num,7,3); } \/\/十进制-->十六进制 public static void toHex(int num){ trans(num,15,4); } ``` ```java \/\/ 十进制 --> 十六进制 public static void toHex(int num){ StringBuffer sb = new StringBuffer(); for(int x=0; x<8; x++){ int temp = num & 15; if(temp>9) \/\/System.out.println((char)(temp-10+'A')); sb.append((char)(temp-10+'A')); else \/\/System.out.println(temp); sb.append(temp); num = num >>> 4; } System.out.println(sb.reverse()); } ``` ```java \/\/ 十进制-->二进制 public static void toBin(int num){ StringBuffer sb = new StringBuffer();\/\/存储数据 while(num>0){ \/\/System.out.println(num%2); sb.append(num%2); \/\/append 添加 num = num \/ 2; } System.out.println(sb.reverse()); \/\/reverse()反转 } ``` ```java \/\/ 查表法十进制转二进制 public static void toBin_1(int num){ if(num==0){ System.out.println("0"); return ; } char[] chs = {'0','1'}; char[] arr = new char[32]; int pos = arr.length; while(num!=0){ int temp = num & 1; arr[--pos] = chs[temp]; num = num >>> 1; } \/\/System.out.println("pos="+pos); for(int x=pos; x>> 4; } System.out.println("pos="+pos); for(int x=pos; x>> offset; } for(int x=pos; x < >= <= == != instanceof` * 逻辑运算符：`& | ^ ! && || ` * `&` ：两边都为true结果才为true，只要有一边是false，结果就是false * `|` ：两边都为false结果才为false，只要有一边是true，结果就是true * `^` ：判断两边的结果是否不同，不同则为true，相同则为false * `!` ：取反，!true结果是false，!fasle结果是true * `&&` ：和&结果相同，具有短路效果，如果前半是false，表达式结果一定为false，不运行后一半 * `||` ：和||结果相同，具有短路效果，如果前半是true，表达式结果一定为true，不运行后一半 * 位运算符：` ~ << >> >>>` * `<<` ：其实就是乘以2的移动的位数次幂。 * `>>` ：其实就是除以2的移动的位数次幂。 * `^` ：一个数异或同一个数两次，结果还是那个数。 * 三元运算符：`z=(x>y)?x:y;` 取模(取余数)： * 当左边小于右边时,结果为左边 * 当右边为1时,结果为0 * 当两边相等时,结果为0 * 当出现负数时,只看左边无符号右移： * `>>` ：最高位补什么由原有数据的最高位值而定。如果最高位0，右移后，用0补空位 * `>>>` ：无论最高位是什么，右移后，都用0补。 ```java System.out.println(5 \/ 2); \/\/ 2 System.out.println(1.0 * 5 \/ 2); \/\/ 2.5 \/\/ 异或 System.out.println(2 > 1 ^ 3 > 1); \/\/ false System.out.println(1 > 1 ^ 2 > 1); \/\/ true System.out.println(true ^ true); \/\/ false System.out.println(false ^ false); \/\/ false System.out.println(false ^ true ); \/\/ true System.out.println(23 ^ 54 ^ 23 ); \/\/ 54 一个数异或同一个数两次，结果还是那个数 \/\/ 短路运算 int c = 5; boolean d = (c < 4) && (c++ < 4); System.out.println(c); \/\/ 5 System.out.println(d); \/\/ false \/\/ 运算符优先级 System.out.println(10 > 3 || 10 > 3 && 10 < 3); \/\/ true ``` 运算符优先级： | 优先级 | 运算符 | | ------ | --------------------------- | | 1 | `()` | | 2 | `! -(负数) ++ -- ` | | 3 | `* \/ %` | | 4 | `+ -(减)` | | 5 | `<< >> >>>` | | 6 | `< <= > >= instanceof` | | 7 | `== !=` | | 8 | `&` | | 9 | `^` | | 10 | \| | | 11 | `&&` | | 12 | \|\| | | 13 | `?:` | | 14 | `= += -= *= \/= %= &=` | ## 转义字符 * `\n` ：回车 * `\b` ：退格 * `\t` ：制表符 * `\r` ：回车（window中允许有两个代表回车） ## 判断语句 * `if` * `if ... else` * `if ...else if ... else` * `switch` ：语句中的变量类型可以是 `byte` 、`short` 、`int` 、`char` 、`String` 、枚举，同时 case 标签必须为字符串常量或字面量。 ```java int score = 95; if (score == 100) { System.out.println("A级"); } else if (score < 100 && score > 80) { System.out.println("B级"); } else { System.out.println("C级"); } String language = "ch"; switch (language) { case "ch": System.out.println("你好"); break; case "fra": System.out.println("Bonjour"); break; default: System.out.println("hi"); } ``` ## 循环语句 * `while` * `do...while` ：无论条件是否满足，循环体至少执行一次 * `for循环` * 增强 for 循环：可以用来遍历集合或者数组不知道循环次数用 while，知道循环次数用 for。流程控制语句： * `break` ：跳出并结束当前所在循环的执行。还可以用于 switch 语句。 * `continue` ：用于跳出当前循环的当次执行，直接进入循环的下一次执行。只能作于循环结构。 * 它们单独存在时，下面不可以有任何语句语句，因为执行不到。 ```java int count = 0; while (count < 5) { System.out.println(count); count++; } int num = 2; do { System.out.println(num); } while (num < 1); for (int i = 0; i < 5; i++) { System.out.println(i); } \/\/ for 嵌套 for (int i = 1; i <= 9; i++) { for (int j = 1; j <= i; j++) { System.out.print(j + "*" + i + "=" + i * j + "\t"); } System.out.println(); } \/\/ 遍历数组或集合的增强型 for 循环格式：for(元素的数据类型变量名:数组或者集合) { } int[] nums = {21, 5, 12, 94, 6}; for (int x : nums) { System.out.println(x); } \/\/ 死循环 for (; ; ) { } while (true) { } ``` ```java for (int i = 0; i < 10; i++) { if (i > 5) { break; } System.out.println(i); } for (int i = 0; i < 10; i++) { if (i % 2 == 0) { continue; } System.out.println(i); } \/\/ 通过标记跳出循环 OUT: for (int i = 0; i <= 20; i++) { if(i%3 == 0) { continue OUT; } System.out.println(i); } ``` ## 函数 function 函数就是定义在类中的具有特定功能的一段独立小程序，函数也称为方法。函数的格式： ``` 修饰符返回值类型函数名(参数类型形式参数1,参数类型形式参数2,...) { 执行语句; return 返回值; } ``` 当函数运算后，没有具体的返回值，就用关键字 `void` 标识。当函数返回值是 `void` 时，`return` 可以省略不写。 ### 重载重载(overload) 就是在一个类中，有相同的函数名称，但形参不同的函数。当定义的功能相同，但参与运算的未知内容不同。那么，就定义一个函数名称以表示该功能，方便阅读，而通过参数列表的不同来区分多个不同名函数。 * 方法名称必须相同 * 参数列表必须不同（个数不同 \/ 类型不同 \/ 参数排列顺序不同） * 与返回值类型无关方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法。如果匹配失败，则编译器报错。 ```java public class Demo { public static void main(String[] args) { System.out.println(add(10, 20)); System.out.println(add(10.0, 20.0)); } public static int add(int a, int b) { return a + b; } public static double add(double a, double b) { return a + b; } } ``` ### 可变参数可变参数就是一种特殊形参，定义在方法、构造器的形参列表中，在数据类型后加一个省略号 `...` 即可指定为一个可变参数。 * 特点：可以不传数据给它；可以传一个或者同时传多个数据给它；也可以传一个数组给它。 * 好处：常常用来灵活的接收数据。注意事项： * 一个形参列表中只能有一个可变参数 * 可变参数必须放在形参列表的最后面 * 可变参数在方法内部，本质就是一个数组 ```java public class Demo { public static void main(String[] args) { System.out.println(add(10, 20, 30, 40)); System.out.println(add(1, new int[]{1, 2, 3})); } \/\/ 可变参数 nums public static int add(int a, int... nums) { \/\/ 可变参数在方法内部，本质就是一个数组 int sum = a; for (int num : nums) { sum += num; } return sum; } } ``` ### 递归递归就是自己调用自己。 * 需要设置停止的条件，不然会进入死循环 * 递归层级不能太大，否则就会出现栈溢出错误 `StackOverflowError` ```java public class Demo { public static void main(String[] args) { System.out.println(f(5)); \/\/ 120 } \/\/ 阶乘 1*2*3* ... * n public static int f(int n) { if (n == 1) { return 1; } else { return n * f(n - 1); } } } ``` ### 命令行传参如果希望运行一个程序时再传递给它消息，要靠传递命令行参数给 `main()` 函数实现。 ```java public class Demo { public static void main(String[] args) { for (int i = 0; i < args.length; i++) { System.out.println(args[i]); } } } ``` 步骤： 1. 在 java 文件目录下编译 `javac Demo.java` 2. 在项目 src 目录下根据包名执行程序 `java com.hyh.demo.Demo 参数1 参数2` ## 数组 Array 数组是相同类型数据的有序集合。每个数据称作一个数组元素，每个数组元素可以通过索引访问，索引从0开始。索引一旦越界，就会出现 `ArrayIndexOutOfBoundsException` 异常。其实数组就是一个容器。其长度是确定的，数组一旦被创建，它的大小就不可以改变。数组的工具类 `java.util.Arrays` 提供了很多实用方法。 ```java int[] arr = new int[]{1, 2, 3, 4, 5}; \/\/ 推荐 int arr2[] = new int[]{1, 2, 3, 4, 5}; int[] arr3 = new int[10]; \/\/ 指定数组长度，数组元素会隐式初始化为相应类型的默认值 int[] arr4 = {1, 2, 3}; \/\/ 静态初始化 for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } arr3[0] = 99; for (int i : arr3) { System.out.println(i); } ``` 数组元素默认值规则： * byte、short、int、long ：0 * float、double ：0.0 * boolean ：false * 类、接口、数组、String ：null ### 多维数组 ```java int[][] arr = new int[2][3]; int[][] arr2 = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; for (int[] ints : arr) { for (int item : ints) { System.out.print(item + "\t"); } System.out.println(); } System.out.println(arr2[1][2]); \/\/ 6 ``` ### 稀疏数组当一个数组中大部分元素为 0，或者为同一值的数组时，可以使用稀疏数组来保存该数组，以节省空间。处理方式： * 记录数组一共有几行几列，和多少个不同值 * 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模 ```java \/\/ 通过稀疏数组保存、还原棋盘数据 \/\/ 棋盘数据 0：没有棋子 1：黑棋 2：白棋 int[][] array1 = new int[11][11]; array1[1][2] = 1; array1[2][3] = 2; for (int[] ints : array1) { for (int anInt : ints) { System.out.print(anInt + "\t"); } System.out.println(); } \/\/ 将棋盘数据保存为稀疏数组 int sum = 2; int[][] array2 = new int[sum + 1][3]; array2[0][0] = 11; array2[0][1] = 11; array2[0][2] = sum; int count = 0; for (int i = 0; i < array1.length; i++) { for (int j = 0; j < array1[i].length; j++) { if (array1[i][j] != 0) { count++; array2[count][0] = i; array2[count][1] = j; array2[count][2] = array1[i][j]; } } } System.out.println("稀疏数组："); for (int i = 0; i < array2.length; i++) { System.out.println(array2[i][0] + "\t" + array2[i][1] + "\t" + array2[i][2]); } \/\/ 还原数据 int[][] array3 = new int[array2[0][0]][array2[0][1]]; for (int i = 1; i < array2.length; i++) { array3[array2[i][0]][array2[i][1]] = array2[i][2]; } System.out.println("还原数据："); for (int[] ints : array3) { for (int anInt : ints) { System.out.print(anInt + "\t"); } System.out.println(); } ``` ### 常用方法 ```java \/\/ 遍历打印数组 public static void printArr(int[] arr) { System.out.print("["); for (int x = 0; x < arr.length; x++) { if (x != arr.length - 1) { \/\/判断角标是否为最后一个 System.out.print(arr[x] + ", "); } else { System.out.print(arr[x] + "]"); } } System.out.println(); } \/\/ 反转数组，不改变原数组 public static int[] reverse(int[] arr) { int[] result = new int[arr.length]; for (int i = 0, j = result.length - 1; i < result.length; i++, j--) { result[j] = arr[i]; } return result; } \/\/ 反转数组，改变原数组 public static int[] reverse2(int[] arr) { for (int i = 0, j = arr.length - 1; i < j; i++, j--) { int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } return arr; } \/\/ 打乱数组中的元素顺序 public static void randomSort(int[] arr) { Random r = new Random(); for (int i = 0; i < arr.length; i++) { \/\/ 让当前值和随机索引位置处的值交换 int index = r.nextInt(arr.length); int temp = arr[index]; arr[index] = arr[i]; arr[i] = temp; } } \/\/ 获取最大值 public static int getMax(int[] arr) { int max = arr[0]; for (int i = 1; i < arr.length; i++) { if (arr[i] > max) max = arr[i]; } return max; } \/\/ 获取最小值 public static int getMin(int[] arr) { int min = arr[0]; for (int i = 1; i < arr.length; i++) { if (arr[i] < min) min = arr[i]; } return min; } \/\/ 查找指定范围内的所有质数\/素数 \/\/ 素数：除了1和它本身以外，不能被其他正整数整除。 public static void search(int min, int max) { for (int i = min; i <= max; i++) { boolean flag = true; for (int j = 2; j <= i \/ 2; j++) { if (i % j == 0) { flag = false; break; } } if (flag) { System.out.println(i); } } } ``` ### 排序总共有八大排序。 ```java \/\/ 冒泡排序：相邻两个元素进行比较,如果符合条件就换位。两层循：外层冒泡轮数，里层依次比较 public static void bubbleSort(int[] arr) { \/\/ 不用遍历最后一个元素 for (int i = 0; i < arr.length - 1; i++) { \/\/ -i：让每一次比较的元素减少；-1：避免角标越界 for (int j = 0; j < arr.length - i - 1; j++) { \/\/ 从小到大 if (arr[j] > arr[j + 1]) { int temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; } } } } \/\/ 选择排序：内循环结束一次，最值出现头角标位置上。 public static void selectionSort(int[] arr) { \/\/ 不用遍历最后一个元素 for (int i = 0; i < arr.length - 1; i++) { for (int j = i + 1; j < arr.length; j++) { if (arr[i] > arr[j]) { int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } } } } ``` ### 元素查找 ```java \/\/ 返回元素第一次出现时的角标 public static int getIndex(int[] arr, int value) { for (int i = 0; i < arr.length; i++) { if (arr[i] == value) { return i; } } return -1; } \/\/ 折半查找：提高效率，但是必须要保证数组是有序的 public static int halfSearch(int[] arr, int value) { int min = 0; int max = arr.length - 1; int mid = (max + min) \/ 2; while (arr[mid] != value) { if (value > arr[mid]) { \/\/ value 比中间值大，最小角标移到中间角标前面 min = mid + 1; } else if (value < arr[mid]) { max = mid - 1; } if (min > max) { return -1; } mid = (max + min) \/ 2; } return mid; } \/\/ 第二种折半查找 public static int halfSearch2(int[] arr, int value) { int min = 0, max = arr.length - 1; int mid; while (min <= max) { mid = (min + max) \/ 2; if (arr[mid] == value) { return mid; } else if (arr[mid] > value) { max = mid - 1; } else { min = mid + 1; } } return -1; } ``` ## 面向对象面向对象(Object Oriented)是一种思想，90年代以后软件开发的主流思想。面向对象编程的本质就是：以类的方式组织代码，以对象的方式封装数据。**万物皆对象。** 面向对象编程的优点： * 提高代码复用性。 * 使用者无需关心具体细节。 * 转变程序员角色，更加符合人的思维习惯。面向对象的三个特征：**封装，继承，多态**。以后开发，其实就是找对象使用。没有对象，就创建一个对象。开发步骤：找对象，建立对象，使用对象，维护对象的关系。 ### 类 class 类是用来描述对象的。对象是类的实例，类是对象的抽象。类的5大成分（成员变量、构造器、方法、代码块、内部类）。 * 类中定义的变量也称为成员变量，类中定义的方法也成为成员方法。 * 成员变量本身存在默认值，在定义时一般不需要赋初始值（没有意义）。`修饰符数据类型变量名称 = 值` * 一个代码文件中，可以写多个 class 类，但只能有一个用 public 修饰，其 public 修饰的类名必须成为代码文件名。 * 如果某个对象没有一个变量引用它，该对象会成为所谓的垃圾对象。`s1 = null;` ```java public class Person { String name; \/\/ 成员变量 int age; \/\/ 成员方法 public void speak() { System.out.println("name=" + name + ",age=" + age); } } ``` 类和对象的关系：类就是对现实生活中事物的描述。对象就是这类事物实实在在存在的个体。 ### 创建对象 new 使用 `new` 关键字和指定类名来创建一个对象。 ```java Person p = new Person(); p.name = "zhangsan"; \/\/访问属性(成员变量) p.age = 20; p.speak(); \/\/访问方法 ``` 这句话先在堆内存中创建了一个对象，然后栈内存中创建一个变量引用了对象的地址。对象的生命周期从 `new` 关键字创建时开始，到没有任何引用达到对象时结束（成为垃圾）。 **成员变量初始化：** * 基本数据类型初始化值为 0。 * 引用数据类型初始化值为 null。 * 布尔类型初始化值为 false。 * char 初始化值为 `\u0000` 表示为空。 ### 成员变量和局部变量 | 区别 | 成员变量 | 局部变量 | | ------------ | -------------------------- | ------------------------------------------ | | 类中位置不同 | 类中、方法外 | 方法内 | | 初始化值不同 | 有默认值，不需要初始化赋值 | 没有默认值，使用之前必须完成赋值 | | 内存位置不同 | 堆内存 | 栈内存 | | 作用域不同 | 整个对象 | 在所归属的大括号内 | | 生命周期不同 | 与对象共存亡 | 随着方法的调用而生，随着方法的运行结束而亡 | ### 构造函数 constructor 对象一建立就会调用与之对应的构造函数。构造函数的作用：**可以用于给对象进行初始化**。创建对象都必须通过构造函数初始化。当一个类没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数，例如 `Person(){}`。当在类中自定义了构造函数后，默认的构造函数就没有了。特点： * 函数名和类名相同 * 必须没有返回类型，也不能写 `void` **什么时候定义构造函数呢?** 当分析事物时，该事件存在具备一些特性或者行为，那么将这些内容定义在构造函数中。构造函数可以有多个，用于对不同的对象进行针对性的初始化。多个构造函数在类中是以重载的形式来体现的。构造函数和一般函数在写法上有不同，在运行上也有不同： * 构造函数是在对象一建立就运行。给对象初始化。而一般方法是对象调用才执行，是给对象添加对象具备的功能。 * 一个对象建立，构造函数只运行一次。而一般方法可以被该对象调用多次。细节： * 构造函数如果完成了 set 功能。set 方法是否需要。 * 一般函数不能直接调用构造函数。 * 构造函数如果前面加了 `void` 就变成了一般函数。 * 构造函数中是没有 `return` 语句的。 **构造代码块：** * 作用：给所有对象进行初始化。 * 对象一建立就运行，而且优先于构造函数执行。 * 构造代码块是给所有对象进行统一初始化，而构造函数是给对应的对象初始化。构造函数和构造代码块的区别：构造代码块是给所有对象进行统一初始化。构造函数是给对应对象初始化。什么时候定义构造函数和构造代码块？在描述事物时，该事物一存在就具备的一些特性或者行为，这些内容都可以定义在构造函数中。不同对象共性的初始化内容可以定义在构造代码块中。 ```java public class Person { private String name; private int age; \/\/ 构造代码块中定义的是不同对象共性的初始化内容。 { System.out.println("这里都是中国人"); } \/\/ 构造函数 Person() { System.out.println("A: name=" + name + ",,age=" + age); cry(); } Person(String n) { name = n; System.out.println("B: name=" + name + ",,age=" + age); cry(); } Person(String n, int a) { name = n; age = a; System.out.println("C: name=" + name + ",,age=" + age); cry(); } public void setName(String n) { name = n; } public String getName() { return name; } public void cry() { System.out.println("cry...."); } public void speak() { System.out.println("name=" + name + ",age=" + age); } } ``` ### this `this` 主要用于解决局部变量和成员变量重名问题的。当成员变量和局部变量重名，可以用关键字 this 来区分。 this 代表它所在函数所属对象的引用，可以用来拿到当前对象。哪个对象调用方法，this 就代表哪个对象。 this 和 this 语句什么时候应用： * this 的应用：当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用 this 来表示这个对象。但凡本类功能内部使用了本类对象，都用 this 表示。 * this 语句：用于构造函数之间相互调用。this语句只能定义在构造函数的第一行。因为初始化要先执行。 super 和 this 的区别：this 代表的是本类对象的引用。super 代表的是父类对象的引用。 super 语句和 this 语句的特点：super 语句和 this 语句都只能在构造函数的第一行，所以一个构造函数中不能同时存在 super 语句和 this 语句。子类中至少会有一个构造函数会访问父类中的构造函数。 ```java public class Person { private String name; public Person() { } public Person(String name) { this.name = name; } public String getName() { return name; } public void setName(String name) { \/\/ this 来区分重名的成员变量和局部变量 this.name = name; } } ``` ### static 静态用法：是一个修饰符，用于修饰成员(成员变量，成员函数)。当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可以直接被类名调用。 `类名.静态成员`。类方法最常见的应用场景是做工具类。工具类中的方法都是一些类方法，每个方法都是用来完成一个功能的。这样可以提高了代码复用、调用方便。提高了开发效率。 **工具类没有创建对象的需求，建议将工具类的构造器私有。** static 特点： * 随着类的加载而加载。也就说: 静态会随着类的消失而消失。说明它的生命周期最长。 * 优先于对象存在。明确一点：静态是先存在的，对象是后存在的。 * 类变量属于类，在计算机里只有一份，会被类的全部对象共享。 * 可以直接被类名所调用。 * 主函数是静态的。类变量：属于类，与类一起加载一次，在内存中只有一份，可以被类和类的所有对象共享。实例变量：属于对象，每个对象中都有一份，只能用对象访问。实例变量和类变量的区别： * 存放位置 * 类变量随着类的加载而存在于方法区中。实例变量随着对象的建立而存在于堆内存中。 * 生命周期 * 类变量生命周期最长，随着类的消失而消失。实例变量生命周期随着对象的消失而消失。静态使用注意事项： * 静态方法只能访问静态成员。非静态方法即可以访问静态也可以访问非静态。 * 静态方法中不可以定义 this，super 关键字。因为静态方法优先于对象存在，所以静态方法中不可以出现this。静态有利有弊： * 利处 * 对对象的共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份。 * 可以直接被类名调用。 * 弊端 * 生命周期过长。访问出现局限性。(静态虽好，只能访问静态) ```java public class Student { static String name; \/\/ 类变量 int age; \/\/ 实例变量 public static void say() { System.out.println("hello"); } } ``` ```java public class Test { public static void main(String[] args) { Student s1 = new Student(); s1.name = "张三"; Student s2 = new Student(); s2.name = "李四"; System.out.println(s1.name); \/\/ 李四 System.out.println(Student.name); \/\/ 李四 Student.say(); } } ``` 什么时候使用静态呢？要从两方面下手，因为静态修饰的内容有成员变量和函数。什么时候定义静态变量（类变量）呢？如果某个数据只需要一份，且希望能够被共享（访问、修改），则该数据可以定义成类变量来记住。例如：计数器。什么时候定义静态函数（类方法）呢？当功能内部没有访问到非静态(对象的特有数据)，那么该功能可以定义成静态的。 ```java public class Student { public static int count; public Student() { Student.count++; } } ``` ### 代码块 * 静态代码块：`static {}` * 特点：类加载时自动执行，由于类只会加载一次，所以静态代码块也只会执行一次。 * 作用：完成类的初始化。例如：对类变量的初始化赋值。 * 实例代码块：`{}` * 特点：每次创建对象时，执行实例代码块，并在构造器前执行。 * 作用：和构造器一样，都是用来完成对象的初始化的。例如：对实例变量进行初始化赋值。 ```java public class Student { { System.out.println("实例代码块"); } static { System.out.println("静态代码块"); } } ``` ### 匿名对象我们可以不定义变量引用对象，使用new关键字创建对象后直接使用，这样的对象没有名字，所以叫匿名对象。`new Car();` 匿名对象使用方式： * 当对对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化。如果对一个对象进行多个成员调用，必须给这个对象起个名字。 * 可以将匿名对象作为实际参数进行传递。匿名对象访问成员变量毫无意义，执行后就变成垃圾。 ### 封装封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。之所以对外提供访问方式，就因为可以在访问方式中加入逻辑判断等语句，对访问的数据进行操作。提高代码健壮性。封装原则：将不需要对外提供的内容都隐藏起来。把属性都隐藏，仅提供公共方法对其访问。封装规范：合理隐藏、合理暴露。 `高内聚`就是类的内部数据操作细节自己完成，不允许外部干涉。`低耦合`就是仅暴露少量的方法给外部使用。好处： * 将变化隔离。 * 便于使用。 * 提高重用性。 * 提高程序的安全性，保护数据。 `private` ：私有，权限修饰符。用于修饰类中的成员(成员变量，成员函数)。私有只在本类中有效。一个变量只有两种使用方式：设置方法，获取方法。(set get) 注意: 私有仅仅是封装的一种表现形式。 ```java public class Person { \/\/ 属性私有 private int age; \/\/ set 方法 public void setAge(int a) { if (a > 0 && a < 130) { this.age = a; speak(); } else { System.out.println("非法年龄"); } } \/\/ get 方法 public int getAge() { return this.age; } void speak() { System.out.println("age=" + age); } } ``` ### 继承继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。用 `extends` 关键字，让一个类和另一个类建立起一种父子关系。所有的类都默认直接或者间接继承 `Object`。 **私有成员无法被继承。** * 提高了代码的复用性。 * 让类与类之间产生了关系。有了这个关系，才有了多态的特性。注意: 千万不要为了获取其他类的功能，简化代码而继承，必须是类与类之间有所属关系才可以继承。所属关系 is a 。 java 只支持单继承，不支持多继承。因为多继承容易带来安全隐患：当多个父类中定义了相同功能，当功能内容不同时，子类对象不确定运行哪一个。但是 java 保留了这种机制，并用另一种体现形式来完成表示：多实现。 java 支持多层继承。也就是一个继承体系。如何使用一个继承体系中的功能呢? 想要使用体系，先查阅体系父类的描述，因为父类中定义的是该体系中共性功能。通过了解共性功能，就可以知道该体系的基本功能，那么这个体系已经可以基本使用了。那么在具体调用时，要创建最子类的对象，为什么呢? 一是因为有可能父类不能创建对象，二是创建子类对象可以使用更多的功能，包括基本的也包括特有的。子父类出现后，类中成员的特点： * 变量 * 如果子类中出现了非私有的同名成员变量时，子类要访问本类中的变量，用this，子类要访问父类中的同名变量，用super。 * super 的使用和 this 的使用几乎一致。this 代表的是本类对象的引用。super 代表的是父类对象的引用。 * 函数 * 当子类出现和父类一模一样的函数时，当子类对象调用该函数，会运行子类函数的内容。如同父类的函数被覆盖一样。这种情况是函数的另一种特性: 重写(覆盖)。当子类继承父类，沿袭了父类的功能到子类中，但是子类虽具备该功能，但是功能的内容却和父类不一致，这时，没有必要定义新功能，而是使用覆盖特性，保留父类的功能定义，并重写功能内容。 * 覆盖注意事项：子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。静态只能覆盖静态。 * 构造函数 * 子类的全部构造器，都会先调用父类的构造器，再执行自己。那是因为子类的构造函数默认第一行有一条隐式的语句 `super();` `super()` 会访问父类中空参数的构造函数。而且子类中所有的构造函数默认第一行都是`super();` * 注意:：super 语句一定要定义在构造函数第一行。 * super 必须只能出现在子类的方法或者构造方法中。为什么子类一定要访问父类中的构造函数呢? 因为父类中的数据子类可以直接获取，所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的，所以子类在对象初始化时，要先访问一下父类中的构造函数。如果要访问父类中指定的构造函数，可以通过手动定义 super 语句的方式来指定。结论： * 子类的所有构造函数，默认都会访问父类中空参数的构造函数。因为子类每一个构造函数内第一行都有一句隐式 `super();` * 当父类中没有空参数的构造函数时，子类必须手动通过 super 语句形式来指定要访问的构造函数。 * 当然，子类的构造函数第一行也可以手动指定 this 语句来访问本类中的构造函数。子类中至少会有一个构造函数会访问父类中的构造函数。 * 子类构造器可以通过调用父类构造器，把对象中包含父类这部分的数据先初始化赋值，再回来把对象里包含子类这部分的数据也进行初始化赋值。方法重写：当子类觉得父类中的某个方法不好用，或者无法满足自己的需求时，**子类可以重写一个方法名称、参数列表一样的方法**，去覆盖父类的这个方法，这就是方法重写。例如：重写 `toString` 方法。重写后，方法的访问，会遵循就近原则。方法重写的注意事项： * 方法名称、参数列表必须相同 * 子类重写父类方法时，访问权限必须大于或等于父类该方法的权限。 `public > protected > 缺省 > private` * 重写的方法返回值类型，必须与被重写方法的返回值类型一样，或者范围更小 * 抛出的异常：范围可以被缩小但不能扩大。`Exception > ClassNotFoundException` * 私有方法、静态方法不能被重写，如果重写会报错 * 建议使用 `@override` 注解，增加代码的可读性子类的实例化过程：子类的所有构造函数，默认都会访问父类中空参数的构造函数。因为子类每一个构造函数内第一行都有一句隐式的 super()。当父类中没有空参数的构造函数时，子类必须手动通过 super 语句形式来指定要访问的构造函数。 ### super 和 this `this(...)` 和 `super(...)` 都只能放在构造器的第一行，且不能同时出现。两者的区别： * 代表的对象不同 * this 代表本身调用者这个对象 * super 代表父类对象的引用 * 前提 * this 没有继承也可以使用 * super 只能在继承条件下才可以使用 * 构造方法 * this() 本类的构造方法 * super() 父类的构造方法 ### 重载和重写重载: 只看同名函数的参数列表。(不看返回值类型) 重写：需要有继承关系，子类重写父类的方法。 * 方法名必须相同 * 参数列表必须相同 * 权限修饰符：范围可以扩大但不能缩小。 `public > protected > 缺省 > private` * 抛出的异常：范围可以被缩小但不能扩大。`Exception > ClassNotFoundException` * 返回值类型：与被重写方法的返回值类型一样，或者范围更小 * 私有方法、静态方法不能被重写，如果重写会报错 * 可以使用 `@override` 注解，增加代码的可读性 ### 对象初始化过程 ```java Person p = new Person("zhangsan",20); ``` 这句话都做了什么事情呢? 1. 因为new用到了 Person.class，所以会先找到 Person.class 文件并加载到内存中。 2. 执行该类中的 static 代码块，如果有的话，给 Person.class 类进行初始化。 3. 在堆内存中开辟空间，分配内存地址。 4. 在堆内存中建立对象的特有属性，并进行默认初始化。 5. 对属性进行显示初始化。 6. 对对象进行构造代码块初始化。 7. 对对象进行对应的构造函数初始化。 8. 将内存地址赋给栈内存中的p变量。初始化顺序： * static 代码块初始化：给类初始化 * 默认初始化：null，0，等等 * 显示初始化：赋值 * 构造代码块初始化：给所有对象初始化 * 构造函数：给特定的对象初始化 ### final final：最终。作为一个修饰符。如果一个值不需要改变，可以加上 final 修饰作为常量。常量通常用于记录系统的配置信息。程序编译后，常量会被“宏替换”，出现常量的地方全部会被替换成其的字面量，以提高程序性能。常量书写规范：所有字母都大写，如果由多个单词组成，单词间通过下划线连接。 * 可以修饰类，函数，变量。 * 被 final 修饰的类被称为最终类，不可以被继承。这是为了避免被继承，被子类复写功能。 * 被 final 修饰的方法不可以被复写。 * 被 final 修饰的变量是一个常量，只能赋值一次。既可以修饰成员变量，也可以修饰局部变量。 * 修饰基本类型的变量，变量存储的数据不能被改变 * 修饰引用类型的变量，变量存储的地址不能被改变，但地址所指向对象的内容是可以被改变的 * 内部类定义在类中的局部位置时，只能访问该局部被 final 修饰的局部变量。 ```java public class Test { public static final String USER_NAME = "张三"; public static void main(String[] args) { final double PI = 3.14; \/\/ Pi = 2; \/\/ 报错 final int[] NUMS = {10, 20, 30}; NUMS[1] = 99; System.out.println(NUMS[1]); \/\/ 99 } } ``` ### 多态即同一个方法可以根据发生对象的不同而采用多种不同的行为方式。可以理解为事物存在的多种体现形态。多态存在的条件： * 有继承关系（要么继承，要么实现） * 子类重写父类方法 * 父类引用指向子类对象多态的出现大大的提高程序的扩展性，但是只能使用父类的引用访问父类的成员。 **注意的是，多态是对象、方法的多态，属性没有多态性。** ``` 人: 男人，女人动物: 猫，狗猫 x= new 猫(); 动物 x = new 猫(); ``` **多态成员特点：** * 在多态中成员函数的特点 * 在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过。如果没有，编译失败。 * 在运行时期：参阅对象所属的类中是否有调用的方法。 * 简单总结就是：成员函数在多态调用时，**编译看左边，运行看右边。** * 在多态中，成员变量的特点: * **无论编译和运行，都参考左边**(引用型变量所属的类)。因为属性没有多态性。 * 在多态中，静态成员函数的特点: * 无论编译和运行，都参考左边。多态的好处： * 在多态形式下，右边对象是解耦合的，更便于扩展和维护 * 定义方法时，使用父类类型的形参，可以接收一切子类对象，扩展性更强、更便利但是，多态下不能使用子类的独有功能。如何使用子类的独有方法？可以向下转型。强制将父类的引用，转成子类类型。我们能转换的是父类引用指向了自己的子类对象时，该引用可以被提升，也可以被强制转换。强转前建议使用 `instanceof` 判断当前对象的真实类型，再进行强转。注意：多态自始自终都是子类对象在做着变化。 ```java public class Person { void run() { System.out.println("person run"); } } public class Student extends Person { @Override void run() { System.out.println("student run"); } void play() { System.out.println("student play"); } } public class Teacher extends Person { @Override void run() { System.out.println("teacher run"); } } ``` ```java public class Test { public static void main(String[] args) { Person person = new Student(); \/\/ 相当于 ((Student) person).run(); person.run(); \/\/ student run 编译看左边，运行看右边 test(new Student()); \/\/ student run test(new Teacher()); \/\/ teacher run \/\/ 父类引用可以指向子类，但是不能调用子类独有的方法。需要强制类型转换 Student student = (Student) person; student.play(); \/\/ student play \/\/ 千万不要将父类对象转成子类类型，编译阶段不会报错，运行时会报错 Person person1 = new Person(); \/\/ Student student1 = (Student) person1; \/\/ 报错 \/\/ instanceof 判断当前对象的真实类型 Person p1 = new Student(); if(p1 instanceof Student){ Student s1 = (Student) p1; s1.play(); } } public static void test(Person p) { p.run(); } } ``` ### instanceof 格式：`x instanceof y` ，用于判断 x 是不是 y 的实例，返回布尔值。 ```java \/\/ 继承关系 Object > Person > Student Object object = new Student(); System.out.println(object instanceof Student); \/\/ true System.out.println(object instanceof Person); \/\/ true System.out.println(object instanceof Object); \/\/ true System.out.println(object instanceof String); \/\/ false ``` ### 抽象 abstract 当多个类中出现相同功能，但是功能主体不同，这时可以进行向上抽取。这时，只抽取功能定义，而不抽取功能主体。 **抽象只能用来修饰类和方法。抽象方法只有方法签名，不要写方法体。** 抽象类的特点： * 抽象类中不一定有抽象方法，但抽象方法一定在抽象类中。 * 抽象方法和抽象类都必须被 abstract 关键字修饰。 * 抽象类不可以用 new 创建对象，它是用来让子类继承的，并且调用抽象方法没意义。 * 一个类继承抽象类，必须重写抽象类的全部抽象方法，否则这个类也必须定义成抽象类。 * 类中该有的成员（成员变量、方法、构造器），抽象类都可以有。好处：父类知道每个子类都要做某个行为，但每个子类要做的情况不一样，父类就定义成抽象方法，交给子类去重写实现，设计这样的抽象类，就是为了更好的支持多态。 **技巧：抽象类中可以不定义抽象方法。这样做仅仅是不让该类建立对象。** ```java \/\/ 抽象类 public abstract class Action { \/\/ 抽象方法 public abstract void doSomething(); } \/\/ 继承抽象类 public class User extends Action { \/\/ 重写抽象类中的抽象方法 @Override public void doSomething() { System.out.println("doSomething run"); } } ``` ### 接口 interface 接口是一个特殊的抽象类。当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。接口是不能创建对象的。因为有抽象方法，需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化。否则子类是一个抽象类。实现接口的类称为实现类。一个类可以实现多个接口，实现类实现多个接口，必须重写完全部接口的方法，否则实现类需要定义成抽象类。 * `class` ：用于定义类。 * `interface` ：用于定义接口。 * `implements` ：实现接口。接口定义时，格式特点: * 接口中常见定义：常量，抽象方法。 * 接口中的成员都有固定修饰符。 * 常量：public static final * 方法：public abstract * 记住：接口中的成员都是 public 的。接口的好处： * 弥补了类单继承的不足，一个类可以同时实现多个接口 * 让程序可以面向接口编程，这样就可以灵活方便的切换各种业务实现注意事项： * 一个接口继承多个接口，如果多个接口中存在方法签名冲突，则此时不支持多继承 * 一个类实现多个接口，如果多个接口存在方法签名冲突，则此时不支持多实现 * 一个类继承了父类，又同时实现了接口，父类中和接口中有**同名的默认方法**，实现类会优先用父类的 * 一个类实现了多个接口，多个接口中存在**同名的默认方法**，可以不冲突，这个类重写该方法即可 ```java \/\/ 定义接口 public interface Drive { \/\/ 接口中常量 String DRIVE_TYPE = "D1"; \/\/ 接口中的所有方法默认都是抽象的，自动省略了 public abstract void drive(); \/\/ 默认方法，使用 default 修饰。只能使用接口的实现类对象调用 default void test1() { System.out.println("default test1"); } \/\/ 类方法，使用 static 修饰。只能用接口名调用 static void test2() { System.out.println("static test2"); } \/\/ 私有方法，JDK9 开始才支持 private void test3() { System.out.println("private test3"); } } \/\/ 实现接口 public class Student implements Drive { \/\/ 必须重写接口的中的所有方法 @Override public void drive() { System.out.println("会开车了：" + DRIVE_TYPE); } } public class Test { public static void main(String[] args) { Student s1 = new Student(); s1.drive(); s1.test1(); \/\/ 调用接口的实例方法 Drive.test2(); \/\/ 调用接口的类方法 } } ``` ### Object 类 Object 类是所有类的祖宗类，该类中定义的肯定是所有对象都具备的功能。如果自定义类中也有比较相同的功能，那么没有必要重新定义。只要沿袭父类的功能，建立自己特有的比较内容即可。这就是覆盖。 * `String toString() ` ：返回对象的字符串形式。存在的意义就是为了被子类重写，以便返回对象的具体内容。 * `boolean equals(Object o)` ：比较两个对象的地址是否相等。存在的意义就是为了被子类重写，以便子类自己来定制比较规则 * `Object clone()` ：对象克隆（浅克隆） ```java public class Student { private String name; public Student(String name) { this.name = name; } public String getName() { return name; } public void setName(String name) { this.name = name; } @Override protected Object clone() throws CloneNotSupportedException { return super.clone(); } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Student student = (Student) o; return Objects.equals(name, student.name); } @Override public int hashCode() { return Objects.hashCode(name); } @Override public String toString() { return "Student{" + "name='" + name + '\'' + '}'; } } ``` ```java public class Test { public static void main(String[] args) { Student s1 = new Student("张三"); System.out.println(s1); System.out.println(s1.toString()); Student s2 = new Student("张三"); System.out.println(s1.equals(s2)); \/\/ 默认比较的是引用地址 System.out.println(s1 == s2); } } ``` ### 内部类内部类就是在一个类的内部再定义一个类。实际上就是类中的一个普通成员。内部类的访问规则： * 内部类可以直接访问外部类中的成员，包括私有。是因为内部类中持有了一个外部类的引用，格式：`外部类名.this` * 外部类要访问内部类，必须建立内部类对象。什么时候定义内部类：当一个类的内部，包含了一个完整的事物，且这个事物没有必要单独设计时，就可以把这个事物设计成内部类。访问格式: * 当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中，直接建立内部类对象。 ```java \/\/ 直接访问内部类中的成员外部类名.内部类名变量名 = new 外部类对象().内部类对象(); Outer.Inner in = new Outer().new Inner(); in.function(); ``` * 当内部类在成员位置上，就可以被成员修饰符所修饰。比如： * private：将内部类在外部类中进行封装。 * static：内部类就具备了 static 的特性。当内部类被 static 修饰后，只能直接访问外部类中的静态成员。出现了访问局限。 * 在外部其他类中，如何直接访问静态内部类的非静态成员呢? `new Outer.Inner1().function();` * 在外部其他类中，如何直接访问静态内部类的静态成员呢? `Outer.Inner1.function();` * 注意：当内部类中定义了静态成员，该内部类必须是 static 的。当外部类中的静态方法访问内部类时，内部类也必须是 static 的。 #### 成员内部类 JDK16 之后，成员内部类中可以定义静态成员了。 ```java public class Outer { private int id = 10; public class Inner { public void run() { System.out.println("成员内部类" + id); System.out.println("获取当前外部类对象" + Outer.this); } } } public class Demo { public static void main(String[] args) { Outer outer = new Outer(); Outer.Inner inner = outer.new Inner(); inner.run(); Outer.Inner inner2 = outer.new Inner(); inner2.run(); Outer.Inner in = new Outer().new Inner(); } } ``` #### 静态内部类 ```java public class Outer { private static int id = 10; public static class Inner { public static void run() { System.out.println("静态内部类" + id); } } } public class Demo { public static void main(String[] args) { Outer.Inner.run(); } } ``` #### 局部内部类局部内部类是定义在方法中、代码块中、构造器等执行体中。内部类定义在局部时: * 不可以被成员修饰符修饰。比如 static * 可以直接访问外部类中的成员，因为还持有外部类中的引用。但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。 ```java public class Outer { private int id = 10; public void method() { String name = "HH"; class Inner { int age = 30; public void run() { System.out.println("局部内部类" + id); System.out.println(name); System.out.println(age); } } new Inner().run(); } } public class Demo { public static void main(String[] args) { Outer outer = new Outer(); outer.method(); } } ``` #### 匿名内部类(重点) * 匿名内部类其实就是内部类的简写格式。 * 匿名内部类本质就是一个子类，并会立即创建出一个子类对象。 * 定义匿名内部类的前提：内部类必须是继承一个类或者实现接口。 * 匿名内部类的格式: `new 父类或者接口() { 类体(一般是方法重写) }` * 匿名内部类中定义的方法最好不要超过3个。作用：用于更方便的创建一个子类对象。通常作为一个参数传输给方法。 ```java public interface UserService { void add(String name); } public class Demo { public static void main(String[] args) { UserService userService = new UserService() { @Override public void add(String name) { System.out.println("add" + name); } }; userService.add("张三"); } } ``` ```java public class Test { public static void main(String[] args) { \/\/ 匿名内部类 go(new Swimming() { @Override public void swim() { System.out.println("游得飞快"); } }); \/\/ lambda 表达式 go(() -> { System.out.println("游游游"); }); } \/\/ 可以接收 Swimming 接口的一切实现类对象 public static void go(Swimming s) { s.swim(); } } interface Swimming { void swim(); } ``` ### main 函数主函数：是一个特殊的函数。作为程序的入口，可以被 jvm 调用。主函数的定义： * public：代表着该函数访问权限是最大的。 * static：代表着主函数随着类的加载就已经存在了。 * void：主函数没有具体的返回值。 * main：不是关键字，但是是一个特殊的单词，可以被 jvm 识别。 * (String[] arr)：函数的参数，参数类型是一个数组，该数组中的元素是字符串。主函数是固定格式的，用于给 jvm 识别。jvm在调用主函数时，传入的是 new String[0]; ```java public static void main(String[] args) { } ``` ### 包装类包装类就是把基本类型的数据包装成对象。自动装箱：基本数据类型可以自动转换为包装类型。自动拆箱：包装类型可以自动转换为基本数据类型。 | 基本数据类型 | 对应的包装类 | | ------------ | ------------ | | byte | Byte | | short | Short | | int | Integer | | long | Long | | char | Character | | float | Float | | double | Double | | boolean | Boolean | - **优先使用 `int`**：适用于大多数情况，性能更高，避免不必要的对象开销。 - **使用 `Integer`**：当需要 `null`、泛型、集合或调用工具方法时。在自定义类中，如果字段 **不能为 `null`** 且 **不需要泛型**，推荐使用 `int`（更高效）。如果字段 **可能为 `null`** 或 **需要存入集合**，则使用 `Integer`。 ```java public class Test { public static void main(String[] args) { \/\/ 包装类.valueOf()：转换成对应的数据类型 Integer a1 = Integer.valueOf(12); System.out.println(a1); \/\/ 自动装箱 Integer a2 = 12; \/\/ 自动拆箱 int a3 = a2; ArrayList list = new ArrayList<>(); list.add(4); \/\/ 自动装箱 list.add(15); int a4 = list.get(1); \/\/ 自动拆箱 } } ``` ### 实体类实体类就是一种特殊形式的类。 * 这个类中的成员变量都要私有，并且要对外提供相应的 getXxx 、setXxx 方法。 * 类中必须要有一个公共的无参的构造器。 * 实体类只负责数据存取，而对数据的处理交给其他类来完成，以实现数据和业务处理相分离。 ```java public class Student { private String name; public Student() { } public String getName() { return name; } public void setName(String name) { this.name = name; } } ``` ```java public class StudentOperator { private Student student; public StudentOperator(Student student) { this.student = student; } \/\/ 业务处理的各种方法... } ``` ### 注解注解：有功能的注释。 ## 枚举枚举是一种特殊类。 * 枚举类中的第一行，只能写一些合法的标识符（名称），多个名称用逗号隔开。这些名称，本质是常量，每个常量都会记住枚举类的一个对象 * 枚举类的构造器都是私有的（写不写都只能是私有的），因此，枚举类对外不能创建对象 * 枚举都是最终类，不可以被继承 * 枚举类中，从第二行开始，可以定义类的其他各种成员 * 编译器为枚举类新增了几个方法，并且枚举类都是继承 `java.lang.Enum` 类的，从 enum 类也会继承到一些方法 **应用场景：用来表示一组信息，然后作为参数进行传输。** ``` 修饰符 enum 枚举类名 { 名称1, 名称2...; 其他成员... } ``` ```java public enum A { \/\/ 枚举类的第一行必须罗列的是枚举对象的名字 X,Y,Z; private String name; public String getName() { return name; } public void setName(String name) { this.name = name; } } ``` ```java \/\/ 抽象枚举：枚举类型中需重写全部的抽象方法 public enum B { X() { @Override public void go() { } }, Y("张三") { @Override public void go() { System.out.println(getName() + "在跑"); } }; private String name; B() { } B(String name) { this.name = name; } public abstract void go(); public String getName() { return name; } public void setName(String name) { this.name = name; } } ``` ```java public class Test { public static void main(String[] args) { A a1 = A.X; A a2 = A.Y; A[] values = A.values(); System.out.println(Arrays.toString(values)); \/\/ valueOf 拿到全部对象 A a3 = A.valueOf("Z"); \/\/ [X, Y, Z] System.out.println(a3); \/\/ Z System.out.println(a3.name()); \/\/ Z \/\/ 索引 System.out.println(a3.ordinal()); \/\/ 2 B b = B.Y; b.go(); \/\/ 张三在跑 } } ``` ```java public class Test { public static void main(String[] args) { check(Gender.GIRL); check(Gender.BOY); } public static void check(Gender gender) { switch (gender) { case BOY: System.out.println("男孩看葫芦娃"); break; case GIRL: System.out.println("女孩看巴拉拉"); break; } } } enum Gender { BOY, GIRL; } ``` ## 异常 Exception 异常：就是程序在运行时出现不正常情况。异常由来：问题也是现实生活中一个具体的事物，也可以通过 java 的类的形式进行描述，并封装成对象。其实就是 java 对不正常情况进行描述后的对象体现。 `java.lang.Throwable` 作为所有异常的超类。 ``` Throwable |--Error |--Exception |--RuntimeException |--其他异常 ``` 对于问题的划分有两种：一种是严重的问题，一种是非严重的问题。 * Error ：代表系统级别错误，通常是灾难性的致命的错误，是程序无法控制和处理的，出现 Error 时，JVM 一般会选择终止线程。对于Error，一般不编写针对性的代码对其进行处理。 * Exception ：代表的是程序可能出现的问题，可以使用针对性的处理方式进行处理。 * 运行时异常：RuntimeException 及其子类，编译阶段不会出现错误提醒。（如：数组索引越界异常） * 编译时异常：编译阶段就会出现错误提醒的。（如：日期解析异常）无论 Error 或者 Exception 都具备一些共性内容。比如：不正常情况的信息，引发原因等。对于异常分两种: * 编译时被检测的异常。 * 编译时不被检测的异常。(运行时异常 RuntimeException 以及其子类) 异常在子父类覆盖中的特点: * 子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者该异常的子类。 * 如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集。 * 如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常。如果子类方法发生了异常，就必须进行try处理，绝对不能抛。常见的异常： * `RuntimeException` ：运行时异常 * `ArrayIndexOutOfBoundsException` ：数组下标越界 * `NullPointerException` ：空指针异常 * `ArithmeticException` ：算术异常 * `MissingResourceException` ：丢失资源 * `ClassNotFoundException` ：找不到类等异常 ### 异常处理 java 提供了特有的语句进行处理。建议在进行 catch 处理时，catch 中一定要定义具体处理方式。不要简单定义一句 `e.printStackTrace();` ，也不要简单的就书写一条输出语句。记住一点：catch 是用于处理异常。如果没有 catch 就代表异常没有被处理过，如果该异常是检测时异常，那么必须声明。 ``` try { 可能出现异常的代码; } catch(异常类变量) { 处理异常的代码; } finally { 一定会执行的语句; } ``` finally代码块：定义一定执行的代码。通常用于关闭资源。处理语句的其他格式: ``` try{} catch(){} try{} catch(){} finally{} try{} finally{} ``` 对捕获到的异常对象进行常见方法操作： * `String getMessage()` ：异常信息 * `toString()` ：异常名称 : 异常信息 * `printStackTrace()` ：打印错误的栈信息：包含异常名称，异常信息，异常出现的位置。对多异常的处理： * 声明异常时，建议声明更为具体的异常。这样处理的可以更具体。 * 对方声明几个异常，就对应有几个catch块。不要定义多余的catch块。如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面（从小到大）。 ```java try { System.out.println(1 \/ 0); } catch (ArithmeticException e) { e.printStackTrace(); \/\/ 打印错误的栈信息 System.out.println("除数不能为0"); } finally { System.out.println("finally"); } ``` ### throws \/ throw * throws ：在方法上使用，可以将方法内部出现的异常抛出去给调用者处理，不处理就编译失败。throws 后面跟的是异常类。可以跟多个，用逗号隔开。 * throw：在方法内使用。throw 后面跟的是异常对象。注意：一般情况下，函数内出现异常，函数上需要声明。 ```java public class Demo { public static void main(String[] args) { try { new Demo().test(2, 0); } catch (ArithmeticException e) { e.printStackTrace(); } finally { System.out.println("finally"); } } \/\/ 如果在方法中处理不了这个异常，可以使用 throws 在方法上抛出异常 public void test(int a, int b) throws ArithmeticException { if (b == 0) { throw new ArithmeticException(); \/\/ 主动抛出异常，throw 一般在方法中使用 } } } ``` ### 自定义异常因为项目中会出现特有的问题，而这些问题并未被 java 所描述并封装对象。所以对于这些特有的问题，可以按照java 对问题封装的思想，将特有的问题，进行自定义的异常封装。当在函数内部出现了 throw 抛出异常对象，那么就必须要给出对应的处理动作。要么在内部 try catch 处理。要么在函数上声明，让调用者处理。一般情况下：函数内出现异常，函数上需要声明。 **自定义异常：必须是自定义类继承 Exception 或 RuntimeException，并重写构造器。** 继承 Exception 的原因：异常体系有一个特点：因为异常类和异常对象都需要被抛出。他们都具备可抛性。这个可抛性是 Throwable 这个体系的独有特点。只有这个体系中的类和对象才可以被 throws 和 throw 操作。发现打印的结果中只有异常的名称，却没有异常的信息。因为自定义的异常并未定义信息。如何定义异常信息呢? 因为父类中已经把异常信息的操作都完成了。所以子类只要在构造时，通过 super 语句将异常信息传递给父类。那么就可以直接通过 getMessage 方法获取自定义的异常信息了。 ```java public class MyException extends Exception { public MyException(String message) { super(message); } } public class Demo { public static void main(String[] args) { try { test(12); } catch (MyException e) { e.printStackTrace(); System.out.println(e); } } public static void test(int a) throws MyException { if (a > 10) { throw new MyException("输入不能大于10，当前值为："+ a); } } } ``` ### RuntimeException Exception 中有一个特殊的子类异常 RuntimeException 运行时异常。如果在函数内抛出该异常，函数上可以不用声明，编译一样通过。如果在函数上声明了该异常，调用者可以不用进行处理，编译一样通过。之所以不用在函数上声明，是因为不需要让调用者处理。当该异常发生，希望程序停止。因为在运行时，出现了无法继续运算的情况，希望停止程序后，对代码进行修正。自定义异常时：如果该异常的发生，无法再继续进行运算，就让自定义异常继承 RuntimeException。 ### 示例 ```java class LanPingException extends Exception{ LanPingException(String message){ super(message); } } class MaoYanException extends Exception{ MaoYanException(String Message){ super(Message); } } class NoPlanException extends Exception{ NoPlanException(String msg){ super(msg); } } class Computer{ private int state = 3;\/\/异常状态 public void run() throws LanPingException,MaoYanException { if(state == 2) throw new LanPingException("蓝屏了"); if(state == 3) throw new MaoYanException("冒烟了"); System.out.println("电脑运行"); } public void reset(){ state = 1; System.out.println("电脑重启"); } } class Teacher{ private String name; private Computer cp; Teacher(String name){ this.name = name; cp = new Computer(); } public void prelect() throws NoPlanException{ try{ cp.run(); } catch(LanPingException e){ \/\/System.out.println(e.toString()); cp.reset(); } catch(MaoYanException e){ test(); throw new NoPlanException("课时无法继续: "+e.getMessage()); } System.out.println("讲课"); } public void test(){ System.out.println("做练习"); } } public class Demo{ public static void main(String[] args){ Teacher t = new Teacher("毕老师"); try{ t.prelect(); }catch(NoPlanException e){ System.out.println(e.toString()); System.out.println("换老师或者放假"); } } } ``` ## 多线程 * 进程：是一个正在执行的程序。每一个进程执行都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元 * 线程：就是进程中的一个独立的控制单元。线程在控制着进程的执行 * 一个进程中至少有一个线程。进程中的多个线程其实是并发和并行执行的 Java VM 启动的时候会有一个进程 java.exe。该进程中至少有一个线程负责 java 程序的执行，而且这个线程运行的代码存在于 main 方法中，该线程称之为主线程。扩展：其实更细节说明 jvm，jvm 启动不止一个线程，还有负责垃圾回收机制的线程。 ### 创建线程 java 已经提供了对线程这类事物的描述，就是 Thread 类。注意： * 启动线程必须是调用 start 方法，不是调用 run 方法 * 直接调用 run 方法会当成普通方法执行，此时相当于还是单线程执行 * 只有调用 start 方法才是启动一个新的线程执行 * 不要把主线程任务放在启动子线程之前 * 这样主线程一直是先跑完的，相当于是一个单线程的效果了 #### 继承Thread类 * 定义类继承 Thread 类。 * 复写 Thread 类中的 run 方法。目的：将自定义的代码存储在 run 方法，让线程运行。 * 调用线程的 start 方法，该方法有两个作用：启动线程，执行 run 方法。这种方式编码简单，但是线程类已经继承 Thread，无法继承其他类，不利于功能的扩展。 ```java \/\/ 继承Thread类 public class MyThread extends Thread { \/\/ 必须重写Thread类的run方法 @Override public void run() { \/\/ 描述线程的执行任务 for (int i = 0; i < 5; i++) { System.out.println("MyThread: " + i); } } } ``` ```java \/\/ 创建线程 MyThread myThread = new MyThread(); \/\/ 启动线程（会自动执行run方法） myThread.start(); ``` #### 实现Runnable接口 * 定义线程任务类实现 Runnable 接口 * 重写 Runnable 接口中的 run 方法，将线程要运行的代码存放在该 run 方法中 * 通过 Thread 类创建线程对象。 * 将 Runnable 接口的子类对象作为实际参数传递给 Thread 类的构造函数。 * `Thread(Runnable target)` ：封装 Runnable 对象成为线程对象 * 调用线程对象的 start 方法开启线程并调用 Runnable 接口子类的 run 方法。 ```java \/\/ 实现Runnable接口 public class MyRunnable implements Runnable { \/\/ 实现Runnable类的run方法 @Override public void run() { \/\/ 描述线程的执行任务 for (int i = 0; i < 5; i++) { System.out.println("MyRunnable: " + i); } } } ``` ```java \/\/ 创建任务对象 MyRunnable target = new MyRunnable(); \/\/ 把任务对象交给一个线程对象处理 new Thread(target).start(); ``` #### 匿名内部类 1. 创建 Runnable 的匿名内部类对象 2. 再交给 Thread 线程对象 3. 再调用线程对象的 start() 启动线程 ```java \/\/ 匿名内部类 Runnable target = new Runnable() { @Override public void run() { for (int i = 0; i < 5; i++) { System.out.println("子线程1: " + i); } } }; new Thread(target).start(); \/\/ 简化形式 new Thread(() -> { for (int i = 0; i < 5; i++) { System.out.println("子线程2: " + i); } }).start(); ``` #### Callable 、FutureTask 假如线程执行完毕后有一些数据需要返回，重写的 run 方法均不能直接返回结果。这时可以通过 Callable 接口和 FutureTask 类来实现。这种方式最大的优点就是可以返回线程执行完毕后的结果。 * 创建任务对象 * 定义一个类实现 Callable 接口，重写 call 方法，封装要做的事情和要返回的数据 * 把 Callable 类型的对象封装成 FutureTask（线程任务对象） * 把线程对象交给 Thread 对象 * 调用 Thread 对象的 start 方法启动线程 * 线程执行完毕后，通过 FutureTask 对象的 get 方法获取线程任务执行的结果 FutureTask 构造器： * `FutureTask(Callable callable)` ：把 Callable 对象封装成 FutureTask 对象 FutureTask 方法： * `V get()` ：获取线程执行 call 方法返回的结果 ```java \/\/ 实现Callable接口 public class MyCallable implements Callable { \/\/ 重写call方法 @Override public String call() throws Exception { int sum = 0; for (int i = 0; i < 10; i++) { sum += i; } \/\/ 返回数据 return "结果是：" + sum; } } ``` ```java \/\/ 创建一个Callable对象 MyCallable call = new MyCallable(); \/\/ 把Callable对象封装成一个未来任务对象 \/\/ 未来任务对象是一个任务对象，实现了Runnable对象。可以在线程执行完毕后，用未来任务对象调用get方法获取线程执行完毕的结果 FutureTask task = new FutureTask<>(call); \/\/ 把任务对象交给一个Thread对象，并执行 new Thread(task).start(); \/\/ 获取线程执行完毕后返回的结果 \/\/ 注意：如果执行到这里，上面的线程还没有执行完毕，这里的代码会暂停，等待上面线程执行完毕后才会获取结果 String s = task.get(); System.out.println(s); ``` #### 区别实现方式和继承方式有什么区别呢? * 继承 Thread：线程代码存放在 Thread 子类的 run 方法中。 * 实现 Runnable：线程代码存放在接口的子类的 run 方法中。实现方式好处：避免了单继承的局限性。在定义线程时，建议使用实现方式。发现运行结果每一次都不同？因为多个线程都获取 cpu 的执行权，cpu 执行到谁，谁就运行。明确一点，在某一时刻，只能有一个程序在运行(多核除外)。cpu 在做着快速的切换，以达到看上去是同时运行的效果。我们可以形象把多线程的运行行为是在互相抢夺 cpu 的执行权。这就是多线程的一个特性：随机性。谁抢到谁执行，至于执行多长，cpu 说的算。为什么要覆盖 run 方法呢? Thread 类用于描述线程。该类就定义了一个功能，用于存储线程要运行的代码。该存储功能就是 run 方法。也就是说，Thread 类中的 run 方法，用于存储线程要运行的代码。 run() 和 start() 的什么不同? * `d.start()` ：开启线程并执行该线程的run方法。 * `d.run()` ：仅仅是对象调用方法，而线程创建了，并没有运行。 ### 线程的状态 Java 总共定义了6种状态，它们定义在 Thread 类的内部枚举类中。 * NEW ：新建。线程刚被创建，但是并未启动 * RUNNABLE ：可运行。线程已经调用了 start()，等待 CPU 调度 * BLOCKED ：锁阻塞。线程在执行的时候未竞争到锁对象，则该进程进入Blocked 状态 * WAITING ：无限等待。一个线程进入 Waiting 状态，另一个线程调用 notify 或者 notifyAll 方法才能唤醒 * TIMED_WAITING ：计时等待。同 waiting 状态，有几个方法（sleep，wait）有超时参数，调用它们将进入该状态 * TERMINATED ：被终止。因为 run 方法正常退出而死亡，或者因为没有捕获的异常终止了 run 方法而死亡 ```java public class Thread { \/\/ ... public enum State { NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED; } } ``` * 被创建：创建线程。 * 运行状态：正在运行。`start();` * 临时状态：具备运行资格，但没有执行权。 * 冻结状态：放弃了执行资格。 * sleep(time)-----sleep(时间到); 休眠 * wait();-----notify(); 等待,唤醒 * 消亡状态：结束线程。 * stop(); 停止，结束。`已过时` * run() 方法结束。如何停止线程? 只有一种，run 方法结束。开启多线程运行，运行代码通常是循环结构。只要控制住循环，就可以让 run 方法结束，也就是线程结束。特殊情况：当线程处于了冻结状态，就不会读取到标记，那么线程就不会结束。当没有指定的方式让冻结的线程恢复到运行状态时，这时需要对冻结进行清除。强制让线程恢复到运行状态中来。这样就可以操作标记让线程结束。Thread类提供该方法 `interrupt()` 。 ### Thread类构造器： * `Thread(String name)` ：可以为当前线程指定名称 * `Thread(Runnable target)` ：封装 Runnable 对象成为线程对象 * `Thread(Runnable target, String name)` ：封装 Runnable 对象成为线程对象，并指定线程名称方法： * `run()` ：线程的任务方法 * `start()` ：启动线程 * `String getName()` ：获取当前线程的名称。线程名称默认是 `Thread-索引` * `setName(String name)` ：为线程设置名称 * `static Thread currentThread()` ：获取当前执行的线程对象 * `static void sleep(long time)` ：让当前执行的线程休眠多少毫秒后，再继续执行 * `void setDaemon(boolean b)` ：将该线程标记为后台线程（守护线程、用户线程），当正在运行的线程都是守护线程时，Java 虚拟机退出，该方法必须在启动线程前调用。 * `void join()` ：让调用当前这个方法的线程先执行完。当 A 线程执行到了 B 线程的 join 方法时，A 就会等待，等 B 线程都执行完，A 才会执行。join 方法可以用来临时加入线程执行。 * `String toString()` ：返回该线程的字符串表示形式，包括线程名称、优先级和线程组。 * `void setPriority()` ：设置该线程的优先级。默认值是5，范围为1~10。 * MAX_PRIORITY：常量10。 * MIN_PRIORITY：常量1。 * NORM_PRIORITY：常量5。 * `void yield()` ：暂停当前正在执行的线程对象，并执行其他线程。 ```java Thread t1 = new Thread(); t1.setName("线程1"); t1.start(); System.out.println(t1.getName()); Thread t2 = new Thread("ss"); t2.start(); t2.join(); System.out.println(t2.getName()); \/\/ ss Thread.sleep(3000); Thread t3 = Thread.currentThread(); System.out.println(t3.getName()); \/\/ main ``` ### 线程间通信当多个线程共同操作共享的资源时，线程间通过某种方式互相告知自己的状态，以相互协调，并避免无效的资源争夺。线程通信的常见模型（生产者与消费者模型） * 生产者线程负责生成数据 * 消费者线程负责消费生产者生产的数据 * 注意：生产者生产完数据应该等待自己，通知消费者消费；消费者消费完数据也应该等待自己，再通知生产者生产 Object 类的等待和唤醒方法： * `wait()` ：让当前线程等待并释放所占锁，直到另一个线程调用 notify() 方法或 notifyAll() 方法 * `notify()` ：唤醒正在等待的单个线程 * `notifyAll()` ：唤醒正在等待的所有线程注意：这些方法应该使用当前同步锁对象进行调用。 ```java public class Desk { private List list = new ArrayList<>(); public synchronized void put() { try { String name = Thread.currentThread().getName(); if (list.size() == 0) { list.add(name + "做的肉包子"); System.out.println(name + "做了一个肉包子"); Thread.sleep(2000); \/\/ 唤醒别人，等待自己 this.wait(); this.notifyAll(); } else { this.wait(); this.notifyAll(); } } catch (Exception e) { e.printStackTrace(); } } public synchronized void get() { try { String name = Thread.currentThread().getName(); if (list.size() == 1) { System.out.println(name + "吃了：" + list.get(0)); list.clear(); Thread.sleep(1000); this.notifyAll(); this.wait(); } else { this.notifyAll(); this.wait(); } } catch (Exception e) { e.printStackTrace(); } } } ``` ```java Desk desk = new Desk(); new Thread(() -> { while (true) { desk.put(); } }, "厨师1").start(); new Thread(() -> { while (true) { desk.put(); } }, "厨师2").start(); new Thread(() -> { while (true) { desk.get(); } }, "吃货1").start(); new Thread(() -> { while (true) { desk.get(); } }, "吃货2").start(); ``` 为什么这些操作线程的方法要定义在 Object 类中呢? 因为这些方法在操作同步中线程时，都必须要标识他们所操作线程持有的锁。只有同一个锁上的被等待线程，可以被同一个锁上的 notify 唤醒。不可以对不同锁中的线程进行唤醒。也就是说，等待和唤醒必须是同一个锁。而锁可以是任意对象，所以可以被任意对象调用的方法定义在 Object 类中。对于多个生产者和消费者，为什么要定义 while 判断标记？原因：让被唤醒的线程再一次判断标记。为什么定义 notifyAll? 因为需要唤醒对方线程。因为只用 notify，容易出现只唤醒本方线程的情况，导致程序中的所有线程都等待。 JDK1.5 中提供了多线程升级解决方案。 * 将同步 Synchronized 替换成显式 Lock 操作。 * 将 Object 中的 wait，notify，notifyAll，替换成 Condition 对象。该对象可以对 Lock 锁进行获取。该示例中，实现了本方只唤醒对方操作。 ### 线程安全 **多个线程，同时操作同一个共享资源**的时候，可能会出现业务安全问题。线程安全问题出现的原因： * 存在多个线程在同时进行 * 同时访问同一个共享资源 * 存在修改该共享资源解决办法：对多条操作共享数据的语句，只能让一个线程都执行完。在执行过程中，其他线程不可以参与执行，也就是**线程同步**。线程同步：保证同步中只能有一个线程在运行 * 解决线程安全问题的方案 * 思想：让多个线程实现先后依次访问共享资源 * 同步的前提：必须是有两个或者两个以上的线程，必须是多个线程使用同一个锁。 #### 同步代码块作用：把访问共享资源的核心代码给上锁，依次保证线程安全。原理：每次只允许一个线程加锁后进入，执行完毕后自动解锁，其他线程才可以进来。 ``` synchronized(同步锁){ 访问共享资源的核心代码 } ``` 对象如同锁，持有锁的线程可以在同步中执行。没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。注意：对于当前同时执行的线程来说，同步锁必须是同一把（同一个对象），否则会出 bug。锁对象的使用规范： * 建议使用共享资源作为锁对象，对于实例方法建议使用 this 作为锁对象 * 对于静态方法建议使用字节码（类名.class）对象作为锁对象 ```java public class Account { private double money = 10000; public void drawMoney(double money) { String name = Thread.currentThread().getName(); \/\/ this正好代表共享资源 synchronized (this) { if (this.money >= money) { System.out.println(name + "取走：" + money); this.money -= money; System.out.println(name + "取走后，余额：" + this.money); } else { System.out.println(name + "余额不足"); } } } } ``` ```java Account account = new Account(); new Thread(() -> { account.drawMoney(10000); }).start(); new Thread(() -> { account.drawMoney(10000); }).start(); ``` #### 同步方法作用：把访问共享资源的核心方法给上锁，以此保证线程安全。原理：每次只能一个线程进入，执行完毕后自动解锁，其他线程才可以进来执行。 ``` 修饰符 synchronized 返回值类型方法名称(形参) { 操作共享资源的代码 } ``` 同步方法底层原理： * 同步方法底层也是有隐式锁对象的，只是锁的范围是整个方法代码 * 如果方法是实例方法：同步方法默认用 this 作为锁对象 * 如果方法是静态方法：同步方法默认用类名.class 作为锁对象 ```java public synchronized void drawMoney(double money) { String name = Thread.currentThread().getName(); if (this.money >= money) { System.out.println(name + "取走：" + money); this.money -= money; System.out.println(name + "取走后，余额：" + this.money); } else { System.out.println(name + "余额不足"); } } ``` 同步代码块和同步方法哪个好一点： * 范围上：同步代码块锁的范围更小，同步方法锁的范围更大 * 可读性：同步方法更好 #### Lock 锁加锁：每次只允许一个线程加锁，加锁后才能进入访问，访问完毕后自动解锁，然后其他线程才能再加锁进来。 Lock 锁是 JDK5 开始提供的一个新的锁定操作，通过它可以创建出锁对象进行加锁和解锁，更灵活、更方便、更强大。 Lock 是接口，不能直接实例化，可以通过它的实现类 `ReentrantLock` 来构建锁对象。构造器： * `ReentrantLock()` ：获得 Lock 锁的实现类对象 Lock 的常用方法： * `lock()` ：获得锁 * `unlock()` ：释放锁 ```java public class Account { private double money = 10000; \/\/ 创建一个锁对象 private final Lock lk = new ReentrantLock(); public void drawMoney(double money) { String name = Thread.currentThread().getName(); lk.lock(); \/\/ 加锁 if (this.money >= money) { System.out.println(name + "取走：" + money); this.money -= money; System.out.println(name + "取走后，余额：" + this.money); } else { System.out.println(name + "余额不足"); } lk.unlock(); \/\/ 解锁 } } ``` #### 如何找问题 1. 明确哪些代码是多线程运行代码。 2. 明确共享数据。 3. 明确多线程运行代码中哪些语句是操作共享数据的。同步函数用的是哪一个锁呢? 函数需要被对象调用。那么函数都有一个所属对象引用，就是this。所以同步函数使用的锁是this。通过程序进行验证：使用两个线程来卖票。一个线程在同步代码块中。一个线程在同步函数中。都在执行卖票动作。如果同步函数被静态修饰，使用的锁是什么呢? 通过验证，发现不再是 this。因为静态方法中也不可以定义 this。静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象。类名.class 该对象的类型是 Class。静态的同步方法，使用的锁是该方法所在类的字节码文件对象。类名.Class ```java \/\/懒汉式延时加载。 class SingleD{ private static SingleD s = null; private SingleD(){} public static SingleD getInstance(){ if(s==null){ synchronized(SingleD.class){ \/\/锁类型是该类字节码文件对象。 if(s==null) s = new SingleD(); } } return s; } } ``` ### 死锁同步中嵌套同步。 ```java \/\/死锁的例子 class DeadLock implements Runnable{ private boolean flag; DeadLock(boolean flag){ this.flag = flag; } public void run(){ if(flag){ while(true){ synchronized(ObjDemo.locka){ System.out.println("if locka"); synchronized(ObjDemo.lockb){ System.out.println("if lockb"); } } } } else{ while(true){ synchronized(ObjDemo.lockb){ System.out.println("else lockb"); synchronized(ObjDemo.locka){ System.out.println("else locka"); } } } } } } class ObjDemo{ static Object locka = new Object(); static Object lockb = new Object(); } public class Demo{ public static void main(String[] args){ Thread t1 = new Thread(new DeadLock(true)); Thread t2 = new Thread(new DeadLock(false)); t1.start(); t2.start(); } } ``` ### 线程池线程池就是一个可以复用线程的技术。每次创建新线程的开销是很大的，如果请求过多，就会产生大量的线程出来，会严重影响系统的性能。 JDK5 起提供了代表线程池的接口：`ExecutorService` 如何得到线程池对象： * 方式1：使用 ExecutorService 的实现类 ThreadPoolExecutor 自创建一个线程池对象 * 方式2：使用 Executors （线程池的工具类）调用方法返回不同特点的线程池对象 #### ThreadPoolExecutor ThreadPoolExecutor 构造器： ```java public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) ``` * corePoolSize ：指定线程池的核心线程的数量 * maximumPoolSize ：指定线程池的最大线程数量 * keepAliveTime ：指定临时线程的存活时间 * unit ：指定临时线程存活的时间单位（秒、分、时、天） * workQueue ：指定线程池的任务队列 * threadFactory ：指定线程池的线程工厂 * handler ：指定线程池的任务拒绝策略（线程都在忙，任务队列也满了的时候，新任务来了该怎么处理） * `ThreadPoolExecutor.AbortPolicy` ：默认。丢弃任务并抛出 RejectedExecutionException 异常 * `ThreadPoolExecutor.DiscardPolicy` ：不推荐。丢弃任务，但是不抛出异常。 * `ThreadPoolExecutor.DiscardOldestPolicy` ：抛弃队列中等待最久的任务，然后把当前任务加入队列中 * `ThreadPoolExecutor.CallerRunsPolicy` ：由主线程负责调用任务的 run() 方法从而绕过线程池直接执行注意事项： * 临时线程什么时候创建 * 新任务提交时发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时才会创建临时线程 * 什么时候会开始拒绝新任务 * 核心线程和临时线程都在忙，任务队列也满了，新的任务过来的时候才会开始拒绝任务 ExecutorService 的常用方法： * `void execute(Runnable command)` ：执行任务\/命令，没有返回值，一般用来执行 Runnable 任务 * `Future submit(Callable task)` ：执行任务，返回未来任务对象，用于获取线程返回的结果，一般用来执行 Callable 任务 * `void shutdown()` ：等全部任务执行完毕后，再关闭线程池 * `List shutdownNow()` ：立即关闭线程池，停止正在执行的任务，并返回队列中未执行的任务 ```java ThreadPoolExecutor pool = new ThreadPoolExecutor(3, 5, 8, TimeUnit.SECONDS, new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy()); MyRunnable target = new MyRunnable(); pool.execute(target); pool.execute(target); pool.execute(target); pool.execute(target); pool.execute(target); pool.shutdown(); ``` ```java ThreadPoolExecutor pool = new ThreadPoolExecutor(3, 5, 8, TimeUnit.SECONDS, new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy()); \/\/ 处理Callable任务 Future f1 = pool.submit(new MyCallable()); Future f2 = pool.submit(new MyCallable()); Future f3 = pool.submit(new MyCallable()); System.out.println(f1.get()); System.out.println(f2.get()); System.out.println(f3.get()); ``` #### Executors Executors 是一个线程池的工具类，提供了很多静态方法用于返回不同特点的线程池对象。 * `static ExecutorService newFixedThreadPool(int nThreads)` ：创建固定线程数量的线程池，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程替代它 * `static ExecutorService newSingleThreadExecutor()` ：创建只有一个线程的线程池对象，如果该线程出现异常而结束，那么线程池会补充一个新线程 * `static ExecutorService newCachedThreadPool()` ：线程数量随着任务增加而增加，如果线程任务执行完毕且空闲了60秒则会被回收掉 * `static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)` ：创建一个线程池，可以实现在给定的延迟后运行任务，或者定期执行任务这些方法的底层，都是通过线程池的实现类 ThreadPoolExecutor 创建的线程池对象。核心线程数量应该配置多少： * 计算密集型任务，核心线程数量 = CPU核数 + 1 * IO 密集型的任务，核心线程数量 = CPU核数 * 2 开发中，线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 方式创建。 ```java ExecutorService pool = Executors.newFixedThreadPool(3); \/\/ 处理Callable任务 Future f1 = pool.submit(new MyCallable()); Future f2 = pool.submit(new MyCallable()); Future f3 = pool.submit(new MyCallable()); System.out.println(f1.get()); System.out.println(f2.get()); System.out.println(f3.get()); ``` ### Lock 锁文档：https:\/\/mp.weixin.qq.com\/s\/hOE51kjJ0do_IVb6i2RTXg ## 集合集合是一种容器，用来装数据的，类似于数组，但它的大小可变，开发中用的更多。集合都是支持泛型的，可以约束存储的数据类型。**定义集合都应该采用泛型。** ![](http:\/\/qiniu.huangyihui.cn\/202507080101991.png) ### 体系集合体系结构： * Collection 代表单列集合，每个元素（数据）只包含一个值。 * Map 代表双列集合，每个元素包含两个值（键值对）。 Collection 集合特点： * List 系列集合：**添加的元素是有序的、可重复、有索引。** * ArrayList、LinkedList ：有序、可重复、有索引。 * Set 系列集合：**添加的元素是无序的、不重复、无索引。** * HashSet ：无序、不重复、无索引。 * LinkedHashSet ：**有序**、不重复、无索引。 * TreeSet ：**按照大小默认升序排序**、不重复、无索引。 Collection 是单列集合的祖宗，它规定的方法是全部单列集合都会继承的。方法： * `int size()` ：返回集合中的元素的个数 * `boolean add(E e)` ：将指定的元素添加到此集合的末尾，返回是否插入成功 * `boolean addAll(Collection c)` ：把一个集合添加到另一个集合的后面 * `boolean remove(E e)` ：将给定的对象在当前集合中删除（如果对象有多个则删除第一个），返回是否删除成功 * `void clear()` ：清空集合中所有的元素 * `boolean contains(Object obj)` ：判断当前集合中是否包含给定对象 * `boolean isEmpty()` ：判断当前集合中是否为空 * `Object[] toArray()` ：把集合中的元素，存储到数组中 * `Iterator iterator()` ：返回集合中的迭代器对象，该迭代器对象默认指向当前集合的第一个元素 * `default void forEach(Consumer action)` ：结合 lambda 遍历集合 ```java Collection c = new ArrayList<>(); \/\/ 多态 c.add("a"); c.add("b"); c.add("c"); System.out.println(c); System.out.println(c.size()); System.out.println(c.contains("a")); System.out.println(Arrays.toString(c.toArray())); c.remove("b"); c.clear(); System.out.println(c.isEmpty()); System.out.println(c); \/\/ T[] toArray(T[] a); String[] array = c.toArray(new String[c.size()]); \/\/ 转换成指定类型的数组 c.forEach(new Consumer() { @Override public void accept(String s) { System.out.println(s); } }); c.forEach(System.out::println); ``` 迭代器是用来遍历集合的专用方式（数组没有迭代器），java 中的迭代器是 `Iterator`。 * `boolean hasNext()` ：询问当前位置是否有元素存在 * `E next()` ：获取当前位置的元素，并同时将迭代器对象指向下一个元素处 ```java Collection c = new ArrayList<>(); c.add("a"); c.add("b"); c.add("c"); Iterator it = c.iterator(); while (it.hasNext()) { System.out.println(it.next()); } \/\/ 增强for遍历集合，本质就是迭代器遍历集合的简化写法 for (String s : c) { System.out.println(s); } ``` ### List List 集合因为支持索引，所以多了一些与索引相关的方法。 * `void add(int index, E e)` ：在此集合中的指定位置插入指定的元素 * `E remove(int index)` ：删除指定索引处的元素，返回被删除的元素 * `E set(int index, E e)` ：修改指定索引处的元素，返回被修改的元素 * `E get(int index)` ：返回指定索引处的元素，索引越界会报异常 IndexOutOfBoundsException ArrayList 和 LinkedList 底层采用的数据结构（存储、组织数据的方式）不同，应用场景不同。 ArrayList 集合的底层原理：基于**数组**实现的。数组的特点：查询快、增删慢。 * 查询速度快（注意：是根据索引查询速度快）：查询数据通过地址值和索引定位，查询任意数据耗时相同。 * 删除效率低：可能需要把后面很多的数据进行前移。 * 添加效率极低：可能需要把后面很多的数据后移，再添加元素；或者也可能需要进行数组的扩容。应用场景： * 适合：根据索引查询数据，比如根据随机索引取数据，或者数据量不是很大时。 * 不适合：数据量大的同时，又要频繁的进行增删操作。底层原理步骤： 1. 利用无参构造器创建的集合，会在底层创建一个默认长度为0的数组 2. 添加第一个元素时，底层会创建一个新的长度为10的数组 3. 存满时，会扩容1.5倍 4. 如果一次添加多个元素，1.5倍还放不下，则新创建数组的长度以实际为准 LinkedList 集合的底层原理：基于**双链表**实现的。特点：查询慢，增删相对较快，**但对首尾元素进行增删改查的速度是极快的。** 链表中的结点是独立的对象，在内存中是不连续的，每个结点包含数据值和下一个结点的地址。链表的特点有：查询慢，无论查询哪个数据都要从头开始找；链表增删相对快。应用场景： * 可以用来设计队列（先进先出，后进后出）。 * 可以用来设计栈（后进先出，先进后出）。 #### ArrayList ArrayList 是用的最多，最常见的一种集合。 ```java List list = new ArrayList<>(); \/\/ 经典代码 ArrayList list = new ArrayList(); list.add("abc"); list.add(547); System.out.println(list); \/\/ [abc, 547] System.out.println(list.get(1)); \/\/ 547 System.out.println(list.size()); \/\/ 2 System.out.println(list.set(1, "666")); System.out.println(list.remove(1)); System.out.println(list.remove("abc")); System.out.println(list); ``` ```java \/\/ 通过泛型约束存储的数据类型 ArrayList