Kotlin语法基础
文章目录
前言 : Java语言与Kotlin语言有相似之处, 但也有很多不同之前, 本文主要关于Kotlin一些基础语法进行展开, 有Java经验的小伙伴可以看看有哪些不同之处.
以下面这个代码为例:
package com.example.mykotlincode
class Hello(val name:String) {
fun halo(){
println("Hello, $name")
}
}
fun main(args:Array<String>){
Hello("World").halo()
//println()
}
-
可以看出Kotlin 文件以
.kt
为后缀 -
代码文件的开头一般为包(package)的声明
-
导入包的关键字
import
-
Kotlin每一行代码的结尾是不用加分号的,当然你加分号也不会报错, 但那是 Java 的写法,Kotlin的代码不需要分号
-
代码注释
-
// 单行注释 /* 块注释 */
-
变量
Kotlin中定义一个变量,只允许在变量前声明两种关键字:
val
和var
,两种变量都可以没有初始化值,但在引用前必须赋初值
-
val
(全称value) : 用来声明一个不可变的变量,即一旦赋初始值就不可再二次赋值 -
var
(全称variable) : 用来声明一个可变的变量, 即可多次进行赋值 -
变量的类型声明放在变量名后, 比如声明一个整型变量 :
var a:Int =1
fun main(){
val num1:Int = 1
var num2:Int = 2
var sum:Int = num1 + num2
println("总和为$sum")
}
永远优先使用val来声明一个变量,而当val没有办法满足你的需求时再改为使用var。这也是为了安全性, 避免了不经意间修改了某个变量的值, 导致未知的安全隐患。
NULL检查机制
Kotlin的空安全设计对于声明可为空的参数,在使用时要进行空判断处理
- 字段后加
!!
: 抛出空异常 - 字段后加
?
: 返回值为null
对象数据类型
Kotlin相比Java来说, 抛弃了基本的数据类型,全部使用对象数据类型, 即数据类型的首字母要大写。Kotlin 中没有基础数据类型,只有封装的数字类型,每定义的一个变量,其实 Kotlin 帮你封装了一个对象,这样可以保证不会出现空指针。
对象数据类型 | 说明 | 位宽度 |
---|---|---|
Int | 整型 | 32bit |
Long | 长整型 | 64bit |
Short | 短整型 | 16bit |
Float | 单精度浮点型 | 32bit |
Double | 双精度浮点型 | 64bit |
Boolean | 布尔型 | – |
Char | 字符型 | 16bit |
Byte | 字节型 | 8bit |
String | 字符串类型 | – |
-
Kotlin中
===
表示比较对象的地址,==
表示比较两个值的大小是否相等val a:Int = 333 val c1:Int? = a val c2:Int? = a println(c1===c2) //对象不同 println(c1==c2) //值相同
类型转换
由于不同的表示方式,较小的数据类型并不是较大数据类型的子类型,较小的数据类型不能隐式转换为较大的数据类型。 这意味着在不进行显式转换的情况下我们不能把 Byte 型值赋给一个 Int 变量
toByte()
: 转换为Byte类型toShort()
: 转换为Short类型toInt()
: 转换为Int类型toLong()
:转换为Long类型toFloat()
: 转换为Float类型toDouble()
: 转换为Double类型toChar()
: 转换为Char类型toString()
: 转换为字符串
val b:Byte= 1
//val n:Int = b //错误的做法
val n:Int = b.toInt()
val c = b.toString()
字符和字符串
-
字符 (Char): 单个字符组成, 字符用单引号
'
引起来- 比如: ‘a’, ‘1’ 等
- Kotlin中的字符(Char)不能直接和数字进行操作,
-
字符串(String): 由单个或多个字符组成,字符串用双引号
"
引起来-
比如 : “hello world”,“H” 等
-
Kotlin 支持三个引号
"""
扩起来的字符串,支持多行字符串 -
和 Java 一样,String 是不可变的。方括号
[]
语法可以很方便的获取字符串中的某个字符,也可以通过 for 循环来遍历 -
字符串内嵌表达式 :
${}
,其中花括号内可以放变量或者变量方法的返回值, 它可以直接放在字符串里面, 将变量的值输出;只有一个变量名或者变量值时可以省略{}
-
Kotlin支持用
+
来做字符串的拼接(但不建议)val a = 1; val b = "变量a的值为$a" println("输出变量a:"+a) //使用字符串拼接,Kotlin不建议使用这种方式, 更建议使用字符串内嵌表达式 println("输出变量a:$a") //单个变量可以省略{} //println("输出变量a:${a}") //也可以不省略{} println("输出字符串b:${b.replace('为','是')}") val s = """ ${'$'}1.00 """.trimIndent() //trimIndent()方法删除多余的空行或缩进 val ss = """ ${'$'}1.00 """ println(s) println(ss)
-
${}也可以用来转义字符
区间
-
..
区间的操作符 -
搭配
in
在这区间范围和!in
不在区间范围 -
for (i in 1..9) { print(i) //从1到9这个区间输出,输出123456789, 即[1,9] } println() for (i in 1..9 step 3) { print(i) //步长为3, 即增长值为3, 输出147 } println() for (i in 9 downTo 1 step 3) { print(i) //输出963 } println() for (i in 1 until 9) { print(i) //输出12345678 , 即[1,9) }
输出:
123456789 147 963 12345678
函数
-
定义函数的关键字
fun
【function的简称】:主要用来声明函数定义 -
有返回值:
fun <函数名>(<参数1,参数2,...,参数n>):<返回值类型>{}
-
fun sum(a: Int, b: Int): Int { return a + b } //或者 public fun sum(a: Int, b: Int): Int = a + b // = 相当于return
-
-
无返回值 :
fun <函数名>(<参数1,参数2,...,参数n>):Unit{}
-
fun sum(a: Int, b: Int): Unit { val sum = a+b } //或者可以省略Unit fun sum(a: Int, b: Int) { val sum = a+b }
-
-
可变长参数函数: 函数的变长参数可以用
vararg
关键字进行标识-
fun vars(vararg v:Int){ //即可以输入多个参数 for(i in v){ print(i) } } fun main() { vars(1,2,3,4,5) // 输出12345 }
-
输出:
-
12345
-
-
当函数只有一行代码时,可以省略函数体, 使用
=
相当于返回值fun largerNumber(num1: Int, num2: Int) = if (num1 >num2) {num1} else {num2}
lambda(匿名函数)
-
lambda表达式 : 没有函数名, 通过变量来调用函数。
-
语法结构 :
{参数1:参数类型, 参数2:参数类型 -> 函数体}
fun main() { val add = {m:Int,n:Int -> m+n} print(add(1,2)) }
或者
fun main(){ val add:(Int,Int)->Int ={m,n->m+n} println(add(1,2)) }
程序逻辑控制
if条件判断
-
判断语句 if
// if..... else..... if (条件判断) { 执行语句 }else{ 执行语句 } // if ..... else if ..... else ...... if (条件判断) { 执行语句 }else if(条件判断){ 执行语句 }else{ 执行语句 }
-
if语句是可以有返回值的, 即if语句每个条件后面的就是返回值
val value = if (num1>num2){num1}else{num2}
when条件语句
类似于java中的switch语句
匹配值 -> {执行逻辑}
- 执行逻辑只有一行代码时,
{ }
可以省略
fun namenum(name:String):Int{
val a = when(name){
"张三" -> 100
"李四" -> 101
"王五" -> 102
else -> 0
}
return a
}
还可以这样写
fun namenum(name:String):Int{
val a = when{
name =="张三" -> 100
name =="李四" -> 101
name =="王五" -> 102
else -> 0
}
return a
}
-
is
关键字, 使用类型匹配when(num){ is Int -> print("this is Int") is Double -> print("this is Double") else -> print("number is not support") }
循环语句
-
while
-
for
-
for - in : 循环遍历区间
-
区间: 和数学中的区间概念一样, 都是表示一个范围
..
创建闭区间, 比如:[0,10]表示为0..10
until
创建左闭右开区间, 比如: [0,10)表示为0 until 10
downTo
创建降序区间, 比如:[10,0] 表示为10 downTo 0
-
步长 :
step
,step 1
相当于递增1; 类似于i=i+1 -
举栗子 :
fun main() { // .. for (i in 0..10 ){ print("$i ") } println() // until for (i in 0 until 10){ print("$i ") } println() // downTo for (i in 10 downTo 0){ print("$i ") } println() // step for (i in 0..10 step 3){ print("$i ") } }
输出结果:
0 1 2 3 4 5 6 7 8 9 10 0 1 2 3 4 5 6 7 8 9 10 9 8 7 6 5 4 3 2 1 0 0 3 6 9
-
面向对象编程
Kotlin是支持面向对象编程,面向对象的基本思想就是对类进行封装,再通过实例化类来创建对象, 调用对象的字段和函数(方法)来满足实际编程的需求。
类与对象
-
类是对事物的一种封装, 字段表示类拥有的属性
-
关键字
class
, 用于创建一个类//创建一个类 class Tool { var name:String = "" var application :String = "" fun use(){ print("该工具的名称为$name, 用途为$application") } } fun main() { // 实例化一个类 val computer = Tool() computer.name = "电脑" computer.application = "办公" computer.use() }
继承与构造函数
-
在子类的基础上继承父类的资源
-
Kotlin中规定任何一个非抽象类默认是不可以被继承的
- 因为类和变量一样, 最安全的情况下是不可变的, 为了防止未知的风险而设计的
- 要想类被继承就需要在类的前面加
open
关键字, 这也表明了你是知道这个类是为继承而设计的, 这样就将未知的风险变为已知的风险
-
子类继承父类的写法是加
:
冒号open class Parent{ ...... } class Son:Parent(){ ...... }
-
构造函数
- 主构造函数 :每个类默认都有一个不带参数的主构造函数, 特点是没有函数体, 直接定义在类名后面, 主构造函数主要是继承类的类名名后的括号
- 次构造函数 :次构造函数是通过
constructor
关键字来定义的
open class Person(val name: String, val age: Int) {
...
}
class Student(val sno: String, val grade: Int, name: String, age: Int) :Person(name, age) {
...
} //Person()就是默认带主构造函数
class Student(val sno: String, val grade: Int, name: String, age: Int) :Person(name, age) {
constructor(name: String, age: Int) : this("", 0, name, age) {
} //次构造函数, this是调用主构造函数
constructor() : this("", 0) {
} //次构造函数, this是调用次构造函数, 间接调用主构造函数
}
val student1 = Student()
val student2 = Student("Jack", 19)
val student3 = Student("a123", 5, "Jack", 19)
Kotlin规定,当一个类既有主构造函数又有次构造函数时,所有的次构造函数都必须调用主构造函数(包括间接调用), 次构造函数用的比较少
接口
- 接口是实现多态编程的一部分
- Kotlin语言是单继承结构语言, 任何一个类只能最多继承几个父类, 但可以实现多个接口
- 接口关键字
interface
- kotlin允许对接口中定义的函数进行默认实现
interface Work {
fun coding()
fun check()
fun doing(){
println("上班打卡")
}
}
class Worker(val name:String,val num:Number) :Work{ //继承接口
override fun coding() { //实现coding函数
println("${name}在写代码")
}
override fun check() { //实现check函数
print("检查${num}号码是否正确")
}
}
fun main() {
val a = Worker("张三", 12345)
a.coding()
a.doing()
}
Kotlin函数可见性修饰符
public
: 所有类可见(默认)private
: 当前类可见protected
: 当前类,子类可见internal
: 同一模块中的类可见
参考资料 : 第一行代码——Android(第3版)
菜鸟教程