当前位置:   article > 正文

Android Kotlin 基础详解

android kotlin

1,基础语法

1.1 可变变量与不可变变量

可以多次赋值的变量是可变变量,用关键字var表示:

var <标识符> : <类型> = <初始化值>  注意,在kotlin中成员变量不会赋默认值,不像java一样,必须手动添加默认值。
  1. var name : String ="yuanzhen"
  2. name ="yuanzhen1"
  3. var age : Int =20
  4. age =30
  5. println("name:$name,age:$age")
  1. 输出:
  2. name:yuanzhen1,age:30

只能赋值一次的变量,是不可变变量,用关键字val表示,类似于java里面的final:

val <标识符> : <类型> = <初始化值> 注意,在kotlin中成员变量不会赋默认值,不像java一样,必须手动添加默认值。

1.2类型推导

kotlin可以根据传入的值,自动推导出变量类型:

  1. var name ="yuanzhen" //类型推导
  2. name ="yuanzhen1"
  3. var age =20 //类型推导
  4. age =30

1.3函数 方法

kotlin中的Unit相当于java中的void ,如果函数的返回值为Unit,可以不用写返回值

kotlin中使用fun关键字定义函数

定义一个有参数和返回值的函数:

  1. fun test(name1:String ,name2:String):String{
  2. return name1+name2
  3. }

   调用:

  1. println(test("yuan","zhen"))
  2. //输出 yuanzhen

   也可以根据类型推导,直接写成:

fun test(name1:String ,name2:String) =name1+name2

  可变参数用关键字vararg表示:

  1. fun lenMethod(vararg value: Int) {
  2. for (i in value) {
  3. println(i)
  4. }
  5. }

调用:

lenMethod(1, 2, 3, 4, 5, 6, 7)

1.4字符串

在kotlin中,$表示一个变量名或者变量值,$name 表示变量值,如果变量值有多个,可以写为:${name1+name2}

  1. var name ="yuanzhen1" //类型推导
  2. var name1 ="yuanzhen"
  3. println("${name+name1}")

输出:yuanzhen1yuanzhen

换行:""" """  自己不用关心换行:

  1. val infoMesage = """
  2. AAAAAAAAAAA
  3. BBBBBBBBBBB
  4. CCCCCCCCCCC
  5. DDDDDDDDDDD
  6. EEEEEEEEEEE
  7. """ // 前置空格
  8. println(infoMesage)
  9. val infoMesage2 = """
  10. AAAAAAAAAAA
  11. BBBBBBBBBBB
  12. CCCCCCCCCCC
  13. DDDDDDDDDDD
  14. EEEEEEEEEEE
  15. """.trimIndent() // 没空格
  16. println(infoMesage2)
  17. val infoMesage3 = """
  18. ?AAAAAAAAAAA
  19. ?BBBBBBBBBBB
  20. ?CCCCCCCCCCC
  21. ?DDDDDDDDDDD
  22. ?EEEEEEEEEEE
  23. """.trimMargin("?") // 没空格 控制?
  24. println(infoMesage3)

输出:

  1. AAAAAAAAAAA
  2. BBBBBBBBBBB
  3. CCCCCCCCCCC
  4. DDDDDDDDDDD
  5. EEEEEEEEEEE
  6. AAAAAAAAAAA
  7. BBBBBBBBBBB
  8. CCCCCCCCCCC
  9. DDDDDDDDDDD
  10. EEEEEEEEEEE
  11. AAAAAAAAAAA
  12. BBBBBBBBBBB
  13. CCCCCCCCCCC
  14. DDDDDDDDDDD
  15. EEEEEEEEEEE

1.5 null检查机制

在kotlin中,如果你这么定义一个变量,一定会报错的

因为这是kotlin特有的机制,不允许直接赋空值。那么要怎么做呢?

var age:Int?=null

加个?的意思就相当于 我发出了一个广播,告诉所有人这个值可能是空的,必须要有处理措施。

第一种处理措施:

  1. var age:Int?=null
  2. val i = age?.and(2)
  3. println("$i")

输出:null

age?.and(2)的意思就是如果age是null,那就不执行?后面的内容了

第二种处理措施:

  1. var age:Int?=null
  2. age!!.and(2)

!!的意思就是我不管,我就强行执行and方法,出了事我负责。

第三种处理措施:

就跟java一样,自己判断处理

  1. var age:Int?=null
  2. if(age !=null){
  3. age.and(2)
  4. }

1.6 区间

区间用..来表示

  1. // 1 到 9
  2. for (i in 1..9) {
  3. println(i)
  4. }

输出 1 2 3 4 5 6 7 8 9

