Kotlin基础语法使用

1、变量修饰符

class Test{
    //可修改变量
    var a : String = "a"
    //不可修改变量
    val b : String = "b"
    //自动类型推导
    var c = "cccc"
    var d = 'c'
}

反编译Test类字节码可看到，b被final修饰，并且只有get方法，其他var修饰的变量均有get和set方法

2、字符串使用

fun main(){
    //字符串拼接
    var name = "小明"
    var age = 5
    var sex = 'm'
    var info = "小学生"
    println("name:$name, age:$age, sex:$sex, info$info")

    //带换行""" """
    var str = """
        row1
        row2
        row3
    """.trimIndent()
    println(str)
}

$符可更方便的拼接字符串，""" """可自动加换行，运行结果： image.png

3、kotlin中的null检查

fun main(){
    //加?意为此变量可能会为null,使用时必须做处理，否则编译器报错
    var info: String? = null;

    //1.像java一样先判断
    if (info != null){
        println(info.length)
    }
    //2.如果为null，则不执行后面.length，直接输出null，若不想输出null可以info?.length ?: "为null了"
    println(info?.length)
    //3.!!自己保证不会为null，如果真的为null，会空指针
    println(info!!.length)

}

运行结果： image.png

4、kotlin中的比较

fun main(){
    val a:String = "1111"
    val b:String = "1111"
    //== 等价于equals,比较值本身
    println(a == b)
    println(a.equals(b))

    val test1:Int? = 10000
    val test2:Int? = 10000
    //比较对象内存地址
    println(test1 === test2)
}

运行结果： image.png

5、数组

fun main(){
    //通过arrayOf生成一个数组
    var numbers : Array<Int> = arrayOf(1,2,3,4)
    println(numbers[1])
    for (num in numbers){
        print("$num ")
    }
    println()
    //直接通过IntArray类创建大小为 5、值为 [0, 0, 0, 0, 0] 的整型数组
    val numbers3: IntArray = IntArray(5)
    for (num in numbers3) {
        print("$num ")
    }
    println()
    // 例如：使用 lambda 表达式初始化数组中的值
    // 大小为 5、值为 [0, 1, 2, 3, 4] 的整型数组（值初始化为其索引值）
    val numbers4: Array<Int> = Array(5){it*1}
    for (num in numbers4) {
        print("$num ")
    }
}

运行结果： image.png

6、区间语法

fun main(){
    //顺序打印
    for (i in 1..10){
        print("$i ")
    }
    println()
    //逆序打印
    for (i in 10 downTo 1){
        print("$i ")
    }
    println()
    //区间做判断
    val value = 33
    if (value in 1..100){
        println("33包含在1~100内")
    }
    println()
    //指定步数，默认为1
    for (i in 1..10 step 2){
        print("$i ")
    }
    println()
    //去掉区间最后一个
    for (i in 1 until 10){
        print("$i ")
    }
}

运行结果： image.png

7、标签与循环

fun main(){
    tag@for (i in 1..5){
        for (j in 1..5){
            println("i:$i, j:$j")
            if (i == 2){
//                break//结束内层循环
                break@tag//结束外面循环
            }
        }
    }
    val listOf = listOf<Int>(1, 2, 3)
    for (l in listOf){
        print("l:$l ")
    }
    println()
    //indices获取下标，相当于迭代器
    for (index in listOf.indices){
        print("下标：$index, 对应值：${listOf[index]} ")
    }
}

运行结果： image.png

8、条件

fun main(){
    val num1 = 2
    val num2 = 100
    //if可以用作表达式，直接对变量进行赋值
    val min = if (num1 < num2) num1 else num2
    println(min)
    //用作表达式时，还可以做其他操作
    val max = if (num1 > num2) {
        println("num1大")
        num1
    } else {
        println("num2大")
        num2
    }
    //when相当于switch，比switch更强大
    val num = 1
    when(num){
        1 -> println("是1")
        2 -> println("是2")
        3 -> println("是3")
        else -> println("其他")
    }
    //判断可以是一个范围
    val num11 = 2
    when(num11){
        in 1..10 -> println("1..10")
        in 11..20 -> println("11..20")
        3 -> println("是3")
        else -> println("其他")
    }
    //在其内部可以有不同的返回值，还可以做其他操作
    val num111 = 5
    val n = when(num111){
        1,5 -> {
            println("是1")
            "返回1"
        }
        2 -> {
            println("是2")
        }
        3 -> {
            println("是3")
            1
        }
        else -> println("其他")
    }
    println(n)

    val x = {v: Int -> (v+10)}
    println(x(1))

}

