Kotlin系列之基础语法

忘是亡心i 2022-06-09 11:23 257阅读 0赞

标签： Kotlin Kotlin基础语法

--------------------

*目录:*

*  一、包的声明
 *  二、函数的定义
 *  三、常量和变量
 *  四、注释
 *  五、字符串模板
 *  六、使用条件表达式
 *  七、NULL检查机制
 *  八、类型检测以及自动类型转换
 *  九、区间
 *  十、使用集合
 *  十一、使用循环
 *  十二、使用条件if,when
 *  十三、创建类和实例

*简述:*

Kotlin的基本语法的介绍，先从整体上体会kotlin的编程风格。

--------------------

### 一、包的声明 ###

在Kotlin中定义包与Java有点不同，在Kotlin中目录与包结构无需匹配，Kotlin的源码可以在磁盘上的任意位置。

*  1、包的声明
    
    源文件的通常是以包的声明的开头和Java一样。
    
        package com.mikyou.kotlin
        
        /**
         * Created by mikyou on 2017/10/12.
         */
        fun main(args: Array<String>) {
          println("hello kotlin")
        }
 *  2、包的默认导入
    
    有多个包会默认导入到每个Kotlin文件中。

### 二、函数的定义 ###

*  1、函数的定义使用关键字"fun",函数参数格式为: “参数:类型”,函数返回值类型 “fun(…): Int”

fun sum(a: Int, b: Int, c: Int): Int {
           return a + b + c
    }

*  2、表达式作为函数体，返回值的类型可以省略，可以利用Kotlin的类型推导功能，推测出函数返回值的类型。
    
        fun sum(a: Int, b: Int, c: Int) = a + b + c
 *  3、无返回值的函数(类似Java中的void空类型返回值)
    
        fun printSum(a: Int, b: Int, c: Int): Unit{
           println(a + b +c)
        }
    
    或者省略Unit类型
    
        fun printSum(a: Int, b: Int, c: Int){
          println("sum = ${a + b + c}")
        }
 *  4、可变长参数函数可以使用"vararg"关键字标识类似Java中的public void setData(Object… objects)。
    
        fun vars(vararg args: Int) {
          for (arg in args) {
              print(arg)
          }
         }
 *  5、lambda(匿名函数)
    
        val sumLambda: (Int, Int, Int) -> Int = { a, b, c -> a + b + c }
    
    测试
    
        println("sum = ${sumLambda(1, 6, 7)}")

### 三、常量和变量 ###

常量与变量都可以没有初始化值,但是在引用前必须初始化编译器支持自动类型判断,即声明时可以不指定类型,由编译器判断。如果不在声明的时候初始化则必须提供变量的类型

*  1、可变变量的定义: var 关键字
    
    var <变量名> : <变量类型> = <初始值>
    
        var sum: Int = 3
         sum = 8
         
         //由于编译支持类型推导可以省略Int类型
         
         var sum = 3
         sum = 8
 *  2、不可变变量的定义: val 关键字， 不能进行二次赋值，类似Java中的final类型
    
    val <常量名> : <常量类型> = <初始值>
    
        val sum: Int //没有赋值初始化之前必须指定类型
        
        sum = 5

### 四、注释 ###

Kotlin 支持单行和多行注释，和java中类似。

### 五、字符串模板 ###

*  1、模板中的简单名称
    
        fun main(args: Array<String>){
          var a = 1
          var s1 = "a is $a" 
        }
 *  2、模板中的任意表达式
    
        fun main(args: Array<String>){
          var a = 1
          a = 2
          val s2 = "${s1.replace("is","was")}, but now is $a"
        }

### 六、使用条件表达式 ###

*  使用if表达式替代了java中的三目运算符
    
        fun maxOf(a: Int, b: Int): Int{
            if(a > b){
             
               return a
             
            }else{
            
               return b
            }
        }
        
        fun main(args: Array<String>){
        
           println(maxOf(1,5))
         
        }
    
    在Kotlin中if表达式是带有返回值的，所以可以简化成下面的形式。
    
        fun maxOf(a: Int, b: Int) = if (a > b) a else b
         
         fun main(args: Array<String>){
        
           println(maxOf(1,5))
         
          }