那如果这样写呢?

  1. for (i in 9..1) {
  2. println(i)
  3. }

注意:这样是不会输出的,因为没有9到1这种写法,那如果非要输出9到1呢?

  1. for (i in 9 downTo 1) {
  2. println(i)
  3. }

要用downTo

还可以指定步长:

  1. for (i in 1..20 step 2) {
  2. println(i)
  3. }

输出:1 3 5 7 9 11 13 15 17 19    每隔2输出一个值

排除最后一个元素:

  1. for (i in 1 until 10) {
  2. println(i)
  3. }

输出:1 2 3 4 5 6 7 8 9 

2, 比较与数组

2.1比较

在java中比较两个字符串,用equls来比较,但是在kotlin中,用==来比较字符串的值

  1. val name1: String = "张三"
  2. val name2: String = "张三"
  3. println(name1 == name2)

比较对象地址用===表示

  1. // --- 比较对象地址
  2. val test1:Int? = 10000
  3. val test2:Int? = 10000
  4. println(test1 === test2)

输出false

2.2 数组

在java中数组有三种创建方式:

  1. int[] array = {1,2,3};
  2. int[] array1 = new int[3];
  3. int[] array2 = new int[]{7,8,9};

在kotlin中 数组有两种方式:

第一种:

val numbers = arrayOf(1, 2, 3, 4, 5, 6, 7, 8)

第二种:

  1. val numbers2 = Array(10, {value: Int -> (value + 200) })
  2. for (value in numbers2) {
  3. println(value)
  4. }

输出:

200
201
202
203
204
205
206
207
208
209

为什么会这样呢? 因为value的默认值是0,之后会依次加一。

3,条件控制

比较大小值,可以这样写:

  1. val number1: Int = 99
  2. val number2: Int = 88
  3. // 表达式 比 大小 最大值
  4. val maxValue = if (number1 > number2) number1 else number2
  5. println(maxValue)

输出99 

如果要执行多行代码,还可以这样写:

  1. val max: Int = if (number1 > number2) {
  2. println("number1是最大的")
  3. number1
  4. } else {
  5. println("number2是最大的")
  6. number2
  7. }

注意:返回值不需要加return关键字

when相当于java中的switch case,只不过用法更加灵活

用于某个值:

  1. val number5 = 5
  2. when(number5) {
  3. 1 -> println("一")
  4. 2 -> println("二")
  5. 3 -> println("三")
  6. 4 -> println("四")
  7. 5 -> println("五")
  8. else -> println("其他")
  9. }

用于区间:

  1. val number = 700
  2. when(number) {
  3. in 1..100 -> println("1..100")
  4. in 200..500 -> println("200..500")
  5. else -> println("其他")
  6. }

用于执行多行代码 并且有返回值:

  1. val number = 3
  2. val result = when (number) {
  3. 1 -> {
  4. println("很开心")
  5. "今天是星期一"
  6. 99
  7. }
  8. 2 -> {
  9. println("很开心")
  10. "今天是星期二"
  11. 88
  12. }
  13. 3 -> {
  14. println("很开心")
  15. "今天是星期三"
  16. true
  17. 100
  18. }
  19. else -> 99
  20. }

4,循环与标签

4.1标签

自定义标签:在kotlin中,我们可以自定义一个标签,用来控制程序的执行流程等

  1. yuanzhen@ for (i in 1..20) {
  2. for (j in 1..20) {
  3. println("i:$i, j:$j")
  4. if (i == 5) {
  5. // break // j循环 给break
  6. break@yuanzhen // i循环 给break
  7. }
  8. }
  9. }

一个类中自带的标签:

  1. class Yuan {
  2. val I = "aa"
  3. fun show() {
  4. println(I)
  5. println(this.I)
  6. println(this@Yuan.I)
  7. }
  8. }

4.2循环

在kotlin中,要遍历一个list,通常有三种方式:

var items  = listOf<String>("aaa", "bbb", "ccc")

方式一:

  1. for (item in items) {
  2. println(item)
  3. }

方式二:

  1. items.forEach {
  2. println(it)
  3. }

方式三:

  1. for (index in items.indices) {
  2. println("下标:$index, 对应的值:${items[index]}")
  3. }

5,类与对象

5.1类的创建

在kotlin中,创建一个类,如果前面不写修饰符,默认就是public final 

  1. // 默认就是public final
  2. class Empty

这样是不能被继承的,要想被继承,就必须加上open

open class Person{}

5.2构造函数

在java中,会有一个默认的构造函数,并且可以重载无数个构造函数。

