Kotlin 入门

引言

Kotlin 的优势

能在多平台运行
- 可以运行在多个平台
- 可以编写包括后端应用、前端页面、原生 Android 应用和原生 IOS 应用
可以使用静态类型编写更加安全类型的代码
- Kotlin 语言使用的是静态类型语言
- 代码在编译阶段就可以通过静态检查发现代码中的隐藏漏洞
支持函数式和面向对象两种编程示范式
兼容 Java

变量和常量

变量

变量用于存放数据。变量的数据类型不可被修改，但是变量所存放的数据室可以被修改的。 变量的创建
Kotlin 使用关键字 "var" 来创建

【语法】
    var 变量名: 数据类型
【举例】
    var a: Int
【初始化】
    a = 1
【创建+初始化】
    var b: Int = 2
【省略】
    var c = 3

数据类型在声明时可以被省略的根本原因：编译器可以用过等号右边的数据类型推断出登号左边的数据类型，如果没有为变量赋值，那么变量的数据类型的声明是不可以被省略的。

常量

常量和变量一样也是用来存放数据的。但是常量的数据类型和存放的数据都是不可以被修改的。 常量的创建 Kotlin 使用 "val" 来创建常量

val a: Int = 1

数据类型

Kotlin 数据类型分位一下两种：

基本数据类型：数值，字符，字符串，字节，布尔，数组
其他数据类型：集合、映射、类、接口。与 Java 不同的是，Kotlin 所有的基本数据类型都是引用类型，在数据上直接访问属性和调用方法。

数值类型——表示数字

数值类型又可以分为两种：

整形(整数)：整形(Int)、长整型(Long)、短整型(Short)

//整形：2的32次方
var a: Int = 1

//长整型：2的64次方
var b: Long = 100L

//短整型：2的16次方
var c: SHort = 100

//特殊字符(10000000000):方便算清数字长度无实际意义
var d = 1000_000_000

//十六进制
var e: Int = 0xFFF

//二进制
var f: Int = 0b000001

//Kotlin 不支持八进制

浮点型(带有小数部分)：单精度浮点型(Float)、双精度浮点型(Double)

//单精度浮点类型
var a: Float = 1.1F
var b: Float = 1.1f

//双精度浮点类型
var c: Double = 1.1D
var d: Double = 1.1d

//如果没有添加后缀默认是双精度浮点类型
var e = 1.1

字符与字符串类型——表示文本

字符类型(Char)表示一种单个字符(数字、字母、四则运算符、下画线)，使用单引号(' ')包裹

//字符
var a: Char = 'a'

字符串类型(String)表示多个字符组合在一起，需要双引号(" ")包裹

//字符串创建
var a: String = "Hello World"

//常用方法
// 获取长度
val length: Int = a.length

//使用"+"链接
var a: String = "Hello "
var b: String = "World "
var c: String = a + b
//输出 Hello world 
printLn(c)
//"+"左边是字符串右边也会当成字符串
var num: String = "one is "+ 1//正确
//"+"左边是数字，"+"会被当成运算符
var num: String = 1 + "is one"//错误

//依次打印字符串
var a: String = "Hello World"
for (c in a) {
    printIn(c)
}

//获得字符串某个字符
var a: String = "Hello World"
//直接访问字符串的第5位字符"o"
var b: Char = a[4]

//获取字符串某一段
var a: String = "Hello World"
//获取到：Wo 左闭右开
var b: String = a.subString(5,8)

//替换字符串
var a: String = "Hello World"
var b: String = a.replace("World","Kotlin")


//连接多个字符串
var str: String = "a" + "b" + "c"
//会创建5个字符串: a、b、c、ab、abc
//使用StringBuilder
val sb: StringBuilder = StringBuilder()
sb.append("Hello")
sb.append("World")
//使用Lambda
var str = buildString{
    append("Hello")
    append("World")
}

Kotlin 可空类型

可空类型意味着该变量可能是空值

