Java SE入门

Java 简介

Java 是一门面向对象编程语言, 其特点是:

面向对象三大特征: 封装 继承 多态
面向对象基本概念: 类 对象 方法 属性

常说的 Java 三大版本是:
Java SE(Standard Edition) 标准版, 面向桌面应用的开发环境.
Java EE(Enterprise Edition) 企业版, 面向企业级应用的开发环境.
Java ME(Micro Edition) 微型版, 面向移动终端的开发环境.

开发工具

开发 Java 程序必须先安装好 JDK, JDK 其中也包含了常见的开发工具, 以及 JRE

• JDK(Java Development Kit): 开发工具包, 包含开发环境, 编译器, 类库, 工具等.
• JRE(Java Runtime Environment): 运行环境, 包含 Java 虚拟机(JVM), 类库, 工具等.

在选择版本时, 选择官方指定的长期支持版 LTS 版本(Long Term Support)

官方下载地址

集成开发环境

集成开发环境(Intergrated Development Environment) IDE, 是集成了代码编写功能、分析功能、编译功能、调试功能等一体化集成环境的开发软件.

目前 Java 开发最知名, 最常用的 IDE 就是 Jetbrain 公司出品的Intellij IDEA了.

IntelliJ IDEA 下载
IntelliJ IDEA 激活

IDEA 中有很多快捷键可以提高我们的开发效率，常见的有：

快捷键	功能说明
CTRL + D	复制一行
CTRL + Y	删除当前行
CTRL + ALT + L	格式化代码风格
ALT + SHIFT + ↑，ALT + SHIFT+ ↓	上下移动当前代码
CTRL + /，CTRL + SHIFT + /	注释选中的代码

Java 程序结构

Java 程序通常由以下几部分组成：

• 方法（Method）: 程序最基本的功能单位, 例如计算器上的 ‘+’ 就包含一个求和的方法.
• 类（Class）: 功能相关联的方法放在一起, 就是一个 类.
• 包（Package）: 将类按照功能模块划分到一个个不同目录中, 这些目录称为包.
• 项目/工程（Project）: 最后再把所有的包放到一个目录中管理，整个目录称之为项目或工程.

特别注意程序的入口, main 方法.
程序启动后都会去执行 main 方法, 然后再通过 main 方法调用其它方法.

因此：任何程序都必须写一个main方法，而且 main 方法的写法是固定的：

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

Java 程序运行原理

作为程序员编写的, 是由很多英文单词和符号组成的源代码, 是方便人类读写的.
计算机目前无法直接理解这种语言, 它只能识别简单的指令.

Java 的解决方式是将 程序员写好的 .java 文件, 使用编译器转换为 .class 文件, 让虚拟机 JVM 转换为机器码以可在计算机上运行.

这种提前准备好的指令集, 一旦编译完成, 就可以在没有编译器的帮助下独立运行的语言类型, 我们称之为:

编译型语言

由于 Java 虚拟机的存在, Java 语言可以很轻易地运行在任意平台上.

在 CMD 中, 使用

javac java文件.java

编译 .java 文件
接着使用:

java java文件

将刚刚编译后生成的 .class 文件运行
这就是不使用集成开发环境手动编译和运行的过程.

基本语法

• 关键字: 被 Java 语言赋予特殊含义的单词, 不能作为标识符.
• 保留字: 现在还未被 Java 语言使用, 但以后版本的 Java 语言可能会使用.
• 标识符: 用来命名变量, 方法, 类等要素, 必须以字母或下划线开头, 不能包含空格.

  标识符不能与关键字或保留字相同.

Java 中的命名规范

• 包名: 全部小写, 单词之间用点分隔.
• 类, 接口名: 首字母大写, 驼峰命名法.
• 方法, 变量名: 首字母小写, 驼峰命名法.
• 常量名: 全部大写, 下划线连接.

变量

变量会存储在内存中的一个区域中, 会有具体数值和类型.

变量按数据类型可分为:

基本数据类型:

Java 是一种强类型语言,这意味着我们在使用变量前需要先定义它们的类型.

• 整数类型

