第01篇_基础语法

第01章_基础语法

第一节 快速入门

1. Java语言简介

Java语言是美国Sun公司在1995年推出的高级编程语言，主要应用于企业应用开发，如商城系统、物流系统、网银系统等。

2. JDK/JRE与JVM

JDK (Java Development Kit)：指Java程序开发工具包，包含JRE和开发人员使用的一些工具。

JRE(Java Runtime Environment)：指Java程序的运行时环境，包含JVM和运行时所需要的核心类库。

JVM(Java Virtual Machine)：指Java虚拟机，所有的Java代码，都运行在Java虚拟机之上。

3. 安装JDK

​x
1
# 1. 下载安装包
2
https://www.oracle.com/java/technologies/javase/jdk11-archive-downloads.html
3
> jdk-11.0.16_linux-x64_bin.tar.gz
4

5
# 2. 解压到指定目录
6
tar -zxvf jdk-11.0.16_linux-x64_bin.tar.gz -C /usr/local
7

8
# 3. 配置3个系统变量
9
$ vim /etc/profile
10
export JAVA_HOME=/usr/local/jdk-11.0.16
11
export CLASSPATH=$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
12
export PATH=$PATH:$JAVA_HOME/bin
13

14
# 4. 加载系统变量
15
$ source /etc/profile
16

17
# 5. 验证
18
java -version
19

4. HelloWorld案例

1) 编写源文件

新建HelloWorld.java文件，输入以下代码：

6
1
public class HelloWorld {
2
   public static void main(String[] args) {  
3
     System.out.println("Hello World!");    
4
   }  
5
}
6

注意：

1. 这里的文件名必须和类名一致，注意大小写。

2) 编译源文件

使用javac命令对源文件进行编译，如果编译成功，将会生成一个HelloWorld.class字节码文件。

1
1
javac HelloWorld.java

3) 运行字节码

使用java命令进行运行，注意文件名不要加.class后缀。

1
1
java HelloWorld

第二节 数据类型

1. 数据类型分类

在Java中，提供了四类八种基本数据类型，分别是：

• 整型：从小到大又可区分为字节型(byte)、短整型(short)、整型(int)、长整型(long)四种，分别占用1、2、4、8个字节。

• 浮点型：有单精度浮点型(float)和双精度浮点型(double)两种，分别占用4和8个字节，默认的浮点型变量是double类型。

• 字符型：只有char一种，其采用unicode方式编码，占用两个字节，取值范围为0-65535。

• 布尔型：布尔型变量(boolean)只有true和false两种值,占用一个字节,用来表示真或假。

引用数据类型包含基本数据类型之外的所有类型，如字符串、类、数组、接口、lamda表达式等。

21
1
// 案例：定义不同类型的变量，并使用字面量进行赋值
2
public class Variable {
3
    public static void main(String[] args){    
4
        // 整型
5
        byte b = 100;  // 字节型 
6
        short s = 1000;  // 短整型 
7
        int i = 123456;  // 整型 
8
        long l = 12345678900L;  // 长整型 
9
        
10
        // 浮点型
11
        float f = 5.5F;  // 单精度浮点型 
12
        double d = 8.5; // 双精度浮点型 
13
        
14
        // 布尔型
15
        boolean bool = false; 
16
        
17
        // 字符型
18
        char c = 'A';  
19
    }    
20
}
21

提示：

1. 字面量除了上述各种基本类型的值外，还有字符串和null值两种。

2. 变量必须初始化后才能使用，否则会出现编译错误。

2. 数据类型转换

参与的计算的数据，必须要保证数据类型的一致性，否则将发生类型的转换，转换可分为：

• 自动类型转换：将取值范围小的类型自动提升为取值范围大的类型。

• 强制类型转换：一般是将取值范围大的类型强制转换成取值范围小的类型，但可能会造成精度损失或数据溢出等。

10
1
public static void main(String[] args) {
2
    // 小类型->大类型，自动类型转换
3
    long l = 100;
4
    float n = 30L;
5
    double d = 2.5F;
6

7
    // 大类型->小类型，强制类型转换
8
    int i1 = (int) 1.5; // 1，精度损失
9
    int i2 = (int) 6000000000L; // 1705032704，发生了数据溢出
10
}

特殊的，对于byte 、short、char类型，在赋值时，如果右边为不超过取值范围的常量，则编译器会自动补上强制类型转换，在参与运算时，至少会被提升为int类型。

14
1
public static void main(String[] args) {
2
    // 赋值时的常量优化
3
    byte b1 = 30; // 不超过范围，自动补充强制类型转换
4
    byte b2 = 128; // 编译错误，超过范围
5
    byte b6 = b1 + 1; // 编译错误，右边不是常量
6

7
    // 运算时提升为int
8
    short s1 = 1;
9
    short s2 = 2;
10
    short s3 = s1 + s2; // 编译失败，因为运算结果为int，不能赋值给更小的类型
11
    int i = s1 + s2;  // 编译成功
12
    s3 = (short) (s1 + s2);  // 编译成功
13
}
14

3. 关于编码问题

字符编码大致可分为Unicode编码和非Unicode编码，不同编码对应了不同的存储格式：