但是在kotlin中,它会有一个默认的主构造函数,其余的都是次构造。

上面的Person类,相当于有一个默认的主构造:

  1. open class Person() // 主构造
  2. {
  3. }

那如果我们要给主构造增加一个参数呢?

  1. open class Person(id: Int) // 主构造
  2. {
  3. }

那如果还要增加好几个次构造呢?

  1. open class Person(id: Int) // 主构造
  2. {
  3. // 次构造
  4. constructor(id: Int, name: String) : this(id) {
  5. }
  6. // 次构造
  7. constructor(id: Int, sex: Char) : this(id) {
  8. }
  9. // 次构造
  10. constructor() : this(222) {
  11. }
  12. }

次构造必须继承主构造,同时把参数传给主构造

在使用时,可以这么用:

  1. val person = Person() // 次构造
  2. val person2 = Person(23456) // 主构造
  3. Person(234, "yy") // 次构造
  4. Person(234, 'M') // 次构造

5.3类的继承

继承父类用:表示

  1. class Student(id: Int) : Person(id) // 主构造
  2. {
  3. // 再Kotlin 全部都是没有默认值的
  4. // 再Java 成员有默认值,但是方法内部没有默认值
  5. // lateinit 懒加载 不用立马赋值,在使用的时候赋值, 没有赋值 就不能使用,否则报错
  6. lateinit var name : String
  7. var age: Int = 0
  8. }

5.4接口

在kotlin中,接口和抽象类默认都是open的

  1. interface Callback {
  2. fun callbackMethod() : Boolean
  3. }
  1. interface Callback2 {
  2. fun callbackMethod() : Boolean
  3. }
  1. abstract class Person : Callback , Callback2 {
  2. abstract fun getLayoutID() : Int
  3. abstract fun initView()
  4. }
  1. class Student : Person() {
  2. override fun getLayoutID(): Int = 888
  3. override fun initView() { }
  4. override fun callbackMethod(): Boolean = false
  5. }

与java差别不大

5.5data数据类

数据类是kotlin中独有的,在java中,我们要写数据类,通常会手写很多属性和方法等。

在kotlin中,我们只需要用数据类定义属性就可以,不用关心get,set等方法,内部会自动帮我们生成。

  1. // 会自动生成get set 构造 equals hashCode toString copy
  2. data class User(val id: Int, val name: String, val sex: Char)
  1. val user = User(99, "lisi", 'M')
  2. //copy 函数
  3. val(myID, myName, mySex) = user.copy()
  4. println("myID:$myID, myName:$myName, mySex:$mySex")

5.6单例

在kotlin中,object只实例一次,相当于单例

  1. object MyEngine {
  2. fun m() {
  3. println("M run")
  4. }
  5. fun show() {
  6. println("我就只有一个实例")
  7. }
  8. }

companion :意思是同伴对象。相当于java的static.

下面来看一下kotlin中的单例模式怎么写:

方式一:

  1. class NetManager {
  2. // 只有一个实例
  3. object Holder {
  4. val instance = NetManager()
  5. }
  6. // 看不到 static 可以 派生操作
  7. companion object {
  8. // 全部都是 相当于 Java static
  9. fun getInstance() : NetManager = Holder.instance
  10. }
  11. fun show(name: String) {
  12. println("show:$name");
  13. }
  14. }

方式二:

  1. class NetManager2 {
  2. companion object {
  3. private var instance: NetManager2? = null
  4. // 返回值:允许你返回null
  5. fun getInstance(): NetManager2? {
  6. if (instance == null) {
  7. instance = NetManager2()
  8. }
  9. // 如果是null,也返回回去了
  10. return instance
  11. // 第二种补救: 我来负责 instance 肯定不为null
  12. // return instance!!
  13. }
  14. }
  15. fun show(name: String) {
  16. println("show:$name");
  17. }
  18. }

5.7嵌套类

嵌套类,就是在类的内部又写了一个类,但是它不是内部类,拿不到外部类的成员。

  1. class Sub {
  2. fun show() {
  3. println()
  4. }
  5. class A {
  6. class B {
  7. class C {
  8. }
  9. }
  10. }
  11. }

5.8内部类

在kotlin中,内部类用关键字inner来表示。

  1. class Sub {
  2. fun show() {
  3. println()
  4. }
  5. class A {
  6. class B {
  7. class C {
  8. }
  9. }
  10. }
  11. }
  12. // 这个才是内部类
  13. inner class Sub2 {
  14. fun show() {
  15. println(I)
  16. }
  17. }
  18. }

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/空白诗007/article/detail/762000
推荐阅读
相关标签
  

闽ICP备14008679号