关键字：
var：定义变量
val：定义常量
fun：定义方法
Unit：默认方法返回值，类似于Java中的void，可以理解成返回没什么用的值
vararg：可变参数
$：字符串模板(取值)
位运算符：or(按位或)，and(按位与)，shl(有符号左移)，shr(有符号右移)，
ushr(无符号右移)，xor(按位异或)，inv(按位取反)
in：在某个范围中
downTo：递减，循环时可用，每次减1
step：步长，循环时可用，设置每次循环的增加或减少的量
when：Kotlin中增强版的switch，可以匹配值，范围，类型与参数
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))
// 类型转换
val b: Byte = 1
val i: Int = b.toInt()
// 类型判断符 is
//obj在&&右边自动动转换成"String"类型
if (obj is String && obj.length > 0){
return obj.length
}
// 范围操作符 .. 以及 in
if (i in 1..10) { // 等价于 1 <= i && i <= 10
println(i)
}
// 未知类型强转 必须是对应类型不然抛出异常
var mPwdtoggle = findViewById(R.id.findpwd_btn_eye) as CheckBox
// 创建对象 Kotlin实例化一个对象时不需要new关键字
var list = ArrayList()
//定义参数的类型
fun makeTool(id:Int){ //参数id为Int类型
}
//定义函数的返回值
fun getAddr(id:Int):String{ //返回值为String类型
}
// var 延迟加载
private lateinit var default : String
fun initDefault(str : String){
default = str
}
// val 懒加载 只有在第一次被调用时，才会初始化
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
}
// 区间和集合
if(x in 1..5){ ...//检查x数值能否在1到5区间
if(name in list){...//检查list中能否有某个元素（比Java简洁多了）
for(i in 1..5){ ...//遍历1到5
for(item in list){...//遍历list中的每个元素（相当于Java的for(String item : list)）
// 数据类
// 关键字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自动转型
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
}
// 数组
var arr = arrayOf(1, 2)
stringTempl(arr)
fun stringTempl(args: Array<String>) {
}
// for循环
val arr = arrayListOf<String>("1111", "2222")
// 迭代角标
for (j in arr.indices) {
println("1=========" + j)
}
var list = ArrayList<String>()
list.add("xxx")
list.add("qqq")
// 迭代数据
for(str in list){
println("2=========" + str)
}
// 全局方法：不写类直接写方法就是全局方法
// 方法简写
fun run1(num:Int):Int{
return num + 2
}
fun run2(num:Int) = num + 2
// 回调写法
button.setOnClickListener(object : View.OnClickListener {
override fun onClick(v: View) {
}
})
// lambda表达式 就是把接口名、方法名和参数类型省掉不写再加个-> 适用于一个方法的接口
// 单参数
button.setOnClickListener{ view ->
}
// 多参数
button.setOnEditorActionListener({ v, id, event ->
false
})
// 多方法
button.addOnAttachStateChangeListener(object : View.OnAttachStateChangeListener{
override fun onViewDetachedFromWindow(p0: View?) {
}
override fun onViewAttachedToWindow(p0: View?) {
}
})
// 扩展方法 连class和interface都不写，直接在文件中写fun方法
// 类方法扩展 创建kt文件 不需要写类 直接写方法就可以 相当于全局方法
public fun View._run(str :String){
Toast.makeText(BaseApplication.getContext(), str, Toast.LENGTH_SHORT).show()
}
扩展方法：
Kotlin中的方法可以直接定义在文件中，而不需要依赖于任何的类，这个称为扩展方法。
成员方法：
而写在class或object中的方法则称成员方法。
本地方法：
定义在方法内部的方法，可以访问外部函数的私有成员！