【语法】
    var 变量名: 变量类型?
【举例】
    var a: String? = null
    
 //安全操作相当于访问对象时先进行一次非空件检查，若为空，则什么都不操作，若不为空，则执行后面的操作
【空安全操作】
    对象?.方法名()
    对象?.属性名
【举例】
    a?.length

强制调用

//空类型赋值给非空类型，编译错误
var nullString: String? = null
var noNullString: String = nullString //编译错误

//强制调用 "!!"
var nullString: String? = null
var noNullString: String = nullString!!//运行崩溃

Kotlin 内置的类型

1. Any 类型——所有类的父类

Any 类型是 Kotlin 中所有类的父类，，开发者任何自定义的类都是 Any 类型，相当于是 Java 中的 Object 类型

2. Unit类型——什么都不返回类型

在 Kotlin 中，Unit 类型表示什么都不返回，功能类似于 Java 中的 void 类型

3. Noting 类型——什么都没有

在 Kotlin 中，Noting 类型表示什么都没有，Noting 可以看成所有类的子类

操作符

按照个数，操作符可以分位一元操作符和二元操作符

一元操作符是指操作符只有一个操作数
二元操作符是指操作符链接两个操作数

一元操作符

1. 正负操作符

正号相当于是调用操作数的 unaryPlus() 方法
负号相当于是调用操作数的 unaryMinus() 方法

var a = 10
//用负号操作符
var b = -a
//调用操作数方法
var c = c.unaryMinus()

2. 自增/减操作符

自增/减操作符相当于是算数操作符，

自增/减操作，相当于调用操作数的 inc()/dec() 方法
赋值操作，会在执行顺序上有所不同

//++在前：先+后赋值
var a = 10
var b = ++a
printIn("a=$a,b=$b")// a=11 b=11

//++在后：先复制再+
var a = 10
var b = a++
printIn("a=$a,b=$b")// a=11 b=10

3. 否定操作符

否定操作符(!)属于逻辑操作符，主要用于不二类型的操作数取反操作.

二元操作符

1. 四则远算操作符

四则运算操作符可以分为 +、-、*、/、%(取余)，属于算数运算符

2. 猫王操作符

操作符号是 (?:)

//举例
var a = null
var b = a ?: "aa"

3. 区间操作符

区间操作符(...)主要用于创建区间对象，相当于调用操作数的 rangeTo() 方法

val range = 1 ... 3// 区间值为1、2、3

4. 操作符重写

Kotlin 中的各种操作符实际上市调用了定义好的操作符方法，重写操作符方法使用 operator 修饰方法

class A{
    //重写符号+
    operator fun plus(b: B): C {
        return C()
    }
}

calss B{
}

class C{
}

fun main() {
    val a: A = A()
    val b: B = B()
    //调用A类中定义的plus方法
    var c: C = a + b
}

流程控制

条件语句

在 Kotlin 中，条件语句可以分为两种，if 语句和 when 语句。

1. if表达式 与 Java 不同，Kotlin 中 if 语句可以作为表达式来使用，即拥有返回值。

单行 if 表达式

//类似于 Java 中的三元运算符
val a = if (b == null) 0 else 1

多行 if 表达式

var a = 10
var b = 20
var result = if (a > b) {
    val res = a - b
    "a - b is $ res"
} else {
    val res = b - a
    "b - a is $ res"
}
printIn(result)// b - a is 10

2. when语句 作用类似与 Java 中的 switch

when 代码块

//包含多个不相关的条件语句。因此，when 代码块可以被看作是将多个 if 语句结合到一起
when {
    x + y == 5 -> printIn("x + y = 5")
    z < 10 -> printIn("z is small 10")
    else -> printIn("else")
}

when 语句

val s = "a"
when (s) {
    "a" -> printIn("s is a")
    "b" -> printIn("s is b")
    "c" -> printIn("s is c")
    else -> printIn("s is else")
}

when 表达式

