【Kotlin 语言】1. 环境安装 | 变量 | 简单使用 | 函数 | 异常 | 递归

一 Kotlin 环境安装
Eclipse 环境安装
1 相关下载地址

2 Eclipse 环境安装

3 Eclipse 插件安装

IntelliJ IDEA 环境安装
1 相关下载地址

2 安装

Kotlin 命令行工具
1 相关下载地址

2 安装 Kotlin 命令行工具

二 Hello World 工程
第一个 Hello World 工程
1 创建 Kotlin 工程

2 Kotlin 的 Hello World 代码

3 Hello World 代码分析

三 变量声明和使用
数据类型 大小 范围 简介

智能类型推断
1 Kotlin 类型智能推断

2 Kotlin 类型智能推断 代码示例

显式类型声明

常量

变量取值范围
1 变量取值范围简介

2 变量取值范围 代码示例

四 Kotlin 简单使用
Kotlin 简单代码测试
1Main函数

2Println函数

3打印 三角形 示例

Boolean 运算
1 简单 Boolean 运算 1 数值对比

2 简单 Boolean 运算 2 带开放运算

3 简单 Boolean 运算 2 幂运算 对比

在命令行进行运算

函数编写规则
1函数格式

2函数格式 代码示例

3 计算器代码示例

字符串模板
1字符串模板格式

2字符串模板代码示例

条件控制
1条件控制示例 1

2条件控制示例2

字符串比较

函数参数空值处理

when 表达式

Loop 和 Range 使用
1区间 和 循环 简单示例

2 其它用法简介

List 和 Map 入门
1List 简单示例

2Map 简单示例

四 函数
函数声明的方式

默认参数 和 具名参数

字符串数字之间转换

人机交互

异常处理
1 异常处理示例

递归
1 阶乘示例

2 阶乘大数字示例

尾递归优化 解决堆栈溢出问题
1 问题说明

2 尾递归优化

一. Kotlin 环境安装

1. Eclipse 环境安装

(1) 相关下载地址

Kotlin Eclipse 环境相关下载地址 :

1.eclipse 下载地址 : https://www.eclipse.org/downloads/;

2.JDK 下载地址 : http://www.oracle.com/technetwork/java/javase/downloads/index.html;

3.Kotlin 插件地址 : http://marketplace.eclipse.org/content/kotlin-plugin-eclipse;

(2) Eclipse 环境安装

Kotlin Eclipse 环境安装 :

1.解压 Eclipse :

2.安装 JDK 并配置环境变量 : 自行百度;

3.安装 Kotlin 插件 : 下面详解;

(3) Eclipse 插件安装

Eclipse Kotlin 插件安装 :

1.进入 Eclipse Marketplace : Help -> Eclipse Marketplace, 进入如下界面;



2.搜索 Kotlin 插件 : 搜 Kotlin, 可以搜索到 Kotlin Plugin for Eclipse 0.8.2, 直接点击右下角的 install 按钮安装该插件;



3.接受协议 : 点击 接受协议, 下一步, 弹出安装界面;



4.安装过程 : 安装过程中会弹出警告, 不管 直接点 OK, 最后安装完毕后重启 Eclipse;





5.重启 Eclipse : 重启后就可以使用了.

2. IntelliJ IDEA 环境安装

(1) 相关下载地址

IntelliJ IDEA 下载地址 :

1.主页 : https://www.jetbrains.com/idea/;

2.软件下载地址 : https://www.jetbrains.com/idea/download/;

3.专业版 和 社区版 : 专业版需要付费, 社区版 免费, 专业版 自己找地方破解, 肯定要使用专业版的(推荐淘宝搜索 IntelliJ IDEA);

(2) 安装

IntelliJ IDEA 安装 : 下一步 -> 下一步 即可, 全部默认设置;

3. Kotlin 命令行工具

(1) 相关下载地址

Kitlin 相关下载地址 :

1.Kotlin 官网地址 : http://kotlinlang.org/;

2.命令行工具下载地址 : http://kotlinlang.org/docs/tutorials/command-line.html;

a. 跳转到 Github 地址 : 点击红框中的链接, 跳转到 GitHub 中下载;



b. 下载命令行工具 : 拉到最底部, 下载 kotlin-compiler-1.1.4-2.zip 选项;

(2) 安装 Kotlin 命令行工具

安装 Kotlin 命令行 工具 :

1.配置 Java 环境变量 : 参考教程;

a. JAVA_HOME = C:\Program Files\Java\jdk1.8.0_25 (安装 Jdk 目录)

b.CLASSPATH = .;%JAVA_HOME%\lib;%JAVA_HOME%\lib\tools.jar

c. PATH = %JAVA_HOME%\bin;%JAVA_HOME%\jre\bin

2.配置 Kotlin 环境变量 : 找到 kotlinc 的 bin 目录, 将该目录配置到 Path 变量中;



3.命令行测试 :

二. Hello World 工程

1. 第一个 Hello World 工程

(1) 创建 Kotlin 工程