运行结果： image.png

9、kotlin函数

//void == :Unit，可省略
fun main() : Unit{
    println(add(1, 2))
    lenMethod(1, 2, 3)
    //lambda表达式
    val addMethod : (Int,Int) -> Int = {num1,num2 -> num1 + num2}
    println(addMethod(2,5))
}
//函数
fun add(num1: Int,num2: Int):Int{
    return num1 + num2
}
//返回类型=类型推导
fun add2(num1: Int,num2: Int) = num1 + num2

//可变参数（可变长 参数函数）
fun lenMethod(vararg value: Int){
    for (i in value) {
        println(i)
    }
}

10、类

• 构造函数：

//默认 public final class Person，默认无法被继承，需要加open
open class Person(id: Int)//主构造函数
{   //次构造必须要调用主构造
    constructor(id: Int,name: String) : this(id) {

    }
    //次构造
    constructor() : this(11) {

    }
}

• 继承：

class Student(id:Int) : //Person()次构造
                        Person(id)//主构造
{
    //kotlin中所有的变量均无默认值,所以无初始值编译器会报错
    //java成员变量有默认值，方法内部局部变量没默认值
    //若不想赋初始值，可以使用lateinit 懒加载，后续赋值，若后续没有赋值，使用会报错
    lateinit var name : String
    var age = 0
}

• 接口：

//接口默认都是open的
interface Callback {
    fun callbackMethod():String
}

• 抽象类：

//默认是public final class Animal，但加上abstract ，相当于open
abstract class Animal() : Callback{
    abstract fun getId():Int
    abstract fun init() :Unit
}

• 内部类用inner修饰：

class InnerClass {
    val a = "AA"
    class Sub{
        fun show(){
            //无法访问InnerClass类成员，这样只是嵌套类，非内部类，和外部类没有任何关系
//            println(a)
        }
    }
    //这样才是内部类，需要加关键字inner
    inner class Sub1(){
        fun show(){
            println(a)
        }
    }
}

• 数据实体类用data修饰：

//自动生成get set 构造函数，equals，hashCode，toString，copy方法，非常便捷
data class UserBean(var id:Int,val name:String,val sex:Char)

• object派生类，相当于饿汉式单例，静态变量实例

object Instance{
    fun m(){
        println("只实例化一次")
    }
}
fun main(){
    //只会实例一次
    Instance.m()
    Instance.m()
    Instance.m()
}

反编译后的java代码

public final class Instance {
   public static final Instance INSTANCE;
   public final void m() {
      String var1 = "只实例化一次";
      boolean var2 = false;
      System.out.println(var1);
   }
   private Instance() {
   }
   static {
      Instance var0 = new Instance();
      INSTANCE = var0;
   }
}

• 懒加载单例1（相当于java的静态内部类实现单例）

class Singleton1 {

    object Holder{
        val instance = Singleton1()
    }
    companion object{
        //伴生对象内部全部相当于java的static
        fun getInstance() = Holder.instance
    }
    fun show(msg: String){
        println("msg:$msg")
    }
}
fun main(){
    var singleton: Singleton1 = Singleton1.getInstance()
    singleton.show("单例方法调用")
}

• 懒加载单例2

class Singleton2 {
    companion object{
        private var instance: Singleton2? = null
        fun getInstance(): Singleton2?{
            if (instance == null){
                instance = Singleton2()
            }
            //是null可以返回,需要方法加 ?
            return instance
            //强制返回,为null在这里就会报空指针
//            return instance!!
        }
    }
    fun show(str:String){
        println(str)
    }
}
fun main(){
    val singleton : Singleton2? = Singleton2.getInstance()
    singleton?.show("单例方法调用")
}