1) Unicode编码

Unicode编码为全球约110万字符分配的的唯一数字编号，编号范围为ox0000～0x10FFFF。

大部分常见的字符都在ox0000～0xFFFF之间，大部分常见的中文字符在ox4E00～ox9FFF之间，如"马"的Unicode编码为U+9A6C。

Unicode编码只是给字符编号，但未说明其二进制形式的编号如何存储，存储方式主要有如下三种：

• UTF-32：所有字符以 4 字节存储，非常浪费空间，使用较少。

• UTF-16：小编号字符(U+0000～U+FFFF)使用两字节存储，大编号字符(U+10000～U+10FFFF)使用四字节存储，但依然浪费空间。

• UTF-8：灵活采用1~4个字节进行存储，使用最为广泛。例如"马"的Unicode编号为U+9A6C，对应的二进制值是1001 101001 101100，格式为三字节格式，因此UTF-8编码为11101001 10101001 10101100，十六进制表示为0xE9A9AC。

  • 编号在0x00～0x7F(0～127)之间的使用单字节存储，兼容ASCII码，格式为0xxxxxxx；

  • 编号在0x80～0x7FF(128～2047)之间的使用双字节存储，格式为110xxxxx 10xxxxxx；

  • 编号在0x800～0xFFFF(2048～65535)之间的使用三字节存储，格式为1110xxxx 10xxxxxx 10xxxxxx；

  • 编号在0x10000~0x10FFFF(65536及以上)之间的使用四字节存储，格式为11110xxx 10xxxxxx 10xxxxxx 10xxxxxx。

提示：

1. 如果第一个字节存储二进制编号的最高位则称为"大端"字节序，如果存储最低位则称为"小端"字节序。

2. UTF-8-BOM：默认情况下，文件不会声明自身的编码格式，但UTF-8编码的文本文件，可以设置前三个字节为0xEF0xBB0xBF来表示当前文件为UTF-8文件，这三个字节被称为BOM(ByteOrder Mark)头，支持UTF-8-BOM格式的文件编辑器可自动识别。

2) 非Unicode编码

• ASCII：中文名称为“美国信息互换标准代码”，单字节编码，最高位固定为0，剩余7位可表示127个符号。其中用第32-126位表示可打印字符，第0-31和127位表示不可打印字符(一般用于控制目的)。ASCII码是最基本的编码，其它非Unicode编码和UTF-8编码都兼容它。

• ISO-8859-1(Latin-1)：单字节编码，256个字符，第0-127与ASCII码兼容，第128-159表示一些控制字符，160-255表示一些西欧字符。

• Windows-1252：单字节编码，是ISO-8859-1的替代版本，将128-159位修改为了一些常用的可打印字符。注意：平时所说的ISO-8859-1编码实际上就是Windows-1252编码。

• GB2312：双字节编码，如果两个字节最高位都为0则表示ASCII码，如果都为1则表示中文字符，高位字节范围是0xA1～0xF7，低位字节范围是0xA1～0xFE，包括约7000个汉字和一些罕用词和繁体字。

• GBK：双字节编码，在GB2312的基础上发展而来，高位字节范围是0x81～0xFE，低位字节范围是0x40～0x7E和0x80～0xFE，额外添加了14000多个中文字符(注意：低字节从0x40开始的，中文字符的低字节最高位有可能为0，因此解析二进制时如果碰到最高位为1的字符，则将连续的两个字节视为一个字符，下一个字符从第三个字节开始解析)。

• GB18030：二/四字节编码，在GBK的基础上发展而来，额外添加了55000多个字符，包括了很多少数民族字符以及中日韩统一字符。它的二字节编码与GBK一致，四字节编码中，第一/三字节的值为0x81～0xFE，第二/四字节的值为0x30～0x39。在解析二进制时，如果判断第二个字节范围为0x30～0x39，则将连续的四个字节视为一个字符，下一个字符从第五个字节开始解析。

• Big5：双字节编码，高位字节范围是0x81～OxFE，低位字节范围是0x40～0x7E和0xA1～0xFE，包括13000多个繁体字，广泛用于我国台湾地区和我国香港特别行政区等地。

3) 乱码原因

字符乱码主要有两种原因：

• 使用了错误的编码进行解析：例如使用UTF-8编码存储的文件使用GBK格式解析查看，就可能出现乱码，这时候，只需要切换正确的编码查看格式就可以解决乱码问题了。

• 错误的解析和编码转换：一些程序为了方便统一处理，经常会将所有编码转换为同一种格式(最常用的为UTF-8)，在转换的时候需要知道原来的编码是什么，但可能会搞错，一旦搞错，就会将二进制弄乱，这时候使用任何编码查看都不管用了。

   

4) Java内部字符处理

在Java内部(内存中)进行字符处理时，采用的都是Unicode编码，具体编码格式是UTF-16BE。

进行字符处理时的基础类型是char，其它的Character、String、StringBuilder都是基于char类型的。

char本质上是一个固定占用两个字节的无符号正整数，这个正整数对应于Unicode编号，用于表示那个Unicode编号对应的字符。