创建 Kotlin 工程 :

1.搜索 Kotlin 工程 : 安装完 Kotlin 插件后, 就可以创建 Kotlin 工程了, 第一次需要在 创建栏 里 找到 Kotlin 工程;



2.输入 工程名称 :



3.查看创建的 Kotlin 工程 :



4.在 src 下创建一个 Kotlin 文件 :

(2) Kotlin 的 Hello World 代码

Hello World 代码 :

1.代码内容 : 没有分号 !!! ;

fun main(args:Array<String>){
println("Hello World!")
}

2. 执行结果 :

Hello World!

(3) Hello World 代码分析

代码分析 :

1.fun : 函数声明, 与 其它语言不太一致;

2.main : 程序执行入口, 与其它语言基本一致;

3.args : 主程序执行 输入的参数, 类似于 C 语言中的 int argc, char ** argv, 或者 Java 中的 String[] args;

4.println : 向控制台打印字符串数据;

三. 变量声明和使用

1. 数据类型 大小 范围 简介

Kotlin 数据类型 :

1.Byte : 字节, 大小 1byte, 范围 -128 ~ 127;

2.Short : 短整型, 大小 2byte, 范围 -32769 ~ 32767;

3.Int : 整形, 大小 4byte, 范围 -2147483648 ~ 2147483647;

4.Long : 长整形, 大小 8byte, 范围 -9223372036854775807 ~ 9223372036854775807;

5.Float : 单精度浮点型, 精确到 小数点后 6 位;

6.Double : 双精度浮点型, 精确到 小数点后 16 位;

7.String : 字符串类型;

2. 智能类型推断

(1) Kotlin 类型智能推断

类型推断 :

1.智能类型推断时机 : 使用 var 定义变量, 第一次为变量赋值时, 该变量才被赋予类型;

(2) Kotlin 类型智能推断 代码示例

智能类型推断 代码示例 :

1.var 声明 代码 : 打印结果是 “27”;

fun main(args: Array<String>){
var age = 27    //此时赋值 27, 即类型智能推断为 int 类型
println(age)
}

2.编译报错 : 智能推断后, 赋予其它类型变量, 此时文档检查报错 :



3.查看报错内容 : Type mismatch, 类型不匹配;

Multiple markers at this line - Type mismatch: inferred type is String but Int was expected - The value '"Joe"' assigned to 'var age: Int defined in main' is never used - 1 changed line

4.说明 : 在 var age = 27, 语句中, age 变量就被推断为 int 类型, 此时如果将其它类型, 就会报错;

5.注意 : 智能类型推断是根据 = 后面的内容进行推断, 如果只定义 var age 就会报错;

This variable must either have a type annotation or be initialized

3. 显式类型声明

显示类型声明 :

1.格式 : var 变量名 : 变量类型 (= 变量值) ;

2.变量定义必须赋予类型 : 如果变量定义的时候不赋予类型, 就会报错;

3.指定类型方式 : ① 智能推断类型, ② 显示类型声明;

4.代码示例 :

fun main(args: Array<String>){

var age : Byte = 27         //定义一个 Byte 类型数据

var time_stap : Long        //定义一个 Long 类型数据

var name : String = "Joe"   //定义一个 字符串 数据

var height : Short          //定义一个 Short 类型数据

}

4. 常量

常量声明 :

1.格式 : val 常量名 = 常量值 ;

2.注意 : 常量不可以修改, 尝试给常量赋值 会 报错;

3.代码示例 : 注意, 这里 最后 一行 会报错;

fun main(args: Array<String>){

var age : Byte = 27         //定义一个 Byte 类型数据

var time_stap : Long        //定义一个 Long 类型数据

var name : String = "Joe"   //定义一个 字符串 数据

var height : Short          //定义一个 Short 类型数据

val dna : String = "DNA Sequence"
dna = "DNA Sequence2"

}

4.错误信息 : Val cannot be reassigned , 常量不可以被赋值;

5. 变量取值范围

(1) 变量取值范围简介

Kotlin 数据类型 :

1.Byte : 字节, 大小 1byte, 范围 -128 ~ 127;

2.Short : 短整型, 大小 2byte, 范围 -32769 ~ 32767;

3.Int : 整形, 大小 4byte, 范围 -2147483648 ~ 2147483647;

4.Long : 长整形, 大小 8byte, 范围 -9223372036854775807 ~ 9223372036854775807;

5.Float : 单精度浮点型, 精确到 小数点后 6 位;

6.Double : 双精度浮点型, 精确到 小数点后 16 位;

7.String : 字符串类型;

(2) 变量取值范围 代码示例

变量取值范围代码示例 :

1.代码内容 :

