学习kotlin的日子
Kotlin学习线（学习kotlin的日子）
Kotlin
使用过程中的一些经验：
1. 在使用过程中最需要记住的就是他的代码书写习惯中的各种符号以及
“:” 冒号在kotlin中是使用最多也是最频繁的一个，
如果用在类名后边表示继承或者实现
open class A {
}
interface C{
fun test()
}
class B : A() ,C{
override fun test() {
TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
如果是跟在变量名后边的话，表示变量类型，变量类型可以是一个函数。
var str:String = "test"
1
“::”俩个冒号是用来表示类的引用，通过这个符号可以用来传递函数引用，
println(String::class.java.simpleName)
1
fun isOdd(x: Int) = x % 2 != 0
fun main(args: Array
val numbers = listOf(1, 2, 3)
println(numbers.filter( ::isOdd) ) //prints [1, 3]
}
1
2
3
4
5
“.”这个符号是用来表示调用的意思
比如通过类名调用方法或者变量
或者通过对象调用类方法等
“?” 问号表示变量是否可以作为可空变量
“?:” 表示如果问号前边为null那么就返回冒号后边的值，如果不为null就返回问号前边的值。
var s = "hehe"?.length ?: 3
println(s)
1
2
“$” 匹配符
var name = "我是张三"
var age = 22
println("$name ,今年 $age 岁")
1
2
3
“!!” 从符号的来说就应该是一个提示用的。所以这符号是用来表明这个变量不能为空，否则会包出异常
var name: String? = null
var age = 22
println("$name ,今年 $age 岁")
println(name!!.length)
1
2
3
4
5
2. kotlin中基本语法的使用 if ，for ，when（代替Switch） ，while
3. 静态变量的创建使用companion object 来指定变量
package com.guoyi.qinghua.receiver
import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import com.guoyi.qinghua.utils.LogUtils
/**
* Created by chenpengfei on 17/9/5.
*/
class NavBroadCast : BroadcastReceiver() {
override fun onReceive(context: Context?, data: Intent?) {
TODO("not implemented")
var action: String = data!!.action;
var key_type: Int = data!!.getIntExtra(KEY_TYPE, 0)
var status: Int = data!!.getIntExtra(EXTRA_STATE, 0)
LogUtils.e(TAG,"action = $action key_type= $key_type status = $status")
if (ACTION_SEND == action && key_type == NavBroadCast.KEY_TYPE_COMPUTED){
when(status){
6-> { //算路成功
//导航状态变化，开始导航
val nav_intent = Intent()
nav_intent.action = ACTION_RECEIVE
nav_intent.putExtra(KEY_TYPE, KEY_TYPE_START_NAVIGATION)
context!!.sendBroadcast(nav_intent)
LogUtils.e(TAG, "导航启动")
}
7-> { //导航失败
}
9-> { //导航关闭
val manager = context!!.packageManager
val start_intent = manager.getLaunchIntentForPackage(context.packageName)
start_intent.flags = Intent.FLAG_ACTIVITY_NEW_TASK
context.startActivity(start_intent)
}
}
}
}
//创建静态变量
companion object {
val TAG : String? = NavBroadCast::class.java.simpleName
val KEY_TYPE_COMPUTED: Int? = 10019
val KEY_TYPE_COMPUTE_LINE: Int? = 10007
val KEY_TYPE_START_NAVIGATION: Int? = 10009
val KEY_TYPE: String? = "KEY_TYPE"
val EXTRA_STATE: String? = "EXTRA_STATE"
val EXTRA_SNAME: String? = "EXTRA_SNAME"
val EXTRA_SLON: String? = "EXTRA_SLON"
val EXTRA_SLAT: String? = "EXTRA_SLAT"
val EXTRA_DNAME: String? = "EXTRA_DNAME"
val EXTRA_DLON: String? = "EXTRA_DLON"
val EXTRA_DLAT: String? = "EXTRA_DLAT"
val ENTRY_LON: String? = "ENTRY_LON"
val ENTRY_LAT: String? = "ENTRY_LAT"
val EXTRA_DEV: String? = "EXTRA_DEV"
val EXTRA_M: String? = "EXTRA_M"
val ACTION_SEND: String? = "AUTONAVI_STANDARD_BROADCAST_SEND"
val ACTION_RECEIVE: String? = "AUTONAVI_STANDARD_BROADCAST_RECV"
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
4、在使用中如果要添加监听器，而且在方法的回调中还要使用该监听器，那么你就只能创建一个该监听器的变量，然后使用。
这样的情况就要使用对象表达式来实现
@JvmStatic
fun main(args: Array
setOnChange(object: onChange{
override fun click() {
println(this::class.java.simpleName)
}
override fun click(s: String) {
}
override fun onClick() {
super.onClick()
}
})
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
fun setOnChange(onChange: onChange){
onChange.onClick()
onChange.click()
onChange.click("hahahah")
}
interface onChange{
fun click()
fun click(s: String)
fun onClick(){
}
}
1
2
3
4
5
6
7
8
9
10
11
12
而且从上边的代码可以看到，我们在定义接口的时候，里边的方法是可以重载的，而且方法的方法体也是可选的，也就是说，我们接口也可以是抽象类。
5、在使用kotlin过程中如果用java编辑的时候如果要吊用main方法必须指定JvmStatic,如果要让开发工具可以识别当前包含入口函数main方法：可以有以下俩种方式
通过定义当前类的类型为object
object FunTest{
@JvmStatic
fun main(args: Array
println(FunTest::class)
}
}
1
2
3
4
5
6
7
8
2、也可以通过把main方法转换为一个companion object类型
class FunTest{
companion object {
@JvmStatic
fun main(args: Array
println(FunTest::class)
}
}
}
1
2
3
4
5
6
7
8
9
这个companion通常是kotlin中用来定义静态变量的，就是java中可以通过类名直接调用的方法或者变量。
3、也可以通过这样的方式
class FunTest2(val p: Int)
fun main(args: Array
println(FunTest2::p.javaGetter) // prints "public final int A.getP()"
println(FunTest2::p.javaField) // prints "private final int A.p"
}
1
2
3
4
5
6
6、Kotlin关键字详解
lazy{}
该关键字只能用在val 修饰的变量上
lazy在第一次被调用时就被初始化，想要被改变只能重新定义
val name : String by lazy { "ni hao " };
1
lateinit 主要是用在var 修饰的变量
lateinit可以在任何位置初始化并且可以初始化多次
class StringKey{
lateinit var name : String;
}
fun main(args:Array
var obj :StringKey = StringKey()
obj.name = "hahahah"
}
这里写代码片
1
2
3
4
5
6
7
8
9
10
main关键字是用来标识该方法是java的入口方法
fun 关键字标识函数
object 用来标识用来声明一个单例对象
object Obj{
init{
println("object init...")
}
}
1
2
3
4
5
let
默认当前这个对象作为闭包的it参数，返回值是函数里面最后一行，或者指定return
// fun
fun testLet(): Any {
"testLet".let {
var age : Int = 10
return age
}
}
1
2
3
4
5
6
7
8
apply 使用apply方法以后，只要在apply这个方法体中，可以使用它的所有方法。
fun applyFun() : Int{
ArrayList
add("hahah")
add("wwawawaw")
println("size = $size") //size 是Arraylist的属性
}.let {
println("结果" + it)
return 0;
}
}
1
2
3
4
5
6
7
8
9
10
11
with
与apply类似
fun withFun(){
with(ArrayList
add("node1")
add("node2")
add("node3")
println("size = $size")
}.let {
println(it)
}
}
1
2
3
4
5
6
7
8
9
10
11
run
该关键字和apply函数很像，只不过run函数是使用最后一行的返回，apply返回当前自己的对象。
class Person{
var name : String = "";
var age : Int = 0;
constructor(name:String,age :Int){
this.name = name
this.age = age
}
override fun toString(): String {
return "name= $name , age = $age"
}
}
fun runFun(){
var person = Person("张三",20)
person.run {
person.toString()
}.let {
println(it)
}
}
---------------------
作者：非花非雾--
来源：CSDN
原文：https://blog.csdn.net/u012808234/article/details/77878788
版权声明：本文为博主原创文章，转载请附上博文链接！