Kotlin语法整理
提示：语法格式符号
“|”表示多选一的并列关系，“[]”表示可选项。这两个语法格式符号用于帮助理解语法，实际程序中并不会出现。
一、基本数据类型
共8种
- Byte, Short, Int, Long, Float, Double, Boolean, Char.
二、变量的声明
语法格式
var|val identifier [: type][ = value]
var用于声明可变变量，val用于声明不可变变量[: type]是指数据类型。当有初始化赋值时可省略，系统自动判断数据类型。[ = value]是对变量进行初始化赋值。当指定数据类型时可暂时不进行初始化赋值。
三、条件
1. if…else if…else语句
if…else if…else 语句是多条件判断的分支结构语句。程序运行到 if 语句时，对 condition1 的逻辑值进行判断。当 condition1 的逻辑值为 true 时，执行完 statement1 语句，结束 if…else if…else 语句。否则，对 condition2 的逻辑值进行判断，当 condition2 的逻辑值为 true 时，执行 statement2 语句体，然后结束 if…else if…else 语句。else if 可以根据需要添加多组，当执行到 else 语句时，无须进行逻辑判断，直接执行 statementN 语句体。
语法格式
if (condition1){
statement1
} else if (condition2){
statement2
}
…
else if{
statementN
} else {
statement(N+1)
}
- 必选项：
condition1，condition2，…，conditionN是用于条件判断的 Boolean 类型变量或逻辑表达式。
2. when 语句
当分支情况较多时，使用 else if 语句会显得不够简洁，使用 when 语句可以解决这个问题。when 语句根据 expression 的值判断与哪个 value 值相等或符合 value 值的区间范围，然后执行 “ -> ” 后的 statement 语句体。如果与 value 值都不相等或不符合 value 值的区间范围，则执行 else 语句后的 statementDefault 语句体。
语法格式
when (expression) {
[in|!in value1..value1N]|[value1[,…][,value1N]]|[is Type1] -> {statement1}
[in|!in value2..value2N]|[value2[,…][,value2N]]|[is Type2] -> {statement2}
…
[in|!in valueN..valueNN]|[valueN[,…][,valueNN]]|[is TypeN] -> {statementN}
[else -> {
statementDefault
}]
}
- 必选项：
expression是条件判断的变量或表达式。 - 可选项：
[in|!in value1..value1N]表示在 value1~value1N 区间内或外。
例如，in 1…10 表示在1~10区间内，!in 1…10 表示在1~10区间外。 - 可选项：
[value1[,…][,value1N]]表示符合条件的并列关系值。例如，1,3,4表示 expression 值等于1、3或4。 - 可选项：
[is Type1]表示符合条件的数据类型。例如，is String 表示是 String 类型。 - 可选项：
[else ->{statementDefault}]表示以上条件均不符合时执行 StatementDefault 语句体。
四、循环
1. while 语句
while 语句是先进行条件判断后执行循环体代码的循环语句。程序运行到 while 语句时,对 condition 的逻辑值进行判断。当 condition 的逻辑值为 true 时，执行花括号包含的 statement 语句体，然后返回到 while 语句;当 condition 的逻辑值为 false 时，执行花括号之后的语句。
语法格式
while (condition) {
statement
}
- 必选项：
condition是用于条件判断的 Boolean 类型变量或逻辑表达式。
2. do…while 语句
do…while 语句是先执行循环体代码后进行条件判断的循环语句。程序运行到 do 语句时，执行 statement 语句体。运行到 while 语句时，对 condition 的逻辑值进行判断。当 condition 的逻辑值为 true 时，返回到 do 语句；当 condition 的逻辑值为 false 时，结束循环。
语法格式
do {
statement
} while (condition)
- 必选项：
condition是用于条件判断的 Boolean 类型变量或逻辑表达式。
3. for 语句
for 语句也是一种先进行条件判断后执行循环体代码的循环语句。for 语使用 startInt 作为 variableName 循环变量的循环初始值，判断 variableName 循环变量是否达到终止循环的 endInt。如果达到或超过终止循环的 endInt，则终止循环，执行花括号后的语句;如果没有达到终止循环的 endInt, 则执行花括号内的 statement 语句体。然后返回到 for 语句，将 variableName 循环变量与 stepInt 进行运算:使用 until 关键字时,variableName 的值加上 stepInt 循环增量;使用 downTo 关键字时, variableName 的值减去 stepInt 循环增量;使用…运算符代替 until 关键字和 downTo 关键字时，根据 startInt 和 endInt 的大小自动判断循环结束后加上或减去 stepInt 循环增量。stepInt 的默认值为 1。最后判断 variableName 循环变量是否达到终止循环的 endInt。
语法格式
for (variableName in startInt until|downTo|.. endInt [step stepInt]) {
statement
}
- 必选项：
variableName是循环变量。 - 必选项：
startInt是循环变量的初始值，endInt 是循环变量的结束值。(不包括此值) - 可选项：
[step stepInt]是循环增减量，默认值为 1。
4. repeat 语句
repeat 语句是指定循环次数的循环语句，同时默认使用 it 变量表示当前的循环次数(如果 Lambda 表达式只有一个参数，而且能够根据代码判断出来参数的数据类型，那么这个参数可以省略，并且可以在语句体中使用 it 关键字代替该参数)。程序运行到 repeat 语句时，根据 times 指定的次数执行 statement 语句体。
语法格式
repeat (times) {
statement
}
- 必选项：
times是循环次数，必须是整数。
5. break 语句
break 语句用于跳出当前循环语句或者 switch 语句，并且继续执行当前循环语句或者 switch 语句之后的下一条语句。在循环语句中，break 语句通常嵌入 if 语句中使用，当满足一定条件时跳出循环。
6. continue 语句
continue 语句是在循环语句中能够立刻跳转到下一次循环的语句。在循环语句中, continue 语句通常嵌入 if 语句中使用，当满足一定条件时结束本次循环。
五、数组
1. 创建元素未初始化的数组
在能够确定数组元素数量却无法确定元素值的情况下，可以创建指定长度的数组，然后根据需要再进行赋值。虽然可以定义数组长度，但是无法重新定义数组长度。
语法格式
var|val arrayName = arrayOfNulls<dataType>(arraySize)
- 必选项：
arrayName是数组的名称。 - 必选项：
dataType是数组的类型。 - 可选项：
arraySize是数组元素的数量。
2. 创建元素初始化的数组
根据初始化元素的数据类型，分为两种语法格式**:基本数据类型数组和其他类型数组，数组所包含元素的数据类型必须与数组的数据类型一致。
语法格式
//基本数据类型数组创建
var|val arrayName : typeÃrray = typeArrayOf([elementO, element1,…, elementN])
//其他类型数组创建
var|val arrayName[:Array<dataType>] = arrayOf([element0, element1,…, elementN])
- 必选项：
arrayName是数组的名称。 - 必选项：
typeArray是基本数据类型的数组类，包括 BooleanArray、CharArray、ByteArray、ShortArray、IntArray、LongArray、FloatArray、DoubleArray。 - 必选项：
typeArrayOf需要与 typeArray 的类型相对应，
如 IntArray 对应 intArrayOf 。arrayOf 是固定的关键字。 - 可选项：
[:Array<dataType>]是数组的数据类型，默认时会根据元素的初始值自动判断数据类型。 - 可选项：
element0,element1,…,elementN是每个元素的初始值,每个元素的数据类型必须一致。
3. 空数组
可以使用 emptyArray<dataType>() 方法创建空数组。要使用数组时，需要使用 arrayOf 或 typeArrayOf 语句对数组进行初始化，或者赋值一个非空数组，才能对元素进行操作。
语法格式
var|val arrayName = emptyArray<dataType>()
- 必选项：
arrayName是空数组的名称。 - 必选项：
dataType是空数组的类型。
4. 二维数组
二维数组本质上是以数组作为元素的数组，即 “数组的数组”，其中每一个元素都是一个一维数组。二维数组可以理解成一个表格，第一个下标表示行数，第二个下标表示列数。在创建二维数组时，可以嵌套或使用一维数组初始化的方式实现。
语法格式
//使用嵌套的方式创建二维数组
val|var arrayName = Array(arrayLenght1){typeArray(arrayLenght2)}
//使用一维数组直接创建二维数组
val|var arrayName = arrayOf([array1, array2,…, arrayN])
- 必选项：
arrayName是数组的名称。 - 必选项：
arrayLenght1是包含的一维数组数量，arrayLenght2是所包含一维数组的元素数量。 - 必选项：
typeArray是基本数据类型的数组类，包括 BooleanArray、CharArray、ByteArray、ShortArray、IntArray、LongArray、FloatArray、DoubleArray。 - 可选项：
array1,array2,…,arrayN是单独的一维数组，且数据类型必须一致。
六、函数和高阶函数
1. 函数声明
函数用于封装可重复使用的代码片段，使用 fun 关键字定义。函数可以包含参数和返回值，也可以不包含参数和返回值。函数参数的作用域是函数内部，没有返回值时的返回类型是Unit 类型。调用函数时，使用函数名加括号包含参数值。
语法格式
//声明函数
fun functionName([para0[:type0][,para1[:type1]][,…][,paraN[:typeN]]]) [:returnType] {
statement
[return returnValue]
}
//调用函数
functionName([para0[:type0][,para1[:type1]][,…][,paraN[:typeN]]])
- 必选项：
functionName是函数的名称。 - 可选项：
para0、para1、…、paraN是函数参数。 - 可选项：
type0、type1、…、typeN是函数参数的数据类型。 - 可选项：
[:returnType]用于设置函数返回值的类型，需要与 [return returnValue] 一起使用，returnType 是返回值的类型。 - 可选项：
[return returnValue]用于设置函数的返回值，返回值的类型需要与 [:returnType] 设置的类型一致，returnValue 是返回值。
2. Lambda 表达式的基本形式
Lambda 表达式的本质是匿名函数，多作为高阶函数使用，也可以直接使用。 使用 Lambda 表达式可以减少代码量，使代码更加简洁，但是会增加理解的难度。在 Lambda 表达式中，-> 左侧的是匿名函数的参数，右侧的是匿名函数的语句体。语句体中可以有返回值，也可以没有返回值。返回值可以使用 return 语句进行设置，也可以不使用return 语句而将最后一行的单个表达式或变量作为返回值。
语法格式
{[para0[:type0][,para1[:type1]][,…][,paraN[:typeN]]] -> statement }
- 可选项：
para0、para1、…、paraN是 Lambda 表达式的参数。 - 可选项：
type0、type1、…、typeN是 Lambda 表达式参数的数据类型。
七、类
(一) 类的声明
Kotlin 提供了大量的内置类来实现各项基本功能，也可以使用 class 关键字声明自定义类。类中一般包含主构造方法、初始化块、次构造方法、属性和方法。 主构造方法在类名后使用 constructor 关键字定义，可以省略。初始化块使用 init 关键字，不能添加参数。次构造方法在类内部使用 constructor 关键字定义，可以添加参数。属性(即成员变量)使用 var 或 val 关键字在类内部的构造方法和方法外直接声明。方法是指类中的函数，方法和函数在定义时只有是否在类内部的区别。
语法格式
class ClassName [constructor([[var|val] attrConst:Type])]{
[var|val attribute[:Type][ = value] ]
[init{
statement
}]
[constructor([para:Type])[:this(attrConst)]{
statement
}]
[fun functionName([para:Type])[:ReturnType]{
statement
[return value]
}]
}
- 必选项：
ClassName是类的名称。 - 可选项：
[constructor([[var|val] attrConst:Type])]是主构造方法，如果主构造方法有注解或可见性修饰符，constructor 关键字可以省略。[[var|val] attrConst:Type] 是主构造方法的可选参数，多个参数之间使用逗号分隔。如果使用var或val声明参数，则会被自动转换为类的属性，否则只能使用在初始化块内。 - 可选项：
[var|val attribute[:Type][=value]]是类的属性，与变量的声明方法相同，一个类可以有多个属性。 - 可选项：
[init {statement}]是初始化块，在属性初始化后执行，没有参数，每个类只能有一个初始化块。 - 可选项：
[constructor([para:Type])[:this(attribute)]{statement}]是次构造方法，在初始化块之后执行。[para:Type] 是可选参数，多个参数之间用逗号分隔。可以有多个参数不同的次构造方法，即次构造方法的重载，在后续章节中会介绍重载的概念。如果主构造方法和次构造方法同时存在，则次构造方法需要使用 [:this(attrConst)] 调用主构造方法，先执行主构造方法再执行次构造方法。 - 可选项：
[fun functionName([para:Type])[:ReturnType]{statement [retum value]}]是类的方法。[para:Type] 是可选参数，多个参数之间用逗号分隔。[:ReturnType] 是方法的返回值类型，设置后需要使用 [return value] 提供返回值。
(二) 创建类的实例
类不能直接使用，需要通过类的实例来使用，使用 var 或 val 声明类实例的变量。声明类变量的同时还可以进行实例化，实例化后才能通过实例的变量调用类的属性和方法。
语法格式
//声明类实例的变量
var|val instanceName:ClassName
//声明类实例的变量并进行实例化
var|val instanceName = ClassName([para])
- 必选项：
instanceName是类的实例名 - 必选项：
ClassName是类名。 - 可选项：
[para]是调用主构造方法或次构造方法的参数，多个参数之间使用逗号分隔，ClassName([para]) 返回该类的实例。
类的实例可以使用.运算符调用类的属性和方法，var 声明的属性可以通过实例调用进行修改，val 声明的属性不可以修改。而主构造方法、初始化块和次构造方法无法直接调用，而是在实例化时自动调用的。
(三) 属性的 get()和 set()方法
属性定义后可以使用 get() 和 set() 方法对属性的赋值和调用进行预处理。这两个方法只能在属性的声明后立即使用，无须使用 fun 关键字，方法内使用 field 关键字表示属性值。
1. 属性的 get()方法
当调用属性时，执行属性的 get() 方法。通常会在方法内对属性值进行预处理，通过 return 关键字返回属性值。如果块语句体可以简化为表达式语句体，也可以使用表达式语句体的形式。
语法格式
get() {
statement
return value
}
或
get() = expression
- 必选项：
value是 get() 方法的返回值，即调用属性的返回值。 - 必选项：
expression是调用属性的返回值，可以直接使用单个变量作为返回值，也可以使用表达式。
2. 属性的 set()方法
使用 val 声明属性时，无法设置 set() 方法。当属性被赋值时，执行属性的 set() 方法。该方法包含一个参数，该参数表示使用=运算符赋值时传递的数据。
语法格式
set(value){
statement
field = expression
}
或
set(value) = expression
- 必选项：
value是存储属性使用=运算符赋值的数据的变量，可以使用任何合法的变量名。 - 必选项：
field是使用 set() 方法预处理后的属性值。 - 必选项：
expression是设置属性值的单个变量或表达式。
(四) 扩展属性和扩展方法
可以在类的外部为该类扩展属性和方法，以达到增加功能的作用。声明扩展方法和扩展属性时，需要用被扩展的类名作为前缀。
1. 扩展方法
语法格式
fun ClassName.functionName([para:Type])[:ReturnType]{
statement
[return value]
}
- 必选项：
ClassName是要扩展方法的类名。 - 必选项：
functionName是扩展的方法名。 - 可选项：
[para:Type]是可选参数，多个参数之间用逗号分隔。 - 可选项：
[:ReturnType]是方法的返回值类型，设置后需要使用 [return value] 提供返回值。
2. 扩展属性
展属性与普通属性的区别是 get() 方法和 set() 方法无法使用 field 关键字获取属性值，且 get() 方法的返回值是可选项。使用 val 声明扩展属性时，同样无法设置 set() 方法。
语法格式
var|val ClassName.attribute: Type
get() {
statement1
[return returnValue]
}
[set(value) {
statement2
}]
或
var|val className.attribute: Type
get() = expression1
[set(value) = expression2]
- 必选项：
ClassName是要扩展属性的类名。 - 必选项：
attribute是扩展属性的属性名。 - 可选项：
[return returnValue]。 - 可选项：
[set(value) {statement2}]只有扩展属性使用 var 关键字声明的时候才可以使用。 - 可选项：
[set(value)=expression2]只有扩展属性使用 var 关键字声明的时候才可以使用。
(五) 继承
类可以有继承的关系，子类可以继承父类的属性和方法。Kotlin 中只允许单继承，即每个类最多只能继承一个父类，但是父类还可以再向上继承。 只要有继承关系，子类中无须包含父类的属性和方法就可以使用这些属性和方法。创建类时，在类名后使用:连算符连接父类名称，就可以继承父类所有的属性和方法。而父类则需要添加 open 发键字后才能允诉其他类继承。
语法格式
class ClassName : ParentClassName{
statement
}
- 必选项：
ClassName是类的名称。 - 必选项：
ParentClassName是 ClassName 类继承的父类名称。
(六) 包
包 ( package ) 对功能相似或相关的类和接口的组织形式，提供了访问保护和命名空间管理的功能。使用 package 关键字定义包，如同文件夹一样，包采用了树形目录的存储方式，每级包之间使用.运算符连接。同一个包中的类名是不能相同的，不同包中的类名是可以相同的，当同时调用两个不同包中相同类名的类时，需要加上包名来区别以避免名字冲突。
语法格式
package packageName1[.packageName2][.…][.packageNameN]
- 必选项：
packageName1是在工程内源代码根目录下包含该类的文件夹。 - 可选项：
[.packageName2][.…][.packageNameN]是类在 packageName1 包内的文件夹路径(.运算符表示文件夹的层级关系)。
在不同包内的类不能直接调用，需要使用 impont 关键字引人类所在的包后，才能使用。
语法格式
import packageName1[.packageName2][.…][.packageN].(className|*)
- 必选项：
.(className|*)引人某一个类或包内所有的类。 className 表示要导人的类名，* 表示导入包内所有的类。
(七) 接口
接口使用 interface 关键字进行定义。接口内的属性只能是抽象变量，且不能初始化赋值，默认修饰符是 public abstract。接口内只定义而未实现的方法是抽象方法，默认修饰符是 public abstract。
语法格式
interface InterfaceName [: ParentInterfaceName]{
statement
}
- 必选项：
InterfaceName是接口的名称。 - 可选项：
[:ParentInterfaceName]是要继承的接口名称。
类实现接口时，需要使用:运算符，并且可以同时实现多个接口。实现接口的类必须重写抽象属性
和抽象方法。
语法格式
class ClassName :InterfaceName{
statement
}
- 必选项：
ClassName是实现接口的类名称。 - 必选项：
InterfaceName是实现接口的名称，多个名称使用逗号分隔，这里的冒号表示实现接口。
八、委托
1. 类的委托
类的委托是将接口定义的方法通过实现该接口另一个类的对象实现的方式。委托类和被委托类明时都定义了同一个接口，委托类实现了该接口的抽象方法。
语法格式
class ClassName : InterfaceName by DelegateClassName() {
statement
}
或
class ClassName (delegate:DelegateClassName) : interfaceName by delegate {
statement
}
- 必选项：
ClassName是类的名称。 - 必选项：
InterfaceName是接口的名称。 - 必选项：
DelegateClassName是委托类的名称。 - 必选项：
delegate是委托类实例的变量名。
2. 变量的委托
变量的委托是指变量不使用 set() 和 get() 方法进行预处理，而将其委托给另一个类的方式。委托类需要导人 kotlin.reflect.KProperty 命名空间，并且需要添加 getValue() 方法和 setValue() 方法实现变量的调用与赋值。声明变量时使用 by 关键字设置委托类，设置委托类时变量不能进行初始化赋值。
语法格式
val|var identifier [: type] by DelegateClassName()
- 必选项：
identifier是变量的名称。 - 必选项：
DelegateClassName是委托类的名称。 - 可选项：
[:type]是数据类型。
九、枚举
枚举 ( Enum ) 是通过预定义列出所有值的标识符来定义的有序集合。枚举继承自 Enum 类，由于 Kotlin 不支持多继承，所以枚举对象不能再继承其他类，但是可以继承接口。枚举类提供了一些常用的属性和方法。
语法格式
enum class enumName [(para:Type)] {
ELEMENT0[(рaгa0)][,ELEMENT1[(para1)]][,…][,ELEMENTN[(paraN)]]
}
- 必选项：
enumName是枚举类的名称。 - 必选项：
ELEMENT0是枚举类的常量，一般采用大写英文字母，枚举类至少要包含一个常量。 - 可选项：
[(para:Type)]定义了元素参数的名称和类型，多个 para:Type 之间使用逗号分隔。para0 是元素参数的名称，Type是元素参数的类型。 - 可选项：
[(para0)]是元素的参数，其类型与 [(para:Type)] 定义的类型一致，多个 ＊para0＊ 之间使用逗号分隔。 - 可选项：
[,ELEMENT1[(para1)]][…][,ELEMENTN[(paraN)]]表示多个枚举类的常量。
1. 枚举类的常用属性属
| 类型 | 方法 |
|---|---|
| Class | declaringClass 返回与此枚举常量的枚举类型相应的Class对象 |
| String | Name 返回此枚举常量的名称，在其枚举声明中对其进行声明 |
| Int | Ordinal 返回枚举常量的序数(它在枚举声明中的位置，其中初始常量序数为零) |
2. 枚举类的常用方法
| 类型 | 方法 |
|---|---|
| Int | compareTo(other:E) 比较此枚举与指定对象的顺序 |
| String | toString() 返回枚举常量的名称 |
示例
enum class Color constructor(var RGB: String,var value: String) {
RED("#ff0000", "红色"), YELLOW("#ffff00", "黄色"), BLUE("#0000ff", "蓝色")
}
val colorSelect = Color.BLUE
println("选取颜色的名称：" + colorSelect.value) //选取颜色的名称：蓝色
println("选取颜色的RGB值：" + colorSelect.RGB) //选取颜色的RGB值：#0000ff
十、泛型
1. 泛型类
泛型类是指声明类时同时声明泛型的类，声明类时在类名后添加 <> 声明泛型，<> 内可以声明多个泛型，多个泛型之间使用逗号分隔。
语法格式
class ClassName <Type[:Any]> {
statement
}
- 必选项：
ClassName是泛型类的名称。 - 必选项：
Type是泛型，可以作为类内部的数据类型。 - 可选项：
[Any]表示非空泛型，即 T 可以是除 null 外的任何类型。
声明泛型类实例的变量时，<Type> 中的 Type 需要替换成相应的类型。如果省略 <Type> ,会自动判断传人参数的数据类型。
语法格式
var|val instanceName[:ClassName<Type>] = ClassName ([para])
- 必选项：
instanceName是类的实例名。 - 必选项：
ClassName是类名。 - 可选项：
[:ClassName<Type>]用于指定泛型的数据类型，Type 是数据类型 - 可选项：
[para]是调用主构造方法或次构造方法的参数。
2. 泛型接口
泛型接口是指声明接口时同时声明泛型，声明接口时在接口名称后添加 <> 声明泛型，<> 内可以声明多个泛型，多个泛型之间使用逗号分隔。
语法格式
interface InterfaceName<Type[:Any]> [: ParentInterfaceName] {
statement
}
- 必选项：
InterfaceName是泛型接口的名称。 - 必选项：
Type是泛型，可以作为接口内部的数据类型。 - 可选项：
[:Any]表示非空泛型，即 T 可以是除 null 外的任何类型。 - 可选项：
[:ParentInterfaceName]是要继承的接口名称。
类实现接口时，需要使用:运算符，可以同时实现多个接口。实现接口的类必须重写抽象属性和象方法。
语法格式
class ClassName <Type [:Ãny]>:InterfaceName<Type>{
statement
}
- 必选项：
ClassName是实现泛型接口的类名称。 - 必选项：
Type是泛型。 - 必选项：
InterfaceName是实现泛型接口的名称。 - 可选项：
[:Any]表示非空泛型，即 T 可以是除 null 外的任何类型。
3. 泛型方法
泛型方法是指声明方法的同时声明泛型，声明方法时在 fun 关键字后添加 <> 声明泛型，<> 内可以声明多个泛型，多个泛型之间使用逗号分隔。
语法格式
fun<Type[:Any]> functionName ([para: ParaType])[:ReturnType] {
statement
}
- 必选项：
Type是泛型。 - 必选项：
functionName是方法的名称。 - 可选项：
[:Any]表示非空泛型，即 T 可以是除 null 外的任何类型。 - 可选项：
[para:ParaType]是参数，多个参数之间使用逗号分隔。 - 可选项：
[:ReturnType]是返回值的类型。
十一、异常处理
当 try 语句内的 statement1 语句体出现异常时，则通过 catch 语句捕获相应类型异常后执行 statement2 语句体，无论是否存在异常最后都执行 finally 语句内的 statement3 语句体。try 语句和 catch 语句不能单独使用，一个 try 语句可以搭配多个 catch 语句以捕获多种不同类型的异常进行不同的处理。
语法格式
try {
statement1
} catch (exceptionName:Exception) {
statement2
}[ finally {
statement3
}]
- 必选项：
Exception是需要捕获的异常类型。 - 必选项：
exceptionName是捕获的异常实例 - 可选项：
[finally{statement3)]语句无论异常是否被捕获都会被执行。即使 catch 语句中执行了return 语句或 break 语句，finally 语句内的语句依然会被执行。
扫一扫
854
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