fun main(args : Array<String>){
val byte_max : Byte = Byte.MAX_VALUE    //Byte 类型最大值
val byte_min : Byte = Byte.MIN_VALUE    //Byte 类型最小值
println("byte_min : " + byte_min + " , byte_max : " + byte_max)

val short_max : Short = Short.MAX_VALUE //Short 最大值
val short_min : Short = Short.MIN_VALUE //Short 最小值
println("short_min : " + short_min + " , short_max : " + short_max)

val int_max : Int = Int.MAX_VALUE   //Short 最大值
val int_min : Int = Int.MIN_VALUE   //Short 最小值
println("int_min : " + int_min + " , int_max : " + int_max)

val long_max : Long = Long.MAX_VALUE    //Long 最大值
val long_min : Long = Long.MIN_VALUE    //Long 最小值
println("long_min : " + long_min + " , long_max : " + long_max)

val float_max : Float = Float.MAX_VALUE //Float 最大值
val float_min : Float = Float.MIN_VALUE //Float 最小值
println("float_min : " + float_min + " , float_max : " + float_max)

val double_max : Double = Double.MAX_VALUE  //Double 最大值
val double_min : Double = Double.MIN_VALUE  //Double 最小值
println("double_min : " + double_min + " , double_max : " + double_max)
}

2.执行结果 :

byte_min : -128 , byte_max : 127
short_min : -32768 , short_max : 32767
int_min : -2147483648 , int_max : 2147483647
long_min : -9223372036854775808 , long_max : 9223372036854775807
float_min : 1.4E-45 , float_max : 3.4028235E38
double_min : 4.9E-324 , double_max : 1.7976931348623157E308

四. Kotlin 简单使用

1. Kotlin 简单代码测试

(1)Main函数

Main 函数 简介 :

1.说明 : main 函数是 Kotlin 的入口函数, 即 执行 Kotlin 应用寻找的第一个函数;

2.代码示例 :

fun main(args : Array<String>){
}

(2)Println函数

Println 函数简介 :

1.说明 : 将函数参数打印到控制台上;

2.代码示例 :

fun main(args : Array<String>){
println("打印到控制台")
}

(3)打印 三角形 示例

打印三角形 :

1.代码示例 :

fun main(args : Array<String>){
//打印三角形
println("   *")
println("  ***")
println(" *****")
println("*******")
}

2.运行结果 :

*
***
*****
*******

2. Boolean 运算

(1) 简单 Boolean 运算 1 (数值对比)

对比运算示例代码 :

1.示例代码 : 对比两个简单的数值;

fun main(args : Array<String>){

//1.比较两个简单数字大小
var age_1 : Int = 16
var age_2 : Int = 18

var bigger : Boolean = age_1 > age_2

println("age_1 : " + age_1 + " , age_2 : " + age_2)
println("bigger : " + bigger)
}

2.运行结果 :

age_1 : 16 , age_2 : 18
bigger : false

(2) 简单 Boolean 运算 2 (带开放运算)

带开放运算的 对比 :

1.对比内容 : 5√−4√>4√−3√

2.调用API : Math.sqrt(), 开平方计算;

3.代码示例 :

fun main(args : Array<String>){

//2.(根号5 - 根号4) 与( 根号4 - 根号3) 对比
var num_1 = Math.sqrt(5.0) - Math.sqrt(4.0);
var num_2 = Math.sqrt(4.0) - Math.sqrt(3.0);

bigger = num_1 > num_2

println("num_1 : " + num_1 + " , num_2 : " + num_2)
println("bigger : " + bigger)
}

4.运行结果 :

num_1 : 0.2360679774997898 , num_2 : 0.2679491924311228
bigger : false

(3) 简单 Boolean 运算 2 (幂运算 对比)

带幂运算的对比 :

1.对比公式 :2100>375

2.幂运算 API : Math.pow(2.0, 100.0), 计算 2 的 100 次方, 注意传入的参数必须都是 double 类型;

3.代码示例 :

fun main(args : Array<String>){

//3. 2的100次方 与 3的75次方 对比
var num_3 : Double = Math.pow(2.0, 100.0);
var num_4 : Double = Math.pow(3.0, 75.0);

println("num_3 : " + num_3 + " , num_4 : " + num_4)
bigger = num_3 > num_4

println("bigger : " + bigger)
}

4.执行结果 :

num_3 : 1.2676506002282294E30 , num_4 : 6.0826678771335774E35
bigger : false

3. 在命令行进行运算

命令行计算 :

1.打开命令行 : 打开 windows cmd 中断, 输入 kotlinc, 进入命令行模式 (需要安装命令行工具并配置环境变量);

C:\Users\octopus-han>kotlinc
Welcome to Kotlin version 1.1.4 (JRE 1.8.0_25-b18)
Type :help for help, :quit for quit
>>>

- 2.命令行计算过程 :

C:\Users\octopus-han>kotlinc
Welcome to Kotlin version 1.1.4 (JRE 1.8.0_25-b18)
Type :help for help, :quit for quit
>>> 16 > 27false
>>>
>>> Math.sqrt(5.0)
2.23606797749979
>>>
>>> Math.sqrt(5.0) - Math.sqrt(4.0)
0.2360679774997898
>>>
>>> Math.sqrt(4.0) - Math.sqrt(3.0)
0.2679491924311228
>>>
>>> Math.pow(2.0, 100.0)
1.2676506002282294E30
>>>
>>> Math.pow(3.0, 75.0)
6.0826678771335774E35
>>>