类型	字节数	取值范围
byte	1	$-128$ 到 $127$
short	2	$-2^{15}$ 到 $2^{15}-1$
int	4	$-2^{31}$ 到 $2^{31}-1$
long	8	$-2^{63}$ 到 $2^{63}-1$

• 浮点类型

类型	字节数	取值范围	精度
float	4	$3.4 \times 10^{-38}$ 到 $3.4 \times 10^{38}$	7 位
double	8	$2.2 \times 10^{-308}$ 到 $2.2 \times 10^{308}$	15 位

• 布尔类型

类型	字节数	取值范围
boolean	1	true 或 false

• 字符类型

类型	字节数	取值范围
char	2	$0$ 到 $65535$

引用数据类型:

不是基本数据类型的, 都称作引用数据类型.

• String 类

String 不是一个基本类型.是一个真正的类 但是 java 语言对这个类有些特殊处理

String 可用 null 赋值.
String 类是典型的不可变类.

容量小的数据类型在计算时会自动转换为容量大的类型.

byte, short, char 之间不能转换, 他们三者在计算时会自动转换为 int.

Java 在处理 字符串 和 基本类型 时, + 号有特殊处理(方法的重载), 例如拼接字符串等.

运算符

• 算术运算符

类型	运算符	描述
加减乘除	+ - * /	基本的四则运算符
取模	%	左操作数除以右操作数的余数
自增	++	变量加 1 自增在前时先加 1, 再赋值 自增在后时先赋值, 再加 1
自减	--	变量减 1, 与自增同理.

除法运算符 / 结果是 double 类型, 而 int 除以 int 结果是 int 类型.

• 赋值运算符

类型	运算符	描述
赋值	=	简单的赋值运算符
四则赋值(包括取余)	*=, /=, %=, +=, -=	先计算右操作数, 再赋值

• 关系运算符

类型	运算符	描述
等于	==	判断两个对象是否相等
不等于	!=	判断两个对象是否不相等
大于 小于	> <	判断左操作数是否大于右操作数 判断左操作数是否小于右操作数
大于等于 小于等于	>= <=	判断左操作数是否大于等于右操作数 判断左操作数是否小于等于右操作数

关系运算符的结果是 boolean 类型.

• 逻辑运算符

类型	运算符	描述
逻辑与	&&	左右操作数都为 true, 结果为 true
逻辑或	||	左右操作数有一个为 true, 结果为 true
逻辑非	!	取反, 若操作数为 true, 结果为 false, 若操作数为 false, 结果为 true

逻辑运算符的结果是 boolean 类型.

• 位运算符

在编程中使用较少, 但在底层有用.

| 类型 | 运算符 | 描述 |
| ———- | —— | ———————————————————————————————- | ————————————– |
| 按位与 | & | 两个操作数的对应位都为 1, 结果为 1 |
| 按位或 | | | 两个操作数的对应位有一个为 1, 结果为 1 |
| 按位异或 | ^ | 两个操作数的对应位不同时为 1, 结果为 1 |
| 按位取反 | ~ | 反转操作数的每一位, 即 0 变 1, 1 变 0 |
| 左移 | << | 按位左移, 左操作数的各二进位全部左移若干位, 右操作数指定了移动的位数 |
| 右移 | >> | 按位右移, 左操作数的各二进位全部右移若干位, 右操作数指定了移动的位数 |
| 无符号右移 | >>> | 逻辑右移, 左操作数的各二进位全部右移若干位, 右操作数指定了移动的位数, 移动后高位丢弃, 低位补 0 |

• 三目运算符

int result = (判断条件) ? 表达式1 : 表达式2;

控制语句

• 顺序结构:

if (条件) {
    // 语句
} else if (条件) {
    // 语句
} else {
    // 语句
}

• 分支结构:

switch (表达式) {
    case 值1:
        // 语句
        break;
    case 值2:
        // 语句
        break;
    default:
        // 语句
}

• 循环结构:

for (初始化; 条件; 迭代) {
    // 语句
}

while (条件) {
    // 语句
}

do {
    // 语句
} while (条件);

数组

数组是一种存储多个相同类型元素的集合, 数组的声明格式如下:

数据类型[] 数组名 = new 数据类型[数组长度];

类

类: 用来描述具有相同属性和行为的对象的集合.
对象: 类的实例, 具有状态和行为.