由于char固定占用两个字节，只能表示Unicode编号在65536以内的字符，而不能表示超出范围的字符，超出范围的字符得使用两个char。

5
1
char c = 'A'; // 将'A'的Unicode编号(0x65)赋值给变量c
2
char c = '马';  // 将'马'的Unicode编号(0x9a6c)赋值给变量c
3
char c = 0x9a6c;  // 将Unicode编号0x9a6c('马')赋值给变量c
4
char c = 39532;  // 将Unicode编号39532('马')赋值给变量c
5
char c = '\u9a6c';  // 将Unicode编号\u9a6c('马')赋值给变量c

注意：

1. 如果使用字面量'马'进行赋值，使用不同的编码格式打开文件可能看到不同的显示效果。

2. 推荐JAVA文件采用UTF-8格式，并采用UTF-8格式进行编译。

第三节 运算符

1. 支持的运算符

2.使用注意事项

1. 整数的除法运算，将会丢弃余数，例如1/2=0。

2. 负数的取余运算，结果的正负始终与前一个操作数相同，例如-3%2==-1，3%-2==1。

3. 复合赋值运算符中隐含了一个强制类型转换，例如short s = 1; s = s + 1;会报错，而s += 1;却不会。

4. 【重要】对于&和|运算符，如果两边为布尔型，则执行不短路的逻辑运算，如果为int型，则执行按位与和按位或。

第四节 流程控制

1. 分支语句

30
1
//if语句
2
public static void main(String[] args) {
3
    int score = 79;
4
    if (score < 60) {
5
        System.out.println("不及格");
6
    } else if (score < 80) {
7
        System.out.println("及格");
8
    } else {
9
        System.out.println("优秀");
10
    }
11
}
12

13
// switch语句
14
public static void main(String[] args) {
15
    String level = "及格";
16
    switch (level) {
17
        case "不及格":
18
            System.out.println("score<60分");
19
            break;
20
        case "及格":
21
            System.out.println(" score>=60分且score<80分");
22
            break;
23
        case "优秀":
24
            System.out.println("score>=80分");
25
        default:
26
            System.out.println("输入错误!");
27
            break;
28
    }
29
}
30

注意：

1. switch语句支持的数据类型有整型、字符串、枚举。

2. 如果case语句的后面不写break语句，将出现穿透现象。

2. 循环语句

24
1
// for循环
2
public static void main(String[] args) {
3
    for (int i = 0; i < 5; i++) {
4
        System.out.println("i = " + i);
5
    }
6
}
7
  
8
// while循环  
9
public static void main(String[] args) {
10
    int i = 0;
11
    while (i < 5) {
12
        System.out.println("i = " + i);
13
        i++;
14
    }
15
}
16

17
// do-while循环
18
public static void main(String[] args) {
19
    int i = 0;
20
    do {
21
        System.out.println("i = " + i);
22
        i++;
23
    } while (i < 5);
24
}

提示：

1. do-while循环至少会被执行一次，可以用do{}while(flase)来实现goto语句。

3. break和continue

break可用于跳出本层循环或结束switch语句，continue可用于结束本次循环。

22
1
// break
2
public static void main(String[] args) {
3
    for (int i = 1; i<=10; i++) {
4
        // 打印完两次HelloWorld之后结束循环
5
        if(i == 3){
6
          break;
7
        }
8
        System.out.println("HelloWorld"+i);
9
    }
10
}
11

12
// continue
13
public static void main(String[] args) {
14
    for (int i = 1; i <= 10; i++) {
15
        // 不打印第三次HelloWorld
16
        if(i == 3){
17
          continue;
18
        }
19
        System.out.println("HelloWorld"+i);
20
    }
21
}
22

第五节 数组

1. 数组的基本使用

41
1
public class ArrayTest {
2
    public static void main(String[] args) {
3
        // 1. 定义Integer数组 (int数组后面不好降序排序)
4
        Integer[] arr = {2, 34, 35, 4, 657, 8, 69, 9};
5
        Integer[] arr2 = {2, 34, 35, 4, 657, 8, 69, 9};
6

7
        // 2. 打印数组地址值
8
        System.out.println(arr); // [I@2ac1fdc4
9

10
        // 2. toString
11
        System.out.println(Arrays.toString(arr)); // [2, 34, 35, 4, 657, 8, 69, 9]
12

13
        // 3. 排序、并行排序
14
        Arrays.sort(arr);  // 默认升序(按字典)
15
        Arrays.sort(arr2, Collections.reverseOrder()); // 降序
16
        Arrays.sort(arr, (o1, o2) -> o2 - o1);  // 降序
17
        Arrays.parallelSort(arr2); // 并行排序
18

19
        // 4. 比较数组是否相等
20
        // 数组元素逐个比较， 注意区分：arr.equals(arr2)比较的是地址
21
        boolean isSame = Arrays.equals(arr, arr2);
22

23
        // 5. 二分查找
24
        // 查到了返回索引位置(>=0)，未查找返回-插入点-1(<0)
25
        int index = Arrays.binarySearch(arr, 3); // -2
26

27
        // 6. 拷贝数组
28
        Integer[] copyArr = Arrays.copyOf(arr, arr.length + 1); // 第二个参数为新数组长度
29
        Integer[] copyArr1_3 = Arrays.copyOfRange(arr, 1, 3); // 拷贝索引1-3的两个元素
30

31
        // 7. 填充元素
32
        Arrays.fill(arr, 0); // arr -> [0, 0, 0, 0, 0, 0, 0, 0]
33

34
        // 8. 转换为List(只读)
35
        List<Integer> integerList = Arrays.asList(arr2);
36

37
        // 9. 转化为Stream
38
        Stream<Integer> integerStream = Arrays.stream(arr2);
39
    }
40
}
41

