【Android学习】kotlin编程快速入门_kotlin代码

目录

1、条件语句&循环语句

2、类的继承、构造、接口

3、数据类&单例类

4、lamada编程

5、空指针检查

6、字符串内嵌表达式、函数参数默认值

---

1、条件语句&循环语句

package com.example.Chapter2
 
//if条件语句
//if(条件){满足条件执行的语句}
fun IfLearn(param1:Int,param2:Int):Int{
    if(param1 < param2){
        return param1
    }
    else{
        return param2
    }
}
 
//when条件语句
//when(变量){匹配值1->{执行逻辑1} 匹配值2->{执行逻辑2}}
fun whenLeran(num:Int){
    var n:String = ""
    when(num){
      8 -> {n="big"}
      7 -> {n="big"}
      1 -> {n="small"}
      2 -> {n="small"}
      else -> {n="NA"}
    }
    println(n)
}
 
//for循环语句
fun forLearn(num1:Int,num2:Int){
    //升序闭区间序列
    println("for i in num1..num2 构造左闭右闭区间")
    for (i in num1..num2)
    {
        println(i)
    }
 
    //升序左闭右开区间序列
    println("for i in num1 until num2 构造左闭右开区间")
    for (i in num1 until num2)
    {
        println(i)
    }
 
    //升序左闭右开区间序列
    println("for i in num1 until num2 step num3 构造左闭右开区间")
    for (i in num1 until num2 step 2)
    {
        println(i)
    }
 
    //降序左闭右开区间序列
    println("for i in num1 downT0 num2降序序列")
    for (i in num2 downTo num1)
    {
        println(i)
    }
 
}
 
fun main(){
    println(IfLearn(1,2))
    println(IfLearn(2,0))
    whenLeran(1)
    whenLeran(9)
    forLearn(0,10)
}
 

2、类的继承、构造、接口

package com.example.Chapter2
 
//-----------1、类的构造
// 在kotlin钟类默认是不可继承的
//构造一个学生类
open class Stuedent {
    //定义学生的属性
    var name:String = ""
    var age:Int = 0
    var weight:Int = 0
    var classNum:Int = 0
 
    //定义学生的方法
    fun basicMess(){
        println(name+" is "+age+" years old,his weight is" + weight + " kg and his classroom is " + classNum)
    }
}
 
//实例化类，即构造一个学生
fun student(name:String,age:Int,weight:Int,classNum:Int){
    //实例化类，即构造一个学生
    val s1 = Stuedent()
    //给类属性赋值，并调用类方法
    s1.name = name
    s1.age = age
    s1.classNum = weight
    s1.weight = classNum
    s1.basicMess()
}
 
//---------2、继承，减少代码重复编写，在共同属性的基础上，添加不同子类的差异性，如人都有年龄身高体重，但是不同职业的人有不同的岗位
// 在kotlin钟类默认是不可继承的，需要添加关键字open来定义来是可继承的
//构造大学生类，继承学生类
class collegeStudent(var subject:String,var school:String): Stuedent(){
    //通过constructor关键字来实现不同大学生类的参数组合
    constructor(name: String,age: Int):this("语文","上海理工大学"){} //组合1：通过this关键字来调用当前类的参数
    constructor(name: String):this("英语","上海大学"){}
    constructor():this("",""){}
    fun printI(){
        println(subject + school)
    }
}
//实例化大学生类
fun colleageStu(){
    val c1 = collegeStudent() //不带参实例化
    val c2 = collegeStudent("tim",18)
    val c3 = collegeStudent("tom")
    c1.printI()
    c1.subject = "数学"
    c1.school = "交通大学"
    c1.printI()
    c2.printI()
    c3.printI()
}
 
//----------3、接口，接口可以只定义函数名而不需要定义函数体
//1）定义接口
interface Study{
    fun readbook()
    fun doHomeWork()
    fun goschool(){
        println("带函数体的接口方法，不需要强制定义函数，未定义时默认运行此语句")
    }
}
//2）让类继承实现多个接口
class coll(subj:String): Stuedent(), Study {
    //利用override重写接口方法
    override fun readbook() {
        println("readbook")
    }
    override fun doHomeWork() {
        println("dohomework")
    }
}
//3)实例化coll类
fun collStu(){
    val cc1 = coll("接口学习")
    cc1.readbook()
    cc1.goschool()
}
 
fun main(){
    //实例化类并调用方法
    student("Tom",18,70,2)
    //继承
    colleageStu()
    //接口
    collStu()
}
 
//可修饰性学习，在fun关键字前面加上对应可修饰性关键字即可
//private：只对当前类可见
//protected：仅对当前类和子类可见
//public：公开
//internal：只对同一模块可见

3、数据类&单例类

package com.example.Chapter2
 
//数据类和单例类学习
 
//数据类，关键字：data
 
data class cell(val sub:String)
val c1 = cell("c1")
val c2 = cell("c2")
 
//单例类，关键字：object
//主要用于希望一个类只有一个实例的情况
object Singleton{
    fun printl() {
        println("单例类")
    }
}
//引用
 
fun main(){
    println(c1 == c2)
    //单例类
    Singleton.printl()
    val s1 = Singleton
    Singleton.printl()
    val s2 = Singleton
    Singleton.printl()
}

4、lamada编程

package com.example.Chapter2
 