类就像一个模板, 而对象就像是根据模板制造出来的具体事物.

类的语法格式

修饰符 class 类名 {
    // 属性声明 (属性, 成员变量, 不用初始化)
    数据类型 变量名;

    // 方法声明 (行为, 方法 也叫函数)
    public 数据类型 方法名(参数列表) {
        // 方法体
    }
}

对象创建

有了 类 这个模板后, 我们就能实例化出具体的对象了.

// 实例化对象
类名 对象名 = new 类名();

// 调用对象的方法
对象名.方法名(参数列表);

类与成员

类的成员（Members）指的是类中定义的所有元素, 它们共同定义了类的功能和属性.

属性

语法格式:

修饰符 数据类型 属性名 = 初始值;

• 修饰符 Public 能使类的属性和方法对其他类可见
• 修饰符 Private 能使类的属性和方法仅对本类可见

所有变量可分为:

• 成员变量: 类中定义的变量, 包括实例成员变量和类成员变量.
• 局部变量: 方法中定义的变量, 仅在方法中有效.

方法

语法格式:

修饰符 返回值类型 方法名(参数列表) {
    // 方法体
}

方法只有被调用时才会执行.

方法的重载

在同一个类中, 允许存在多个同名方法, 只要它们的参数不同.

例如既能计算两位相加,也可计算三位相加:

public int add(int a, int b) {
    return a + b;
}

public int add(int a, int b, int c) {
    return a + b + c;
}

传递可变参数

1. 用数组的方式来传递可变参数:

public void printArray(String[] arr) {
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
}

public static void main(String[] args) {
    String[] arr = {"hello", "world"};
    printArray(arr);
}

2. 用 java 特有的 ... 来传递可变参数 (推荐):

public void printArray(String... arr) {
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
}

public static void main(String[] args) {
    String[] arr = {"hello", "world"};
    printArray(arr);
}

软件包

软件包就像电脑中文件管理的文件夹, 包帮助管理大型软件系统.

包的定义

关键字 package 用来定义一个包, 语法格式如下:

package 顶层包名.子包名.子包名;

包通常小写, 类名首字母大写.

导入包

为使用定义在不同包中的 Java 类.

关键字 import 用来导入一个包, 语法格式如下:

import 包名[.子包名...].<类名|*>;

若需要导入全部的类, 可使用 * 号.

JDK 中主要的包简介

包名	介绍
java.lang	包含了 Java 的语言核心类, 如 String, System, Math 等
java.util	包含了 Java 的实用工具类, 如定义系统特性, 接口, 集合等.
java.io	包含能提供多种输入输出功能的类.
java.net	包含执行网络相关操作类.
java.sql	包含了 Java 进行 JDBC 数据库编程的相关类/接口.
java.awt	包含了 Java 的图形用户界面(GUI)类.
java.text	包含一些 java 格式化相关的类.
java.applet	包含了 Java 的小程序相关类.

面向对象

• 封装
• 继承
• 多态

是面向对线的三大特征.

1. 封装和隐藏

如果能直接访问对象的属性:

public class Person {
    ...;
    public int age;
}

public class Main {
    public static void main(String[] args) {
        Person p = new Person();
        p.age = -18; // 直接访问对象的属性
        System.out.println(p.age);
    }
}

显然, 年龄 -18 是非法的, 程序能执行, 但不符合逻辑.
所以, 我们需要对属性进行封装, 隐藏起来, 只提供一些方法来访问和修改属性.

修改后的代码如下:

public class Person {
    private int age; // 私有属性, 只能在本类中访问和修改

    public void setAge(int age) { // 提供修改属性的方法
        if (age <= 150 && age >= 0) { // 年龄范围限制
        this.age = age;
        } else {
            System.out.println("年龄范围不合法");
        }
    }

    public int getAge() { // 提供获取属性的方法
        return age;
    }
}

public class Main {
    public static void main(String[] args) {
        Person p = new Person();
        p.setAge(18); // 修改属性
        System.out.println(p.getAge()); // 获取属性
    }
}

四种访问权限修饰符

修饰符	作用
public	对所有类可见
private	对本类可见
protected	对本类和子类可见
default	对同一包内可见

构造器(构造方法)