2. 多维数组

18
1
public static void main(String[] args) {
2
    // 二维数组
3
    int[][] arr = new int[2][3];
4
    for (int i = 0; i < arr.length; i++) {
5
        for (int j = 0; j < arr[i].length; j++) {
6
            arr[i][j] = i + j;
7
        }
8
    }
9

10
    // 三维数组
11
    int[][][] arr02 = new int[10][10][10];
12

13
    // 多维数组本质上还是一维数组，只是一位数组的元素又是一个数组，并且这些子数组的长度可以不相同
14
    int[][] arr03 = new int[2][];
15
    arr03[0] = new int[3];
16
    arr03[1] = new int[5];
17
}
18
    

3. Arrays工具类

java.util.Arrays 类包含用来操作数组的各种方法，比如排序和搜索等。其所有方法均为静态方法，调用起来非常简单。

17
1
public static void main(String[] args) {
2
    // 定义Integer数组 (int数组后面不好降序排序)
3
    Integer[] arr = {2, 34, 35, 4, 657, 8, 69, 9};
4

5
    // 打印数组地址值
6
    System.out.println(arr); // [I@2ac1fdc4
7

8
    // 打印数组内容
9
    System.out.println(Arrays.toString(arr)); // [2, 34, 35, 4, 657, 8, 69, 9]
10

11
    // 排序 
12
    Arrays.sort(arr);  // 默认升序
13
    Arrays.sort(arr, (o1, o2) -> o2 - o1);  // 降序
14

15
    System.out.println("排序后:" + Arrays.toString(arr)); // 排序后:[657, 69, 35, 34, 9, 8, 4, 2]
16
}
17

第六节 方法

1. 方法的基本使用

10
1
// 定义 
2
public static void method01() {
3
   System.out.println("method01......");  
4
}
5

6
public static void main(String[] args) {
7
    // 调用 
8
    method01();
9
}
10
    

2. 方法重载

方法重载是指在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同即可。参数列表不同可以是参数个数不同、参数类型不同和参数的顺序不同三种形式。

4
1
// 参数顺序不同
2
public void open(double a,int b){} 
3
public void open(int a,double b){} 
4

注意：方法重载与参数的名称以及返回值类型无关。

3. 可变参数

方法的最后一个参数可以定义为可变参数，同时支持数组和可变参数形式的传参。

18
1
public static void main(String[] args) {
2
    // 可变参数形式传参
3
    int sum01 = sum(6, 7, 2, 12, 2121);
4

5
    // 数组形式传参
6
    int[] arr = {1, 4, 62, 431, 2};
7
    int sum02 = sum(arr);
8
}
9

10
// 使用可变参数的方法
11
public static int sum(int... arr) {
12
    int sum = 0;
13
    for (int a : arr) {
14
        sum += a;
15
    }
16
    return sum;
17
}
18

注意：

1. 可变参数形式与数组形式的方法定义相互冲突，只能保留一个。

2. 形参格式使用数组形式的方法则只能通过数组传参。

第02章_面向对象

面向对象的三大基本特征：封装、继承、多态。

第一节 类与对象

1.基本使用

类是一组相关属性和行为的集合，对象是一类事物的具体体现。

57
1
// 定义一个类
2
public class Student {
3
    /*  成员变量  */
4
    private String name;
5
    private int age;
6

7
    /*  无参数构造方法  */
8
    public Student() {
9
    }
10

11
    /*  全参数构造方法  */
12
    public Student(String name, int age) {
13
        this.name = name;
14
        this.age = age;
15
    }
16

17
    /*  成员方法  */
18
    public void study() {
19
        System.out.println("好好学习，天天向上");
20
    }
21

22
    /*  getter/setter方法  */
23
    public String getName() {
24
        return name;
25
    }
26
    public void setName(String name) {
27
        this.name = name;
28
    }
29
    public int getAge() {
30
        return age;
31
    }
32
    public void setAge(int age) {
33
        this.age = age;
34
    }
35
}
36

37

38
// 使用类
39
public class Test01_Student {
40
    public static void main(String[] args) {
41
        // 创建对象 
42
        Student student = new Student();
43

44
        // 获取成员变量
45
        System.out.println("姓名：" + student.getName()); //null
46
        System.out.println("年龄：" + student.getAge()); //0
47
        System.out.println("‐‐‐‐‐‐‐‐‐‐");
48

49
        // 设置成员变量
50
        student.setName("赵丽颖");
51
        student.setAge(18);
52

53
        // 调用成员方法
54
        student.study(); // "好好学习，天天向上"
55
    }
56
}
57

