Kotlin也没那么难（二）

本系列第一篇文章我们学习了kotlin的基本概念，本篇文章我们将继续学习类、接口、lambda以及可空性。

接口

接口声明

interface FirstInterface {
    fun function()
}

接口实现

class FirstClass : FirstInterface {
    override fun function() {
    }
}

kotlin相比于java没有 extends 和 implements关键字，而是直接使用 : 符号

默认方法

interface FirstInterface {
    fun function()
    fun defaultfunction() = { print("hello world") }
}

open关键字

kotlin默认所有类都是final，也就是不能被重写、继承
如果想让类和方法可以被重写、继承需要加 open 关键字

open class OpenClass : FirstInterface {
    final override fun function() {
        //由override修饰的方法默认是open，如不想被重写需要显式加final
    }

    open fun openFun() {
        //该方法可以被重写
    }
}

abstract class AbsClass {
    abstract fun fun0() //强制子类重写
    open fun fun1() {} //允许子类重写
    fun fun2() {} //禁止子类重写
}

可见修饰符

kotlin较java而言少了默认(即什么都不加) 修饰符，多了 internal 修饰符

internal修饰符修饰的类和类成员模块类可见，比如对于一个android项目通常有多个模块，如果a模块的kotlin类A使用internal修饰，b模块kotlin类B就引用不到类A。但是这特性对java无效，在B模块的java类照样能引用类A

类

内部类和嵌套类

class Outter {
    //这是静态类 创建对象：Outter.Static()
    class Static
    //这是内部类 创建对象：Outter().Inner()
    inner class Inner {
        fun getOutterHash() = [email protected]()
    }
}

kotlin由于没有 static 关键字，类中声明的类默认就是静态类，声明内部类时需要使用 inner 关键字
同时内部类引用外部类对象的方式也和java不同，需要使用 this@外部类

密封类

使用 sealed 关键字修饰的一个类是密封类
sealed class Student
密封类默认是open，密封类不能被实例化
sealed类通常用在when语句中，如

sealed class Student
class Girl : Student()
class Boy : Student()
fun `when`(student: Student) {
    return when (student) {
    }
}

此时点击Add remaining branches按钮就会自动把所有Student的子类情况列举出来

sealed class Student
class Girl : Student()
class Boy : Student()
fun `when`(student: Student) {
    return when (student) {
        is Girl -> TODO()
        is Boy -> TODO()
    }
}

