1.val与var

• val —–> value 不可变值，相当于java中final变量。
• var —–> variable 可变值，相当于java普通变量。

2.object与companion object

• object : 声明static对象，常用作单例。
  特点：不可定义构造函数。使用时才立即初始化。
• companion object : 译作伴随对象，可以理解为类静态成员。

3.open与abstract

• open : 声明此类非final，可以继承。如果一个class没有同时声明open，则此类不能被继承，相当于final类。
• abstract : 跟java抽象类一样，可以有未实现方法。而open不能有未实现方法。
• 题外话：那么单例object能不能被继承呢？
  答案是不能的，因为object类没有共有构造函数，只有私有构造函数，子类无法调用父类的构造函数，因而无法被继承。这与java是一样的。

4.操作符==,!=,===,!==,[]

以下均为在kotlin的意义

• ==：重载为a?.equals(b) ?: (b===null) ，即调用equals。
• ===：判断两个引用是否相等。
• []：重载get，set方法。

特别注意

• 以上操作符使用均针对对象，而像int等基本数据类型的操作符，是没有改变的。

5.匿名内部类

1
2
3
4
5
6
7
8
9
10
11
12

user.login(object : SaveListener<BmobUser>() {
     override fun done(b: BmobUser?, e: BmobException?) {
         hideLoading()
         if (e != null) {
             toast("登陆成功！")
             MainActivity.start(this@LoginActivity)
             finish()
         } else {
             toast(e.toString())
         }
     }
})

6.静态代码块与非静态代码块

• 静态代码块

1
2
3
4
5

companion object {
    init {
    	...       
    }
}

• 非静态代码块

1
2
3

init {
	...
}

7.for循环

(1)普通循环

1
2
3
4
5
6
7
8
9

for(i in 0..9){
    println(i)
}
i范围是0到9
for(i until 0..9){
    println(i)
}
i范围是0到8

(2)迭代器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

val list = listOf("A", "B", "C")
for(s in list){
    print(s)
}
for((index, item) in list.withIndex()){
    print(index + ":" + item)
}
带下标的循环，index、item名称可以改。
list.forEach{
    print(it)
}
这里的it相当于迭代器。

8.data class

写java bean很easy。

有参构造函数

1
2
3
4
5
6
7
8
9
10

data class Violation(var username: String?,
                     var location: String?,
                     var date: String?,
                     var car_type: String?,
                     var car_color: String?,
                     var car_number: String?,
                     var reason: String?,
                     var urls: List<String>?) {
}

无参构造函数

给参数加默认值

1
2
3
4
5
6
7
8
9

data class Violation(var username: String? = null,
                      var location: String? = null,
                      var date: String? = null,
                      var car_type: String? = null,
                      var car_color: String? = null,
                      var car_number: String? = null,
                      var reason: String? = null,
                      var urls: List<String>? = null) {
}

9.数组

基本数据类型

1
2

val intArr = intArrayOf(1, 2, 3) 
val booleanArr = booleanArrayOf(false, true, false)

对象数组

1

val arr = arrayOf("1", "2", "3")

空数组

1

val empty = emptyArray<Int>()

1.官方网站

https://kotlinlang.org/

2.微信公众号

KotlinX

高级：

1: git checkout C4

2: git checkout bugFix^

3: git branch –f bugFix C0
git branch –f master C6
git checkout HEAD^

4: git reset HEAD^
git checkout pushed
git revert HEAD

移动提交记录：

1: git cherry-pick C3 C4 C7

2: git rebase –i HEAD~4

杂项：

1: git checkout master
git cherry-pick C4

2: git rebase –i HEAD~2
git commit –amend
git rebase –i HEAD~2
git branch –f master HEAD

3: git checkout master
git cherry-pick C2
git commit –amend
git cherry-pick C3

4: git checkout C2
git tag v1
git tag v0 C1

5: git describe master
git commit

高级话题:

1: git rebase master bugFix
第一个参数是父节点，第二个参数是目标节点。
git rebase bugFix side
git rebase side another
git rebase another master

2: git branch bugWork HEAD^^2^

3: git checkout one
git cherry-pick C4 C3 C2
git checkout two
git cherry-pick C5 C4 C3 C2
git branch –f three C2

远程仓库：

2: git commit
git checkout o/master
git commit

3: git fetch

4: git pull

5: git clone
git fakeTeamwork master 2
git commit
git pull

6: git commit
git commit
git push

7: git clone
git fakeTeamwork
git commit
git pull –rebase
git push

远程仓库高级：

1: git fetch
git rebase o/master side1
git rebase side1 side2
git rebase side2 side3
git rebase side3 master
git push

2: git checkout master
git pull
git merge side1
git merge side2
git merge side3
git push

3: git checkout –b side o/master
git commit
git pull –rebase
git push

4: git push origin master
git push origin foo

5: git push origin master^:foo
git push origin foo:master

6: git fetch origin master~1:foo
git fetch origin foo:master
git checkout foo
git merge master

7: git push origin :foo
git fetch origin :bar

8: git pull origin bar:foo
git pull origin master:side