未完待续······太监直播吃电脑(●'◡'●)
一.基础操作符、语法、定义等
val --> 常量 ; var --> 变量
：继承、实现::引用
fun isOdd(x: Int) = x % 2 != 0
println(numbers.filter(::isOdd)) // 输出 [1, 3]
=、==、=== 分别表示 赋值、比值、比引用
is 、!is --> instanceof
$ (取值符)
.. 表示区间 1..5 --> 1至5
?相关：
val num : Int? = number //标识num允许为null,但是会将num自动装箱
num?: println("num is null") //?: 在num为null时
num?.let { println("num not null") } //?.let在num非null时
- 构造函数constructor
一个类可以有一个主构造函数和多个次构造函数，且主构造函数不能包含任何代码，代码仅能置于init块中：
class Customer constructor(name: String) {
init {
logger.info("Customer initialized with value ${name}")
}
}
通过:this调用其它构造方法：
constructor(name: String, parent: Person) : this(name)
open 开放类/成员: open 标注与 Java 中 final 相反，它允许其他类 继承这个类、重写某个方法。默认情况下，在 Kotlin 中所有的类都是 final
setter、getter 的使用：
val isEmpty: Boolean(可以省略类型)
get() = this.size == 0
var name: String
set(value) {
this = value
}
- as类型强转符
fun getMvpView():V{
return this as V
}
- 属性修饰符
private //自身可见
protected //自身及子类可用
internal //本模块(module)内可用
public //任何客户端可用
- when的使用
when(tag1){
"a" -> println("a")
"abc" -> println("bb")
is String -> println("string")
else -> println("unknow")
}
- 方法由fun声明，且类型声明后置 （方法参数类型、返回值类型等）：
val number : Int = 555
fun sum(a: Int, b: Int): Int {
return a + b
}
fun sum(a: Int = 1, b: Int = 2) : Int = a + b
- 允许为方法参数设置默认值 :
fun sum(a: Int = 1, b: Int = 2): Int {
return a + b
}
- 数组Array相关：
//创建数组
val myAray = arrayOf(1,2,3)
val myArrat = Array(3,{i -> i })
//遍历
for (s in myAray)
println(s)
- List:
val list = listOf<String>("a","b","c")
val list1 = List(3,{i -> i })
list.filter { s -> s != "a" } //过滤
list.map { s -> s+"@" } //变化
- 对象声明 object关键字后加对象管理者名称
object Hero {
fun getInstance() : Hero {
return Hero()
}
}
Hero.getInstance()
伴生对象 companion object关键字声明
匿名对象的创建(方便的是匿名对象访问外部变量时不必再去申明final类型了):
val noName= object {
var x: Int = 0
var y: Int = 0
}
- 单例
object Singletons {
val something: OfMyType by lazy() { ... }
val somethingLazyButLessSo: OtherType = OtherType()
val moreLazies: FancyType by lazy() { ... }
}
- by lazy{} 只能用在val类型, lateinit 只能用在var类型
二.函数、Lambda、代码分析
- 1.函数扩展：为某个类定义一个扩展函数，使得在任何地方都可以通过对象.函数名的方式去调用改函数。（简化了通过extend创建子类）
常见的使用场景就是拓展Context类，增加一个showToast的简单方法，避免每次show Toast的大量重复代码，：
fun Context.showToast(message:String = "this is a toast",length : Int = Toast.LENGTH_SHORT){
Toast.makeText(this,message,length)
}
如果一个类定义有一个成员函数和一个扩展函数，而这两个函数又有相同的接收者类型、相同的名字 并且都适用给定的参数，这种情况总是取成员函数。 例如：
class C {
fun foo() { println("member") }
}
fun C.foo() { println("extension") }
如果我们调用 C 类型 c的 c.foo()，它将输出“member”，而不是“extension”。
- 2.属性扩展 (布能直接初始化，只能通过setter、getter):
val <T> List<T>.lastIndex: Int
get() = size - 1
3.copy()函数，可以理解为拷贝一个对象，仅改变其部分成员值
4.函数的命名参数(当函数有默认参数值时，我们可以通过命名参数的方式，指定某几个参数的值，而其他参数仍采用默认值)：
fun goEasy(name : String = "me",
time : String = "now",
isShow: Boolean = true): Unit{}
goEasy() //使用默认参数
goEasy(name = "axe",isShow = false) //命名参数
- 5.vararg可变数量的参数,动态参数，省去了重载：
fun <T> asList(vararg ts: T): List<T> {
val result = ArrayList<T>()
for (t in ts) // ts is an Array
result.add(t)
return result
}
- 6.函数作用域：
全局函数，在kt文件中申明，可以在全局使用；
成员函数，类中申明；
内部函数，在函数内部还可以申明函数，并可以访问父外部函数的变量，可以参考匿名内部类
- 7.高阶函数，函数的参数是另一个函数体（一般传一个lambda表达式,必须制定参数类型和返回值类型）:
fun <T> lock(lock: Lock, body: () -> T): T {
lock.lock()
try {
return body()
}
finally {
lock.unlock()
}
}
val result = lock(lock, { sharedResource.operation() })
- 8.Lambda相关:
lambda 表达式总是被大括号括着
其参数（如果有的话）在 -> 之前声明（参数类型可以省略）
函数体（如果存在的话）在 -> 后面
如果函数字面值只有一个参数， 那么它的声明可以省略（连同 ->）,其名称是 it
ints.map { it->(省略)it * 2 }
- 9.告别findViewById,可以直接把控件的id当作其实例使用，但是前提:
apply plugin: 'kotlin-android'
apply plugin: 'kotlin-android-extensions'
import kotlinx.android.synthetic.main.activity_read_detail.*;
headText.text = "放开我~你就能刷新了哦(●'◡'●)"
headText.gravity = Gravity.CENTER
- 10.with()扩展函数:在with代码块中我们可以使用this和直接访问所有的public的方法和属性
inline fun <T> with(t: T, body: T.() -> Unit) { t.body() }
with(A){
A.method();
A.field;
}