这里我们定义了一个when方法，因为和系统的when关键字重名，所以需要使用两个`符号转义

构造函数

class People constructor(name: String, val age: Int) {
    var name: String = ""

    init {
        this.name = name
    }
}

class People(var name: String, val age: Int)

要点：

以上两段代码编译结果一模一样，类名旁的括号声明了默认构造函数(也叫主构造函数)
如果在构造函数中声明参数时有使用val和var则会自动把该参数设置为成员变量(第二段代码两个参数都被编译器默认设置为同的名成员变量)，如果没有则只当成一个临时变量：主构造函数执行完后该变量就访问不到
init 关键字可以引导一个语句块，该语句块伴随主构造函数执行，所以第一段代码的init语句块中可以访问到name这个临时变量
一个类可以有多个init语句块，顺序是从上到下依次执行
如果主构造函数没有注解和可见性修饰符则可以去掉constructor 关键字
所有声明的从构造函数最终都必须要执行主构造函数，不管是直接还是间接

open class Button() {
    constructor(x: Float, y: Float) : this() {} //直接调用无参的主构造函数
    constructor(x: Float) : this(x, 0F) {} //通过另一两个参数的从构造函数间接实现主构造函数
}

子类定义构造函数时一定要实现父类的构造函数

open class Button
class MyButton1 : Button {
    constructor() : super() //定义构造函数
}
class MyButton2() : Button() //定义构造函数

Data class

DataClass其实只要在定义的class前加一个data关键字就好
唯一要求就是主构造函数至少有一个字段

data class MyData(var name:String)

使用DataClass声明类时编译器会自动为该类重写hashCode()、equals()、copy()和toString()等方法，很方便。

Object class

ObjectClass极大的简化了单例的声明

object SingleDb

这里我们定义了一个SingleDb类，他是一个单例，不能实例化，所以我们也无法指定构造函数
我们可以看看编译成java文件是什么样子

public final class SingleDb {
   public static final SingleDb INSTANCE;

   static {
      SingleDb var0 = new SingleDb();
      INSTANCE = var0;
   }
}

伴生对象(Companion)

kotlin是没有static关键字的，所以没有静态变量与静态方法
但是我们可以使用伴生对象实现

class SingleDb {
    companion object Db {
        var dbName: String = "example"
    }
}

fun test() {
    //两种写法都行，但是Java中只能使用第一种，原因看编译后的java文件就明白了
    print(SingleDb.Db.dbName)
    print(SingleDb.dbName)
}

我们使用companion object + 伴生对象名字 + 语句块的方式声明了一个伴生对象，其中伴生对象名字可以省略，这样编译器会默认赋予一个COMPANION的名字
编译后java文件

public final class SingleDb {
   private static String dbName = "example";
   public static final SingleDb.Db Db = new SingleDb.Db();

   public static final class Db {
      public final String getDbName() {
         return SingleDb.dbName;
      }

      public final void setDbName(String var1) {
         SingleDb.dbName = var1;
      }

      private Db() {
      }
   }
}

可空类型

kotlin最为人津津乐道的就是不会产生空指针异常
其实说白了就是编译期检查代码，把可能会出现异常的地方全部编译失败，丢给开发一个个去解决
我们可以在任何声明类型的时候给该类型后加一个?来告诉编译器这是可空的类型(可以为null)，如果没加?号表示这是不可空的，那么如果你想给不可空的对象赋值null是一定编译不过去的!!!

class People {
    val name: String? = null
    val region: String = "china"
}

比如上面的people类我们就定义name可以为空，region不能为空
同样的，我们可以看看编译后的java文件

public final class People {
   @Nullable
   private final String name;
   @NotNull
   private final String region = "china";

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

   @NotNull
   public final String getRegion() {
      return this.region;
   }
}

可以看到其实是通过java的@Nullable和@NotNull注解实现的

有时候我们明明知道该值此时不为空，但是由于声明为可空类型我们得判空后才能操作，此时可以直接使用!!操作符调用，如 print(people!!name)，使用!!就是告诉编译器不用检查这里的可控性，当然如果运行的时候people对象为空就会直接抛出空指针异常。
所以通常使用了kotlin还是老空指针就是滥用!!操作符的原因了

Kotlin中的Lambda表达式

还剩一些篇章，我们就来了解下kotlin中的lambda表达式吧
lambad是一个很简单的小语法，这里贴出一个教程链接大家可以自行阅读
lambda教程
这里我们主要讲lambda在kotlin中的用处

fun sayHello(name: String, onSayHelloFinished: () -> Unit) {
    print("hello $name")
    onSayHelloFinished()
}

以上是一个最最最直观的例子
Unit其实就类似java中的Void
其中String和() -> Unit都是类型，前者是String类型，后者是函数类型！
()->Unit定义了一个函数类型，该类型的对象是一个函数，该函数的参数在括号内（本例无参数），返回值是Unit类型
本例声明了该函数类型的函数对象onSayHelloFinished，该对象的使用很简单：
onSayHelloFinished()或onSayHelloFinished.invoke() ，两种方式都可以调用
有了函数类型这一语法糖，至少本人自定义view时不用再写各种接口来提供点击事件了

伪代码献上：

class MyView {
    var clickCallBack: ((MyView) -> Boolean)? = null
    fun setListener(onClick: (MyView) -> Boolean) {
        clickCallBack = onClick
    }

    fun clickTwice() {
        if (clickCallBack != null) {
            clickCallBack.invoke(this)
        }
    }
}

查看编译后java文件

学习kotlin最好的方法就是一边写，一边想编译后的class文件是怎样的
AndroidStudio自带了一个很好的工具用于查看编译后的class文件
步骤1：打开一个kt文件，注意焦点要在文件内，也就是文件内要显示一闪一闪的光标
步骤2：如图，点击Show Kotlin Bytecode

步骤3: 点击Decompile，搞定！

结语

通过本篇文章的学习我们已经算 掌握kotlin 了，基本上加上一篇文章可以应对一般的开发需求，之后会有番外篇讲Kotlin的反射、泛型以及委托等。