【官方澳门新永利下载】基础语法,写给Java程序员的Kotlin简介

可以定义中缀函数

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

infix fun Int.add(another:Int):Int { return this + another}// call example var c = 1 and 2

//——————-函数定义————————
//格式 : 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<String>) {
sum(1,2)
sum2(1,2)
sum3(1,2)
printSum(1,2)
printSum2(1,2)
}
/

kotlin 支持函数嵌套定义

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

fun dfs(graph: Graph) { val visited = HashSet<Vertex>() fun dfs(current: Vertex) { if (!visited.add return // 可访问外部函数定义的局部变量 for (v in current.neighbors) dfs } } dfs(graph.vertices[0]) }

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

支持inline function支持尾递归优化,需使用tailrec关键字

//————-定义常量与变量——————-
//可变变量定义var关键字 || 格式:var 变量名:类型=初始化的值
//不可变变量类似于java中的final val关键字 || 格式:val
变量名:类型=初始化值
//kotlin中常量和变量均可以没有初始化值,但是在引用前必须初始化,编译器支持自动类型判断,可以不指定类型。
/fun main(args: Array<String>) {
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的注释可以嵌套

fun <T> lock(lock: Lock, body: () -> T): T { lock.lock() try { return body() } finally { lock.unlock() }}fun <T, R> List<T>.map(transform:  -> R): List<R> { val result = arrayListOf<R>() for (item in this) result.add(transform return result }}val doubled = ints.map { it -> it * 2 }or ints.map { it * 2 } // one params it-> can be omitted

var sum = {x:Int, y:Int -> x+y}val sum:->Int={x, y->x+y}val sum:  -> Int = { x, y -> println; x+ 3 ; x + y}// 如果只有一个参数,可以使用it来代替

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

lambda可以声明返回值类型,但是如果能推断出返回类型,我们就无需定义

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

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

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

如果参数的数据类型能被推断出来的话也可以省略之lambda
和匿名函数的区别主要在于,lambda无法声明return 表达式

}*/

var sum = 0ints.filter { it > 0 }.forEach { sum += it }print

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

匿名函数或者lambda表达式可以访问作用域范围内的变量

/*fun main(args: Array<String>) {
//类型后面加?表示可以为空
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

我们可以定义函数的接受对象sum
:Int.(other:Int)->Int此时sum被定义为带Int接收者的函数1.sum//这个有点类似扩展函数,我们可以将其当做Int的扩展函数val
sum = fun Int.(other:Int):Int = this + other

//当一个引用为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类型

发表评论

电子邮件地址不会被公开。 必填项已用*标注