本系列第一篇文章我们学习了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的反射、泛型以及委托等。