很久没有对一段时间的工作学习进行总结,所以想就近一个月使用kotlin编程,进行简单的总结.首先,kotlin真的十分好用,在Android开发中,能体会到kotlin带来便捷和灵活性.java程序员能十分友好的过渡到kotlin.
下面我将主要介绍下Android中的使用.
### 1)引入kotlin ###
AS3.0很好的支持了kotlin,创建一个新的.kt文件,kotlin所依赖的库基本都会导进来;
module build.gradle 中
```
apply plugin: 'kotlin-android'
apply plugin: 'kotlin-android-extensions'
compile "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
```
项目 build.gradle中
```
dependencies {
.....
classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
}```
### 2)基本语法 ###
1) 基本类型
在.kt中 基本类型都类似于java中的包装类型,比如:Int,Long,String,Boolean...
需要注意的是,当没有被"?"申明时,这些对象是不可为null的,这也是kotlin能最大程度干掉NPE的所在之处吧;
2)定义函数
无返回值eg:
```
fun sum(a:Int ,b:Int){
println("$a plus $b = ${a+b}")
}
or
fun sum(a:Int ,b:Int):Unit{
println("$a plus $b = ${a+b}")
}
```
有返回值eg:
```
fun sum(a:Int ,b:Int):Int{
return a+b
}
//注意的是,这里返回值是Int,所以不允许返回null,如果允许返回值为null,这样申明函数.
fun sum(a:Int ,b:Int):Int?{
return null// 这里允许返回null
}
or
fun sum(a:Int ,b:Int)=a+b
```
3) if,for,when,rang等表达式的使用
eg:
```
if语句
fun maxOf(a:Int,b:Int)=if(a>b) a else b
上述函数类似于java三目运算 ;
kotlin 在类型可推断时,可省略返回值类型的申明;
for语句
val fruits = arrayOf("apple", "banana", "kiwi")
for(fruit in fruits){
println(fruit)
}
or
fruits.forEach {println(it)} //当lamda表达式只有一个参数时,该参数可用it表示
when语句
val fruits = arrayOf("apple", "banana", "kiwi")
when {
"orange" in items -> println("juicy")
"apple" in items -> println("apple is fine too")
}
or
fruits.forEach {
when (it) {
"apple", "banana" -> println("I love $it")
else -> println("I don't love $it")
}
}
rang语句
val x=520;
if(x in 1..521){
println("$x in range")
}
```
4)区间迭代
eg:
```
打印1,3,5;step为1时可省略step
for(x in 1..5 step 2){
println(x)
}
or
for(x in 5 downTo 1 step2){
println(x)
}
```
还有许多基本用法就不一一列出了,具体可以参考kotlin官方文档
### 3)创建类及实例 ###
1)与java不同的是,kotlin默认所有class是不可以被集成的,类要被继承,需要显性用 open 来修饰 class;
```
eg:
主构造无参
open class Foo{
}
Sub class :Foo(){
}
//Sub继承Foo,主构造没有参数时,在类申明时可以省略构造
主构造有参
open class Foo(p:String?){
fun run1(){
println("invoke run1 in Foo")
}
open fun run2(){
println("invoke run2 in Foo")
}
}
Sub(p:String?) class:Foo(p){
override fun run2() {
super.run2()
}
//此处并未重写父类方法
fun run1(){
println("invoke run1 in Sub")
}
}
在kotlin中,创建新的对象,不需要new 关键字;
同样的,函数也需要 open 修饰才能被子类重写.
val foo=Foo("google Jang")
foo.run1().apply{run2()}
//打印:
invoke run1 in Foo
invoke run2 in Foo
```
时间有限,先写这些,下一篇将主要介绍lambda表达式以及扩展函数
网友评论