注意：可以通过this关键字来显示指明需要访问成员变量，来区分同名的局部变量。

2. 权限修饰符

权限修饰符可以用来修改类、方法、属性等的访问权限，体现了面向对象的封装性。

1. public：公有的，对所有人开放，无访问限制。

2. protected：被保护的，对同包和其子类开放。

3. [default]：默认值(缺省值)，对同包开放。

4. private：私有的，仅对所属类开放。

注意：

1. 一般将类定义为public，此时要求文件名和类名保持一致；如果定义为[default]，则仅有同包中才能访问该类。

2. 一般将成员变量定义为private，并提供相应的Getter/Setter方法和构造器。

3. 不能对父类的private方法进行重写。

3. static修饰符

static可以用来修饰变量、方法、代码块、内部类等，被修饰的内容保存在静态区(方法区的一部分)，随着类的加载而加载，且只加载一次，加载后被所有对象共享，一般用类名进行调用。

44
1
public class Student {
2
    private Integer id;
3
    private String name;
4
    private static Integer stuCount;  // 静态变量
5

6
    static {
7
        System.out.println("---静态代码块---");
8
        stuCount = 0;
9
    }
10

11
    {
12
        System.out.println("---构造代码块---");
13
        this.id = null;
14
        this.name = null;
15
    }
16

17
    public Student(String name) {
18
        System.out.println("---构造函数---");
19
        this.name = name;
20
        this.id = ++stuCount; // 通过 stuCount 给学生分配学号
21
    }
22

23
    public void showStudent() {
24
        {
25
            System.out.println("---普通代码块---");
26
            System.out.println("Student : id = " + id + ", name = " + name);
27
        }
28
    }
29

30
    public static void showStuCount() {
31
        System.out.println("---静态方法---");
32
        System.out.println("stuCount：" + stuCount);
33
    }
34

35
    public static void main(String[] args) {
36
        System.out.println("---Main---");
37

38
        Student student = new Student("张三");
39
        Student student2 = new Student("李四");
40
        student.showStudent();
41
        Student.showStuCount();
42
    }
43
}
44

注意：

1. 静态属性和静态方法一般使用类名来调用，虽然也可以通过对象来调用，但不推荐。

2. 静态方法和静态代码块只能访问类中的静态变量，不能直接访问普通成员变量或成员方法。

3. 除静态代码块外，Java中还有构造代码块，它们的执行顺序为：静态代码块->Main函数->构造代码块->构造函数->普通代码块。

4. 在Java1.7后，静态代码块不能存在于主类中，防止干扰main函数的执行。

5. 关于静态内部类的使用请参考内部类章节。

4. final修饰符

final表示不可改变，可以用于修饰类、方法和变量等，分别具有不同的含义。

16
1
// 1) finnal修饰的类不能被继承
2
final public class FinalClass {
3

4
    // 2) final修饰的变量不能被重新赋值，必须在声明时或构造函数中初始化
5
    final public Integer id;
6

7
    public FinalClass(Integer id) {
8
        this.id = id; // 初始化final变量
9
    }
10

11
    // 3) finnal修饰的方法不能被重写
12
    final public void finalMethod() {
13

14
    }
15
}
16

注意：

1. 被final修饰的静态变量一般称为常量，通常使用大写字母+下划线的形式命名。

2. 必须保证类当中所有重载的构造方法，最终都会对final变量进行赋值。

第二节 继承与多态

1. 继承的基本使用

继承指子类继承父类的特征和行为，使子类对象具有父类的实例域和方法，不仅复用了代码，而且使不同子类的对象能够被统一处理。

36
1
public class Base {
2
    String name;  // 父类变量
3

4
    public Base(String name) {
5
        this.name = name;
6
    }
7

8
    public void parentShow() {
9
        System.out.println("I am " + name + ".");
10
    }
11
}
12

13

14
public class ChildA extends Base {
15
    String name;  // 子类同名变量
16

17
    public ChildA(String parentName, String childName) {
18
        // 调用父类构造
19
        super(parentName);
20
        this.name = childName;
21
    }
22

23
    public void childShow() {
24
        // 使用super关键字调用父类同名变量
25
        System.out.println("I am " + name + ", parent is " + super.name);
26
    }
27
}
28

29

30
public class Test {
31
    public static void main(String[] args) {
32
        ChildA childA = new ChildA("小头爸爸", "大头儿子");
33
        childA.parentShow(); // I am 小头爸爸.
34
        childA.childShow();  // I am 大头儿子, parent is 小头爸爸
35
    }
36
}

注意：

1. Java只支持单继承，一个类只能有一个父类，并且最终都继承自java.lang.Object类。

2. 构造子类对象前必须先构造父类对象，如果父类没有无参构造，则必须在子类构造器的首行通过super显式调用有参构造。

3. 不建议在构造方法中调用非private方法，特别是可被子类重写的方法，这将带来不必要的麻烦。

4. 在子类中，可以使用super关键字来显式调用父类属性或方法。

5. 子类初始化顺序为：基类静态代码块->子类静态代码块->基类实例代码块->基类构造方法->子类实例代码块->子类构造方法。

2. 方法重写与动态绑定

