第01篇_Java基础

第01章_基础语法

第一节 快速入门

1. Java语言简介

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

2. JDK/JRE与JVM

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

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

JVM(Java Virtual Machine)：指Java虚拟机，用于运行 Java 字节码，常见的有HotSpot JVM、GraalVM、Android Runtime (ART)等。

扩展：

1. HotSpot JVM 分为 Oracle HotSpot JVM 和 OpenJDK HotSpot JVM ，后者又衍生了一些发行版，如：BishengJDK。

2. OpenJDK 是完全开源免费的，而Oracle JDK 是商业收费的，JDK8u221 是其最后一个永久免费版本，后续版本只免费使用3年。

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

5. 面试补充

1) 编译流程

Java源文件经过javac命令编译后，生成.class字节码文件，字节码文件可被虚拟机解释执行。

扩展：

1. 使用字节码的好处：在一定程度上解决了解释型语言执行效率低的问题，又保留了解释型语言可移植的特点。

2) JIT和AOT

JIT（Just in Time Compilation）：运行时编译，在第一次编译后，将字节码对应的机器码保存下来，下次可以直接使用。

AOT(Ahead of Time Compilation)：提前编译，在程序被执行前就将其编译成机器码，属于静态编译。

• 可以提高 Java 程序的启动速度，减少内存占用和增强 Java 程序的安全性（反编译难），特别适合云原生场景。

• 无法支持 Java 的一些动态特性，如反射、动态代理、动态加载、JNI（Java Native Interface）等。

3) Java vs C++

• Java 和 C++ 都是面向对象的语言，都支持封装、继承和多态。

• Java 有自动内存管理和垃圾回收机制，C++ 通过指针访问内存。

• Java 类不支持多继承，只有接口能够支持多继承。

• Java泛型的本质是“类型擦除”，而C++模板的本质是“编译时展开”。

• Java 不支持操作符重载、友元、宏函数等复杂特性。

第二节 数据类型

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格式进行编译。

4. 关于浮点数精度丢失问题

浮点数在转换为二进制时，可能出现无限循环，如 0.2 -> 001100110011...，因此存储时可能会被截断，出现精度损失：

7
1
// 乘2取整法
2
0.2 * 2 = 0.4 -> 0
3
0.4 * 2 = 0.8 -> 0
4
0.8 * 2 = 1.6 -> 1
5
0.6 * 2 = 1.2 -> 1
6
0.2 * 2 = 0.4 -> 0（发生循环）
7
...

当浮点数进行运算时，就可能出现下面情况：

5
1
float a = 2.0f - 1.9f;
2
float b = 1.8f - 1.7f;
3
System.out.printf("%.9f",a);// 0.100000024
4
System.out.println(b);// 0.099999905
5
System.out.println(a == b);// false

此时，可以考虑使用 BigDecimal 或 Long 类型(放大N倍)来存储浮点数。

第三节 运算符

1. 支持的运算符

2. 移位运算符

移位运算符将被操作的数据被视为二进制数，移位就是将其向左或向右移动若干位的运算。

• << :左移运算符，向左移若干位，高位丢弃，低位补零。x << n，相当于 x 乘以 2 的 n 次方(不溢出的情况下)。

• >> :带符号右移，向右移若干位，高位补符号位，低位丢弃。正数高位补 0,负数高位补 1。x >> n，相当于 x 除以 2 的 n 次方。

• >>> :无符号右移，忽略符号位，空位都以 0 补齐。

它的优点是高效(移位操作对应硬件指令，一般只需要一个时钟周期)和节省内存(使用一个整数来存储多个布尔值或标志位)，应用场景如：优化乘2或除2操作、使用 int 或 long 存储多个标志位、哈希算法等。

注意：

1. 如果移位位数大于32位(int)/64位(long)，则会对位数取余，例如：int x = 1; x<<42;等同于x<<10。

3.注意事项

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
    

注意：

1. 通过 static 关键字可以定义静态方法，静态方法属于类，可通过类名或对象调用。

2. 静态方法只能访问静态方法和静态变量，而实例方法则没有这个限制。

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. 形参格式使用数组形式的方法则只能通过数组传参。

第七节 面试补充

1. 值传递 vs 引用传递

• 值传递：从实参拷贝一份副本给形参，基本类型拷贝的是值本身，对象类型拷贝的是对象的内存地址。

• 引用传递：实参共享自身地址给形参，修改会相互影响，如 int a = 1; int& p = a;，Java 不支持引用传递。

2. 引用拷贝 vs 浅拷贝 vs 深拷贝

• 引用拷贝：两个引用指向同一个对象实例，一般发生在函数传参;

• 浅拷贝：两个引用指向两个对象实例，但内部引用类型成员指向同一个实例，一般在调用默认 clone 方法时出现。

• 深拷贝：两个引用指向两个对象实例，且其内部的引用类型成员指向不同实例，一般在调用自定义的 clone 方法或序列化+反序列化时出现。

第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变量进行赋值。

5. 面试补充

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

面向对象与面向过程的主要区别如下：

• 面向过程：把解决问题的过程拆成一个个方法，通过调用方法来解决问题，如：吃(我,饭)。

• 面向对象：先抽象出对象，然后使用对象解决问题，这种方式开发效率更高，代码也好维护，如 我.吃(饭)。

第二节 继承与多态

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