java学习笔记

java学习 asleer 2022/6/27

前言

程序员的重要能力

想成为大佬，就是要通过学习和积累，提升自己的各方面能力，比较抽象，共勉！

1. 团队协作能力

2. 高效沟通能力

3. 需求分析能力

4. 架构设计能力

5. 抽象复用能力

6. 独立创造能力

7. 问题解决能力

8. 归纳总结能力

9. 自主学习能力

10. 工具利用能力

11. 高效编码能力

12. 信息检索能力

13. 开源建设能力

14. 源码阅读能力

15. 自测审查能力

16. 文档编写能力

17. 知识表达能力

18. 绘图描述能力

19. 兴趣驱动（长期学习能力）

20. 保持好奇心

21. 其他

    • 复制粘贴能力
    • 打架能力
    • PPT 制作能力

高效法则

1. 不要过分追求完美，完成比完美更重要。
2. 有现成的代码，就不要自己写，避免重复劳动（学习除外）。
3. 学会使用软件及快捷键来提升自己的编码效率。
4. 做项目前，要先想清楚怎么做，做好充分的预研和设计。这样不仅便于后续的程序扩展，也能避免无意义的返工。
5. 将大的目标进行拆解，做好计划，分清主次。不要因为觉得目标遥不可及而拖延，也不要盲目乐观而松懈。
6. 养成好的作息习惯，找到自己适合工作的黄金时间。
7. 记性不好，就多记录、多总结、定期复习。哪怕实在记不住，也可以借助文档、收藏夹软件来当自己的第二大脑。
8. 积累属于自己的工具库，配合搜索软件实现随用随取。
9. 多和其他同行交流或订阅技术推送，拓宽知识渠道，从而了解更多的工具和方法。有些东西你只要听说过，要用时也许就能节省大量查找时间。
10. 找到让自己进入专注做事的状态的方法，比如戴上耳机、嚼口香糖等。
11. 做事高效，离不开经验的积累，因此要多写代码、多做项目。

阶段1：java入门

java编程基础（45天）

学习资源

• 视频

  • b站韩顺平java课程：https://www.bilibili.com/video/BV1fh411y7R8 （讲课超有耐心、细致、认真、萌新之友）

• 文档

  • 菜鸟教程：Java 教程 | 菜鸟教程 (runoob.com)
  • JAVA8在线API中文手册：https://www.matools.com/api/java8

• 老师忠告

  • 我亦无他，唯手熟尔——欧阳修
  • 纸上得来终觉浅，绝知此事要躬行——陆游
  • 读书破万卷，下笔如有神——杜甫

学习笔记

chapter1-1(学前须知)

JDK,JRE,JVM的关系

1. JDK = JRE + java开发工具
2. JRE = JVM + 核心类库

环境变量path的配置及作用

1. 为了在dos的任意目录可以使用java和javac命令
2. 先配置JAVA_HOME= 指向jdk安装的主目录
3. 编辑path环境变量，增加%JAVA_HOME%\bin

java编写步骤

1. 编写java的源代码
2. javac编译，得到对应的.class字节码文件
3. java运行，本质就是把.class加载到jvm运行

java转义字符

在命令台使用table可以实现命令补全

1. \t：一个制表位，实现对齐的功能
2. \n：换行符
3. \\：一个\
4. \"：一个''
5. \'：一个'
6. \r：一个回车（光标会到本行的最前面）

中文符号不需要转义，英文符号需要

注释（comment）

• 介绍：

  用于注解说明解释程序的文字，提高了代码的可阅读性，是良好的编程习惯。将自己的思想通过注释先整理出来，再用代码体现。对自己写的代码负责。

• 类型：

  • 单行注释：//后跟注释，快捷键：ctrl+/

  • 多行注释：/* 注释 */，快捷键：ctrl+shift+/

    多行注释里不能nest多行注释

  • 文档注释：注释内容可以被javadoc所解析，生成一套以网页文件形式体现的该程序的说明文档，一般写在类

  /**
  * @author asleer
  * @version 1.0
  */
  

  javadoc -d 文件夹名 -xx -yy 文件名.java

代码规范

1. 类、方法的注释，要以javadoc的方式去写
2. 非javadoc注释，往往是给维护者看的，着重告诉读者为什么这么写，如何修改，注意什么问题等
3. 使用tab操作，实现缩进，默认整体向右边移动，shift+tab整体向左边移动
4. 操作符和 = 两边习惯性各加一个空格
5. 源文件使用utf-8编码
6. 行宽度不超过80字符
7. 代码编写次行风格和行尾风格（推荐）

dos命令（了解）

相对路径与绝对路径图解：

常见dos命令

1. dir：查看当前目录有什么内容

2. cd：切换到其他盘，切换到c盘：cd /D c:

3. 切换到当前盘的其他目录，看上图所示，两种写法

4. cd ..：切换到上一级

5. cd \：切换到根目录

6. tree：查看指定目录下的自己目录

7. cls：清屏

8. 退出dos exit

9. 了解内容：

   • md：创建目录
   • rd：删除目录
   • copy：拷贝文件
   • del：删除文件
   • echo：输入内容到文件echo ok > hello.txt
   • type，move：剪切

   主要用于Linux

chapter1-2(变量)

变量

• 变量是程序的基本组成单位

• 概念：

  • 变量相当于内存中一个数据存储空间的表示，变量可以看做是一个房间的门牌号，通过门牌号我们可以找到房间，而通过变量名可以访问到变量(值)

类型+名称+值

for example:int a = 1;

计算机分配一个内存存储数值1，a是访问这个内存的方式（地址）

变量使用注意事项

• 变量在同一个作用域不可重名
• 变量表示内存中的一个存储区域
• 变量需要先声明再使用

程序中+号的使用

• 代码过长时，加号后可以换行

数据类型（会背）

• 基本数据类型

  • 数值型

    • 整数型(byte[1],short[2],int[4],long[8])：存放整数
    • 浮点型(float[4],double[8])：存放小数

  • 字符型(char[2])：存放单个字符“a”或汉字

  • 布尔型(boolean[1])：存放true，false

• 引用数据类型

  • 类(class)
  • 接口(interface)
  • 数组(list, [])

整数类型

• byte[字节]：-128 ~ 127

• short[短整型]：-(2^15) ~ 2^15-1等价于-32768 ~32767

• int[整型]：-2^31 ~ 2^31-1

• long[长整型]：-2^63 ~ 2^63-1

• 使用细节

  • 整型常量默认为int型，声明long型常量，需后加 l 或 L
  • java程序中变量常声明为int型，除非不足以表示大数，才使用long
  • bit：计算机中的最小存储单元，byte：计算机中基本存储单元。1byte = 8 bit

浮点类型

• float[单精度]：-3.403E38 ~ 3.403E38

• double[双精度]：-1.798E308 ~ 1.798E308

• 说明一下

  • 浮点数在机器中的存放形式：浮点数=符号位+指数位(38)+尾数位(3.403)
  • 尾数部分可能丢失，造成精度损失（小数都是近似值）

• 使用细节

  • java的浮点型常量默认为double型，可以但不必要在后加 D 或 d，声明float型常量，需后加 f 或 F

  • 浮点型常量的两种表示形式

    • 十进制：5.12 5.12.0F .512
    • 科学记数法：5.12e2[5.12*10^2] 5.12e-2[5.12/10^2]

  • 通常情况下，应该使用double类型，因为他比float精度更高

  • 浮点数使用陷阱：2.7和8.1/3比较

  当我们对运算结果是小数的进行相等判断要小心。应该以两个数的差值的绝对值，在某个精度范围内判断

xxxxxxxxxx
public class floatdetail{
    public static void main(String[] args){
        double num1 = 2.7;
        double num2 = 8.1 / 3;
        System.out.println(num1);//2.7
        System.out.println(num1);//2.666666669
        if( num1 == num2 ){
            System.out.println("num1 == num2,equal");
        }
        System.out.println(Math.abs(num1 - num2));
        if(Math.abs(num1 - num2) < 0.000001){
            System.out.println("差值非常小，认为相等");
        }
    }
}

字符类型

char：表示单个字符，可以存放汉字，多个字符使用字符串String

使用细节：

1. 字符常量使用单引号括起来的单个字符
2. 允许使用转义字符来将其后的字符转变为特殊字符型常量 \n 表示单个字符
3. char本质是一个整数，在默认输出时，是unicode码对应的字符。要输出对应的数字可以 (int) 字符
4. char类型是可以进行运算的，相当于一个整数，因为它都对应有unicode码。System.out.println('a'+10) = 107

本质：

• 存储：‘a’=>码值97=>二进制（1100001）=>存储

• 字符和码值的对应关系是通过字符编码表决定的

  • ASCII：一个字节表示，一个128个字符，实际上一个字节可以表示256个字符
  • unicode：固定大小的编码，全球通用，使用两个字节来表示字符，浪费空间
  • utf-8：大小可变的编码，是对unicode的改进，字母使用1个字节，汉字使用3个字节
  • gbk：可以表示汉字并且范围广，范围小于utf-8，字母使用1个字节，汉字2个字节
  • big5：繁体中文

布尔类型

介绍：boolean类型数据只允许取值true和false，占用1个字节。不能用0或非0的整数替代。