val s = "a"
val s: String = when (s) {
    "a" -> printIn("s is a")
    "b" -> printIn("s is b")
    "c" -> printIn("s is c")
    else -> printIn("s is else")
}

when 其他用法

//判断参数值是否在一组给定的值当中
when(area) {
    "湖南","湖北" -> "南方"
    "河北","辽宁" -> "北方"
    else -> "西方"
}

//判断参数值是否在一组给定的区间当中
when (score) {
    in 90..100 -> "优秀"
    in 80..90 -> "良好"
    in 70..80 -> "一般"
    else -> "还需努力"
}

//判断参数值不在一组给定的区间当中
when (score) {
    !in 60..100 -> "不合格"
    !in 80..90 -> "不良好"
    !in 90..100 -> "不优秀"
    else -> "还需努力"
}

//判断参数值属于什么数据类型
when(a){
    is Boolean -> "布尔类型"
    is Int -> "整形"
    is String -> "字符串类型"
    else -> "其他类型"
}

循环语句

Kotlin 中，循环语句分为 while 循环和 for 循环 1. while循环

//while循环
val times = 3
var i: Int = 0
while(i<times) {
    printIn("$i")
    i++
}
//输出0、1、2


//do...while
val times = 3
var i: Int = 0
do{
    i++
    printIn("$i")
}while (i<times)
//输出1、2、3

2. for循环

3. repeat循环

//括号内3表示重复执行的次数
repeat(3){
    //隐式参数it保存了当前循环的次数
    printIn(" $it times")
}

数组类型

引用数组

//创建引用类型数组
//创建长度为3的空数组
var arr = arrayOfNulls<Int>(3)

//创建指定元素的数组
var arr = arrayOf<Int>(1,2,3)

//使用arrayOf构造方法
val arr = Array<Int>(3){
    it
}//创建一个保函0，1，2的数组

基本数据类型数组

//创建基本类型数组
//创建长度为3的整形数组
var arr = IntArray(3)

//使用构造方法创建
val arr = Array<Int>(3){
    it
}//创建一个保函0，1，2的数组

数组的常用操作

var arr = intArrayOf(1,2,3)

//获取数组长度
var len = arr.size

//访问下标
var arr1 = arr[1]
var arr0 = arr.get(0)

//修改元素
arr[1] = 4//1，4，3
arr.set(0,5)//5,4,3

//遍历数组
for(a in arr){
    printIn("$a")
}//遍历数组

for(a in arr.indices){
    printIn(arr[a])
}//遍历索引

for(index in arr.withIndex()) {
    printIn("index: ${index.index} value: ${index.value}" )
}//直接获取当前元素的下标和对应的值

多维数组

val arr1 = arrayOf("a","b")
val arr2 = arrayOf("c","d")
val arr = arrayOf(arr1,arr2)

集合类型

Kotlin 中可以按照是否支持修改操作，分为不可变列表(Immutable List)和可变列表(Mutable List)。这两种列表都包含下面几个特点：

数据有序
数据可以重复
支持随机访问 1. 不可变列表 不可变列表只支持访问操作，不支任何修改操作。

//创建形式
val list = listOf("a","b""c")

2. 可变列表

//创建形式
val list = mutableListOf("a","b""c")

3. 列表常用操作

val list = listOf("a","b""c")
//获取列表长度
val len = list.size

//访问元素
val index = list[0]
val index1 = list.get(0)

//添加元素
val list = mutableListOf("a","b""c")
list.add("d")

//修改元素
list[0] = "f"
list.set(0,"f")

//删除元素
list.remove("a")
list.removeAt(0)

//遍历列表
for(s in list){
    printIn("$s")
}

for(index in list.indices){
    printIn("${list[index]}")
}

区间类型

//创建闭区间
for(s in 1..3){
}

//通过until创建左闭右开区间
for(s in 0.until(3)) {
}//0,1,2

Kotlin 学习记录一入门