4. 函数编写规则

(1)函数格式

函数编写规则 :

1.编写格式 : fun 函数名(参数名 : 参数类型) : 返回值类型 {}

fun 函数名(参数名 : 参数类型) : 返回值类型 {
函数内容
}

(2)函数格式 代码示例

函数格式代码示例 :

1.代码示例 :

fun main(args:Array<String>):Unit{
}

2.代码示例解析 :

a.函数标识 : fun, 固定写法, 说明这是个函数, 变量使用 var 声明, 常量使用 val 声明;

b.函数名 : main, 入口函数;

c.参数名 : args, 参数名, 可以使其它名称, 符合标准即可;

d.参数类型 : Array, 参数的类型;

e.返回值类型 : Unit, 代表无返回值;

(3) 计算器代码示例

计算器代码示例 :

1.代码示例 :

fun main(args : Array<String>){

var a : Int = 4
var b : Int = 2

println(plus(a, b))     //计算 a + b
println(subtract(a, b)) //计算 a - b
println(multiply(a, b)) //计算 a * b
println(divide(a, b))   //计算 a / b

}

//加法函数
fun plus(a : Int, b : Int):Int{
return a + b;
}

//减法函数
fun subtract(a : Int, b : Int):Int{
return a - b;
}

//乘法函数
fun multiply(a : Int, b : Int):Int{
return a * b;
}

//乘法函数
fun divide(a : Int, b : Int):Int{
return a / b;
}

2.执行结果 :

6
2
8
2

5. 字符串模板

(1)字符串模板格式

字符串模板格式简介 :

1.模板格式 :

"""模板字符串1${变量表达式}模板字符串2"""

2.模板内容 : 模板的内容使用 三个引号 “”” “”” 括起来;

3.模板占位符 : ${表达式} 是字符串替换占位符;

(2)字符串模板代码示例

字符串模板代码示例 :

1.代码示例 :

fun main(args : Array<String>){
println(student_data("Joe", 27))

println(student_data("Jane", 30))
}

//占位符 字符串模板 """模板内容""" 使用 """ 三个引号括起来, ${表达式} 是用来替换的字符串内容
fun student_data(name : String, age : Int) : String{
var student_data : String = """学生 ${name} 资料 : 年龄 ${age}, 学生名字位数 : ${name.length}"""
return student_data
}

2.执行结果 :

学生 Joe 资料 : 年龄 27, 学生名字位数 : 3
学生 Jane 资料 : 年龄 30, 学生名字位数 : 4

6. 条件控制

(1)条件控制示例 1

条件控制代码示例 :

1.需求 : 输入分数, 大于等于 60分及格, 小于 60 分不及格;

2.代码示例 :

//查看是否及格
fun main(args : Array<String>){
check_score(59)
check_score(61)
}

//检查分数是否合格, 大于等于  60 分合格, 否则 不合格
fun check_score(score : Int) : Boolean{
var is_pass : Boolean
if(score >= 60){
println("及格")
is_pass = true
}else{
println("不及格")
is_pass = false
}
return is_pass
}

3.运行结果 :

不及格
及格

(2)条件控制示例2

条件控制代码示例 :

1.需求 : 返回两个数之间较大的数字;

2.代码示例 :

//返回较大的数
fun main(args : Array<String>){
var num1 : Int = 27
var num2 : Int = 30
println("${num1} 和 ${num2} 中较大的数字是 ${get_bigger_num(num1, num2)}")
}

//返回较大的数
fun get_bigger_num (num1 : Int, num2 : Int) : Int{
var bigger_int : Int = 0
if(num1 > num2){
bigger_int = num1
}else if(num1 < num2){
bigger_int = num2
}else if(num1 == num2){
bigger_int = num1
}
return bigger_int
}

3.执行结果 :

27 和 30 中较大的数字是 30

7. 字符串比较

字符串比较 :

1.字符串比较方法 : == 符号可以比较两个字符串, 注意这里与 Java 不同, Kotlin 中的 == 等价于 Java 中的 equals() 方法;

2.忽略大小写方法 : Kotlin中, equals 有第二个参数, 将第二个参数设置为 true, 即忽略大小写对比字符串内容是否相等;

3.代码示例 :

//字符串比较
fun main(args : Array<String>){
var name1 : String = "Joe"
var name2 : String = "joe"
var name3 : String = "Joe"

//Kotlin 中 == 是字符串对比, 不是 地址对比, == 等价于 Java 中的 equals 方法
println(name1 == name2)
println(name1.equals(name2))

println(name1 == name3)
println(name1.equals(name3))

//忽略字幕大小写对比
println(name1.equals(name2, true))
}

4.执行结果 :

false
false
true
true
true

8. 函数参数空值处理

Kotlin 空值处理 : 这里的空值处理是指函数传入的空值处理方案;

