今天来学习下基本语法，参考了官方文档

包


package com.kotlin


导入

import关键字


import java.util*



类型的声明

Kotlin使用var

var a:Int = 1

var b:Double = 2

使用val

val c:Char = "你好"

函数



函数声明


Kotlin使用fun关键字作为函数声明 





    1. fun double(a:Int) {  
2. return 2*a  
3. }



    函数用法


    传统方式：



      1. val result = double(2)  
 
 调用类成员 
cal.double(2) //创建cal实例，并且调用double


      函数参数


      函数参数使用pascal定义法，即name:type。参数之间使用逗号隔开，参数必须是显式类型



      1. fun haha(hao:Char) : Char {  
2.     ...  
3. }


      默认参数


      函数可以有默认值，当省略参数时，使用默认值，以下引用官方手册



      1. fun read(b: Array<Byte>, off: Int = 0, len: Int = b.size) {  
2. ……  
3. }


      默认值通过类型后面的 =覆盖方法总是使用与基类型方法相同的默认参数值。 当覆盖一个带有默认参数值的方法时，必须从签名中省略默认参数值：




      1. open class A {  
2. 10) { …… }  
3. }  
4.   
5. class B : A() {  
6. // 不能有默认值  
7. }


      如果一个默认参数在一个无默认值的参数之前，那么该默认值只能通过使用命名参数调用该函数来使用： 






        1. fun foo(bar: Int = 0, baz: Int) { /* …… */ }  
2.   
3. foo(baz = 1) // 使用默认值 bar = 0



        不过如果最后一个

        lambda表达式

        参数从括号外传给函数函数调用，那么允许默认参数不传值： 




        1. fun foo(bar: Int = 0, baz: Int = 1, qux: () -> Unit) { /* …… */ }  
2.   
3. foo(1) { println("hello") } // 使用默认值 baz = 1   
4. foo { println("hello") }    // 使用两个默认值 bar = 0 与 baz = 1


        命名参数



        可以在调用函数时使用命名的函数参数。当一个函数有大量的参数或默认参数时这会非常方便。

        给定以下函数




        1. fun reformat(str: String,  
2. true,  
3. true,  
4. false,  
5. ' ') {  
6. ……  
7. }


        我们可以使用默认参数来调用它 






          1. reformat(str)



          然而，当使用非默认参数调用它时，该调用看起来就像 





          1. reformat(str, true, true, false, '_')


          使用命名参数我们可以使代码更具有可读性 




          1. reformat(str,  
2. true,  
3. true,  
4. false,  
5. '_'  
6. )


          并且如果我们不需要所有的参数 




          1. reformat(str, wordSeparator = '_')




          定义函数



          定义一个有两个Int类型的入参，及返回类型是Int。 


          1. fun sum1(a:Int,b:Int) : Int {  
2. return a + b  
3. }



          定义一个将表达式作为函数体、返回值类型为自动推断的函数 


          1. fun sum2(a:Int,b:Int) = a + b




          定义一个函数，返回无意义的值 



          1. fun printSum1(a: Int, b: Int): Unit {  
2. "sum of $a and $b is ${a + b}")  
3. }