方法重写指在子类中覆盖父类的实例方法，以此来实现子类的特异性功能，其要求方法名、参数列表和返回值完全一致，一般使用@Override注解标识。由于实例方法可能被重写，因此采用动态绑定方式，实际调用的方法取决于对象的动态类型。

37
1
public class Base {
2
    public Base(String name) {
3
        this.name = name;
4
    }
5

6
    // 父类待重写方法
7
    public void print(){
8
        System.out.println("--- Base print() ---");
9
    }
10
}
11

12

13
public class ChildA extends Base {
14
    public ChildA(String parentName, String childName) {
15
        super(parentName);
16
        this.name = childName;
17
    }
18
    
19
    // 子类重写方法
20
    @Override
21
    public void print() {
22
        System.out.println("--- ChildA print() ---");
23
    }
24
}
25

26

27
public class Test {
28
    public static void main(String[] args) {
29
        ChildA childA = new ChildA("小头爸爸", "大头儿子");
30
        Base base = childA;
31
        
32
        // 动态绑定(取决于动态类型，即为.号右边的类型)
33
        base.print();  // --- ChildA print() ---
34
        childA.print();  // --- ChildA print() ---
35
    }
36
}
37

注意：

1. 使用final修饰的类不能被继承，使用final修饰的方法不能被重写，可用于加强封装性。

2. 使用向下转型时可以先用instanceof关键字进行判断是否是某个类的子类，避免ClassCastException。

3. 重名与静态绑定

子类还可以定义与父类重名的变量或静态方法，其采用静态绑定(编译期绑定)方式，实际调用取决于对象的静态类型。

44
1
public class Base {
2
    // 父类公有变量
3
    public String name;
4

5
    public Base(String name) {
6
        this.name = name;
7
    }
8

9
    // 父类静态方法
10
    public static void staticShow() {
11
        System.out.println("--- Base staticShow() ---");
12
    }
13
}
14

15

16
public class ChildA extends Base {
17
    // 子类同名的公有变量
18
    public String name;
19

20
    public ChildA(String parentName, String childName) {
21
        super(parentName);
22
        this.name = childName;
23
    }
24

25
    // 子类同名的静态方法
26
    public static void staticShow() {
27
        System.out.println("--- ChildA staticShow() ---");
28
    }
29
}
30

31

32
public class Test {
33
    public static void main(String[] args) {
34
        ChildA childA = new ChildA("小头爸爸", "大头儿子");
35
        Base base = childA;
36

37
        // 静态绑定(取决于静态类型，即为.号左边的类型)
38
        System.out.println(base.name); // 小头爸爸
39
        System.out.println(childA.name); // 大头儿子
40
        Base.staticShow(); // --- Base staticShow() ---
41
        ChildA.staticShow(); // --- ChildA staticShow() ---
42
    }
43
}
44

注意：

1. 此处所说的重名指方法名(变量名)与参数列表皆相同，而非方法重载的情形(重载始终优先于重写)。

第三节 接口

1. 定义接口

接口是Java提供的一种的引用类型，其中可以定义常量、抽象方法、默认方法和静态方法(JDK 8)以及私有方法(JDK 9)等。

22
1
public interface InterfaceA {
2
    // 常量
3
    public static final int NUM_OF_MY_CLASS = 12;  //必须进行初始化
4
    
5
    // 抽象方法(使用 public abstract 修饰，可以省略，没有方法体，非抽象子类必须实现该方法)
6
    void abstractMethod();
7

8
    // 默认方法(使用 default 修饰，default不可省略，供子类调用或者子类选择性重写)
9
    // JDK8之前一般通过抽象类实现
10
    default void defaultMethod() {
11
    }
12

13
    // 静态方法(使用 static 修饰，通过接口直接调用)
14
    // JDK之前，相关的静态方法往往定义在单独的类中，比如，Collection接口有一个对应的单独的类Collections
15
    static void staticMethod() {
16
    }
17

18
    // 私有方法(JDK9)(使用 private 修饰，供接口中的其它方法调用)
19
    private void privateMethod() {
20
    }
21
}
22

接口也可以继承其它接口，并且能够同时继承多个，如果父接口中有重名的方法，那么子接口中只需要重写一次。

18
1
// 接口1
2
public interface A1 {
3
    void compare();
4
}
5

6
// 接口2
7
public interface A2 {
8
    void compare();
9
}
10

11
// 类B继承接口1和接口2
12
public interface B extends A1, A2 {
13
    @Override
14
    default void compare() {
15

16
    }
17
}
18

注意：

1. 接口中只可以定义public static final修饰的常量，且不可以定义任何变量。

2. 接口中没有静态代码块、构造方法，不能实例化对象。

2. 实现接口

一个类可以实现多个接口，一个接口也可以被多个类实现。

8
1
// 类C实现接口1和接口2
2
public class C implements A1, A2 {
3
    @Override
4
    public void compare() {
5
        
6
    }
7
}
8

类在继承基类的同时，也可以实现一个或多个接口，但要求extends关键字在implements之前。

3
1
public class Child extends Base implements IChild {
2
}
3

注意：