### 七、NULL检查机制 ###

Kotlin的空安全设计对于声明可为空的参数，在使用时要进行空判断处理，有两种处理方式，**字段后加!!像Java一样抛出空异常**，另一种**字段后加?可不做处理返回值为 null或配合?:做空判断处理**

//类型后面加?表示可为空
    	var age: String? = "23" 
    	//字段后面加"!!"抛出空指针异常
    	val ages = age!!.toInt()
    	//字段后面加”？“不做处理返回 null
    	val ages1 = age?.toInt()
    	//使用”?:“ 表示age为空返回-1
    	val ages2 = age?.toInt() ?: -1

*  1、当一个引用可能为 null 值时, 对应的类型声明必须明确地在类型后面标记为”？“表示可为 null。  
    当 str 中的字符串内容不是一个整数时, 返回 null:
    
        fun main(args: Array<String>) {
        
            if (args.size < 2){
                println("Two Integers Expected")
                return
            }
        
            val x = parseInt(args[0])
            val y = parseInt(args[1])
        //    println(x + y) 由于标识了可能为null,直接使用x + y在编译器看来是非法，需要去做非空判断
        
            if (x != null && y != null){
                println(x + y)
            }
        
        }
        
        fun parseInt(s: String): Int?{//表示当前函数返回值可能为null,就必须在类型后面标识"?"
            return s.toInt()
        }

### 八、类型检测以及自动类型转换 ###

我们可以使用 is 运算符检测一个表达式是否某类型的一个实例(类似于Java中的instanceof关键字)。

fun getStringLength(obj: Any): Int? {
      if (obj is String) {
        // 做过类型判断以后，obj会被系统自动转换为String类型
        return obj.length 
      }
    
      //在这里还有一种方法，与Java中instanceof不同，使用!is
      // if (obj !is String){
      //   // XXX
      // }
    
      // 这里的obj仍然是Any类型的引用
      return null
    }

或者

fun getStringLength(obj: Any): Int? {
      if (obj !is String)
        return null
      // 在这个分支中, `obj` 的类型会被自动转换为 `String`
      return obj.length
    }

甚至可以是这样的

fun getStringLength(obj: Any): Int? {
      // 在 `&&` 运算符的右侧, `obj` 的类型会被自动转换为 `String`
      if (obj is String && obj.length > 0)
        return obj.length
      return null
    }

### 九、区间 ###

使用in运算符来检测某个数字是否在指定的区间内，区间表达式具有操作符形式"…"的rangeTo函数辅助in和!in组合而成。区间可以支持任何可以比较的类型，对于原生的整型，内部有一个优化的实现。

*  1、检测某个数字是否在指定区间内

val x = 10
       val y = 9
       if (x in 1..y + 1) {//表示x是否在1~y+1范围内。
           println("fits in range")
       }

*  2、检测某个数字是否在指定区间外

val list = listOf("a", "b", "c")
       if (-1 !in 0..list.lastIndex) {
           println("-1 is out of range")
       }
    
       if (list.size !in list.indices) {
           println("list size is out of valid list indices range too")
       }

*  3、区间迭代

for(x in 1..10){//相当于 x >= 1 && x <= 10
          println(x)
     }

或者

fun printList(num: Int){
    
      for(i in 1..num){//相当于 i >= 1 && i <= num
          print(i)
         }
    }

使用 until 函数排除结束元素

for (i in 1 until 10) {   // i in [1, 10) 排除了 10,相当于 i >= 1 && i < 10
        println(i)
    }

*  4、数列迭代

for(x in 1..100 step 2){//递增数列迭代，每次间隔步长是2；1，3，5，7...
           println(x)
       }
    
     for(x in 9 downTo 0 step 3){//递减数列迭代，每次间隔步长是3；9，6，3，0
           println(x)
        }

### 十、使用集合 ###

*  1、对集合进行迭代

fun main(args: Array<String>){
     val items = list.of("java","kotlin","python")
     for(item in items){
       println(item)
     }
    }

*  2、使用 in 运算符判断集合内是否包含某个实例