基本数据类型转换

自动类型转换

精度小的类型自动转换为精度大的类型。

数据类型按精度大小排序：

char => int => long => float => double

byte => short => int => long => float => double

自动类型转换注意和细节

1. 多种类型数据混合运算，自动将所有数据转换成容量最大的那种数据类型，然后再进行计算
2. 精度大的数据类型不能赋值给精度小的数据类型
3. (byte,short)和char之间不会相互自动转换
4. byte,short,char他们三者不论是互相间运算还是自己运算，都会在计算时首先转换为int类型。
5. boolean不参与类型的自动转换

强制类型转换

自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型，使用时要加上强制转换符( )，但可能造成精度降低或外溢，格外要注意。

• 强转符号只针对最近的操作数有效，往往会使用小括号提升优先级
• char类型可以保存int的常量值，但不能保存int的变量值，需要强制类型转换

基本数据类型和String类型的转换

基本数据类型 => String：n + ""

String => 基本数据类型：

通过基本类型的包装类调用parseXX方法即可

使用基本数据类型对应的包装类的相应方法，得到基本数据类型

​x
for example: String num = "123";
​
int num = Integer.parseInt(num);//得到数字123
System.out.println(num.charAt(0));//得到字符'1'

xxxxxxxxxx
Integer.parseInt("");
Double.parseDouble("");
Float.parseFloat("");
Short.parseShort("");
Long.parseLong("");
Boolean.parseBoolean("");
Byte.parseByte("");

字符串之间的比较方式

xxxxxxxxxx
String yyy = "xxx";
"xxx".equals(yyy)//则为true

java API 文档

中文在线文档：Java 8 中文版 - 在线API中文手册 - 码工具 (matools.com)

使用方式：

1. 直接索引
2. 按照组织形式找：

chapter1-3(运算符)

运算符

算数运算符

1. % 取模的本质：a % b = a - a / b * b，如果a是小数，则 a % b = a - (int)a / b * b

2. 自增++：

   • 独立使用时：i++; == ++i; == i = i +1;

   • 作为表达式使用：

     • 前++：++i先自增后赋值
     • 后++：i++先赋值后自增

关系运算符

结果都是boolean，注意不要把 == 写成 =

逻辑运算符

• &&短路与：如果第一个条件为false，则第二个条件不会判断，效率高
• &逻辑与：不论第一个条件是否为false，第二个条件都要判断，效率低
• ||短路或与|逻辑或，同上

赋值运算符

• 基本赋值运算符：int a = 10;

• 复合赋值运算符：

  • a += b; [等价于a = a + b]
  • a -= b;[等价于a = a - b]
  • 还有*=, /=, %=

• 特点

  • 运算顺序从右往左

  • 复合赋值运算符会进行类型转换

    xxxxxxxxxx
    byte b = 3;
    b += 2;//等价于 b = (byte)(b + 2);
    b++;// b = (byte)(b + 1);
    

三元运算符

• 基本语法：条件表达式？表达式1：表达式2；

xxxxxxxxxx
a > b ? a : b;
true?new Integer(1):new Double(2.0);1.0//因为三元运算符是一个整体，后者提高了前者的运算级别

• 运算规则：

  • 如果条件表达式为true，运算后的结果是表达式1；
  • 如果条件表达式为false，运算后的结果是表达式2；

• 使用细节：

  • 表达式1和表达式2要为可赋值给接收变量的类型（或可以自动转换，或可以强转）
  • 三元运算符本质是if--else语句

运算符的优先级

标识符

标识符的命名规则和规范

• 概念：对各种变量、方法和类等命名时使用的字符序列，或凡是自己可以起名字的地方

• 规则：

  • 由26个英文字母大小写，0-9，_或$组成
  • 数字不可以开头
  • 不可以使用关键字和保留字
  • 不能包含空格

• 规范：

  • 包名：多单词组成时，所有字母都小写
  • 类名，接口名：多单词组成时，所有单词的首字母大写【大驼峰】
  • 变量名、方法名：第一个单词首字母小写，第二个单词开始每个单词首字母大写【小驼峰，简称驼峰法】
  • 常量名：所有字母都大写，多单词时每个单词用下划线连接

进制

介绍

二进制：binary

四种表示方式：

1. 二进制：0,1，满2进1，以0B或0b开头
2. 十进制：0-9，满10进1
3. 八进制：0-7，满8进1，以0开头
4. 十六进制：0-9及A(10)-F(15)，满16进1，以0X或0x开头，不区分大小写

进制的转换（基本功）

• 转十进制：从最低位（右边）开始，将每个位上的数提取出来，乘以2/8/16的（位数-1）次方，然后求和

• 十进制转其他：将该数不断除以2/8/16，直到商为0为止，然后将每步得到的余数倒过来，就是对应的二进制

  34转成二进制 = 0B00100010，0B后面自动补成八位

• 二进制转其他：

  • 转八进制：从低位开始，将二进制数每3位一组，转成对应的八进制数即可
  • 转十六进制：从低位开始，将二进制数每4位一组，转成对应的十六进制数即可

• 转二进制：

  • 八进制转：将八进制每1位，转成对应的一个3位的二进制数即可
  • 十六进制转：将十六进制每1位，转成对应的一个4位的二进制数即可

原码、反码、补码（重点、难点）

对于有符号的而言：

1. 二进制的最高位是符号位：0表示正数，1表示负数
2. 正数三码合一
3. 负数的反码 = 负数的原码符号不变，其他位取反
4. 负数的补码 = 负数的反码 + 1
5. 0的反码，补码也是0
6. java没有无符号数
7. 计算机以补码的方式来运算的
8. 当我们看运算结果的时候，要看它的原码

~2 = ?

2的原码等于补码：00000000 00000000 00000000 00000010

~2的补码：11111111 11111111 11111111 11111101

~2的反码：11111111 11111111 11111111 11111100

~2的原码：10000000 00000000 00000000 00000011

所以答案为-3

位运算符

• 按位与 &：两位全为1，结果为1，否则为0
• 按位或 |：两位有一个为1，结果为1，否则为0
• 按位异或 ^：两位一个为0，一个为1，结果为1，否则为0
• 按位取反 ~：0->1，1->0
• 算术右移 >>：低位溢出，符号位不变，并用符号位补溢出的高位。本质是除以移动位数的2
• 算术左移 <<：符号位不变，低位补0。本质是乘以移动位数的2
• 逻辑右移 >>>：也叫无符号右移，运算规则是：低位溢出，高位补0

chapter1-4(控制结构)

顺序控制

程序按顺序从上到下进行执行

分支控制（if，else，switch）

if,else分支结构

• 单分支
• 双分支
• 多分支：多分支可以没有else
• 嵌套分支：不要超过三层（可读性不好）
• 执行代码块后程序结束

xxxxxxxxxx
if(条件表达式1){
    执行代码块1;//可以有多条语句
}
else if(条件表达式2){
    执行代码块2;
}
......
else{
    执行代码块n;
}

switch和if的比较

1. 如果判断的具体数值不多，而且符合六种数据（byte，short，int，char，enum[枚举]，String）类型，虽然两个语句都可以，但是建议使用switch语句
2. 其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广

switch

• 执行语句后程序不结束

xxxxxxxxxx
switch(表达式){
    case 常量1://当表达式返回值对于常量1时执行
        语句块1;
        break;//表示退出switch，而不是退出程序。如果没有break，---> 则不经过判断，直接执行语句块2(穿透) <---
    case 常量2:
        语句块2;
        break;
        ......
    default:
        default语句块;
        break;//这个break可有可无
}

需要注意的细节：

• 表达式数据类型，应和case后的常量类型一致，或者是可以自动转成可以互相比较的类型
• switch(表达式)中表达式的返回值必须是：（byte，short，int，char，enum[枚举]，String）
• case子句中的值必须是常量或常量表达式，而不能是变量
• default语句是可选的
• break语句用来在执行完一个case分支后使程序跳出switch语句块；如果没有写break，程序会穿透地顺序执行到结尾或直到遇到break。

循环控制（for，while，do while，多重循环）

for

xxxxxxxxxx
for(循环变量初始化;循环条件;循环变量迭代){
循环操作(语句);
}

使用细节：

• 执行顺序：循环变量初始化 => 循环条件（true） => 循环操作(语句) => 循环变量迭代 => 循环条件 =====>......=>循环条件（false）
• 循环条件是返回一个布尔值的表达式
• for（；循环判断条件；）中的初始化和变量迭代可以写到其他地方，但是两边的分号不能省略
• 循环初始值和变量迭代可以有多条，中间用逗号隔开

while

xxxxxxxxxx
while(循环条件){
    循环体(语句);
    循环变量迭代;
}

do while

xxxxxxxxxx
do{
    循环体（语句）;
    循环变量迭代;
}while(循环条件);

• 先执行，再判断，一定会至少执行一次
• 最后有一个 ;

break

用法：用于终止某个语句块的执行，等于跳出本次循环，一般使用在switch或者循环中。

• break在多层嵌套的语句块中时，可以通过标签指定要终止的是哪一层语句块，尽量不要使用标签(标签写在循环外)

continue

用法：用于结束本次循环，继续执行下一次循环

• 和break一样可以指定标签

return