1.空值处理方案 : Kotlin 默认设置不接收 null, 如果传入 null 参数, 编译时就会报错;

2.接收空值设置 : 如果函数参数可以接收空值, 在参数类型后加上 ? 即可, 如 fun fun_name(参数名 : 参数类型 ? )

3.代码示例 :

//获取学生数据
fun student(name : String, age : Int) : String{
return "name : " + name + " , age : " + age
}

//获取学生数据, 如果设置可以接收控制, 那么在参数类型后加上 ?
fun student_null(name : String ?, age : Int) : String{
return "name : " + name + " , age : " + age
}

fun main(args : Array<String>){
//null 值代表没有数据
//Kotlin 语言 在 编译时就不允许将 null 传入函数, 这样在编译时避免了空指针异常

var student_data : String = student("Joe", 27)
println(student_data)

//编译时传入了控制, 函数默认设置不可接收控制, 报错
var student_data1 : String = student(null, 27)

//该函数设置了可以接收控制, 因此不报错
var student_data2 : String = student_null(null, 27)
}

4.报错信息 :

9. when 表达式

when 表达式 :

1.when 表达式格式 : 该表达式类似于 switch 语句, 接收 int 类型参数, else 相当于 default 选项;

when (int表达式)
int数值1 -> 对应结果1
int数值2 -> 对应结果2
int数值3 -> 对应结果3
else -> 对应其它结果

2.when表达式代码示例 :

fun main(args : Array<String>){
score_grade(0)
score_grade(91)
score_grade(100)
score_grade(61)
}

//when 表达式类似于 switch 语句, else 相当于 default
fun score_grade(score : Int){
when(score){
100 -> println("满分")
61 -> println("及格")
59 -> println("不及格")
0 -> println("鸭蛋")
else -> println("分数 : " + score)
}
}

3.执行结果 :

鸭蛋
分数 : 91
满分
及格

10. Loop 和 Range 使用

(1)区间 和 循环 简单示例

区间 和 循环 简介 :

1.区间简介 : 使用 .. 可以定义区间, 下面是区间定义的代码片段 :

//声明一个数组范围是 1 ~ 100, 定义了 1 ~ 100 的 闭区间(包含1 和 100)
var nums = 1 .. 100

2.循环简介 : 使用 in 关键字, 可以循环遍历数组, 下面是一段 in 关键字循环的代码片段 :

var nums = 1 .. 100
//遍历数组, 使用  in 关键字, 取出数组中的元素
for(num in nums){
//执行内容
}

3.区间循环代码示例 : 先定义一个区间, 然后循环遍历计算区间范围内的累加和;

fun main(args : Array<String>){
//声明一个数组范围是 1 ~ 100, 定义了 1 ~ 100 的 闭区间(包含1 和 100)
var nums = 1 .. 100
//存储结果
var result : Int = 0;

//遍历数组, 使用  in 关键字, 取出数组中的元素
for(num in nums){
result += num
}
println(result)
}

4.执行结果 :

5050

(2) 其它用法简介

数组 循环 范围 其它用法简介 :

1.设置开区间 : 使用 until 关键字, 如 1 until 100, 取值范围是 1 ~ 99;

//取值范围 1 ~ 99
var nums_2 = 1 until 100    //[1, 100) 前闭后开区间

2.设置遍历步长 : 使用 step 关键字, 如 for(num in nums_3 step 4) , 每隔 4 个元素遍历一个;

//1. 设置步长遍历, 每隔 4 位执行一次
for(num in nums_3 step 4){
println(num)
}

3.设置数组倒序 : 调用数组的 reversed() 方法;

//2. 数组倒序
var nums_4 = nums_3.reversed()

4.获取数组个数 : 调用数组的 count() 方法;

//3. 获取数组个数
var array_count : Int = nums_4.count()

5.代码示例 :

fun main(args : Array<String>){
//声明一个数组范围是 1 ~ 100, 定义了 1 ~ 100 的 闭区间(包含1 和 100)
var nums = 1 .. 100
//存储结果
var result : Int = 0;

//遍历数组, 使用  in 关键字, 取出数组中的元素
for(num in nums){
result += num
}
println(result)

//取值范围 1 ~ 99
var nums_2 = 1 until 100    //[1, 100) 前闭后开区间
//for(num in nums_2) println(num)

var nums_3 = 1 .. 20

//1. 设置步长遍历, 每隔 4 位执行一次
for(num in nums_3 step 4){
println(num)
}

//2. 数组倒序
var nums_4 = nums_3.reversed()

for(num in nums_4 step 5){
println(num)
}

//3. 获取数组个数
var array_count : Int = nums_4.count()
println("nums_4 count : " + array_count)

}

6.执行结果 :

50501
5
9
13
17
20
15
10
5
nums_4 count : 20

11. List 和 Map 入门

(1)List 简单示例

List 简单示例 :

1.List 定义 : 使用 listOf 初始化 list;