//1、常见数据结构
//1）列表：有序集合，listof()---不可变有序列表，mutablelistof()---可变有序列表
fun listLearn(){
    println("list数据结构学习")
    val list1 = listOf<String>("a","b","c")
    for (l in list1){
        println(l)
    }
    val list2 = mutableListOf<String>("a","b","c")
    list2.add("d")
    for (l2 in list2){
        println(l2)
    }
}
 
//2）集合：无序集合，setof()---不可变集合，mutablesetof()---可变集合
fun setLearn(){
    println("set数据结构学习")
    val set1 = setOf<String>("a","b","c")
    for (s in set1){
        println(s)
    }
    val set2 = mutableSetOf<String>("a","b","c")
    set2.add("d")
    for (s2 in set2){
        println(s2)
    }
}
 
//3）字典：无序字典，mapof()---不可变集合，mutablemapof()---可变集合
fun mapLearn(){
    println("map数据结构学习")
    val map1 = mapOf<String,Int>("a" to 1,"b" to 2,"c" to 3)
    for (m in map1){
        println(m)
    }
    val map2 = mutableMapOf<String,Int>("a" to 1,"b" to 2,"c" to 3)
    map2.put("d", 4)
    for (m2 in map2){
        println(m2)
    }
}
 
//2、集合式的API
//1）maxby()---取一个集合的最大值
//2）map()---将集合每一个元素按照规则映射成另一个元素
//3）filter（）---将集合中符合条件的元素筛选出来
//4）any()---判断集合中是否至少存在一个符合条件的元素，是返回true，否返回false
//5）all()---判断集合中是否所有元素都符合条件，是返回true，否返回false
fun apiLearn(){
    val list3 = listOf<String>("ab","bcs","cdff")
 
    val maxLength = list3.maxBy { l3->l3.length }
    val maxLength2 = list3.maxBy { it.length } //只有一个参数，所以可以用It关键字来代替
    println("maxLength:"+maxLength)
    println("maxLength2:"+maxLength2)
 
    val mapEle = list3.map { l3->l3.uppercase() }
    val mapEle2 = list3.map { it.uppercase() }
    println("mapEle:"+mapEle)
    println("mapEle2:"+mapEle2)
 
    val filterEle = list3.filter { l3 -> l3.length <= 3 }
    val filterEle2 = list3.filter { it.length <= 3 }
    println("filterEle:"+filterEle)
    println("filterEle2:"+filterEle2)
 
    val anyEle = list3.any { l3 -> l3.length > 5 }
    val anyEle2 = list3.any { l3 -> l3.length < 5 }
    val anyEle3 = list3.any { it.length < 5 }
    println("anyEle:"+anyEle)
    println("anyEle2:"+anyEle2)
    println("anyEle3:"+anyEle3)
 
    val allEle = list3.all { l3 -> l3.length > 5 }
    val allEle2 = list3.all { l3 -> l3.length < 5 }
    val allEle3 = list3.all { it.length < 5 }
    println("allEle:"+allEle)
    println("allEle2:"+allEle2)
    println("allEle3:"+allEle3)
}
fun main(){
    //1、数据结构学习
    listLearn()
    setLearn()
    mapLearn()
    //2、集合式API
    apiLearn()
}

5、空指针检查

package com.example.Chapter2
 
//kotlin默认是传入函数的参数和变量不可以为空，在编译前期实现了空指针的检查
 
//1、可空类型系统：在数据类名后加问号，表示参数可空，如Int为不可空整型，Int？为可空整型
fun nullLearn(l1:Int,l2:Int?){
    //l1：不可空参数，l2：可空参数
    if (l2 != null){ //进行空指针检查，避免出现空指针异常
        println("l1+l2="+(l1+l2))
    }
    else {
        println("l2为空")
    }
}
 
//2、判空辅助工具
//1）？.工具：如果变量不为空则运行，否则跳过
fun wenhaoDot(l1:String?){
    val l2 = l1?.length
    println(l2)
}
 
//2）？:工具。如果变量不为空，执行左边表达式，否则执行右边表达式
fun wenhaoMao(l1:String?){
    val l3 = l1?:0
    println(l3)
 
    val l4 = l1?.length?:-1
    println(l4)
}
 
//3）！！强制通过判空，具有一定风险
fun tanhao(l1:String?){
    println(l1!!.length) //这个其实是错误的，因为未解决为空的风险
}
 
//4）let函数API，可以对全局变量进行判断
var ll:String? = "content"
fun letLearn(){
//    if (ll != null) {
//        println(ll.length) //这里会提示为空的风险，因为if 无法对全局变量进行判空操作
//    }
    println(ll?.length)
    println(ll?.let{ lll->
        lll.length
    })
    println(ll?.let{ lll->lll.length?:lll
    })
}
 
fun main(){
    nullLearn(1,2)
    nullLearn(1,null)
 
    wenhaoDot(null)
    wenhaoDot("非空")
 
    wenhaoMao(null)
    wenhaoMao("非空")
 
    tanhao("非空")
//    tanhao(null) //这个运行是会报错的，因为null无length属性
 
    letLearn()
 
}

6、字符串内嵌表达式、函数参数默认值

package com.example.Chapter2
 
//通过${}来内嵌变量到一个完整的字符串句子中,只有一个变量时，大括号可以删除
fun stringPad(){
    val num = 2
    val string = "null"
    println("test ${num} $string")
}
 
fun main(){
    stringPad()
}

package com.example.Chapter2
 
fun functionParams(num:Int = 2,string:String){
    println("$num $string")
}
 
fun main(){
    functionParams(1,"iii")
    functionParams(string = "hello")
}