是类的特殊方法, 用来创建类的实例.

new 对象 实际上就是调用了构造方法.

标准 JavaBean 类

例如一个 student 类:

public class Student {
    private String name;
    private int age;
    private String gender;

    public Student() { // 无参构造 (默认的构造方法)
    }

    // 如果显式定义了构造方法, 则默认的构造方法就不会自动使用了.

    public Student(String name, int age, String gender) { // 带参构造
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public String getGender() {
        return gender;
    }
}

• 调用方式

public static void main(String[] args) {
    Student s = new Student("张三", 18, "男");
    System.out.println(s.getName());
    System.out.println(s.getAge());
    System.out.println(s.getGender());
}

构造器也是一种方法, 因此也能重载.

2. 继承

继承是面向对象编程的重要特征之一.

继承的语法格式

class 子类 extends 父类 {
    // 子类独有属性和方法
}

方法的重写(override)

子类可以重新定义父类的方法, 不能修改除方法体以外的东西.

public class Animal {
    public void eat() {
        System.out.println("动物吃东西");
    }
}

public class Dog extends Animal {
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal a = new Animal();
        Dog d = new Dog();
        a.eat(); // 输出: 动物吃东西
        d.eat(); // 输出: 狗吃骨头
    }
}

这里 Dog 类重写了 Animal 类的 eat() 方法.

两个 eat() 都是 public 方法, 因此可以被其他类调用.

区分:

• 重载(overload): 同名方法, 参数不同.
• 重写(override): 子类重写父类方法, 参数相同.

关键字 super

super 关键字用来调用父类的方法和属性.

public class Animal {
    public void eat() {
        System.out.println("动物吃东西");
    }
}

public class Dog extends Animal {
    public void eat() {
        System.out.println("狗吃骨头");
        super.eat(); // 调用父类的方法
    }
}

public class Main {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.eat(); // 输出: 狗吃骨头, 动物吃东西
    }
}

Dog 类重写了 Animal 类的 eat() 方法, 并调用了父类的方法 super.eat().

3. 多态

多态是面向对象编程的重要特征之一, 在 java 中体现为:

1. 方法的重写和重载.
2. 对象的多态性.

Java 引用变量有两个类型:

1. 编译时类型: 变量声明时所指的类型.
2. 运行时类型: 变量实际指向的对象的类型.

例如一个 Student stu = new Student();

• 编译时类型: Student stu
• 运行时类型: new Student()

JVM 分为:

• 方法区: 存放类的信息
• 堆: 是一个大仓库,存放对象实例
• 栈: 是一个工作台,存放局部变量和方法调用

当 new 一个对象时, JVM 会在堆内存中创建一个对象, 并将对象的引用存入栈内存中.
当调用方法时, JVM 会根据栈内存中的引用找到对象, 并根据对象的实际类型调用相应的方法.

instanceof 运算符

instanceof 运算符用来判断一个对象是否属于某个类.

if (obj instanceof 类名) {
    // 代码块
}

包装类

针对 8 种基本定义相应的引用类型.

基本数据类型	对应的包装类
boolean	Boolean
int	Integer
float	Float
double	Double
char	Character
byte	Byte
short	Short
long	Long

Integer i = new Integer(10);
System.out.println(i.intValue()); // 输出: 10

有了类的特点, 就可以调用类中的方法.

装箱

Java 提供了 8 种基本数据类型, 每种类型都有相应的包装类, 用于将基本数据类型封装成对象.
以下是基本数据类型与它们对应的包装类的对照表：

基本数据类型	对应的包装类
boolean	Boolean
int	Integer
float	Float
double	Double
char	Character
byte	Byte
short	Short
long	Long

包装类实例化

• 通过构造器

包装类可以通过构造器直接使用基本数据类型来创建实例：

Integer i = new Integer(10);
System.out.println(i.intValue()); // 输出: 10

• 通过字符串

包装类也可以通过字符串参数来创建实例，但需要注意字符串必须能正确转换为相应的基本数据类型：

Float f = new Float("3.14"); // 正确
Long l = new Long("123"); // 正确
Long l2 = new Long("asdf"); // 报错，因为"asdf"不是数字

装箱与拆箱

• 装箱

