【Android学习之路】Kotlin语言基础

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 帮你封装了一个对象，这样可以保证不会出现空指针。

• 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版）
菜鸟教程