基础语法

package jichuyufa
/*
默认导入
kotlin.*
kotlin.annotation.*
kotlin.collections.*
kotlin.comparisons.*
kotlin.io.*
kotlin.ranges.*
kotlin.sequences.*
kotlin.text.*
*/

//-------------------函数定义------------------------
//格式 : fun 函数名 （参数：参数类型...） ： 返回值类型{ 执行的语句}
fun sum(a:Int,b:Int):Int{ return a+b}
// 只有一条返回语句的方法，可以由编译器自己判断返回的类型。
fun sum2(a:Int,b:Int)=a+b
//public 方法必须明确写出返回值的类型
public fun sum3(a:Int,b:Int):Int=a+b
//无返回值的函数，需要用Unit类型作为返回值，也可以省略
fun printSum(a:Int,b:Int):Unit{print(a+b)}
//省略
fun printSum2(a:Int,b:Int){print(a+b)}
//测试
/fun main(args: Array) {
sum(1,2)
sum2(1,2)
sum3(1,2)
printSum(1,2)
printSum2(1,2)
}/

//-----------------可变长参数--------------------------
//多个相同的参数，可以使用可变长参数 使用关键字vararg进行标识
fun vars(vararg v:Int){
for(vt in v)
print(vt)
}
//测试
/fun main(args: Array) {
vars(1,2,3,4,5)//输出12345
}/

//---------------lambda匿名函数-----------------
/fun main(args: Array) {
val sumLambda:(Int,Int)->Int={x,y->x+y}
println(sumLambda(1,2))//输出3
}/

//-------------定义常量与变量-------------------
//可变变量定义var关键字 || 格式：var 变量名:类型=初始化的值
//不可变变量类似于java中的final val关键字 || 格式：val 变量名：类型=初始化值
//kotlin中常量和变量均可以没有初始化值，但是在引用前必须初始化，编译器支持自动类型判断，可以不指定类型。
/fun main(args: Array) {
val a:Int=1
val b=1 //系统自动推断变量类型为int
val c:Int //不在声明时初始化，必须提供变量类型
c=1// 明确赋值
var x=5//系统自动推断变量的类型为int
x+=1 //变量可修改
println(""+a+","+b+","+c+","+x)
}/

//------------注释------------
//与java的注释一样，但是kotlin的注释可以嵌套

//-------------字符串模板----------------
/*
$ 表示一个变量名或者变量值
$varName 表示变量值
${(varName.fun()} 便是变量的方法返回值
*/

/*fun main(args: Array) {
var a=1
//模板中的简单名称：
val s1="a is $a"
println(s1)//a is 1

a=2
//模板中的任意表达式
val s2="${s1.replace("is","was")},but now is $a"

println(s2)//a was 1,but now is 2

}*/

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

/*fun main(args: Array) {
//类型后面加？表示可以为空
var age:String?=null
println(age) //null
//抛出空指针异常
val ages=age!!.toInt()
println(ages) //null异常
//不做处理返回null
val ages1=age?.toInt()
println(ages1)//null
//age为空返回-1
val ages2=age?.toInt()?:true
println(ages2)//若为null 返回true

//当一个引用为null值时，对应的类型声明必须明确的标识为null
//当str中的字符串内容不是一个整数时，返回null
fun parseInt(str:String):Int?{
    if(str.equals("a"))
        return null
    return Integer.parseInt(str)
}
val x=parseInt("a")
println(x)//返回null
if(x!=null) println(x) //经过null检查之后会自动转换成非null类型

}
*/

//--------------类型检测及自动类型转换---------------
//我们可以使用is运算符检测一个表达式时候某类型的一个实例 类似于java中的instanceof关键字
fun getStringLength(obj:Any):Int?{
if(obj is String) return obj.length
return null

//还有另一种方法 与 java的 instanceof不同    使用!is
/*if(obj !is String)
    return null*/

}
//或者
fun getStringLength2(obj:Any):Int?{
if(obj !is Int)return null
//在此之前obj仍是Any类型的引用，在这里会被自动转换成String
return obj
}
//也可以
fun getStringLength3(obj:Any):Int?{
//在&&运算符的右侧，obj会被自动转换成String
if(obj is String && obj.length>0)
return obj.length
return null
}

/*fun main(args: Array) {
println(getStringLength("aaaaa"))
println(getStringLength2(3))
println(getStringLength3("aaaaa"))
}
*/

//-------------区间--------------------
//区间表达式具有操作符形式.. 的rangeTo 函数辅以in和！in 形成
//区间是为任何可以比较类型定义的，但对于整型原生类型，他有一个优化的实现。
fun main(args: Array) {
for(i in 1..4) print(i)//输出1234 闭区间【】
println()
for(i in 4..1)print(i)//什么都不输出 a<=i<=b 即 4<=i<=1
println()
for(i in 1..10)print(i)//输出1-10 等价于 a<=i<=b 即 1<=i<=10
println()

//使用step 指定步长
for(i in 1..4 step 2) print(i) //等价于 a<=(i+=2滞后计算)<=b
println()
//倒序可以使用downTo
for(i in 4 downTo 1 step 2) print(i)

//使用until 排除元素 可变成模仿开区间
println()
for(i in 1 until 10) print(i) //【1,10）

}

fun test(){}

class Runoob{}