用法：使用在方法，表示跳出所在的方法；如果return写在main方法，退出程序

chapter1-5(数组array、排序和查找)

数组

定义

• 动态初始化（类似创建变量的两种方式）

  • 先定义数组的大小，然后向里面赋值（通过.length循环输入，遍历输出）

  xxxxxxxxxx
  数据类型 数组名[] = new 数据类型[];
  数据类型[] 数组名 = new 数据类型[];
  ​
  int[] a = new int[5];
  

  • 先声明数组，再创建数组

  xxxxxxxxxx
  数据类型[] 数组名;
  int[] a;
  数组名 = new 数据类型[大小];
  a = new int[10];
  

• 静态初始化

  要求知道数组有多少元素，具体指

  xxxxxxxxxx
  double[] hens = {3, 5, 1, 3.4, 2, 50}
  hens.length//可以得到数组的长度
      
  String strs[] = new String[]{"a", "b", "c"};//ok
  String[] strs = new String[3]{"a", "b", "c"};//error,编译不通过
  

注意事项和细节

1. 数组内数据赋值同样遵守自动类型转换

2. 数组中的元素可以使任何数据类型，包括基本数据类型和引用数据类型，但不能混用

3. 数组创建后，如果没有赋值，有默认值：

   • int，short，byte，long：0
   • float，double：0.0
   • char：\u0000
   • boolean：false
   • String：null

4. 数组的下标从0开始

5. 数组的下标必须在指定范围内使用，否则报：下标越界异常

数组赋值原理

• 基本数据类型赋值，赋值方式为值拷贝
• 数组在默认情况下是引用传递，赋的值是地址，赋值方式为引用赋值

xxxxxxxxxx
int[] arr1 = {1, 2, 3};
​
//地址传递
int[] arr2 = arr1;
​
//值传递
int[] arr2 = new int[arr1.length];
for(int i = 0; i < arr1.length; i++){
    arr2[i] = arr[1];
}

数组扩容

• 数组扩容一次

xxxxxxxxxx
int[] arr = {1, 2, 3};
int[] arrNew = new int[arr.length +1 ];
//选择创建一个新的数组来存放新的元素
for(int i = 0; i < arr.length; i++){
    arrNew[i] = arr[i];
}
arrNew[arrNew.length - 1] = 4;
arr = arrNew;

• 数组动态扩容

xxxxxxxxxx
import java.util.Scanner;
public class arrayadd{
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        int[] arr = {1, 2, 3};
        do {
            int[] arrNew = new int[arr.length + 1];
            for(int i = 0; i < arr.length; i++){
                arrNew[i] = arr[i];
            }
            System.out.println("请添加数值");
            int addnum = scanner.nextInt();
            arrNew[arrNew.length - 1] = addnum;
            arr = arrNew;
            System.out.println("扩容后数组为");
            for(int i = 0; i < arrNew.length; i++){
                System.out.print(arrNew[i] + "\t");
            }
            System.out.println();
            System.out.println("添加成功，是否继续？y/n");
            char key = scanner.next().charAt(0);
            if(key == 'n')
                break;
        }while(true);
        System.out.println("退出程序~~");
    }
}

• 数组动态缩减

xxxxxxxxxx
import java.util.Scanner;
public class arrayReduce{
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        int[] arr = {1, 2, 3, 4, 5};
        int temp;
        do{
            int[] arrNew = new int[arr.length - 1];
            System.out.println("请选择你要删除的元素");
            int reducenum = scanner.nextInt();
            for(int i = 0; i < arr.length; i++){
                if(arr[i] == reducenum){
                    for(int j = i; j < arr.length - 1; j++){
                        arrNew[j] = arr[j + 1];
                    }
                    break;
                }else{
                    arrNew[i] = arr[i];
                }
            }
            arr = arrNew;
            System.out.println("缩减后的数组为");
            for(int i = 0; i < arrNew.length; i++){
                System.out.print(arrNew[i] + "\t");
            }
            System.out.println();
            if(arrNew.length == 1){
                System.out.println("当前只剩最后一个元素，不能再缩减");
                break;
            }
            System.out.println("是否继续缩减?y/n");
            char addnum = scanner.next().charAt(0);
            if(addnum == 'n')
                break;
        }while(true);
        System.out.println("退出程序~~");
    }
}

排序

将多个数据依指定的顺序进行排列的过程

• 内部排序：指将需要处理的所有数据都加载到内部存储器中进行排序。
• 外部排序：数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。

冒泡排序法(Bubble Sorting)

思想：通过对待排序序列从后向前，依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就像水底下的气泡一样逐渐向上冒

