Kotlin学习笔记——类和函数

• val和var

  • val(来自value)——不可变引用。使用val使用val声明的变量不能在初始化之后再次赋值。它对应的是Java的final变量。

    定义只读局部变量使用关键字val定义，只能为其赋值一次。——来自Kotlin官方文档

    val a: Int = 1  // 立即赋值
    val b = 2   // 自动推断出 `Int` 类型
    val c: Int  // 如果没有初始值类型不能省略
    c = 3       // 明确赋值
    

  • var(来自variable)——可变引用。这种变量的值可以被改变。这种声明对应的是普通(非final)的Java变量。

    可重复赋值的变量使用var关键字。——来自Kotlin官方文档

    var x = 5 // 自动推断出 `Int` 类型
    x += 1
    

• ?和!!

  • "?."是安全调用运算符，它允许你把一次null检测和一次方法调用合并成一次操作。foo?.bar()相当于 if (foo != null) foo.bar() else null

    "?"表示当前对象可以为空。如果"?"加在变量后，系统任何时候都不会包他的空指针异常。f : foo?

    当某个变量可以为空的时候，必须在声明的类型后面加上"!"来标识该引用可为空。——来自Kotlin官方文档

    //如果str的内容不是数字返回null
    fun parseInt(str: String): Int? {
        // ……
    }
    

  • "!!"是非空断言，可以把任何值转换为非空类型。如果对null值做非空断言。则会抛出异常。foo!!相当于if (foo != null) foo else NullPointerExperience

    "!!"表示当前对象不为空的时候执行后面语句，为空则抛出异常。加在变量后，如果对象为null，那么系统一定会报异常。

• 类

  • 抽象函数

    abstract fun Fly()
    

    抽象函数不用手动添加open，默认被open

    抽象函数必须用abstract关键字修饰
    抽象函数没有具体实现
    含有抽象函数的类是抽象类，必须用abstract关键字修饰

  • 抽象类、接口

    在抽象类中，类以及其中的某些成员可以声明为 abstract。 抽象成员在本类中可以不用实现。 需要注意的是，我们并不需要用 open 标注一个抽象类或者函数——来自Kotlin官方文档。

    open class Base {
        open fun f() {}
    }
    abstract class Derived : Base() {
        override abstract fun f()
    }
    

    Kotlin 的接口与 Java 8 类似，既包含抽象方法的声明，也包含实现。与抽象类不同的是，接口无法保存状态。它可以有属性但必须声明为抽象或提供访问器实现。

    使用关键字 interface 来定义接口

    interface Action {
        fun eat()
        fun sleep() {
          // 可选的方法体
        }
    }
    

  • 单例类

    饿汉式

    //Java实现
    public class Singleton {
        private static Singleton instance=new Singleton();
        private Singleton(){
    
        }
        public static Singleton getInstance(){
            return instance;
        }
    }
    

    //Kotlin实现
    object Singleton
    

    懒汉式

    //Java实现
    public class Singleton {
        private static Singleton instance;
        private Singleton(){}
        public static Singleton getInstance(){
            if(instance==null){
                instance=new Singleton();
            }
            return instance;
        }
    }
    

    //Kotlin实现
    class Singleton private constructor() {
        companion object {
            private var instance: Singleton? = null
                get() {
                    if (field == null) {
                        field = Singleton()
                    }
                    return field
                }
                fun get(): Singleton{//不需要再用getInstance作方法名，
                //在伴生对象声明时，内部已有getInstance方法。
                 return instance!!
                }
        }
    }
    

  • 嵌套类、内部类、匿名类

    嵌套类：不能访问外部类的实例，嵌套类不持有外部类的引用，而外部类持有。(相当于Java中静态内部类)在Kotlin中，默认是嵌套类。

    类可以嵌套在其他类中——来自Kotlin官方文档

    class Outer {
        private val bar: Int = 1
        class Nested {
            fun foo() = 2
        }
    }
    val demo = Outer.Nested().foo() // == 2
    

    内部类：能访问外部类的实例，内部类持有外部类的引用。(相当于Java中内部类)

    类可以标记为 inner 以便能够访问外部类的成员。内部类会带有一个对外部类的对象的引用——来自Kotlin官方文档

    class Outer {
        private val bar: Int = 1
        inner class Inner {
            fun foo() = bar
        }
    }
    val demo = Outer().Inner().foo() // == 1
    

    类A在另一个类B中声明	在Java中	在Kotlin中
    嵌套类(不储存外部类的引用，相当于Java中静态内部类)	static class A	class A
    内部类(储存外部类的引用，相当于Java中内部类)	class A	inner class A

    匿名类：

    使用对象表达式创建匿名内部类实例

    window.addMouseListener(object: MouseAdapter() {
        override fun mouseClicked(e: MouseEvent) { …… }
        override fun mouseEntered(e: MouseEvent) { …… }
    })
    

    如果对象是函数式 Java 接口（即具有单个抽象方法的 Java 接口）的实例， 你可以使用带接口类型前缀的lambda表达式创建它

    val listener = ActionListener { println("clicked") }
    

  • 伴生类

    伴生对象：Kotlin允许在类中使用companion object创建伴生对象，用伴生对象的成员来代替静态成员。

    class Person(val name:String){
        companion object {
            val kotPerson=Person("kot")
            fun sayHello(){
                println("Hello")
            }
        }
        var age=0
        fun sayName(){
            println("My name is $name")
        }
    }
    

