【Kotlin】Kotlin 语言基础 ( 环境安装 | 变量 | 简单使用 | 函数 | 异常 | 递归 )

一. Kotlin 环境安装 1. Eclipse 环境安装 ( 1 ) 相关下载地址 ( 下载 eclipse | JDK | Kotlin插件 )

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 环境安装 ( 安装 eclipse | 安装 JDK 配置环境变量 | 安装 Kotlin 插件 )

Kotlin Eclipse 环境安装 :

• 1.解压 Eclipse :
• 2.安装 JDK 并配置环境变量 : 自行百度;
• 3.安装 Kotlin 插件 : 下面详解;

( 3 ) Eclipse 插件安装 ( Help -> Eclipse Marketplace | 搜索 Kotlin 插件 | 安装 Kotlin Plugin for Eclipse 0.8.2 插件 | 期间点下一步 接收协议 警告框 OK | 重启 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 环境安装 ( 自带 Kotlin 环境 ) ( 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 ) 相关下载地址 ( 官网 GitHub 中下载 )

Kotlin 相关下载地址 :

• 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 命令行工具 ( 配置 Java 环境变量 | 配置 Kotlin 环境变量 即 Kotlin 安装目录下的 bin 目录 )

安装 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 工程 ( eclipse 中创建 Kotlin Project | 输入工程名 | src 下创建 kotlin 文件 )

创建 Kotlin 工程 :

• 1.搜索 Kotlin 工程 : 安装完 Kotlin 插件后, 就可以创建 Kotlin 工程了, 第一次需要在 创建栏 里 找到 Kotlin 工程;
• 2.输入 工程名称 :
• 3.查看创建的 Kotlin 工程 :
• 4.在 src 下创建一个 Kotlin 文件 :

( 2 ) Kotlin 的 Hello World 代码

Hello World 代码 :

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

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

• 2. 执行结果 :

Hello World!

( 3 ) Hello World 代码分析 ( 函数声明 fun | 程序入口 main | 主程序参数 args | 控制台打印 println )

代码分析 :

• 1.fun : 函数声明, 与 其它语言不太一致;
• 2.main : 程序执行入口, 与其它语言基本一致;
• 3.args : 主程序执行 输入的参数, 类似于 C 语言中的 int argc, char ** argv, 或者 Java 中的 String[] args;
• 4.println : 向控制台打印字符串数据;

三. 变量声明和使用 1. 数据类型 大小 范围 简介 ( Byte 1 | Short 2 | Int 4 | Long 8 | Float | Double | String )

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 类型智能推断 ( var 定义变量 第一次赋值 才被赋予类型 )

类型推断 :

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

( 2 ) Kotlin 类型智能推断 代码示例 ( var 声明变量 第一次初始化赋值 确定类型 | 变量定义 或者 显示声明类型 或者 直接赋值一个值 进行智能类型推断 )

智能类型推断 代码示例 :

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

fun main(args: Array){
	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. 显式类型声明 ( var 变量名 : 变量类型 (= 变量值) | var age : Byte = 27 | var time_stap : Long | var name : String = “Joe” )

显示类型声明 :

• 1.格式 : var 变量名 : 变量类型 (= 变量值) ;
• 2.变量定义必须赋予类型 : 如果变量定义的时候不赋予类型, 就会报错;
• 3.指定类型方式 : ① 智能推断类型, ② 显示类型声明;
• 4.代码示例 :

fun main(args: Array){
	
	var age : Byte = 27			//定义一个 Byte 类型数据
	
	var time_stap : Long		//定义一个 Long 类型数据
	
	var name : String = "Joe"	//定义一个 字符串 数据
	
	var height : Short			//定义一个 Short 类型数据
	
}

4. 常量 ( val 常量名 : 常量类型 = 常量值 )

常量声明 :

• 1.格式 : val 常量名 = 常量值 ;
• 2.注意 : 常量不可以修改, 尝试给常量赋值 会 报错;
• 3.代码示例 : 注意, 这里 最后 一行 会报错;

fun main(args: Array){
	
	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 ) 变量取值范围简介 ( Byte -128 ~ 127 | Short -32768 ~ 32767 | 详情看下面代码示例 )

Kotlin 数据类型 :

• 1.Byte : 字节, 大小 1byte, 范围 -128 ~ 127;
• 2.Short : 短整型, 大小 2byte, 范围 -32768 ~ 32767;
• 3.Int : 整形, 大小 4byte, 范围 -2147483648 ~ 2147483647;
• 4.Long : 长整形, 大小 8byte, 范围 -9223372036854775807 ~ 9223372036854775807;
• 5.Float : 单精度浮点型, 精确到 小数点后 6 位;
• 6.Double : 双精度浮点型, 精确到 小数点后 16 位;
• 7.String : 字符串类型;

( 2 ) 变量取值范围 代码示例 ( Byte 最大值 Byte.MAX_VALUE 最小值 Byte.MIN_VALUE | 所有数据类型的 最小值 数据类型.MIN_VALUE | 所有数据类型的最大值 数据类型.MAX_VALUE )

变量取值范围代码示例 :

• 1.代码内容 :

fun main(args : Array){
	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函数 ( fun main(args : Array){} )

Main 函数 简介 :

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

fun main(args : Array){
}

( 2 ) Println函数 ( println(“打印到控制台”) )

Println 函数简介 :

• 1.说明 : 将函数参数打印到控制台上;
• 2.代码示例 :

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

( 3 ) 打印 三角形 示例

打印三角形 :

• 1.代码示例 :

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

• 2.运行结果 :

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

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

对比运算示例代码 :

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

fun main(args : Array){

	//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 \sqrt{5} - \sqrt{4} > \sqrt{4} - \sqrt{3} 5 ​−4 ​>4 ​−3 ​
• 2.调用API : Math.sqrt(), 开平方计算;
• 3.代码示例 :

fun main(args : Array){
	
	//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);
	
	var 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.对比公式 : 2 100 > 3 75 2^{100} > 3^{75} 2100>375
• 2.幂运算 API : Math.pow(2.0, 100.0), 计算 2 的 100 次方, 注意传入的参数必须都是 double 类型;
• 3.代码示例 :

fun main(args : Array){
	
	//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 > 27
false
>>>
>>> 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 ) 函数格式 ( fun 函数名(参数名 : 参数类型) : 返回值类型 { 函数内容 } )

函数编写规则 :

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

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

( 2 ) 函数格式 代码示例 ( 函数标识 fun | 函数名 main | 参数名 args | 参数类型 Array | 返回值类型 Unit )

函数格式代码示例 :

• 1.代码示例 :

fun main(args:Array):Unit{
}

• 2.代码示例解析 :
  • a.函数标识 : fun, 固定写法, 说明这是个函数, 变量使用 var 声明, 常量使用 val 声明;
  • b.函数名 : main, 入口函数;
  • c.参数名 : args, 参数名, 可以使其它名称, 符合标准即可;
  • d.参数类型 : Array, 参数的类型;
  • e.返回值类型 : Unit, 代表无返回值;

( 3 ) 计算器代码示例

计算器代码示例 :

• 1.代码示例 :

fun main(args : Array){
	
	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${变量表达式}模板字符串2"”" )

字符串模板格式简介 :

• 1.模板格式 :

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

• 2.模板内容 : 模板的内容使用 三个引号 “”" “”" 括起来;
• 3.模板占位符 : ${表达式} 是字符串替换占位符;

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

字符串模板代码示例 :

• 1.代码示例 :

fun main(args : Array){
	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){
	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){
	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  对应结果1 int数值2 -> 对应结果2 else -> 对应其它结果 ) 
 
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){
	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 ) 区间 和 循环 简单示例 ( var nums = 1 … 100 定义 1 ~ 100 闭区间 | for(num in nums){ 执行操作 } 使用 in 区间 进行循环 | ) 
 
区间 和 循环 简介 :
 
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){
	//声明一个数组范围是 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 ) 其它用法简介 ( var nums_2 = 1 until 100 定义 1 ~ 100 的前闭后开区间 [1, 100) | 遍历步长设置 for(num in nums_3 step 4){} 每次累加 4 | 数组倒序 reversed() | 数组个数 count() ) 
 
数组 循环 范围 其它用法简介 :
 
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){
	//声明一个数组范围是 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.执行结果 :
 
5050
1
5
9
13
17
20
15
10
5
nums_4 count : 20

 
 
 
 
11. List 和 Map 入门 
 
( 1 ) List 简单示例 ( 定义 : var lists = listOf(“Joe”, “Bob”, “Jane”) | 遍历 : for(name in lists){} | for((i, e) in lists.withIndex()){ } : i 代表索引 e 代表内容) 
 
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){
	//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 创建 TreeMap() | Map 赋值 map变量名[key值] = value值 | Map 取值 value值 = map变量名[key值] ) 
 
Map 简单示例 :
 
1.定义Map : 直接使用 TreeMap() 创建 Map, 注意这里没有 new, 另外需要导入包
 
	//导入的包
	import java.util.TreeMap
	
	//1. 创建 map, 注意导入包
	var map = TreeMap()
 
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){
	//1. 创建 map, 注意导入包
	var map = TreeMap()
	
	//2. 为 map 赋值
	map["Joe"] = 27
	map["Bob"] = 16
	map["Jane"] = 24
	
	//获取 map 中的内容
	println(map["Joe"])
}
 
5.执行结果 :
 
27

 
 
 
 
 
五. 函数 
 
 
1. 函数声明的方式 ( 带 {} 和 return | 函数只有一行 可以省略 {} return 直接使用 = 替换 | 函数变量定义 | 定义带参数返回值函数 var plus_3 = {a : Int, b : Int -> a + b} | 定义带类型的函数变量 var plus_4 : (Int, Int) -> Int = {a, b -> a + b} ) 
 
函数声明的方式 :
 
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){
	
	//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){
	
	//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. 字符串数字之间转换 ( str.toInt() 字符串转数字 | 数字转字符串 toString() ) 
 
字符串 与 数字 之间转换 :
 
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){
	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 , 27
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. 人机交互 ( readLine() 从控制台读取数据 ) 
 
简单的人机交互栗子 :
 
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){
	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. 异常处理 ( try { } catch (e : Exception) {//异常处理代码} ) 
 
( 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) {
	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){
	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){
	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){
	
	//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){
	
	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