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

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<String>){
  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<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

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

4.说明 : 在 var age = 27, 语句中, age 变量就被推断为 int 类型, 此时如果将其它类型, 就会报错;
5.注意 : 智能类型推断是根据 = 后面的内容进行推断, 如果只定义 var age 就会报错;

This variable must either have a type annotation or be initialized

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

3. 显式类型声明 ( var 变量名 : 变量类型 (= 变量值) | var age : Byte = 27 | var time_stap : Long | var name : String = “Joe” )

显示类型声明 :

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. 常量 ( val 常量名 : 常量类型 = 常量值 )

常量声明 :

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 ) 变量取值范围简介 ( 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<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函数 ( fun main(args : Array){} )

Main 函数简介 :

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

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

( 2 ) Println函数 ( 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 \sqrt{5} - \sqrt{4} > \sqrt{4} - \sqrt{3} 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);

  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<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
>>>

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

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
>>>

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

4. 函数编写规则

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

函数编写规则 :

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

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

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

函数格式代码示例 :

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.执行结果 :

5. 字符串模板

( 1 ) 字符串模板格式 ( “”“模板字符串1${变量表达式}模板字符串2"”" )

字符串模板格式简介 :

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. 字符串比较 ( == 符号可以比较两个字符串, 不是地址对比, == 等价于 Java 中的 equals 方法 | 以下对比等价 name1 == name2 等价于 name1.equals(name2) | 忽略大小写对比 name1.equals(name2, true) )

字符串比较 :

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. 函数参数空值处理 ( 函数参数默认不接收 null | 如果需要接收在参数后加上 ? | 举例 : fun student_null(name : String ?, age : Int) : String{ } )

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 表达式 ( switch | when (int表达式) int数值1 -> 对应结果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<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 ) 区间和循环简单示例 ( 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<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.执行结果 :

( 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<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.执行结果 :

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<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 创建 TreeMap<String, Int>() | Map 赋值 map变量名[key值] = value值 | Map 取值 value值 = map变量名[key值] )

Map 简单示例 :

1.定义Map : 直接使用 TreeMap<String, Int>() 创建 Map, 注意这里没有 new, 另外需要导入包

//导入的包
  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.执行结果 :

五. 函数

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<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.运行结果 :

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. 字符串数字之间转换 ( 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<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 , 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<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. 异常处理 ( 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<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

上一篇：Android Studio NDK 代码 Source Insight调试 (NDK 目前开发方案 | NDK 编译 | 导入 so 库 | 项目编码转换)

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