//1.定义一个 List
var lists = listOf("Joe", "Bob", "Jane")

2.遍历 List : 使用 in 关键字, 遍历 list;

//2.打印内容
for(name in lists){
println(name)
}

3.打印List 索引 : 使用 i 代表索引, e 代表内容 打印 List 元素 + 索引;

//3.打印索引和内容
for((i, e) in lists.withIndex()){
println("${i} ${e}")
}

4.代码示例 :

fun main(args : Array<String>){
//1.定义一个 List
var lists = listOf("Joe", "Bob", "Jane")

//2.打印内容
for(name in lists){
println(name)
}

//3.打印索引和内容
for((i, e) in lists.withIndex()){
println("${i} ${e}")
}
}

5.执行结果 :

Joe
Bob
Jane
0 Joe
1 Bob
2 Jane

(2)Map 简单示例

Map 简单示例 :

1.定义Map : 直接使用 TreeMap

//导入的包
import java.util.TreeMap

//1. 创建 map, 注意导入包
var map = TreeMap<String, Int>()

2.为Map赋值 : map变量名[key值] = value值;

//2. 为 map 赋值
map["Joe"] = 27
map["Bob"] = 16
map["Jane"] = 24

3.取出Map中的内容 : value值 = map变量名[key值];

//获取 map 中的内容
println(map["Joe"])

4.代码示例 :

import java.util.TreeMap

fun main(args : Array<String>){
//1. 创建 map, 注意导入包
var map = TreeMap<String, Int>()

//2. 为 map 赋值
map["Joe"] = 27
map["Bob"] = 16
map["Jane"] = 24

//获取 map 中的内容
println(map["Joe"])
}

5.执行结果 :

27

四. 函数

1. 函数声明的方式

函数声明的方式 :

1.最正常的函数声明 : 带 {} 和 return 返回值;

//1.一个中规中矩 的 加法 方法, 传入 Int 参数 a 和  b, 返回 a + b
fun plus (a : Int, b : Int) : Int{
return a + b
}

2.省略 {} 和 return 的声明方式 : 如果函数只有一行, 那么可以省略大括号 {}, 将 return 换成 等号 = ;

//2.如果函数只有一行, 可以将 {} 和 return 关键字省略, 同时 用 = 代替
fun plus_1 (a : Int, b : Int) : Int = a + b

3.定义函数变量 : 定义的 带 参数 返回值的函数 可以直接赋给一个变量, 这个变量就是函数变量, 类似于 C 中的函数指针;

//3.定义函数变量, 类似于 C 中的函数指针, 返回值 使用 -> 标识
var plus_3 = {a : Int, b : Int -> a + b}

4.定义带类型的函数变量 : 赋值给 函数 的变量 可以 声明一个类型, 这个类型由 参数 -> 返回值 组成, 在对应的函数定义的 {} 中只使用变量名称对应类型即可;

//5.声明函数, 显示声明其类型,
//函数类型声明 (声明函数 参数 返回值 类型) : (Int : Int) -> Int 声明参数是两个 Int 值, 返回值是 Int 值,
//函数参数声明 (声明函数 参数 返回值 变量 及 函数体) : {a, b -> a + b} 是
var plus_4 : (Int, Int) -> Int = {a, b -> a + b}

5.代码示例 :

fun main(args : Array<String>){

//1.测试正常方法
var result : Int = plus(1, 2)
println(result)

//2.测试简化方法
result = plus_1(1, 2)
println(result)

//3.定义函数变量, 类似于 C 中的函数指针, 返回值 使用 -> 标识
var plus_3 = {a : Int, b : Int -> a + b}

//4.测试函数变量方法
result = plus_3(1, 2)
println(result)

//5.声明函数, 显示声明其类型,
//函数类型声明 (声明函数 参数 返回值 类型) : (Int : Int) -> Int 声明参数是两个 Int 值, 返回值是 Int 值,
//函数参数声明 (声明函数 参数 返回值 变量 及 函数体) : {a, b -> a + b} 是
var plus_4 : (Int, Int) -> Int = {a, b -> a + b}

//6.测试显示声明函数变量方法
result = plus_4(1, 2)
println(result)

}

//1.一个中规中矩 的 加法 方法, 传入 Int 参数 a 和  b, 返回 a + b
fun plus (a : Int, b : Int) : Int{
return a + b
}

//2.如果函数只有一行, 可以将 {} 和 return 关键字省略, 同时 用 = 代替
fun plus_1 (a : Int, b : Int) : Int = a + b

6.运行结果 :

3
3
3
3

2. 默认参数 和 具名参数

默认参数 和 具名参数 :

1.默认参数 : 定义一个常量, 参数定义时 变量名 : 变量类型 = 常量值, 这个参数就是默认参数;

val PI : Float = 3.1415926f

//计算圆面积, 其中的 pi 是默认参数
fun circle_area(pi : Float = PI, radius : Float) : Float{
return 2 * pi * radius * radius
}

2.具名参数 : 调用方法时, 传参时, 使用 变量名 = 常量, 这就是具名参数用法;

