Kotlin 学习笔记(一) 基础语法、类、属性

1.HelloWorld 及包的声明

// 包格式和 java 一致

package com.example.myapplication
fun main(args: Array<String>) {
    println("hello World")
}

注意:

main 函数不需要在class 中就可以运行
fun 代表一个函数，后边紧跟函数名称，参数列表和返回值类型
参数实现写参数名称然后冒号隔开，再写参数类型（和java 相反）
函数的返回值是在后边的（和java刚好相反的）当然有返回值也可以不写返回类型（前提是：只有表达式体函数返回类型可以省略，如果是代码块体函数就必须要写明函数返回类型），因为kotlin 通过类型推导也是可以知道返回值类型的
system.out.println 被包装为 println
在行末可以省略分号（类似 js）
看到max函数中 if类似于三元表达式 kotlin中，if 是有结果值的表达式
如果返回值类似于 java 中的 void 则可以写成 :Unit ，当然也可以省略不写

2.变量

考虑到kotlin 的变量声明是可以省略类型的，所以kotlin 变量声明有别于java ，kotlin 变量声明顺序为关键字变量名称类型（可不加），如果变量没有初始化则需要明确表明变量类型。

常量与变量都可以没有初始化值,但是在引用前必须初始化编译器支持自动类型判断,即声明时可以不指定类型,由编译器判断。如果不在声明的时候初始化则必须提供变量的类型

val ：不可变引用 ，在val声明变量后不能再初始化之外再次赋值（java final）
var ：可变引用 ， 该类型变量可以随便赋值
*** 官方推荐** 尽量使用val 声明变量，使程序更接近函数式编程风格

1、可变变量的定义: var 关键字

var <变量名> : <变量类型> = <初始值>

var age :Int = 18
var name :String = "kotlin"
//不可以这样写
    age2 = 18
    name2 = "kotlin" //Expecting member declaration

2、不可变变量的定义: val 关键字，不能进行二次赋值，类似Java中的final类型

val <常量名> : <常量类型> = <初始值>

val sum: Int //没有赋值初始化之前必须指定类型
sum = 5 //属性必须初始化或抽象
sum = 6 //X  Val cannot be reassigned,不可再次赋值

已知值的属性可以使用 const 修饰符标记为编译期常量。需要满足如下几种条件 (类似 java 中的 constanUtil 中的常量值)

位于顶层或者是 object 的一个成员
用 String 或原生类型 值初始化
没有自定义 getter

3.字符串模板

println("Hello world $name")   // $变量
println("Hello world ${age[0]}")   // ${变量}
println("Hello world " + name)   // 原来的方法也是可以继续使用的

var a = 1
a = 2
var s1 = "a is $a"
val s2 = "${s1.replace("is", "was")}, but now is $a"

4.类和属性

1.类

java

public class DemoBean {

    private final String name;

    public DemoBean(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

kotlin

class DemoBean(var name:String)

2.属性

class Person{
    var name :String  = "ymc"    // 可读可写
    val isMarried : Boolean  = false    // 只读
}

var person = Person()
    person.name = "我家有个王胖胖"
    //如果 我们设置 属性为 val 但是通过自定义 getter 修改属性那么 属性会修改么？
    person.isMarried = false//报错:Val cannot be reassigned
    println(person.name+"..."+person.isMarried)

执行结果:

我家有个王胖胖...false

5 kotlin 幕后字段属性 field

首先需要明确的是幕后字段的作用域为属性的默认访问器或者在自定义访问器中通过 field 标识符访问属性，编译器就会为属性自动生成幕后字段。这就是说其在默认访问器实现了幕后字段，但是当我们在自定义访问器时如果忽略了此操作，那么程序将会报你以崩溃。

class People {
    var name: String
        get() = name
        set(value) {
            name = value
        }
}
```object Main {
    val people = People()
    @JvmStatic
    fun main(arg: Array<String>) {
      println(people.name)
    }
}

在 Main 类中调用 People 的 name 我们看会发生什么：

Exception in thread "main" java.lang.StackOverflowError
    at People.getName(People.kt:3)
    at People.getName(People.kt:3)
    at People.getName(People.kt:3)

报出 java.lang.StackOverflowError 异常并且程序中断。
报错原因(转换成java代码):

public final class People {
   @NotNull
   public final String getName() {
      return this.getName();// 此处会递归调用 getName，直到程序抛出堆栈异常
   }

   public final void setName(@NotNull String value) {
      Intrinsics.checkParameterIsNotNull(value, "value");
      this.setName(value);// 此处会递归调用 setName，直到程序抛出堆栈异常
   }
}
//调用到的是getname()和setName()属性,成为递归调用

正确的用法

class People {
    var name: String = "Mike"
        get() = field
        set(value) {
            field = value
        }
}

转换成java代码

public final class People {
   @NotNull
   private String name = "Mike";

   @NotNull
   public final String getName() {
      return this.name;
   }

   public final void setName(@NotNull String value) {
      Intrinsics.checkParameterIsNotNull(value, "value");
      this.name = value;
   }
}
//这里调用到的直接是name属性

6.lateinit 关键字

顾名思义，这是指一个延迟初始化的变量。在kotlin里面，如果在类型声明之后没有使用符号?，则表示该变量不会为null。但是这个时候会要求我们初始化一个值。有些时候，我们在声明变量的时候，并不能初始化这个变量。

一个声明成lateinit的变量，如果在整个代码里面都没有进行任何的初始化，那么能否编译通过？如果你加上了lateinit关键字，kotlin的编译器不会做这种检查。如果你将变量声明为lateinit，它就认为你肯定会初始化，至于你是怎么初始化它的，它就不管了.

lateinit 延迟加载
2.lateinit 只能修饰, 非kotlin基本类型
3.lateinit 只能修饰可变变量(var)
4.如果你的代码真的显示初始化了lateinit变量，而又抛出了UninitializedPropertyAccessException异常，因为你恰好将变量初始化为null了

因为Kotlin会使用null来对每一个用lateinit修饰的属性做初始化，而基础类型是没有null类型，所以无法使用lateinit

7.null检查机制

Kotlin的空安全设计对于声明可为空的参数，在使用时要进行空判断处理，有两种处理方式，字段后加!!像Java一样抛出空异常，另一种字段后加?可不做处理返回值为 null或配合?:做空判断处理

//类型后面加 ? 表示可为空
var age: String? = "23"

//字段后面加 "!!" ，如果为null则抛出空指针异常
val ages = age!!.toInt()

//字段后面加 ”？“  如果为null不做处理返回 null
val ages1 = age?.toInt()

//使用 ”?:“  表示age为null返回-1
val ages2 = age?.toInt() ?: -1

kotlin 中如果数值或返回值可以为空的时候则可以在类型后边加上 ?

fun getStringLength(obj: Any): Int? {
    if (obj is String) {
        // `obj`在这个分支中自动转换为`String`类型
        return obj.length
    }
    // `obj`仍然是`Any`类型
    return null
}

fun getStringLength(obj: Any): Int? {
    // `obj`在这个分支中自动转换为`String`类型
    if (obj !is String) return null
    return obj.length
}

该方法返回值可以为 null 也可以是 int 类型字符串的长度，在判断中我们有看到了新的词语 is ，is 表达式主要检查表达式或者值的类型是否是 is 后边的类型，如果是则会进行自动转换，如果不是则仍然保持原来的数据类型。

本文章只是用于记录学习
————————————————
版权声明：本文为CSDN博主「Yang19950329」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_27948659/article/details/82190429