Kotlin研发第一弹——基本语法

基本语法

• 基本语法
  • 包定义
  • 定义函数
  • 定义局部变量
  • 注释
  • 使用字符串模板
  • 使用条件表达式
  • 使用可空变量以及空值检查
  • 使用值检查以及自动转换
  • 使用for循环
  • 使用while循环
  • 使用when表达式
  • 使用ranges
  • 使用集合

基本语法

包定义

在源文件的开头定义包

package com.wyc.accountschool.kotlin.test.zheshi.zhende

import com.wyc.accountschool.kotlin.test.JavaTest

包名不必和文件夹路径一致：源文件可以放在任意位置.

定义函数

定义一个函数接收两个int型参数，返回值int：

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

只有一个表达式作为函数体，以及自推导型的返回值：

fun sum(a:Int,b:Int)=a+b

kotlin默认返回一个Unit的值，这个相当于java中Object是所有类的父类，不含有任何值

fun printSum(a:Int,b:Int):Unit{
    println("a = $a,b= $b")
}

Unit返回类型可以不带

fun printSum(a:Int,b:Int){
    println("a=$a,b=$b")
}

定义局部变量

一次赋值（只读）的局部变量

//定义局部变量
fun getDeTest(){
    val a:Int=1//立刻赋值
    val b=2//自推导类型
    val c:Int//没有初始化需要指定类型
    c=3//推导赋值型
}

可修改的变量：

var x=5
x+=1

注释

与java和JavaScript一样，kotlin支持单行注释和块注释。

// 单行注释
/*  哈哈哈哈
    这是块注释 */

与java不同的是kotlin的块注释能够级联

块标签

KDoc 目前支持以下块标签（block tags）：

@param <名称>

用于函数的值参数或者类、属性或函数的类型参数。 为了更好地将参数名称与描述分开，如果你愿意，可以将参数的名称括在方括号中。因此，以下两种语法是等效的：

@param name 描述。
@param[name] 描述。

@return

用于函数的返回值。

@constructor

用于类的主构造函数。

@receiver

用于扩展函数的接收者。

@property <名称>

用于类中具有指定名称的属性。这个标签可用于在主构造函数中声明的属性，当然直接在属性定义的前面放置 doc 注释会很别扭。

@throws <类>, @exception <类>

用于方法可能抛出的异常。因为 Kotlin 没有受检异常，所以也没有期望所有可能的异常都写文档，但是当它会为类的用户提供有用的信息时， 仍然可以使用这个标签。

@sample <标识符>

将具有指定限定的名称的函数的主体嵌入到当前元素的文档中， 以显示如何使用该元素的示例。

@see <标识符>

将到指定类或方法的链接添加到文档的另请参见块。

@author

指定要编写文档的元素的作者。

@since

指定要编写文档的元素引入时的软件版本。

@suppress

从生成的文档中排除元素。可用于不是模块的官方 API 的一部分但还是必须在对外可见的元素。

使用字符串模板

val name="wyc"
val myName="my name is $name"
val myCompany="${myName.replace(name,"da")}, is a big company"

使用表达式

 //使用表达式
fun maxOf(a:Int,b:Int):Int{
        return if(a>b)
            a
        else
            b
    }
fun maxOf1(a:Int,b:Int)=if (a>b) a else b

使用可空变量以及空值检查

当空值可能出现时应该明确指出该引用可空

当str中不包含整数时返回空：

 //返回空值
    fun praseInt(s:String):Int?{
        return s.toIntOrNull()
    }
    fun testPraseInt(s1:String,s2:String){
        val a=praseInt(s1)
        val b=praseInt(s2)
        if (a!=null&&b!=null)
            println(a*b)
        else
            println("either a is $a or b is $b")
    }

使用值检查以及自动转换

使用is操作符检查一个表达式是否是某个类型的实例，如果对不可变的局部变量或属性进行过了类型检查，就没必要明确转换

fun getStringLength(o:Any):Int?{
        return if (o is String) o.length else null
    }

使用for循环

 //使用for
    val nameList= listOf("wyc","lyb","zyf")
    for (name in nameList){
        println("name is $name")
    }
    //或者是这样
    for (num in nameList.indices){
        println("my name at position in $num is ${nameList[num]}")
    }

使用when表达式

 //when表达式
    fun gescribeTest(obj:Any)=when(obj){
        is String->"its String"
        is Int->"its Int"
        else ->"its no"
    }

使用ranges

使用in操作符检查数值是否在某个范围内：

使用 in 操作符检查数值是否在某个范围内：

val x = 10
val y = 9
if (x in 1..y+1) {
    println("fits in range")
}
检查数值是否在范围外：

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")
}

使用范围内迭代：

for(x in 1..5){
    println(x)
}

使用步进

for(x in 1..2 step 2){
    println(x)
}
for(x in 9 downTo 0 step 3){
    println(x)
}

使用集合

对一个集合尽心迭代

   fun printList(namelist:List<String>)=nameList.forEach{
        when(it){
             in "wyc" -> println("name is $it")
            in "lyb"-> println("name is $it")
            in "zyf"->println("name is $it")
        }
    }

使用 in 操作符检查集合中是否包含某个对象

  fun printList1(list: List<String>) =when{
        "wyc" in list->println("printList name is wyc")
        else -> {
            println("printList name is nobody")
        }
    }

使用lambda表达式

//使用lambda表达式
    nums.filter { it.startsWith("w") }
            .sortedBy { it.length }
            .map { it.toUpperCase() }
            .forEach {
                println(it)
            }

跳转下一章 Kotlin研发第二弹——习惯用语