本系列第一篇文章我们学习了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() = this@Outter.hashCode()
}
}
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的反射、泛型以及委托等。
网友评论