關(guān)鍵字：
var：定義變量
val：定義常量
fun：定義方法
Unit：默認方法返回值踱侣，類似于Java中的void粪小，可以理解成返回沒什么用的值
vararg：可變參數(shù)
$：字符串模板(取值)
位運算符：or(按位或)，and(按位與)泻仙，shl(有符號左移)糕再，shr(有符號右移)，
ushr(無符號右移)玉转，xor(按位異或)突想，inv(按位取反)
in：在某個范圍中
downTo：遞減，循環(huán)時可用究抓，每次減1
step：步長猾担，循環(huán)時可用钉迷，設(shè)置每次循環(huán)的增加或減少的量
when：Kotlin中增強版的switch茉盏，可以匹配值盼理，范圍抡柿，類型與參數(shù)
is：判斷類型用妓羊，類似于Java中的instanceof()
在Kotlin里嘲驾，可以用“?”表示可以為空写半，也可以用“!!”表示不可以為空屿衅。
例如：
var num:Int? = null
val v1 = num?.toInt() //不做處理返回 null
val v2 = num?.toInt() ?:0 //判斷為空時返回0
val v3 = num!!.toInt() //拋出空指針異常（用“!!”表示不能為空）
用var定義變量（像js）
用val定義常量（相當于final）
// 定義變量 必須要初始化
private var name: String? = ""
private val id: String = "122222"
// 簡化 Kotlin支持類型推斷
private var name = ""
// Elvis操作符 ?: 使用變量 如果name為空返回1 也可以寫成name?:1
var name : String? = "xxxx"
name = null
println("length==========" + (name?.length?:1))
// 類型轉(zhuǎn)換
val b: Byte = 1
val i: Int = b.toInt()
// 類型判斷符 is
//obj在&&右邊自動動轉(zhuǎn)換成"String"類型
if (obj is String && obj.length > 0){
return obj.length
}
// 范圍操作符 .. 以及 in
if (i in 1..10) { // 等價于 1 <= i && i <= 10
println(i)
}
// 未知類型強轉(zhuǎn) 必須是對應(yīng)類型不然拋出異常
var mPwdtoggle = findViewById(R.id.findpwd_btn_eye) as CheckBox
// 創(chuàng)建對象 Kotlin實例化一個對象時不需要new關(guān)鍵字
var list = ArrayList()
//定義參數(shù)的類型
fun makeTool(id:Int){ //參數(shù)id為Int類型
}
//定義函數(shù)的返回值
fun getAddr(id:Int):String{ //返回值為String類型
}
// var 延遲加載
private lateinit var default : String
fun initDefault(str : String){
default = str
}
// val 懶加載 只有在第一次被調(diào)用時畅卓，才會初始化
private val laz : String by lazy{
"懶加載"
}
private val mTextView : TextView by lazy {
findViewById(R.id.money_text) as TextView
}
private val mm by lazy {
findViewById(R.id.money_text) as TextView
}
// 區(qū)間和集合
if(x in 1..5){ ...//檢查x數(shù)值能否在1到5區(qū)間
if(name in list){...//檢查list中能否有某個元素（比Java簡潔多了）
for(i in 1..5){ ...//遍歷1到5
for(item in list){...//遍歷list中的每個元素（相當于Java的for(String item : list)）
// 數(shù)據(jù)類
// 關(guān)鍵字Any 等于Object
class Client {
var id: Long = 0
var name: String? = null
var birth: Int = 0
}
// 簡寫
data class Client(var id:Long, var name:String, var birth:Int)
// 添加共享對象 Client.VERSION
data class Client(var name:String){
companion object{
val VERSION = "我是共享對象"
}
}
// 單例 Client2.run()
object Client2 {
val VERSION = "我是共享對象"
init {
println("==========初始化")
}
fun run(){
println("==========run")
}
}
// 輸入表達式
val x = 2
val y = 3
println("===========$x ${x + y}")
// 表達式 替換java switch
override fun onClick(v: View?) {
when (v?.id) {
R.id.button3 -> Toast.makeText(this, "1111", Toast.LENGTH_LONG).show()
R.id.button34 ->{
}
// 相等于default
else -> Toast.makeText(this, "2222", Toast.LENGTH_LONG).show()
}
}
// when自動轉(zhuǎn)型
when (view) {
is TextView -> toast(view.text)
is RecyclerView -> toast("Item count = ${view.adapter.itemCount}")
is SearchView -> toast("Current query: ${view.query}")
else -> toast("View type not supported")
}
// 類繼承
abstract class Persons{
var name:String? = null
}
class Student : Persons(){
var names:String? = null
}
// 泛型
abstract class DList<T>{
var t: T? = null
}
class Studen : DList<Int>(){
var name:String? = null
}
// 數(shù)組
var arr = arrayOf(1, 2)
stringTempl(arr)
fun stringTempl(args: Array<String>) {
}
// for循環(huán)
val arr = arrayListOf<String>("1111", "2222")
// 迭代角標
for (j in arr.indices) {
println("1=========" + j)
}
var list = ArrayList<String>()
list.add("xxx")
list.add("qqq")
// 迭代數(shù)據(jù)
for(str in list){
println("2=========" + str)
}
// 全局方法：不寫類直接寫方法就是全局方法
// 方法簡寫
fun run1(num:Int):Int{
return num + 2
}
fun run2(num:Int) = num + 2
// 回調(diào)寫法
button.setOnClickListener(object : View.OnClickListener {
override fun onClick(v: View) {
}
})
// lambda表達式 就是把接口名擅腰、方法名和參數(shù)類型省掉不寫再加個-> 適用于一個方法的接口
// 單參數(shù)
button.setOnClickListener{ view ->
}
// 多參數(shù)
button.setOnEditorActionListener({ v, id, event ->
false
})
// 多方法
button.addOnAttachStateChangeListener(object : View.OnAttachStateChangeListener{
override fun onViewDetachedFromWindow(p0: View?) {
}
override fun onViewAttachedToWindow(p0: View?) {
}
})
// 擴展方法 連class和interface都不寫，直接在文件中寫fun方法
// 類方法擴展 創(chuàng)建kt文件 不需要寫類 直接寫方法就可以 相當于全局方法
public fun View._run(str :String){
Toast.makeText(BaseApplication.getContext(), str, Toast.LENGTH_SHORT).show()
}
擴展方法：
Kotlin中的方法可以直接定義在文件中翁潘，而不需要依賴于任何的類趁冈，這個稱為擴展方法。
成員方法：
而寫在class或object中的方法則稱成員方法拜马。
本地方法：
定義在方法內(nèi)部的方法渗勘，可以訪問外部函數(shù)的私有成員！