• 函数

  • 可变参数

    可变长参数函数：函数的变长参数可以用 vararg 关键字进行标识

    fun vars(vararg v:Int){
        for(vt in v){
            print(vt)
        }
    }
    fun main(args: Array) {
        vars(1,2,3,4,5)  // 输出12345
    }
    

    代码实现实现	在Java中	在Kotlin中
    可变参数	int ... v	vararg v : Int

  • let、run、also、apply

    let：调用某对象的let函数，则该对象为函数的参数。在函数块内可以通过 it 指代该对象。返回值为函数块的最后一行或指定return表达式。

    val a = "string".let {
        println(it)
        3
    }
    println(a)
    //运行结果
    string
    3
    

    一般和安全调用运算符处理可空参函数，并且在非空参函数中使用let函数时，只有在表达式不为bull时执行lambda，为空时什么都不发生。let是以闭包的形式返回，返回函数体内最后一行的值，如果最后一行为空，返回一个Unit类型的默认值。

    //一个不可空参函数
    fun sendEmailTo(email : String)
    
    //Kotlin检测传来参数不为null
    email?.let{ //表示email不为空才会去执行函数体
        email -> sendEmailTo(email)
    }
    //相当于Java中
    if(email != null) sendEmailTo(email)
    

    run：

    调用某对象的run函数，在函数块内可以通过 this 指代该对象。返回值为函数块的最后一行或指定return表达式。

    val a = run {
        println("run")
        return@run 1
    }
    println(a)
    //输出
    run
    3
    

    调用某对象的run函数，在函数块内可以通过 this 指代该对象。返回值为函数块的最后一行或指定return表达式。

    val a = "string".run {
        println(this)
        1
    }
    println(a)
    //输出
    string
    3
    

    also：调用某对象的also函数，则该对象为函数的参数。在函数块内可以通过 it 指代该对象。返回值为该对象自己。

    val a = "string".also {
        println(it)
    }
    println(a)
    //输出
    string
    string
    

    apply：调用某对象的apply函数，在函数范围内，可以任意调用该对象的任意方法，并且返回该对象。

    新的TextView实例创建之后立即被传给apply，在传给apply的lambda中，TextView 的实例变成了(lambda的)接收者，可以调用它的方法并设置它的属性。lambda执行之后。apply返回已经初始化过的接收者实例，它变成createViewWithCustomAttributes函数的结果。

    //使用apply初始化一个TextView
    fun createViewWithCustomAttributes(context: Context){
        TextView(context).apply{
            text = "Sample Text"
            textSize = 20.0
            setPadding(10,0,0,0)
        }
    }