//2. 具名参数, 其中的 radius = 6.0f 是具名参数
var area_2 = circle_area(radius = 6.0f)

3.代码示例 :

//定义常量
val PI : Float = 3.1415926f

fun main(args : Array<String>){

//1. 普通参数
var area_1 = rect_area(4.0f, 6.0f)
println(area_1)

//2. 具名参数, 其中的 radius = 6.0f 是具名参数
var area_2 = circle_area(radius = 6.0f)
println(area_2)

}

//计算长方形面积
fun rect_area(width : Float, height : Float) : Float{
return width * height
}

//计算圆面积, 其中的 pi 是默认参数
fun circle_area(pi : Float = PI, radius : Float) : Float{
return 2 * pi * radius * radius
}

//计算圆周长, 其中的 pi 是默认参数
fun circle_perimeter(pi : Float = PI, radius : Float) : Float{
return 2 * pi * radius
}

//计算圆柱体体积, 其中的 pi 是默认参数
fun cylinder_volume(pi : Float = PI, radius : Float, height : Float) : Float{
return 2 * pi * radius * radius * height
}

//计算球体面积, 其中的 pi 是默认参数
fun sphere_area(pi : Float = PI, radius : Float) : Float{
return 4 * pi * radius * radius
}

4.执行结果 :

24.0
226.19467

3. 字符串数字之间转换

字符串 与 数字 之间转换 :

1.字符串转数字 : 调用 字符串的 toInt() 方法即可;

num = str.toInt()   //将 str 转为 Int 类型, 并赋值给 num 变量

2.数字转字符串 : 调用数字的 toString() 方法即可;

str = num.toString()//将 num 转为 String 类型, 并赋值给 str 变量

3.注意 : 字符串转数字前要先看下 字符串 是否是数字格式, 如果不符合数字格式, 会报异常;

var str_1 = "Joe"
num = str_1.toInt()

//异常内容
Exception in thread "main" java.lang.NumberFormatException: For input string: "Joe"
at java.lang.NumberFormatException.forInputString(Unknown Source)
at java.lang.Integer.parseInt(Unknown Source)
at java.lang.Integer.parseInt(Unknown Source)
at Kotlin_10_strnumKt.main(Kotlin_10_strnum.kt:12)

4.代码示例 :

fun main(args : Array<String>){
var str = "27"
var num = 27
num = str.toInt()   //将 str 转为 Int 类型, 并赋值给 num 变量
str = num.toString()//将 num 转为 String 类型, 并赋值给 str 变量

println(str + " , " + num)

var str_1 = "Joe"
num = str_1.toInt()
}

5.执行结果 :

27 , 27Exception in thread "main" java.lang.NumberFormatException: For input string: "Joe"
at java.lang.NumberFormatException.forInputString(Unknown Source)
at java.lang.Integer.parseInt(Unknown Source)
at java.lang.Integer.parseInt(Unknown Source)
at Kotlin_10_strnumKt.main(Kotlin_10_strnum.kt:12)

4. 人机交互

简单的人机交互栗子 :

1.需求 : 从控制台输入两个数字, 并将两个数字相加打印出来;

2.从控制台读取字符串 : readLine() 方法, 返回一个字符串;

//从控制台输入字符串, 然后将字符串赋值给 num_1_str
var num_1_str = readLine()

3.设置空值处理 : 调用 toInt() 前使用 !! 标识, 表示可接受空值, 需要确保输入的不是空值;

//将输入的两个字符串转为 Int 类型, 注意这里要做一下 非空设置, !! 代表 确保输入的数字不是 null, 如果输入 null 就会爆出异常
var num_1 : Int = num_1_str!!.toInt()

4.代码示例 :

//键盘接受数据, 然后将接收的数据处理后, 将结果打印出来

fun main(args : Array<String>){
println("输入数字1 : ")
//从控制台输入字符串, 然后将字符串赋值给 num_1_str
var num_1_str = readLine()

println("输入数字2 : ")
//从控制台输入字符串, 然后将字符串赋值给 num_1_str
var num_2_str = readLine()

//将输入的两个字符串转为 Int 类型, 注意这里要做一下 非空设置, !! 代表 确保输入的数字不是 null, 如果输入 null 就会爆出异常
var num_1 : Int = num_1_str!!.toInt()
var num_2 : Int = num_2_str!!.toInt()
println("${num_1} + ${num_2} = ${num_1 + num_2}")
}

5.运行结果1 (正常结果) : 正确输入, 走完流程;

输入数字1 :
27输入数字2 :
16
27 + 16 = 43

6.运行结果2 (异常结果) : 故意输入空值, 产生异常;

输入数字1 :

输入数字2 :

Exception in thread "main" java.lang.NumberFormatException: For input string: ""
at java.lang.NumberFormatException.forInputString(Unknown Source)
at java.lang.Integer.parseInt(Unknown Source)
at java.lang.Integer.parseInt(Unknown Source)
at Kotlin_11_reactKt.main(Kotlin_11_react.kt:13)