1. 如果实现类不是抽象类，则必须实现接口的所有抽象方法。

2. 子接口在重写默认方法时，default关键字可以保留，而子类重写默认方法时，不可以保留，因为类中不存在默认方法。

3. 如果继承来的方法和接口的默认方法重名，则子类会优先使用继承来的方法，即继承优于实现。

3. 使用接口

11
1
public static void main(String[] args) {
2
    // 调用接口声明的方法
3
    InterfaceAImpl interfaceA = new InterfaceAImpl();
4
    interfaceA.abstractMethod();
5

6
    // 判断是否继承某个接口
7
    if (interfaceA instanceof InterfaceA) {
8
        System.out.println("instanceof InterfaceA");
9
    }
10
}
11

4. 接口+组合替代继承

继承至少有两个好处：一个是复用代码；另一个是利用多态和动态绑定统一处理多种不同子类的对象。使用组合替代继承，可以复用代码，但不能统一处理。使用接口替代继承，针对接口编程，可以实现统一处理不同类型的对象，但接口没有代码实现，无法复用代码。将组合和接口结合起来替代继承，就既可以统一处理，又可以复用代码了。

如下例，Child复用了Base的代码，又都实现了IAdd接口，这样，既复用代码，又可以统一处理，还不用担心破坏封装。

26
1
public interface IAdd {
2
    void add(int number);
3
}
4

5

6
public class Base implements IAdd {
7
    @Override
8
    public void add(int number) {
9
        System.out.println("---Base.add()---");
10
    }
11
}
12

13

14
public class Child implements IAdd {
15
    private Base base;  // 组合
16

17
    public Child() {
18
        base = new Base();
19
    }
20

21
    @Override
22
    public void add(int number) {
23
        base.add(number);  // 复用
24
    }
25
}
26

第四节 抽象类

1. 抽象类的定义和使用

抽象类指使用abstract修饰的类，一般存在抽象方法。抽象方法指只有方法声明，但没有方法体的方法。

26
1
// 抽象类
2
public abstract class Shape {
3
    // 抽象方法
4
    public abstract void draw();
5
}
6

7
// 子类
8
public class Circle extends Shape {
9
    // 实现抽象方法
10
    @Override
11
    public void draw() {
12
        System.out.println("---画圆---");
13
    }
14
}
15

16
// 测试
17
public class Test {
18
    public static void main(String[] args) {
19
        // 创建子类对象
20
        Shape shape = new Circle();
21

22
        // 调用子类方法
23
        shape.draw();
24
    }
25
}
26

注意：

1. 抽象类的子类，必须重写抽象父类中所有的抽象方法，除非该子类也是抽象类。

2. 抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。

3. 抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

2. 抽象类和接口

抽象类和接口经常配合使用，接口定义能力，而抽象类提供默认实现，方便子类实现接口，如List接口对应AbstractList，Map接口对应AbstractMap等。它们之间的对比如下：

第五节 内部类

1. 成员内部类

成员内部类指定义在其它类内部的类，如List返回的Iterator对象等，适用于与外部类关系密切且需要访问外部类实例的变量或方法的类。

34
1
public class Outer {
2
    private int a = 100;
3

4
    // 成员内部类
5
    public class Inner {
6
        public void innerMethod() {
7
            System.out.println("outer a " + a);
8

9
            // 访问外部类变量或方法 Outer.this.xxx
10
            Outer.this.action();
11
        }
12
    }
13

14
    private void action() {
15
        System.out.println("action");
16
    }
17

18
    public void test() {
19
        // 在外部类中使用成员内部类
20
        Inner inner = new Inner();
21
        inner.innerMethod();
22
    }
23
}
24

25

26
public class Test {
27
    public static void main(String[] args) {
28
        // 在其他类中使用成员内部类
29
        Outer.Inner inner = new Outer().new Inner();
30
        inner.innerMethod();
31
    }
32
}
33

34

注意：

1. 如需创建成员内部类对象，则必须先创建外部类对象，成员内部类会保存外部类对象的引用。

2. 内部类在编译后会生成独立的.class文件，类名用$进行分隔，如Body$Heart.class。

3. 如果在内部类中访问了外部类的私有变量或方法，则在编译时会被替换为[default]权限的access$0系列方法。

4. 外部类只可以用public或[default]修饰，但内部类还额外支持private和protected修饰符。

5. 接口也可以定义内部接口和内部抽象类等，了解即可。

2. 静态内部类

静态内部类指定义在其它类内部的静态类，如LinkedList类内部的Node类等，适用于与外部类关系密切但不依赖于外部类实例的类。

25
1
public class Outer {
2
    private static int shared = 100;
3

4
    // 静态内部类
5
    public static class StaticInner {
6
        public void innerMethod() {
7
            System.out.println("inner " + shared);
8
        }
9
    }
10

11
    public void test() {
12
        // 在外部类使用静态内部类
13
        StaticInner si = new StaticInner();
14
        si.innerMethod();
15
    }
16
}
17

18
public class Test {
19
    public static void main(String[] args) {
20
        // 在其他类使用静态内部类
21
        Outer.StaticInner staticInner = new Outer.StaticInner();
22
        staticInner.innerMethod();
23
    }
24
}
25