xxxxxxxxxx
public class BubbleSort{
    public static void main(String[] args) {
        int[] arr = {22, 55, 44, 77, 99, 33, 11};
        int temp;
        for(int i = 0; i < arr.length - 1; i++){
            for(int j = 0; j < arr.length - 1 - i; j++){
                if(arr[j] > arr[j + 1]){
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        System.out.println("");
        for(int i = 0; i < arr.length; i++){
            System.out.print(arr[i] + "\t");
        }
    }
}

查找

常用的查找：

• 顺序查找：从头到尾一个一个查找
• 二分查找：边从中间分割边查找

多维数组 — 二维数组

dimensional：维数

• 二维数组：原来的一维数组的每个元素也是一维数组，这些一维数组长度可以不相等。
• 二维数组和一维数组之间不能相互直接相互赋值
• 声明方式有三种：

xxxxxxxxxx
int[][] y
int[] y[]
int y[][]

动态初始化

xxxxxxxxxx
//列数相等
int[][] arr = new int[5][6];
//列数不确定形
//1
//2   2
//3   3   3
int[][] arr = new int[3][];//创建了3个一维数组，但每个元素没有开空间
for(int i = 0; i < arr.length; i++){
    arr[i] = new int[i + 1];//给元素开空间
    for(int j = 0; j < arr[i].length; j++){
        arr[i][j] = i + 1;
    }
}

chapter1-6(面向对象编程||初级)(类与对象object)(OOP)

类与对象的解释

类与对象的关系

把所有猫的特性（属性）提取出来 ===>

猫类Cat：自定义的数据类型，包含：

• 属性：name，age，color
• 行为：run，cry，eat

===> 猫对象：具体的一只猫，而不再是一个种类

类与对象的创建形式

xxxxxxxxxx
public class xxx{
    public static void main(String[] args){
        //cat是对象名(对象引用)
        //new Cat()创建的对象空间(数据)才是真正的对象
        Cat cat = new Cat();
        cat.name = "xioabai";
        cat.age = 3;
        cat.color = "white";
    }
}
class Cat{
    String name;
    int age;
    String color;
}

对象在内存中的存在形式

栈里的cat是对象的名字，堆里空间与数据才是真正的对象

java内存的结构分析

1. 栈：一般存放基本数据类型(局部变量)
2. 堆：存放对象(Cat cat，数组等)
3. 方法区：常量池(常量，比如字符串)，类加载信息

java创建对象的流程简单分析

1. 先加载Cat类信息(属性和方法信息，只会加载一次)
2. 在堆中分配空间，进行默认初始化(看规则)
3. 把地址赋给cat，cat就指向对象
4. 进行指定初始化

属性的使用

• 属性(成员变量/field即字段)

  • 属性是类的一个组成部分，可以使基本数据类型，也可以是引用类型（对象，数组）

• 属性的定义语法同变量

  • 示例：访问修饰符 属性类别 属性名；
  • 访问修饰符：public，protected，默认，private

• 属性如果不赋值，有默认值，规则和数组一致。

  • int，short，byte，long：0
  • float，double：0.0
  • char：\u0000
  • boolean：false
  • String：null

对象分配、赋值机制

类似于数组

成员方法(method)

方法入门

• 简单介绍：某些情况下，我们需要定义方法。比如人类，除了属性外，还有一些行为，这时候需要使用成员方法。

• 作用/好处：

  • 提高代码的复用性
  • 可以将实现的细节封装起来，然后供其他用户来调用即可

xxxxxxxxxx
//main里面写
//先创建对象
//再调用输出
Person p = new Person();
p.speak();
int returnRes = p.getSum(10, 20);
​
class Person{
    String name;
    int age;
    //方法(成员方法)
    //public表示方法是公开的
    //void表示方法没有返回值
    //speak()：speak是方法名，()是形参列表
    //{}是方法体，里面写需要执行的代码
    public void speak(){
        System.out.println("我是一个好人");
    }
    public int getSum(int num1, int num2){
        int res = num1 + num2;
        return res;
    }
}

方法的定义和细节

xxxxxxxxxx
public(访问修饰符) void/返回数据类型 方法名 (形参列表){
    //方法体
    语句;
    return 返回值;
}

使用细节：

• 一个方法最多有一个返回值，也可以使用数组的方式返回多个结果
• 返回数据类型可以为任意类型，包含基本类型和引用类型(数组，方法)
• 如果方法是void，则方法体中可以没有return语句，或者只写return而不写返回值
• 方法名：遵循驼峰命名法，最好见名知意，表达出该功能的意思即可，比如得到两个数的和getSum
• 方法体：里面写完成功能的具体语句，但是里面不能再定义方法(可以创建对象，调用别的类的方法，但不能定义)

形参列表的细节：

• 一个方法可以有0个参数，也可以有多个参数，中间用逗号间隔
• 参数类型可以用任意类型比如数组 printArr(int[][] map)，或对象 Person p
• 方法定义时的参数称为形式参数，简称形参；方法调用时的传入参数称为实际参数，简称实参；形参和实参的类型要一致或兼容、个数、顺序必须一致。

方法调用细节：

• 同一个类中的方法可以直接调用，不需要创建
• 跨类中的方法A类调用B类方法，需要通过对象名调用

方法调用机制

• 调用方法会产生一个新的栈，栈与栈之间没有影响

方法传参机制

parameter：参数

基本数据的传参机制

• 形参的任何变化不影响实参

引用数据的传参机制

• 调用方法时，如果方法中改变了数组或对象属性，则main方法中原来的对象也会改变
• 在main方法里调用方法，传参是对象的话，会在栈里开辟一个新的空间，这个空间里的对象名也指向堆里的那个对象。如果在新空间里把null赋值给对象名，则指针悬空，链接地址断开

方法递归(recursion)调用

递归就是方法自己调用自己，每次调用时传入不同的变量，递归有助于解决复杂的问题，同时让代码变得更简洁

xxxxxxxxxx
//打印问题，输出2,3,4
public void recursion(int n){
    if(n > 2){
        recusion(n - 1);
    }
    System.out.println("n=" + n);
}
//阶乘问题
public int factorial(int n){
    if(n == 1){
        return 1;
    }else{
        return factorial(n - 1) * n;
    }
}

递归的重要规则

1. 执行一个方法时候，就会创建一个新的受保护的独立栈空间
2. 方法的局部变量是独立的，不会相互影响
3. 如果方法中使用的是引用数据类型，就会共享该引用类型的数据
4. 递归必须向退出递归的条件逼近，不然就无限递归了
5. 方法执行完毕，或者遇到return，就会返回，遵守谁调用，就将结果返回给谁。

老鼠走迷宫问题

xxxxxxxxxx
public class MiGong{
    public static void main(String[] args){
        int[][] map = new int[8][7];
        for(int i = 0; i < 7; i++){
            map[0][i] = 1;
            map[7][i] = 1;
        }
        for(int i = 0; i < 8; i++){
            map[i][0] = 1;
            map[i][6] = 1;
        }
        map[3][1] = 1;
        map[3][2] = 1;
        map[2][2] = 1;//导致回溯
        System.out.println("=====当前地图=====");
        for(int i = 0; i < map.length; i++){
            for(int j =0; j < map[i].length; j++){
                System.out.print(map[i][j] + " ");
            }
            System.out.println();
        }
        T ti = new T();
        ti.findWay(map, 1, 1);
        System.out.println("=====新地图=====");
        for(int i = 0; i < map.length; i++){
            for(int j =0; j < map[i].length; j++){
                System.out.print(map[i][j] + " ");
            }
            System.out.println();
        }
    }
}
class T{
    //找到就返回true，否则就返回false
    //i和j表示老鼠当前的坐标
    //规定，0是可走的路，1是障碍物，2是走过的确认可走的路，3是走过的确认不可走的路
    //当map[6][5] = 2就说明找到了通路
    //规定策略，下->右->上->左
    public boolean findWay(int[][] map, int i, int j){
        if(map[6][5] == 2){
            return true;
        }else{
            if(map[i][j] == 0){
                map[i][j] = 2;
                if(findWay(map, i + 1, j)){
                    return true;
                }else if(findWay(map, i, j + 1)){
                    return true;
                }else if(findWay(map, i - 1, j)){
                    return true;
                }else if(findWay(map, i, j - 1)){
                    return true;
                }else{
                    map[i][j] = 3;
                    return false;
                }
            }else{
                return false;
            }
        }
    }
}

汉罗塔问题

xxxxxxxxxx
public class HanoiTower{
    public static void main(String[] args){
        Tower tower = new Tower();
        tower.move(3, 'A', 'B', 'C');
    }
}
class Tower{
    //num表示要移动的个数，a，b，c分别表示A塔，B塔，C塔
    public void move(int num, char a, char b, char c){
        //如果只有一个盘
        if(num == 1){
            System.out.println(a + "->" + c);//指的是将A塔上的移动到C塔上
        }else{
            //如果有多个盘，可以看成是两个，最下面是一个，上面所有盘是一个 num-1
            //先移动上面所有盘到b，借助c
            move(num - 1, a, c, b);
            //把最下面的盘移动到c
            System.out.println(a + "->" + c);
            //再把b塔的所有盘移动到c，借助a
            move(num - 1, b, a, c);
        }
    }
}

八皇后问题

方法重载(overload)

定义：java中允许同一个类中，多个同名方法的存在，但要求形参列表不一致

注意事项：

• 方法名必须相同
• 形参列表必须不同(形参类型或个数或顺序，至少有一个不同，参数名无要求)
• 返回类型无要求

可变参数

定义：java允许将同一个类中多个同名同功能但参数个数不同的方法，封装成同一个方法

xxxxxxxxxx
public int sum(int... nums){
    int res = 0;
    for(int i =0; i < nums.length; i++){
        res += nums[i];
    }
    return res;
}

注意事项：

• 可变参数的实参可以为0个或者任意多个
• 可变参数的实参可以为数组，本质就是数组
• 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
• 一个形参列表中只能出现一个可变参数

作用域(scope)

基本使用

1. 在java编程中，主要的变量就是属性(成员变量)和局部变量

2. 局部变量一般指的是在成员方法中定义的变量(或代码块)

3. java中作用域的分类

   • 全局变量：也就是属性，作用域为整个类体
   • 局部变量：也就是除了属性外的其他变量，作用域为定义它的代码块中

4. 全局变量可以不赋值，直接使用，因为有默认值；局部变量必须赋值后才能使用，因为没有默认值

注意事项：

1. 属性和局部变量可以重名，访问时遵循就近原则

2. 在同一个作用域中，比如在同一个成员方法中，两个局部变量不能重名

3. 作用域范围不同

   • 全局变量/属性：可以被本类使用，或被其他类使用
   • 局部变量：只能在本类中对应的方法中使用

   xxxxxxxxxx
   public class test{
       public static void main(String[] args){
           Person p1 = new Person();
           T t = new T();
           t.test1();//第一种方法
           t.test2(p1);//第二种方法
       }
   }
   class T{//在类的方法中中调用其他类的属性
       public void test1(){
           Person p1 = new Person();
           System.out.println(p1.name);
       }
       public void test2(Person p){
           System.out.println(p.name);
       }
   }
   class Person{
       String name = "jack";
       int age = 10;
   }
   

4. 修饰符不同

   • 全局变量/属性可以加修饰符
   • 局部变量不可以加修饰符

构造器/构造方法(constructor)

定义：是类的一种特殊方法，作用是完成对新对象的初始化。构造器对于方法较多的情况下非常好用。

基本语法

xxxxxxxxxx
[修饰符] 方法名 (形参列表){
    方法体；
}
​
public class test{
    public static void main(String[] args){
        //new对象时，可以直接通过构造器指定名字和年龄
        Person p1 = new Person("jack", 80);
    }
class Person{
    String name;
    int age;
    //创建构造器，完成对象属性的初始化
    public Person(String pName, int pAge){
        name = pName;
        age = pAge;
    }
}

使用细节：

1. 一个类可以定义多个不同的构造器，及构造器重载
2. 构造器名和类名必须相同
3. 构造器是完成对象的初始化，不是创建对象
4. 构造器没有返回值
5. 修饰符可以是默认，也可以是其他，一般用public
6. 在创造对象时，系统会自动调用该类的构造器完成对对象的初始化
7. 如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造器(也叫默认构造器)，比如Person(){}，使用javap指令可以反编译查看
8. 一旦定义了自己的构造器，默认构造器就被覆盖了，除非显示的定义一下：Person(){}(这点很重要)

对象创建的流程分析

看一个案例：

xxxxxxxxxx
class Person{
    int age = 90;
    String name;
    Person(String n, int a){
        name = n;
        age = a;
    }
}
Person p = new Person("小倩"，20)；

分析：

1. 在方法区中先加载了Person类信息，只会加载一次

2. 在堆中分配空间

3. 完成对象初始化

   • 默认初始化：age = 0，name = null
   • 显式初始化：age = 90，name = null
   • 构造器初始化：age = 20，name = 小倩

4. 把对象在堆中的地址返回给p(p是对象的引用)

This关键字

对象里面隐藏一个this属性，this属性指向方法自己。简单地说，哪个对象调用，this就代表哪个对象

使用细节：

• this可以用来访问本类的属性、方法、构造器

• this可以区分当前类的属性和局部变量，即不受局部变量的影响，this.准确定位到属性

• 访问成员方法的语法：this.方法名(参数列表);

• 访问构造器语法：this(参数列表);（注意只能在构造器中调用另外一个构造器，且这条语句必须是构造器中的第一个语句）

• this不能在类定义的外部使用，只能在类定义的方法中使用

• this先调用本类的，然后再调用不同名的父类

  xxxxxxxxxx
  class T{
      public T(){
          this("jack", 10);//必须放在第一句话
          System.out.println("T()构造器");
      }
      public T(String name, int age){
          System.out.println("T(String name, int age)构造器");
      }
  }
  

比较两个人是否相同

xxxxxxxxxx
public class TestPerson{
    public static void main(String[] args){
        Person p1 = new Person("jack",21);
        Person p2 = new Person("tom",21);
        System.out.println(p1.compareTo(p2));
    }
}
class Person{
    String name;
    int age;
    public Person(String name, int age){
        this.name = name;
        this.age = age;
    }
    public boolean compareTo(Person p){
        return this.name.equals(p.name) && this.age == p.age;
    }
}

chapter1-7(面向对象编程||中级)(IDEA，封装，继承，多态)

IDEA快捷键(ctrl+j)

普通快捷键

1. ctrl+d：删除当前行
2. ctrl+shift+向下光标：复制当前行
3. alt+/：补全代码
4. alt+enter：自动导入类
5. ctrl+shift+L：快速格式化代码
6. alt+R：快速运行程序
7. alt+insert：生成构造器（esc+fn锁定F按键，或者alt+fn+insert）
8. ctrl+H：查看一个类的层级关系
9. ctrl+B：定位到方法
10. .var：自动分配变量名

模板快捷键(template)

1. main：主方法
2. sout：输出
3. fori：for循环

包

包的简单介绍：

• 作用：

  • 区分相同名字的类
  • 控制访问范围
  • 语法，打包语句：package com.xxx(包名)

• 包的本质：创建不同的文件夹来保存类文件

• 包的命名

  • 规则：只能包含数字、字母、下划线、小圆点，但不能用数字开头，不能由关键字或保留字
  • 规范：一般是小写字母+小圆点com.公司名.项目名.业务模块名

• 常用的包

  • java.lang.*：基本包，默认引入
  • java.util.*：工具包
  • java.net.*：网络包
  • java.awt.*：做java的界面开发，GUI

• 如何导入包

  • import java.util.Scanner;表示只会引入这个包下的Scanner
  • import java.util.*表示将这个包下的所有类都引入
  • 注意：我们需要使用到哪个类，就导入哪个类

• 注意事项

  • package的作用是声明当前类所在的包，需要放在类的最上面，一个类中最多只有一句package
  • import指令，位置放在package下面，在类定义前面，可以有多句且没有顺序要求

访问修饰符(modifider)

java提供四种访问控制修饰符，用于控制方法和属性的访问权限(范围)

• 公开级别：用public修饰，对外公开
• 受保护级别：用protected修饰，对子类和同一个包中的类(同类、同包、子类)公开
• 默认级别：没有修饰符号，向同一个包的类公开(同类、同包)
• 私有级别：用private修饰，只有类本身(同类)可以访问

注意事项：

• 修饰符可以用来修饰类中的属性、成员方法和类
• 只有默认修饰符和public才能修饰类

封装(encapsulation)

• 封装的理解

  • 把抽象出的数据[属性]和对数据的操作[方法]封装在一起，数据被保护在内部，程序的其他部分只有通过被授权的操作[方法]，才能对数据进行操作

• 好处：

  • 隐藏实现的细节
  • 可以对数据进行验证，保证安全合理

• 封装的实现步骤

  1. 将属性进行私有化private
  2. 提供一个公共的(public)setXxx方法，用于对属性判断并赋值，这个方法可以直接写在构造器中
  3. 提供一个公共的(public)getXxx方法，用于获取属性的值

继承(extends)

• 基本介绍：

  • 继承可以解决代码复用，让我们的代码更加接近人类思维。当多个类存在相同的属性和方法时，可以从这些类中抽象出父类，在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过extends来声明继承父类即可。

• 基本语法：class 子类 extends 父类{}

  • 子类就会自动拥有父类定义的属性和方法
  • 父类又叫超类和基类，子类又叫派生类

• 带来的便利：

  • 代码的复用性提高
  • 代码的扩展性和维护性提高

• 注意事项：

  1. 子类继承了所有的属性和方法，但是private不能在子类直接访问，要通过父类提供公共的方法去间接地访问
  2. 子类必须调用父类的构造器，完成父类的初始化
  3. 在创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器(super();)，如果父类没有提供无参构造器(即无参构造器被新构造器覆盖了)，则必须在子类的构造器中用super去指定使用父类的哪个构造器完成对父类的初始化工作，否则编译不会通过
  4. 如果希望指定去调用父类的某个构造器，则显示的调用一下：super(参数列表)
  5. super需要放在构造器第一行，super可以省略不写，但是一定要注意，super不写也是存在的
  6. super()和this()都只能放在第一行，所以这两个方法不能共存
  7. java所有类都是Object类的子类
  8. 父类构造器的调用不限于直接父类，将一直往上追溯到Object类
  9. 子类最多只能继承一个父类，即单继承机制
  10. 不能滥用继承，子类和父类之间必须满足is-a的逻辑关系

• 继承的本质

  • 可以通过子类名调用父类的信息
  • 调用信息时遵循就近原则

super关键字

• 介绍

  • super代表父类的引用，用于访问父类的属性、方法、构造器

• 基本语法

  • super.属性名;访问父类的属性，但不能访问父类的private属性
  • super.方法名(参数列表)访问父类的方法，但不能访问父类的private方法

• 使用细节

  • 调用父类的构造器的好处 ：分工明确，父类属性由父类初始化，子类属性由子类初始化
  • 当子类中有和父类中的成员(属性和方法)重名时，为了访问父类的成员，必须通过super。没有重名时，super、this和直接访问效果一样
  • super的访问不限于直接父类。如果爷爷类和本类中有同名的成员，也可以用super访问；如果多个上级类都有同名成员，则遵循就近原则

方法重写/覆盖(override)

• 介绍：子类有一个方法和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法覆盖了父类的方法

• 使用细节

  • 子类的方法的参数、方法名称，要和父类的参数、方法名称完全一样
  • 子类方法的返回类型和父类方法的返回类型一样，或者是父类返回类型的子类。比如父类的返回类型是Object，子类方法返回类型是String，或者返回类型是引用类型(自定义的父类与子类 )
  • 子类方法不能缩小父类方法的访问权限(访问修饰符)

xxxxxxxxxx
    //重写equals方法，比较两个对象的属性是否相等
    @Override
    public boolean equals(Object obj) {
        if(this == obj){
            return true;
        }
        if(!(obj instanceof Doctor)){
            return false;
        }
​
        Doctor doctor = (Doctor) obj;
        return this.name.equals(doctor.name) &&
                this.age == doctor.age &&
                this.gender == doctor.gender &&
                this.job.equals(doctor.job) &&
                this.sal == doctor.sal;
​
    }

多态(polymorphic)

• 介绍：方法和对象具有多种形态。

• 方法的多态：重写和重载

• 对象的多态(记住)

  • 一个对象的编译类型和运行类型可以不一致
  • 编译类型在定义对象时，就确定了，不能改变
  • 运行类型是可以改变的
  • 编译类型看定义时 = 号的左边，运行类型看 = 号的右边，可用getClass()查看运行类型

多态的细节讨论：

• 向上转型

  • 本质：父类的应用指向了子类的对象

  • 语法：父类类型 引用名 = new 子类类型();

  • 调用方法的规则

    • 可以调用父类的所有成员
    • 但不能调用子类的特有的成员(因为在编译阶段，能调用哪些成员，是由编译类型来决定)
    • 最终运行效果看子类的具体实现(即调用方法时，按照从子类/运行类型开始查找方法，然后调用)

• 向下转型

  • 语法：子类类型 引用名 = (子类类型) 父类引用

  • 调用规则

    • 只能强转父类的引用，不能强转父类的对象
    • 要求父类的引用必须指向的是当前目标类型的对象
    • 当向下转型后，可以调用子类类型中所有的成员

• 属性没有重写之说法。属性的值直接看编译类型

• instanceof是比较操作符，用于判断对象的运行类型是否为XX类型或其子类型

动态绑定机制(dynamic binding)

1. 当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定(即优先调用子类的方法)
2. 调用对象属性时，没有动态绑定机制，哪里声明哪里使用

Object类

equals方法

• ==

  1. 既可以判断基本类型，也可以判断引用类型
  2. 判断基本类型时，判断的是值是否相等
  3. 判断引用类型时，判断的是地址是否相等

• equals

  1. equals是Object类中的方法，只能判断引用类型
  2. 默认(Object)判断的是地址是否相等，子类(String、Integer等)中往往重写该方法，用于判断内容是否相等

hashCode方法

1. 提高具有哈希结构的容器的效率
2. 两个引用，如果指向同一个对象则哈希值肯定是一样的，如果指向不同的对象则哈希值不一样
3. 哈希值主要根据地址号来的，但不能完全将哈希值等价于地址

toString方法

• 默认返回：全类名(包名+类名)+@+哈希值的十六进制字符串
• 重写toString方法，打印对象时，都会调用自动调用该对象的toString方法，一般情况下会打印该对象的属性
• 重写toString方法后，直接输出一个对象时候，toString方法会被默认调用，即System.out.println(Person); == System.out.println(Person.toString());

finalize方法(已过期，开发中不会使用，应付面试)

• 当对象被回收时，系统自动调用该对象的finalize方法。子类可以重写该方法
• 什么时候被回收：当某个对象没有任何引用时，则jvm就认为这个对象是一个垃圾对象，就会使用垃圾回收机制来销毁该对象。在销毁该对象前，会先调用finalize方法
• 垃圾回收机制的调用，是由系统来决定的(即有自己的GC算法)，也可以通过System.gc()主动出发垃圾回收机制

断点调试(debug)

快捷键

• F7(跳入方法)
• alt+shift+F7(强制跳入方法)
• F8(跳过，即正常执行)
• shift+F8(跳出方法)
• F9(resume，执行到下一个断点)

chapter2-1(面向对象编程||高级)(静态成员，内部类)

类变量和类方法(static)

类变量

• 定义：类变量又叫静态变量、静态属性，是该类的所有对象共享的变量。
• 定义语法：

xxxxxxxxxx
访问修饰符 static 数据类型 变量名;//(推荐)
static 访问修饰福 数据类型 变量名;
    
//访问方式：
类名.类变量名;//(推荐)
对象名.类变量名;

• 注意事项：

  • JDK8之前，static变量存放在方法区中，JDK8之后存放在堆中
  • static变量是同一个类所有对象共享的
  • static类变量在类加载的时候就生成了，即便没有创建对象，也可以使用类变量

类方法

• 语法：

xxxxxxxxxx
//推荐
访问修饰福 static 返回类型 方法名(){}
static 访问修饰福 返回类型 方法名(){}
//访问方式：
类名.类对象名();//(推荐)
对象名.类对象名();

• 使用：

  • 当方法中不涉及到任何和对象相关的成员，则可以将方法设计成静态方法，提高开发效率，比如Math类等
  • 在实际开发中会将通用的方法设计成静态方法，这样我们不需要再创建对象就可以使用，比如打印一维数组、冒牌排序等

• 使用细节：

  • 类方法和普通方法都是随着类的加载而加载，将结构信息存储在方法区。类方法中无this的参数，而普通方法中隐含着this的参数
  • 类方法中不允许使用和对象有关的关键字，比如this和super
  • 类方法(静态方法)中只能访问静态成员(静态变量或静态方法)
  • 普通成员方法既可以访问非静态成员，也可以访问静态成员

main方法

xxxxxxxxxx
public static void main(String[] args){}

解释main方法的形式

1. main方法是虚拟机调用的
2. java虚拟机需要调用类的main()方法，所以该方法的访问权限必须是public
3. java虚拟机在执行main()方法时不必创建对象，所以该方法必须是static
4. 该方法接受String类型的数组参数，该数组中保存执行java命令时传递给所运行的类的参数：java 执行的程序名 参数1 参数2 参数3...

代码块

• 基本介绍：

  • 代码化块又叫初始化块，属于类中的成员(即类的一部分)，类似于方法，将逻辑语句封装在方法体中，用{}包围起来。但其与方法不同，只有方法体，而且不用通过对象或类显式调用，而是加载类或创建对象时隐式调用

• 基本语法：[修饰符]{代码}; ;号可以省略

• 好处：

  1. 相当于另一种形式的构造器(对构造器的补充机制)，可以做初始化操作
  2. 如果多个构造器中有重复的语句，可以抽取到代码块中，提高代码的重用性

• 说明注意：

  1. 修饰符是否写可选，写的话也只能写static。static代码块也叫静态代码块，作用就是对类进行初始化，而且它随着类的加载而执行，并且只会执行一次。如果是普通代码块，每创建一个对象都会执行一次

  2. 类什么时候被加载 [重要]

     1. 创建对象实例时(new)
     2. 创建子类对象实例，父类也会被加载
     3. 使用类的静态成员时

  3. 普通代码块会在创建对象实例时，被隐式的调用。如果只是使用类的静态成员，普通代码块不会被调用

  4. 创建一个对象时，类的调用过程是：

     • 调用静态代码块和静态属性初始化(如果有多个，则按照定义的顺序调用)
     • 调用普通代码块和普通属性的初始化
     • 调用构造方法

  5. 构造器的最前面隐含了super()和调用普通代码块

  6. 创建一个子类对象时，调用顺序：

     1. 父类的静态代码块和静态属性
     2. 子类的静态代码块和静态属性
     3. 父类的普通代码块和普通属性初始化
     4. 父类的构造器
     5. 子类的普通代码块和普通属性初始化
     6. 子类的构造器

  7. 静态代码块只能调用静态成员，普通代码块可以调用任意成员

单例设计模式

介绍：采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法

• 饿汉式步骤

  1. 构造器私有化=>防止直接new
  2. 类的内部创建static对象
  3. 向外暴露一个静态static的公共方法：getInstance

xxxxxxxxxx
public class single01 {
    public static void main(String[] args) {
        System.out.println(GirlFriend.getInstance());
    }
}
class GirlFriend{
    private String name;
    private static GirlFriend gf = new GirlFriend("凌华");
    private GirlFriend(String name) {
        this.name = name;
    }
​
    public static GirlFriend getInstance() {
        return gf;
    }
​
    @Override
    public String toString() {
        return "GirlFriend{" +
                "name='" + name + '\'' +
                '}';
    }
}

• 懒汉式步骤

  1. 构造器私有化
  2. 定义一个static对象
  3. 定义一个public的static方法，返回一个该类的对象

xxxxxxxxxx
//只有当用户使用getInstance时，才返回cat对象。后面再次调用时，会返回上次创建的cat对象，从而保持了单例
public class single02 {
    public static void main(String[] args) {
        System.out.println(Cat.getInstance());
    }
}
class Cat{
    private String name;
    private static Cat cat;
​
    private Cat(String name) {
        this.name = name;
    }
​
    public static Cat getInstance() {
        if(cat == null){
            cat = new Cat("团子");
        }
        return cat;
    }
​
    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                '}';
    }
}

小结：

1. 饿汉式的问题：在类加载时候就创建了，可能存在资源浪费问题
2. 懒汉式的问题：线程安全问题

final关键字

• 基本介绍：可以修饰类、属性、方法、局部变量

• 应用场景：

  1. 当不希望类被继承时
  2. 当不希望父类的某个方法被子类重写时
  3. 当不希望类的某个属性的值被修改时
  4. 当不希望某个局部变量被修改

• 使用细节

  1. final修饰的属性又叫常量，一般用XX_XX_XX来命名

  2. final修饰的属性在定义时必须赋初值，并且以后不能再改，赋值可以在如下的位置之一：

     • 定义时
     • 构造器中
     • 代码块中

  3. 如果final修饰的属性是static的，则初始化的位置可以是：

     • 定义时
     • 在静态代码块中

  4. final类不能继承，但能实例化对象

  5. 如果类不是final类，但是含有final方法，则该方法虽然不能被重写，但可以被继承

  6. 一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法了

  7. final不能修饰构造器

  8. final和static往往搭配使用，效率更高，不会导致类加载。底层编译器做了优化处理

  9. 包装类(Integer,Double,Float,Boolean,String等)都是final

抽象类(abstract)

• 介绍：

  • 用abstract关键字来修饰一个类：访问修饰符 abstract 类名名叫抽象类
  • 用abstract来修饰一个方法访问修饰符 abstract 返回类型 方法名(参数列表);名叫抽象方法。注意抽象方法没有方法体
  • 抽象类的价值更多在于设计，是设计者设计好后，让子类继承抽象类

• 细节讨论：

  • 抽象类不能被实例化(即new 类名)
  • 抽象类不一定要包含abstract方法，但可以有实现的方法(即普通的方法)
  • 一旦类包含了abstract方法，则这个类必须声明为abstract类
  • abstract只能修饰类和方法，不能修饰属性和其他
  • 抽象类可以有任意的成员(抽象类本质还是类)
  • 如果一个类继承了抽象类，就必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类
  • 抽象方法不能使用private、final、static(此关键字和方法重写无关)来修饰，因为这些关键字都适合重写相违背的

• 模板设计模式

  • 设计一个抽象类完成计算某段代码的耗时

xxxxxxxxxx
abstract class Template{
    public abstract void job();
    public void calculateTime(){
        long start = System.currentTimeMillis();
        job();
        long end = System.currentTimeMillis();
        System.out.println((end - start));
    }
}

接口(interface)

• 基本介绍：接口就是给出一些没有实现的方法，封装到一起，到某个类要使用的时候，再根据具体情况把这些方法写出来

xxxxxxxxxx
interface 接口名{
    //属性
    //方法(1.抽象方法 2.默认实现方法 3.静态方法)
}
class 类名 implements 接口{
    //自己属性;
    //自己方法;
    //必须实现的接口的抽象方法;
}
​
//接口名.属性
//类名.属性
//类创建的对象名.属性
//这三种方式都能访问到接口内的属性
    
//在JDK7前，接口里的所有方法都没有方法体，都是抽象方法
//JDK8之后接口可以有静态方法，默认方法(default)，也就是说接口中可以有方法的具体实现

• 使用细节

  1. 接口不能被实例化
  2. 接口中所有的方法是public方法，接口中抽象方法可以不用abstract修饰
  3. 一个普通类实现接口，就必须将该接口的所有方法都实现，可以使用alt+enter
  4. 抽象类去实现接口时，可以不用实现接口的方法
  5. 一个类可以同时实现多个接口
  6. 接口中的所有属性都是public static final修饰的。属性的访问形式：接口名.属性名
  7. 接口不能继承其他类，但可以继承多个别的接口
  8. 接口的修饰符只能是public和默认

• 实现接口 VS 继承类

  • 当子类继承了父类，就自动的拥有了父类的功能，类似于先天继承。继承的价值主要在于，解决代码的复用性和可维护性
  • 如果子类需要扩展功能，可以通过实现接口的方式扩展，类似于后天学习。接口的价值主要在于，设计，让其他的类去实现这些方法，更加的灵活
  • 实现接口是对java单继承机制的一种补充，而且在一定程度上实现代码解耦

• 接口的多态特性

  1. 多态参数：接口类型的变量可以指向实现了接口类的对象实例(类似于继承中的向上转型，父类类型的变量可以指向子类的对象实例)
  2. 多态数组：接口定义的数组中可以存放实现接口的类的对象。使用不同类的特有方法时候，可以(instanceof)后向下转型。
  3. 多态传递：接口间的继承也会传递

内部类

• 基本介绍：一个类的内部又完整的嵌套了另一个类的结构，被嵌套的类成为内部类。类的五大成员为[属性、方法、构造器、代码块、内部类]。内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系

局部内部类

• 定义：局部内部类是定义在外部类的局部位置上的，通常在方法中

• 使用细节：

  1. 可以直接访问外部类的所有成员，包含私有的
  2. 不能添加访问修饰符，因为它的地位是一个局部变量，局部变量是不能使用访问修饰福的。但是可以使用final修饰，局部变量也可以使用final
  3. 作用域：仅仅在定义它的方法或代码块中
  4. 外部类在方法中，可以创建局部内部类的对象，然后调用方法
  5. 外部其他类不能访问局部内部类
  6. 如果外部类和局部内部类的成员重名时，默认遵循就近原则。如果想要访问外部类的成员，则可以使用(外部类名.this.成员)来访问

匿名(anonymous)内部类！！！

• 本质：

  • 本质是类，内部类，没有名字
  • 同时还是一个对象
  • 匿名内部类是定义在外部类的局部位置，比如方法中，并且没有类名，可以简化开发
  • 本质上匿名内部类有名字：外部类名$数字1...

xxxxxxxxxx
//语法:
new 类或接口(参数列表){
    类体
};
//调用方法:
new A(){//方法1，因为匿名内部类本质是返回对象
    public void cry(){
    }
}.cry();
=============
A a = new A(){//方法2,此处编译类型是A，运行类型是匿名内部类
    public void cry(){
    }
};
a.cry();

• 使用细节

  1. 不能添加访问修饰符，因为其地位就是局部变量
  2. 作用域：方法或代码块
  3. 外部其他类不能访问匿名内部类
  4. 如果外部类和匿名内部类重名，则遵循就近原则。如果想要访问外部类的成员，则可以使用(外部类名.this.成员)来访问

• 使用场景：

  • 匿名内部类当做实参直接传递，简洁高效
  • 两个使用场景分析

xxxxxxxxxx
public class hhhhh {
    public static void main(String[] args) {
        f(new IB() {//匿名内部类传参法
            @Override
            public void show() {
                System.out.println("show()");
            }
        });
        f(new BB());//传统方法
    }
    public static void f(IB ib){//写一个方法传递接口类型参数
        ib.show();
    }
}
interface IB{
    void show();
}
class BB implements IB{//硬编码
    @Override
    public void show() {
        System.out.println("show()");
    }
}

xxxxxxxxxx
public class Homework04 {
    public static void main(String[] args) {
        CellPhone cellPhone = new CellPhone();
        cellPhone.testWork(new Computer() {//匿名内部类作为参数传递
            @Override
            public double work(double num1, double num2) {
                return num1 + num2;
            }
        }, 10, 20);
        cellPhone.testWork(new Computer() {
            @Override
            public double work(double num1, double num2) {
                return num1 * num2;
            }
        }, 10, 5);
        //这里可以看出匿名内部类是很方便的，可以重写来改变计算方法
    }
}
​
interface Computer {//接口
    public double work(double num1, double num2);
}
​
class CellPhone {//接口的方法只调用，让匿名内部类实现
    public void testWork(Computer computer, double num1, double num2) {
        double result = computer.work(num1, num2);
        System.out.println(result);
    }
}

成员内部类

• 定义：成员内部类是定义在外部类的成员位置，并且没有static修饰

• 使用细节

  • 可以直接访问外部类的所有成员
  • 可以添加任意访问修饰符，因为它的地位就是一个成员
  • 作用域：这个外部类的类体中
  • 外部类可以创建成员内部类的对象来访问成员内部类
  • 外部其他类访问成员内部类的方式：

xxxxxxxxxx
public class innerClass01 {
    public static void main(String[] args) {
        new Outer().new Inner().say();//方式1
        new Outer().getInner().say();//方式2
    }
}
class Outer{
    public class Inner{
        private int n = 1;
        public void say(){
            System.out.println("ok");
        }
    }
    public Inner getInner(){
        return new Inner();
    }
}

静态内部类

• 定义：静态内部类是定义在外部类的成员位置，并且有static修饰

• 使用细节

  • 可以直接访问外部类的所有静态成员

  • 可以添加任意访问修饰符

  • 作用域为整个类体

  • 外部其他类访问静态内部类方式

    • 可以直接通过类名访问new Outer.Inner();
    • 写一个方法(可以是static方法)，可以返回静态内部类的对象实例，同上

  • 如果外部类和静态内部类的成员重名时，静态内部类访问时，遵循就近原则；如果想访问外部类的成员，则可以使用(外部类名.成员)来访问

chapter2-2(枚举和注解)

枚举类(enumeration)

• 枚举属于一种特殊的类，里面只包含一组有限的特定的对象，是一组常量的集合

自定义枚举

• 实现方法

  1. 将构造器私有化，防止直接new
  2. 去掉setXxx方法，防止属性被修改
  3. 在该类内部，直接创建固定的public static final对象

• 注意细节

  1. 枚举对象名通常使用全部大写，常量的命名规范
  2. 枚举对象根据需要，也可以有多个属性
  3. 对枚举对象/属性使用final+static共同修饰，实现底层优化

enum枚举类

• 使用

  1. 用enum替代class
  2. 常量名(实参列表)
  3. 如果有多个常量(对象)，使用，分隔

xxxxxxxxxx
enum Season{
    SPRING("春天", "温暖"),
    SUMMER("夏天", "炎热"),
    AUTUMN("秋天", "凉爽"),
    WINTER("冬天", "寒冷");
    private String name;
    private String desc;
​
    Season(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }
​
    public String getName() {
        return name;
    }
​
    public String getDesc() {
        return desc;
    }
​
    @Override
    public String toString() {
        return "Season{" +
                "name='" + name + '\'' +
                ", desc='" + desc + '\'' +
                '}';
    }
}

• 注意事项

  1. enum关键字开发一个枚举类时，默认会继承Enum类，而且是一个final类
  2. 如果使用无参构造器创建枚举对象，则小括号可以省略
  3. 如果使用enum来实现枚举，要求将定义常量对象，写在最前面

Enum成员方法

• enum常用方法的使用

  1. toString：Enum类已经重写过了，返回的是当前的对象名，子类也可以重写该方法，使其返回对象的属性信息

  2. name：输出枚举对象的名称

  3. ordinal：输出的是该枚举对象的编号(从0开始)

  4. values：返回枚举类的数组，遍历枚举对象(原码内看不到values，但可以通过javap反编译看到)

     xxxxxxxxxx
     Season[] values = Season.values();
     for(Season season: values){//增强for循环，values的值直接赋给season
         System.out.println(season);
     }
     

  5. valueOf：将字符串转换成枚举对象，要求字符串必须为已有的常量名，否则会报错

  6. compareTo：比较两个枚举变量，比较的是编号。返回值为编号相减

• 细节讨论

  • 使用enum关键字后，就不能再继承其他类了，因为enum会隐式继承Enum，java是单继承机制
  • 枚举类可以实现接口

JDK内置的基本注解(Annotation)类型

• 介绍：

  • 注解也称为元数据(Metadata)，用于修饰解释包、类、成员、构造器、局部变量等数据信息
  • 和注释一样，不影响程序逻辑，但可以被编译或运行，相当于嵌入在代码中的补充信息
  • 使用Annotation时，要在其前面增加@，并把Annotation当做一个访问修饰符

@Override

• 如果写了@Override注解，编译器就会去检查该方法是否真的重写了父类的方法。如果重写了则编译通过，如果没有构成重写，则编译错误

xxxxxxxxxx
//@Override源码
​
@Target(ElementType.METHOD)//说明只能修饰方法，@Taeget是修饰注解的注解，成为元注解
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}
//@interface表示一个注解类，而不是接口

@Deprecated

• 如果用@Deprecated修饰某个元素，则表示该元素已经过时
• 可以修饰方法、类、字段、包、参数等
• 作用：新旧版本的兼容和过渡

@SuppressWarnings

• 使用：

  • 不希望看到警告时，使用@SuppressWarning注解来抑制警告信息
  • 在@SuppressWarning({""})中可以写入希望抑制的警告信息类型
  • 作用范围和放置的位置有关

• 说明各种值

  • uncheck：忽略没有检查的警告
  • rawtypes：忽略没有指定泛型的警告
  • unused：忽略没有使用某个变量的警告
  • 可以点击右边黄色线条标志来看错误类型

JDK的元注解(了解)

• 类型

  • Retention：指定注解的作用范围：SOURCE,CLASS,RUNTIME
  • Target：指定注解可以在哪些地方使用
  • Documented：指定该注解是否会在javadoc体现
  • Inherited：子类会继承父类注解

• @Retention说明

  • 只能用于修饰一个Annotation定义，用于指定其可以保留多长时间

  • 包含一个RetentionPolicy类型的成员变量，三种值为

    • SOURCE：编译器使用后，直接丢弃这种策略的注解
    • CLASS：编译器将把注解记录在class文件中，当运行程序时，JVM不会保留注解，这是默认值
    • RUNTIME：编译器将注解记录在class文件中，当运行程序时，JVM会保留注解，程序可以通过反射获取该注解

chapter2-3(异常Exception)

异常

• 基本概念：java语言中，将程序执行中发生的不正常称为异常(不包括语法错误和逻辑错误)

• 分类：

  • Error：java虚拟机无法解决的严重问题。比如JVM系统内部错误、资源耗尽；比如StackOverFlowError栈溢出、OOM(out of memory)。
  • Exception：其他因编程错误或偶然的外在因素导致的一般性问题。比如空指针访问、试图读取不存在的文件、网络连接中断。分为两类：运行时异常和编译时异常

异常体系图

常见的异常

• 运行异常

  • NullPointerException：空指针异常，当应用程序试图在需要对象的地方使用null时，抛出该异常
  • ArithmeticException：数学运算异常，比如一个整数除以零时，抛出该异常
  • ArrayIndexOutOfBoundsException：数组越界异常
  • ClassCastException：类型转化异常，试图将对象强制转换为不是实例的子类
  • NumberFormatException：数字格式不正确异常，当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时，抛出该异常

• 编译异常

  • SQLException
  • IOException
  • FileNotFoundException
  • ClassNotFoundException
  • EOFException

异常处理

try—catch—finally

• 快捷键：ctrl+alt+t

xxxxxxxxxx
try{
    //代码/可能有异常
}catch(Exception e){
    //当异常发生时，系统将异常封装成Exception对象e，传递给catch，得到异常对象后，程序员自己处理。
    //注意，如果没有发生异常，catch代码块不执行
}finally{
    //不管try代码块是否有异常发生，始终要执行finally，finally可以不写
    //所以通常将释放资源的代码放在finally中
}

• 注意事项

  • 如果异常发生了，则异常发生后面的代码不会执行，直接进入到catch块
  • 如果异常没有发生，则顺序执行try的代码块，不会进入catch
  • 如果希望不管是否发生异常，都执行某段代码(比如关闭连接，释放资源等)，则使用如下代码finally{}
  • 可以有多个catch语句，捕获不同的异常，要求父类异常在后，子类异常在前。如果发生异常，只会匹配一个catch
  • 可以进行try—finally，相当于没有捕获异常，因此程序会直接崩掉。应用场景：执行一段代码，不管是否发生异常，都必须执行某个业务逻辑
  • finally优先级高于return，即便catch里有return，也会先执行finally代码块后再执行return

throws

• 基本介绍

  • 如果一个方法可能生成某种异常，但是并不能确定如何处理这种异常，则此方法应显示的声明抛出异常，表明该方法将不对这些异常进行处理，而由该方法的调用者(main，可能是方法，可能是JVM，JVM收到后直接输出异常信息并退出程序)负责处理
  • 在方法声明中用throws语句可以声明抛出异常的列表(即一次性抛出多个异常)，throws后面的异常类型可以使方法中产生的异常类型，也可以是它的父类

• 使用细节

  • 对于编译异常，程序必须处理，try—catch和throws二选一
  • 对于运行时异常，程序中如果没有处理，默认使用throws
  • 子类重写父类方法时，对于抛出异常的规定：子类重写的方法所抛出的异常类型要么和父类抛出的异常一致，要么为父类抛出的异常型的子类
  • 方法A调用方法B，如果B存在编译异常且已throws，则A调用B会直接报错；如果B存在运行异常且已throws，则A调用B不会报错

自定义异常

• 步骤

  1. 定义类：自定义异常名继承Exception或RuntimeException
  2. 一般情况下，自定义异常继承RuntimeException，即把自定义异常做成运行时异常
  3. 好处：我们可以使用默认的处理机制，默认自动抛出异常给上一级。如果设置为编译异常，则需要在调用自定义异常的类写throws抛出异常

• throw和throws

  • throw：手动生成异常对象的关键字，定义在方法体中，后面跟着异常的对象
  • throws：是异常处理的一种方式，定义在方法声明出，后面跟着异常类型

chapter2-4(常用类)

包装类(Wrapper)

• 定义：包装类就是基本数据类型对应的引用数据类型

• 除了Character和Boolean包装类，其余6个包装类的父类是Number

• 包装类和基本数据类型的转换(以int为例)

  1. JDK5前的手动装箱：基本类型->包装类型，反之是拆箱

     xxxxxxxxxx
     int n1 = 100;
     Integer integer = new Integer(n1);//过时
     Integer integer1 = Integer.valueOf(n1);
     int i = integer.intValue();
     

  2. JDK5后实现了自动装箱和拆箱

     xxxxxxxxxx
     int n2 = 200;
     Integer integer2 = n2;//底层仍然含有Integer.valueOf()
     int n3 = integer2;
     

  3. 自动装箱底层调用的是valueOf方法，比如Integer.valueOf()

包装类方法

• 包装类型和String相互转换

  xxxxxxxxxx
  //Integer->String
  Integer i = 10;
  //方法1
  String s1 = i + "";
  //方法2
  String s2 = String.valueOf(i);
  //方法3
  String s3 = i.toString();
  ​
  //String->Integer
  String s = "123";
  //方法1
  Integer i1 = Integer.valueOf(s);
  //方法2
  Integer i2 = new Integer(s);//已过时
  

• Integer类和Character类的常用方法

  • Integer.MIN_VALUE：返回最小值
  • Integer.MAX_VALUE：返回最大值
  • Charecter.isDigit('a')：判断是不是数字
  • Charecter.isLetter('a')：判断是不是字母
  • Charecter.isUpper('a')：判断是不是大写
  • Charecter.isLower('a')：判断是不是小写
  • Charecter.isWhitespace('a')：判断是不是空格
  • Charecter.toUpperCase('a')：转成大写
  • Charecter.toLowerCase('a')：转成小写

String类

结构剖析

• String类实现了Serializable和Comparable接口，前者说明String可以串行化(可以进行网络传输)，后者说明String对象可以相互比较

• 理解

  • String对象用于保存字符串
  • 字符串常量对象是用双引号括起来的字符序列
  • 字符串的字符使用Unicode字符编码，一个字符占两个字节
  • String常用的构造器有很多，构造器的重载
  • String是final类，不能被其他类继承

• 本质：String有属性private final char values[]；用于存放字符串类型，且values是final类型，不可修改(地址)

创建方式

xxxxxxxxxx
//方式一：直接赋值
String s = "asleer";
//方式二：调用构造器
String s1 = new String("asleer");
.intern()//可以返回常量池的地址

• 方式一：先从常量池查看是否有"asleer"数据空间，如果有直接指向；如果没有则重新创建后指向。s最终指向的是常量池的空间地址
• 方式二：先在堆中创建空间，里面维护了value属性，指向常量池的"asleer"空间。如果常量池没有"asleer"则重新创建，如果有则通过value指向。最终s1指向的是堆中的空间地址

String对象特性

xxxxxxxxxx
String a = "abc";
String b = "def";
String c = a + b;
System.out.println("abc"+"drf" == c);//false
//常量相加和变量相加规则不同

• 创建一个StringBuilder sb = new StringBuilder()
• 执行sb.append("abc");
• 执行sb.append("def");
• String c = sb.toString();
• 最后c指向堆中的对象(String) value[]指向常量池中"abcdef"

String类的常用方法

• 第一组

xxxxxxxxxx
//1. equals比较字符串是否相等，区分大小写
String str1 = "hello";
String str2 = "Hello";
System.out.println(str1.equals(str2));//false
​
//2. equalsIgnoreCase忽略大小写的判断内容是否相等
String username = "John";
System.out.println("john".equalsIgnoreCase(username));//true
​
//3. length获取字符的个数，字符串的长度
System.out.println("asleer".length());//6
​
//4. indexOf获取字符在字符串对象中第一次出现的索引，索引从0开始，如果找不到返回-1
String s1 = "asleer@*(@)";
int index = s1.indexOf('@');
System.out.println(index);//6
System.out.println(s1.indexOf("ee"));//3
​
//5. lastIndexOf获取字符在字符串中最后一次出现的索引，如果找不到返回-1
index = s1.lastIndexOf('@');
System.out.println(index);//9
​
//6.substring截取指定范围的子串
String name = "hello,张三";
System.out.println(name.substring(6));//张三,从索引6开始截取后面的字符
System.out.println(name.substring(2,5));//llo，截取[2,5)位置的字符[2,5)
​
//7. trim删除前后空格
//8. charAt(n)获取某索引处的字符