装箱是将基本数据类型转换为对应的包装类实例的过程。这可以通过自动装箱（auto-boxing）实现，Java 编译器会自动将基本数据类型转换为包装类：

int i = 10;
Integer t = i; // 自动装箱

• 拆箱

拆箱是将包装类实例转换回基本数据类型的过程。这可以通过自动拆箱（auto-unboxing）实现，Java 编译器会自动将包装类实例转换为基本数据类型：

Integer i = new Integer(10);
int j = i; // 自动拆箱

字符串与基本数据类型的转换

• 字符串转基本数据类型

可以使用 parseXXX 方法将字符串转换为基本数据类型：

String str = "123";
int num = Integer.parseInt(str); // 输出: 123

• 基本数据类型转字符串

可以使用 String.valueOf 方法或toString方法将基本数据类型转换为字符串：

int num = 123;
String str = String.valueOf(num); // 输出: "123"
// 或者
String str2 = num + ""; // 输出: "123"

自动装箱和拆箱是 Java 5 引入的特性, 它们简化了基本数据类型和包装类之间的转换。

Object 类

所有类的父类, 所有类的祖先类.

当确定传进来的一定是一个类时, 将类型设置为 Object 类即可.

public void print(Object obj) {
    // 代码块
}

object 类中的主要方法

方法	说明
public Object()	空参构造
equals(Object obj)	判断两个对象是否相等
hashCode()	返回对象的哈希码值
toString()	返回对象的字符串表示

高级类特性

关键字 static

在 Java 类中, 可用 static 修饰属性和方法等.

被修饰后的成员具备以下特点:

• 随着类的加载而加载.
• 优先于对象存在.
• 修饰的成员, 被所有对象所共享.
• 访问权限允许时, 可以不创建对象, 直接被调用.

字符串

创建 String 对象的两种方式:

1. 直接赋值

String name = "雲之残骸";

直接赋值的字符串会在串池中, 更加节约内存.

2. 关键字 new

public String() // 创建空白字符串, 不含任何内容

public String(String original) // 根据传入的字符串, 创建字符串对象

public String(char[] chs) // 根据字符数组, 创建字符串对象

public String(byte[] chs) // 根据字节数组, 创建字符对象

new 的字符串会在堆中.

特别注意:

• 字符串一旦被创建, 就无法修改.
• scanner 录入的字符串也是 new 出来的

字符串常用方法

• 区分大小写比较: boolean equals() 方法
• 忽略大小写比较: boolean equalsIgnoreCase() 方法

如果直接使用 == 号比较字符串, 比较的是其地址值.

== 的拓展:
当比较 基本数据类型 时, 其比较的是 数据值.
当比较 引用数据类型 时, 其比较的是 地址值.

使用语句包裹快捷键: ctrl+alt+T
补全对象: ctrl+alt+V

• 根据索引返回字符: charAt(索引)

• 根据索引截取字符串: String substring(开始索引(包含), 结束索引(包含)不包含)

• 从索引处截取到末尾: String substring(开始索引)
  例如:

// 截取手机号码的中间4位 (131 1234 5678) -> (1234)

String phone = 13112345678;
phone.substring(3,7); // 输出结果: 1234

• 替换字符串: replace(旧值,新值)

• 将字符串转换为字符数组: toCharArray()

StringBuilder

StringBuilder 可以看作为一个容器, 创建后可以修改其中的内容, 能提高字符串的操作效率.

当考虑 字符串拼接 , 字符串反转 时 可以优先使用 StringBuilder.

构造方法

StringBuilder sb = new StringBuilder(); // 空参构造--创建一个空白可变字符串对象, 不含任何内容.

StringBuilder sb = new StingBuilder("指定字符串"); // 有参构造--根据字符串的内容, 来创建可变字符串对象.

成员方法

• 添加数据, 并返回对象本身: append(任意类型)

• 反转容器中的内容: reverse()

• 返回字符出现的个数: length()

• 把 StringBuilder 对象转换为 String: toString()

Java 已在底层对 StringBuilder 做处理, 打印对象输出时不是地址值而是其属性值.

底层理解

容量: 最多能装多少 capacity()
长度: 已经装了多少 length()