5. 异常处理

(1) 异常处理示例

处理异常 :

1.异常产生原因 : 在上面的计算器示例中, 要求输入数字, 结果输入 a, 导致 类型转换 异常;

Exception in thread "main" java.lang.NumberFormatException: For input string: ""
at java.lang.NumberFormatException.forInputString(Unknown Source)
at java.lang.Integer.parseInt(Unknown Source)
at java.lang.Integer.parseInt(Unknown Source)
at Kotlin_11_reactKt.main(Kotlin_11_react.kt:13)

2.异常处理格式 :

try{
}catch(e : Exception){
//异常处理代码
}

3.异常处理代码示例 :

import java.lang.Exception

fun main(args: Array<String>) {
println("输入数字1 : ")
//从控制台输入字符串, 然后将字符串赋值给 num_1_str
var num_1_str = readLine()

println("输入数字2 : ")
//从控制台输入字符串, 然后将字符串赋值给 num_1_str
var num_2_str = readLine()

try {
//将输入的两个字符串转为 Int 类型, 注意这里要做一下 非空设置, !! 代表 确保输入的数字不是 null, 如果输入 null 就会爆出异常
var num_1: Int = num_1_str!!.toInt()
var num_2: Int = num_2_str!!.toInt()
println("${num_1} + ${num_2} = ${num_1 + num_2}")
} catch(e: Exception) {
println("输入数据产生异常!!!")
}
}

4.执行结果 :

输入数字1 :
1
输入数字2 :
a
输入数据产生异常!!!

6. 递归

(1) 阶乘示例

阶乘示例 :

1.使用递归完成一个阶乘示例 : 代码如下

//使用递归完成一个阶乘运算
fun main(args : Array<String>){
var num = 4;

//打印出 4 的阶乘 4 * 3 * 2 * 1
println(factorial(num))

//数字太大, 溢出了
println(factorial(50))
}

//阶乘方法
fun factorial(num : Int) : Int{
if(num == 1){
return 1;
}else{
return num * factorial(num - 1)
}
}

2.执行结果 :

24
0

(2) 阶乘大数字示例

使用 BigInteger 解决阶乘溢出问题 : 该问题在 Java 中无法解决, Kotlin 可以解决;

1.代码示例 :

import java.math.BigInteger

//解决阶乘数据溢出问题
fun main(args : Array<String>){
var num = BigInteger("50")

//计算 50 的阶乘
println(factorial(num))
}

//巨大的数字的阶乘
fun factorial(num : BigInteger) : BigInteger{
if(num == BigInteger.ONE){
return BigInteger.ONE
}else{
return num * factorial(num - BigInteger.ONE)
}
}

2.运行结果 :

30414093201713378043612608166064768844377641568960512000000000000

7. 尾递归优化 (解决堆栈溢出问题)

(1) 问题说明

堆栈溢出异常 :

1.代码示例 :

//进行累加操作
fun main(args : Array<String>){

//3 + 2 + 1 = 6
println(factorial_add(3))

//10万累加, 出现堆栈溢出操作
println(factorial_add(100000))
}

//计算 num 累加, num + (num - 1) + (num - 2) ... + 1
fun factorial_add(num : Int) : Int{
if(num == 1){
return 1
}else{
return num + factorial_add(num - 1)
}
}

2.执行结果 :

6
Exception in thread "main" java.lang.StackOverflowError
at Kotlin_14_Factorial_2Kt.factorial_add(Kotlin_14_Factorial_2.kt:16)
at Kotlin_14_Factorial_2Kt.factorial_add(Kotlin_14_Factorial_2.kt:16)
at Kotlin_14_Factorial_2Kt.factorial_add(Kotlin_14_Factorial_2.kt:16)
at Kotlin_14_Factorial_2Kt.factorial_add(Kotlin_14_Factorial_2.kt:16)
at Kotlin_14_Factorial_2Kt.factorial_add(Kotlin_14_Factorial_2.kt:16)
at Kotlin_14_Factorial_2Kt.factorial_add(Kotlin_14_Factorial_2.kt:16)
at Kotlin_14_Factorial_2Kt.factorial_add(Kotlin_14_Factorial_2.kt:16)
... ...

(2) 尾递归优化

尾递归优化 :

1.代码示例 :

//进行累加操作
fun main(args : Array<String>){

var result = 0
//10万累加, 出现堆栈溢出操作
println(factorial_add_optimize(100000, result))
}

//经过尾递归优化后的方法, 计算 num 累加, num + (num - 1) + (num - 2) ... + 1
tailrec fun factorial_add_optimize(num : Int, result : Int) : Int{
println("${num} . result = ${result}" )
if(num == 0){
return 1
}else{
return factorial_add_optimize(num - 1, result + num)
}
}

2.执行结果 :

...
5 . result = 705082689
4 . result = 705082694
3 . result = 705082698
2 . result = 705082701
1 . result = 705082703
0 . result = 705082704
1