when {
           "java" in items -> println("is good lang")
           "kotlin" in items -> println("is good good lang")
           else -> println("python is best lang")
       }

*  3、使用lambda 表达式来过滤(filter)和映射(map)集合
    
        fun main(args: Array<String>){
           val langs = listOf("C","C++","Java","Python","JavaScript")
            
            langs
                 .filter{ it.startsWith("C")}
                 .sortedBy{ it }
                 .map{ it.toUpperCase() }
                 .forEach{ println(it) }
        }

### 十一、使用循环 ###

在Kotlin中的循环有两种方式分别是for，while，在for循环中使用"in"来遍历，并且有两个遍历方式。

*  1、for循环

val items = listOf("java", "kotlin", "android")
        for (item in items) {//for遍历集合
            println("lang $item")
        }
    
        for (index in items.indices) {//类似于java中的数组的length-index的遍历
            println("The $index index is ${items[index]}")
        }

*  2、while循环

val items = listOf("java", "kotlin", "android")
        var index = 0
        while (index < items.size) {//while 循环的遍历方式
            println("The $index lang is ${items[index++]}")
        }

### 十二、使用条件if,when ###

在kotlin中if的使用于java相似但是在kotin中if是表达式有值的，而在java中是语句，可以使用kotlin中的if表达式替代java中的三目运算符在kotlin中的。when与switch功能类似

fun main(args: Array<String>){
      
      println(descript("hello"))
      
    }
    
    fun descript(obj: Any): String = when(obj){
         
           1 -> "one"
           "hello" -> "hello word"
           is Long -> "long type"
           !is String -> "is not String"
           else -> {
                "unknown type"
           }
         
     
    }

### 十三、创建类与实例 ###

/**
      * Created by mikyou on 2017/11/9.
      */
    fun main(args: Array<String>) {
        val rectangle = Rectangle(100.0, 200.0)
        val triangle = Triangle(100.0, 100.0, 100.0)
        println("rectangle is ${rectangle.isSquare}, and perimeter is ${rectangle.perimeter}, and area is ${rectangle.calculateArea()}")
        println("triangle  perimeter is ${triangle.perimeter}, and area is ${triangle.calculateArea()}")
    }
    
    abstract class Shape(val sides: List<Double>) {
        val perimeter: Double get() = sides.sum()
        abstract fun calculateArea(): Double
    }
    
    interface RectangleProperity {
        val isSquare: Boolean
    }
    
    class Rectangle(var height: Double, var length: Double)
        : Shape(listOf(height, length, height, length)), RectangleProperity {
        override fun calculateArea(): Double = height * length
        override val isSquare: Boolean get() = height == length
    }
    
    class Triangle(var sideA: Double, var sideB: Double, var sideC: Double)
        : Shape(listOf(sideA, sideB, sideC)) {
        override fun calculateArea(): Double = sideA * sideB * sideC
    }

![1635c3fb0ba21ec1_w_430_h_430_f_jpeg_s_39536][]

**欢迎关注Kotlin开发者联盟，这里有最新Kotlin技术文章，每周会不定期翻译一篇Kotlin国外技术文章。如果你也喜欢Kotlin，欢迎加入我们~~~**

### Kotlin系列文章，欢迎查看: ###

> Kotlin邂逅设计模式系列:

*  **[当Kotlin完美邂逅设计模式之单例模式(一)][Kotlin]**

> 数据结构与算法系列:

*  **[每周一算法之二分查找(Kotlin描述)][Kotlin 1]**

> 翻译系列：

