kotlin基础语法

声明变量

val声明赋值后不可改变的变量，类似Java中的final；var声明允许重复赋值的变量。

val sex="女"
var name="每日教程"
print("sex=$sex,name=$name")

指定变量类型String

val sex: String="女" 

不指定变量类型，程序根据赋值推断类型：var name="每日教程"，识别到name为字符串类型

Android声明常量使用static和final关键字，kotlin声明常量使用const和val关键字

const val TAG="MainActivity"
const val REQ_CODE=0x003

声明方法

fun关键字声明方法，类似Javascript声明函数的function。

fun声明不带参数的函数：

val name="北京大学"
val address="北京市海淀区颐和园路5号"
fun school(){
print("name=$name,address=$address")
}

fun声明带参数的函数：

fun school(name:String,address:String){
    print("name=$name,address=$address")
}

fun声明带参数和返回值的函数：

fun school(name:String,address:String){
    return "name=$name,address=$address"
}

字符串引用

Android字符串引用变量，使用函数String.format("This is %s","每日教程")，kotlin可以在字符串中直接引用：

val name="每日教程"
var nickName="This is $name"

kotlin字符串中引用代码块：

val name="每日教程"
var nickName="This is %name"
print("This is ${name.substring(2,5)} and name is $name")

空值和null值

声明null变量：

var name:String?=null
var sex:String?=null
fun val(){
    name="每日教程"
    sex="女"
}

声明返回null函数：

fun val(name:String):String?{
    return "$name"
}

语句和表达式

if语句，用法和Android一样：

fun val(name:String):String?{
    if (name==null){
        println("当前名字为空，请输入正确的名字")
    }else{
       println("当前输入的名字是：$name")
    }
    return "$name"
}

if...else...表达式，返回一个值，这是和Android不一样的地方，可以赋值给一个变量或作为方法结果返回

val a=12
val b=23
var sum=if (a < b) a else b
println(sum)

fun main() {
    val a=12
    val b=23
    println("sum=${sum(a,b)}")
}
fun sum(a:Int,b:Int)=if (a>b) a-b else a+b

for语句，第一种方法和Java一样，第二种方法根据索引遍历

fun main() {
    var tmpLis=listOf("item1","item2","item3")
    
    //遍历数组方法
    for(item in tmpLis){
        println("${item}")
    }
    
    //根据索引遍历数组方法
    for(index in tmpLis.indices){
        println("index=$index，value=${tmpLis[index]}")
    }
    
}

while语句，语法和Java中的while语句一样

fun main() {
    var tmpLis=listOf("item1","item2","item3")
    var index=0
    while(index<tmpLis.size){
        println("index=$index，value=${tmpLis[index]}")
        index++
    }
}

when表达式，Java提供多分支语句switch或if...else if ...else...，kotlin使用when表示多分支

fun main() {
    var request_code=0x002
    var result=when(request_code){
        0x001 -> "This is request code 1"
        0x002 -> "This is request code 2"
        0x003 -> "This is request code 3"
        else  -> "This is unknown"
    }
    println(result)
}

is语句，Java使用instanceof判定当前对象是否某个类型，kotlin使用is代替

fun main() {
    var a="每日教程"
    println("name=${valid(a)}")
}
fun valid(a:Any)=if (a is String) a.substring(a.length-2,a.length) else a

JavaBean

kotlin创建实体简单、方便、快捷

fun main() {
    var school=School("北京大学","北京市海淀区颐和园5号")
    var name=school.name
    school.address="广东省广州市"
    println("$school,$name")
}
data class School(var name:String,var address:String)

重写toString()方法

data class School(var name:String,var address:String){
    override fun toString():String{
        return "School[name=$name,address=$address]"
    }
}

单例

kotlin创建单例也很方便，使用object声明类

object GlideUtil{
    fun displayImage(url: String, target: ImageView) {
    	Glide.with(target).loadUrl(url).into(target)
	}
}

伴生对象

在类里面使用companion object声明的属性和方法，可以当成是静态的属性或方法引用

fun main() {
    var school=School(School.NAME,School.ADDRESS)
    var name=school.name
    var detail=School.detail()
    println("$school,$name,$detail")
}

data class School(var name:String,var address:String){
    override fun toString():String{
        return "School[name=$name,address=$address]"
    }
    companion object {
        const val NAME="北京大学"
        const val ADDRESS="北京市海淀区颐和园5号"
        fun detail():String{
            val detail=NAME+" 位于 "+ADDRESS
            return detail
        }
    }
}

接口

kotlin创建接口和Java比较，去掉修饰符public，下面以创建MVP模式为例

interface HomeContract{
    interface View:BaseMvpView{
        fun show()
        fun dismiss()
    }
    interface Presenter:BaseMvpPresenter{
        fun getHomeData()
    }
}

?.、?:和!!.区别

前面空值和null值中，?在变量类型后表示变量允许为空，比如：var nickName:String?=null，在调用方法时使用?表示当前对象如果为空则跳过想要执行的方法，Java实现和kotlin实现的区别

Person person=null;
if(person!=null){
    person.school();
}

person:Person?=null
//如果person对象为空，则跳过调用school()方法，类似Java的if语句，执行了println()方法
person?.schoole()
println(person)

?:表示对象为空跳过执行方法，则取值冒号后的结果，类似else语句

//如果person?.school()，结果打印“北京大学”
schoolName=person?.school()?:"北京大学"

!!.表示对象为null值，程序抛出异常并暂停执行

person:Person?=null
//程序抛出异常并暂停执行，不会调用println()方法
person!!.school()
println(person)

listOf函数

使用listOf()函数快速创建一个列表，相比Java更简洁

    val tmpLis=listOf("北京大学","清华大学","上海大学","武汉大学")
    for( value in tmpLis){
        println("$value")
    }

mapOf函数

使用mapOf()创建散列对象，键和值之间使用关键字to相连（to前后注意空格，否则报错 Unsupported [literal prefixes and suffixes] ）

    val tmpMap=mutableMapOf<String,String>("a" to "aaa","b" to "bbb","c" to "ccc")
    for((key,value) in tmpMap){
        println("$key,$value")
    }

lateinit关键字

延迟初始化var声明的变量对象，需要注意val声明的变量和kotlin基本数据类型不允许使用lateinit

//正确的，HomeBean/String是一个变量对象，可以使用lateinit
private lateinit var mHomeBean:HomeBean
private lateinit var count:String
//错误的，'lateinit' modifier is allowed only on mutable properties
private lateinit val count:Int

construct关键字

construct传入参数，在init代码块执行初始化，例如：封装retrofitClient类

class RetrofitClient constructor(context:Context,url:String?=null){
    val sContext:Context
    init{
        sContext=context
        var tmpUrl=url
    }
}

internal关键字

internal是一个访问控制关键字，修饰的成员变量仅限当前模块可用

//声明的INSTANCE变量仅限当前模块可用
object SingletonHolder {
        internal val INSTANCE = RetrofitClient(BaseApplication.getInstance())
    }

let函数

let是一个作用域函数，作用域内可用使用当前对象的属性和方法，比如：字符串调用let函数，在作用域内就可以直接使用String的属性和方法

val school_name:String="北京大学"
school_name?.let{
        println(it.substring(2))
        println(it.length)
}