所有要拼接的内容都会往一个 StringBuilder 中存放, 不会创建很多无用空间, 节约内存.

当创建一个 StringBuilder 对象时, 其默认为 容量 16 字节的数组. 添加的内容长度小于 16 字节, 则直接存放. 反之则将 原来的容量 * 2 +2. 如果还不够, 以实际长度为准.

链式编程

当我们在调用一个方法时, 不需要用变量接收它的结果, 可以继续调用其他方法.

例如:

public static void main(String[] args) {
        System.out.println(getString().substring(1).replace("A", "Q").length()); // 依赖前一个方法的结果, 再去调用后一个方法, 称之为链式编程.
    }

    public static String getString(){ // 自定义getString()方法提示输入并接收
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入:");
        return sc.next();
    }

此处 链式编程 大意是: 接收输入内容, 从索引 1 开始截取到末尾, 再将结果中的 “A” 替换为 “Q” ,然后计算并输入其中的字符数.

StringJoiner

StringJoiner 也可以看作一个容器, 同样是可变的, 注意是 JDK8 才可使用.

构造方法

// StringJoiner 没有空参构造
StringJoiner sj = new StringJoiner("间隔符号");

StringJoiner sj = new StringJoiner("间隔符号", "开始符号", "结束符号");

成员方法

• 添加数据: add("添加的内容")

• 返回长度: length()

• 把 StringJoiner 对象转换为 String: toString()

字符串拼接

拼接时检查, 分为以下两种情况:

• 没有变量参与

触发字符串优化机制, 在编译的时候就已经是最终结果了.

例如:

String s = "a"+"b"+"c";
System.out.printIn(s);

当其编译成 class(字节码)文件时, 会优化为:

String s = "abc";
System.out.printIn(s);

• 有变量参与

例如:

String s1 = "a";
String s2 = s1 + "b";

在 JDK8 以前, 底层会使用 StringBuilder.

s2 在拼接的时候创建 StringBuilder(); 对象.

但每次拼接都会创建 StringBuilder(); 对象, 影响性能.

在 JDK8 拼接时, 会预估字符串长度并创建数组, 存入数组中然后转换成字符串.

但预估同样也会消耗时间.

结论:

如果很多字符串变量拼接, 不推荐直接 + .

快捷搜索方法: ctrl+n

集合

会自动扩容, 但不能存基本数据类型, 需要把基本数据类型转换成包装类.

基本数据类型	对应的包装类
int	Integr
char	Character
byte	Byte
short	Short
long	Long
float	Float
double	Double
boolean	Boolean

构造方法

创建集合对象.

ArrayList list = new ArrayList();

集合没法直接限定其存储的类型, 这时需要 泛型 来限定集合中存储数据的类型.

ArrayList list<String> = new ArrayList<String>(); // JDk7 以前

ArrayList list<String> = new ArrayList<>(); // JDk7 之后

当限定的类型为基本数据类型时, 泛型填写其对应的包装类.

ArrayList list<Integer> = new ArrayList<>(); // int限定

底层已经对 ArrayList 做处理, 打印的对象不是地址值, 而是集合中存储数据内容.

在展示时, 会使用 [ ] 将内容包裹.

成员方法

方法	说明
增: add(Element e)	添加元素, 返回值表示是否添加成功
删: remove(Element e)	删除指定元素, 返回值表示是否删除成功
删: remove(int index)	删除指定索引的元素, 返回被删除的元素
改: set(int index, Element e)	修改指定索引的元素, 返回被修改的元素
查: get(int index)	获取指定索引的元素
查: size()	查询集合中元素的个数

快捷查看方法的调用参数列表信息 ctrl + p

异常处理

Java 提供异常处理机制.
它将异常处理代码和业务代码分离, 使得程序更优雅.

Java 的异常处理是通过以下 5 个关键字来实现的:

关键字	说明
try	异常处理的开始
catch	捕获异常
finally	异常处理的结束
throw	抛出异常
throws	声明可能会抛出的异常

try {
    // 可能产生异常的代码
} catch (Exception e) {
    // 异常处理代码
} finally {
    // 无论是否有异常, 都会执行的代码
}

会将可能产生的错误封装成一个 Exception 对象, 并抛出给调用者.

集合