*  **[\[译\] Kotlin中关于Companion Object的那些事][Kotlin_Companion Object]**
 *  **[\[译\]记一次Kotlin官方文档翻译的PR(内联类)][Kotlin_PR]**
 *  **[\[译\]Kotlin中内联类的自动装箱和高性能探索(二)][Kotlin 2]**
 *  **[\[译\]Kotlin中内联类(inline class)完全解析(一)][Kotlin_inline class]**
 *  **[\[译\]Kotlin的独门秘籍Reified实化类型参数(上篇)][Kotlin_Reified]**
 *  **[\[译\]Kotlin泛型中何时该用类型形参约束?][Kotlin 3]**
 *  **[\[译\] 一个简单方式教你记住Kotlin的形参和实参][_Kotlin]**
 *  **[\[译\]Kotlin中是应该定义函数还是定义属性?][Kotlin 4]**
 *  **[\[译\]如何在你的Kotlin代码中移除所有的!!(非空断言)][Kotlin 5]**
 *  **[\[译\]掌握Kotlin中的标准库函数: run、with、let、also和apply][Kotlin_ run_with_let_also_apply]**
 *  **[\[译\]有关Kotlin类型别名(typealias)你需要知道的一切][Kotlin_typealias]**
 *  **[\[译\]Kotlin中是应该使用序列(Sequences)还是集合(Lists)?][Kotlin_Sequences_Lists]**
 *  **[\[译\]Kotlin中的龟(List)兔(Sequence)赛跑][Kotlin_List_Sequence]**

> 原创系列：

*  **[教你如何完全解析Kotlin中的类型系统][Kotlin 6]**
 *  **[如何让你的回调更具Kotlin风味][Kotlin 7]**
 *  **[Jetbrains开发者日见闻(三)之Kotlin1.3新特性(inline class篇)][Jetbrains_Kotlin1.3_inline class]**
 *  **[JetBrains开发者日见闻(二)之Kotlin1.3的新特性(Contract契约与协程篇)][JetBrains_Kotlin1.3_Contract]**
 *  **[JetBrains开发者日见闻(一)之Kotlin/Native 尝鲜篇][JetBrains_Kotlin_Native]**
 *  **[教你如何攻克Kotlin中泛型型变的难点(实践篇)][Kotlin 8]**
 *  **[教你如何攻克Kotlin中泛型型变的难点(下篇)][Kotlin 9]**
 *  **[教你如何攻克Kotlin中泛型型变的难点(上篇)][Kotlin 10]**
 *  **[Kotlin的独门秘籍Reified实化类型参数(下篇)][Kotlin_Reified 1]**
 *  **[有关Kotlin属性代理你需要知道的一切][Kotlin 11]**
 *  **[浅谈Kotlin中的Sequences源码解析][Kotlin_Sequences]**
 *  **[浅谈Kotlin中集合和函数式API完全解析-上篇][Kotlin_API_-]**
 *  **[浅谈Kotlin语法篇之lambda编译成字节码过程完全解析][Kotlin_lambda]**
 *  **[浅谈Kotlin语法篇之Lambda表达式完全解析][Kotlin_Lambda]**
 *  **[浅谈Kotlin语法篇之扩展函数][Kotlin 12]**
 *  **[浅谈Kotlin语法篇之顶层函数、中缀调用、解构声明][Kotlin 13]**
 *  **[浅谈Kotlin语法篇之如何让函数更好地调用][Kotlin 14]**
 *  **[浅谈Kotlin语法篇之变量和常量][Kotlin 15]**
 *  **[浅谈Kotlin语法篇之基础语法][Kotlin 16]**

> Effective Kotlin翻译系列

*  **[\[译\]Effective Kotlin系列之考虑使用原始类型的数组优化性能(五)][Effective Kotlin]**
 *  **[\[译\]Effective Kotlin系列之使用Sequence来优化集合的操作(四)][Effective Kotlin_Sequence]**
 *  **[\[译\]Effective Kotlin系列之探索高阶函数中inline修饰符(三)][Effective Kotlin_inline]**
 *  **[\[译\]Effective Kotlin系列之遇到多个构造器参数要考虑使用构建器(二)][Effective Kotlin 1]**
 *  **[\[译\]Effective Kotlin系列之考虑使用静态工厂方法替代构造器(一)][Effective Kotlin 2]**

> 实战系列:

*  **[用Kotlin撸一个图片压缩插件ImageSlimming-导学篇(一)][Kotlin_ImageSlimming-]**
 *  **[用Kotlin撸一个图片压缩插件-插件基础篇(二)][Kotlin_-]**
 *  **[用Kotlin撸一个图片压缩插件-实战篇(三)][Kotlin_- 1]**
 *  **[浅谈Kotlin实战篇之自定义View图片圆角简单应用][Kotlin_View]**