注意：

1. 创建静态内部类对象时不依赖外部类对象，因此它只能访问外部类的静态变量和方法，不可以访问实例变量和方法。

2. 静态内部类除了可以定义成员方法、成员变量、构造方法、静态final变量等，还额外支持静态变量和静态方法。

3. 方法内部类

方法内部类指定义在方法内部的类，方法可以是成员方法或静态方法，适用于只在当前方法中使用该类的场景。

24
1
ppublic class Outer {
2
    private int a = 100;
3

4
    public void test(final int param) {
5
        final String str = "hello";
6

7
        // 方法内部类
8
        class Inner {
9
            public void innerMethod() {
10
                // 访问外部类变量或方法
11
                System.out.println("outer a " + a);
12

13
                // 访问方法参数或局部变量
14
                System.out.println("param " + param);
15
                System.out.println("local var " + str);
16
            }
17
        }
18

19
        // 在方法内部使用方法内部类
20
        Inner inner = new Inner();
21
        inner.innerMethod();
22
    }
23
}
24

注意：

1. 如需在方法内部类中访问方法参数或局部变量，则该变量必须是final的，或等效final的(因为该变量是通过构造参数直接传入)。

2. 方法内部类不能写任何权限修饰符。

4. 匿名内部类

匿名内部类指定义在方法内部的匿名类，它没有类名和构造方法，且只能在定义类时创建对象，适用于接口回调的场景。

13
1
public class Outer {
2
    public void sortIgnoreCase(String[] strs) {
3
        // 使用匿名内部类创建的对象
4
        Arrays.sort(strs, new Comparator<String>() {
5
            @Override
6
            public int compare(String o1, String o2) {
7
                return o1.compareToIgnoreCase(o2);
8
            }
9
        });
10
    }
11
}
12

13

注意：

1. 匿名内部类可以定义实例变量、实例方法、初始化代码块、参数列表等，其中参数列表将会传递给父类的构造方法。

2. 与方法内部类一样，匿名内部类也可以访问外部类的变量和方法，可以访问等效final的方法参数和局部变量。

第六节 枚举类

枚举(enum)是一种特殊的类，它只有类中声明的有限个对象，对象名称一般大写。

1. 基本枚举类

43
1
// 定义枚举
2
public enum Size {
3
    // 该枚举有三个对象
4
    SMALL, MEDIUM, LARGE
5
}
6

7
// 使用枚举
8
public class Test {
9
    public static void main(String[] args) {
10
        // 获取单个枚举对象
11
        Size size = Size.SMALL; // 直接获取
12
        Size size2 = Size.valueOf("SMALL");  // 使用字面值获取
13

14
        // 枚举对象的字面值、序号
15
        System.out.println(size.toString()); // SMALL，等同name()
16
        System.out.println(size.name());  // SMALL
17
        System.out.println(size.ordinal());  // 0
18

19
        // 枚举对象进行比较
20
        System.out.println(size == Size.SMALL);  // true
21
        System.out.println(size.equals(Size.SMALL));  // true
22
        System.out.println(size.compareTo(Size.MEDIUM));  // -1  比较ordinal值
23

24
        // 获取所有枚举对象 .values()
25
        for (Size item : Size.values()) {
26
            System.out.println(item);
27
        }
28

29
        // switch使用枚举
30
        switch (size) {
31
            case SMALL:
32
                System.out.println("chosen small");
33
                break;
34
            case MEDIUM:
35
                System.out.println("chosen medium");
36
                break;
37
            case LARGE:
38
                System.out.println("chosen large");
39
                break;
40
        }
41
    }
42
}
43
    

2. 带成员的枚举类

枚举类可以定义自己的成员变量、成员方法以及继承接口等。

48
1
// 接口
2
public interface ExceptionMessage {
3
    String getCode();
4
    String getMessage();
5
    ExceptionLevel getLevel();
6
}
7

8
// 继承接口的枚举
9
public enum KfmsExceptionMessage implements ExceptionMessage {
10
    // 枚举对象
11
    ERR_NOT_SUPPORTED("-99", "暂不支持", ExceptionLevel.NORMAL),
12
    ERR_DEFAULT("-1", "未知异常", ExceptionLevel.NORMAL),
13
    ERR_RTMSG_OK("0", "业务程序运行正常", ExceptionLevel.NORMAL);
14

15
    // 定义的变量
16
    private String code;
17
    private String message;
18
    private ExceptionLevel level;
19

20
    // 构造器，用于上述枚举对象的构造
21
    KfmsExceptionMessage(String code, String message, ExceptionLevel level) {
22
        this.code = code;
23
        this.message = message;
24
        this.level = level;
25
    }
26

27
    // 实现接口方法
28
    @Override
29
    public String getCode() {
30
        return this.code;
31
    }
32
    @Override
33
    public String getMessage() {
34
        return this.message;
35
    }
36
    @Override
37
    public ExceptionLevel getLevel() {
38
        return this.level;
39
    }
40

41
    // 重写抽象类Enum<T>中的方法
42
    @Override
43
    public String toString() {
44
        return this.message;
45
    }
46
    
47
}
48