[1635c3fb0ba21ec1_w_430_h_430_f_jpeg_s_39536]: https://user-gold-cdn.xitu.io/2018/5/14/1635c3fb0ba21ec1?w=430&h=430&f=jpeg&s=39536
[Kotlin]: https://blog.csdn.net/u013064109/article/details/89078666
[Kotlin 1]: https://blog.csdn.net/u013064109/article/details/89023937
[Kotlin_Companion Object]: https://blog.csdn.net/u013064109/article/details/89199478
[Kotlin_PR]: https://blog.csdn.net/u013064109/article/details/85180755
[Kotlin 2]: https://blog.csdn.net/u013064109/article/details/84899657
[Kotlin_inline class]: https://blog.csdn.net/u013064109/article/details/84866092
[Kotlin_Reified]: https://blog.csdn.net/u013064109/article/details/83388976
[Kotlin 3]: https://blog.csdn.net/u013064109/article/details/83120352
[_Kotlin]: https://blog.csdn.net/u013064109/article/details/83099581
[Kotlin 4]: https://blog.csdn.net/u013064109/article/details/80344848
[Kotlin 5]: https://blog.csdn.net/u013064109/article/details/80358822
[Kotlin_ run_with_let_also_apply]: https://blog.csdn.net/u013064109/article/details/80387322
[Kotlin_typealias]: https://blog.csdn.net/u013064109/article/details/80444565
[Kotlin_Sequences_Lists]: https://blog.csdn.net/u013064109/article/details/80562009
[Kotlin_List_Sequence]: https://blog.csdn.net/u013064109/article/details/80740230
[Kotlin 6]: https://blog.csdn.net/u013064109/article/details/88985474
[Kotlin 7]: https://blog.csdn.net/u013064109/article/details/86695094
[Jetbrains_Kotlin1.3_inline class]: https://blog.csdn.net/u013064109/article/details/84837918
[JetBrains_Kotlin1.3_Contract]: https://blog.csdn.net/u013064109/article/details/84782206
[JetBrains_Kotlin_Native]: https://blog.csdn.net/u013064109/article/details/84729814
[Kotlin 8]: https://blog.csdn.net/u013064109/article/details/84504847
[Kotlin 9]: https://blog.csdn.net/u013064109/article/details/84060626
[Kotlin 10]: https://blog.csdn.net/u013064109/article/details/83869716
[Kotlin_Reified 1]: https://blog.csdn.net/u013064109/article/details/83507076
[Kotlin 11]: https://blog.csdn.net/u013064109/article/details/82794410
[Kotlin_Sequences]: https://blog.csdn.net/u013064109/article/details/80588034
[Kotlin_API_-]: https://blog.csdn.net/u013064109/article/details/80275942
[Kotlin_lambda]: https://blog.csdn.net/u013064109/article/details/80139556
[Kotlin_Lambda]: https://blog.csdn.net/u013064109/article/details/80088158
[Kotlin 12]: https://blog.csdn.net/u013064109/article/details/79968846
[Kotlin 13]: https://blog.csdn.net/u013064109/article/details/79887528
[Kotlin 14]: https://blog.csdn.net/u013064109/article/details/79503709
[Kotlin 15]: https://blog.csdn.net/u013064109/article/details/79296502
[Kotlin 16]: https://blog.csdn.net/u013064109/article/details/77843579
[Effective Kotlin]: https://blog.csdn.net/u013064109/article/details/84996951
[Effective Kotlin_Sequence]: https://blog.csdn.net/u013064109/article/details/84981570
[Effective Kotlin_inline]: https://blog.csdn.net/u013064109/article/details/84948769
[Effective Kotlin 1]: https://blog.csdn.net/u013064109/article/details/82121020
[Effective Kotlin 2]: https://blog.csdn.net/u013064109/article/details/81916446
[Kotlin_ImageSlimming-]: https://blog.csdn.net/u013064109/article/details/80850992
[Kotlin_-]: https://blog.csdn.net/u013064109/article/details/80879296
[Kotlin_- 1]: https://blog.csdn.net/u013064109/article/details/81814643
[Kotlin_View]: https://blog.csdn.net/u013064109/article/details/80102036