Kotlin 基础教程之类、对象、接口

kotlin 基础教程之类、对象、接口

kotlin中类、接口相关概念与java一样，包括类名、属性、方法、继承等，如下示例：

interface a {
  fun bar()
  fun foo() {
  // 可选方法体
  }
}

class child: a {
  override fun bar() {
    // todo
  }
  override fun foo() {
    super.foo()
  }
}

class

构造器

kotlin 中的类可以有一个 主构造器, 以及一个或多个次构造器, 主构造器是类头部的一部分, 位于类名称之后。

class person constructor(name: string) {...}

如果主构造器没有任何注解(annotation), 也没有任何可见度修饰符, 那么 constructor 关键字可以省略

class person(name: string) {...}

主构造器中不能包含任何代码. 初始化代码可以放在初始化代码段 (initializer block) 中

class persion(name: string) {
  private val firstname: string = name
  private var age: int
  init {
    age = 10
  }
}

kotlin 有一种简洁语法, 可以通过主构造器来定义属性并初始化属性值:

class persion(val name: string, var age: int) {...}

如果构造器有注解, 或者有可见度修饰符, 这时 constructor 关键字是必须的, 注解和修饰符要放在它之前

class persion public @inject constructor(val name: string) {...}

类还可以声明次级构造器 (secondary constructor)。如果类有主构造器, 那么次级构造器都必须委托给主构造器

class persion(val name: string) {
  constructor(name: string, age: int): this(name) {
    // todo
  }
}

类实例化

kotlin 没有 new 关键字

val persion = persion("jason")

继承

kotlin的继承概念和java一样，”类名: 超类“ 冒号表示继承。

与java的object相对，kotlin也有一个这样的any类，类默认继承any。

与java的final相反，kotlin类默认是final的，允许被继承的类，需要加 open 修饰。

open class base {
  open fun v() {...}
  fun nv() {...} // can't be override
}

方法和属性的覆盖

方法的覆盖和java类似，但是只有 open 的方法才能 override, final 类是不允许定义 open方法。

class other: base() {
  override fun v() {...}
}

可以加final禁止ovrride, final override fun v() {...}

与方法的覆盖类似， kotlin提供了属性的覆盖，例如

open class foo {
  open val x: int = 0
}

class bar(override val x: int): foo {...}

class bar1: foo() {
  override var x: int = 0 // override to var
}

抽象类

类本身, 或类中的部分成员, 都可以声明为 abstract 的, 抽象类不必标识 open。

abstract class base {
  abstract fun v()
}

同伴对象

kotlin 的类没有静态方法, 大多数情况下, 建议使用包级函数(packagelevel function)替代, 或者使用同伴对象,
达到静态方法效果

class foo {

companion object {
  fun v() {}
}
}

interface

kotlin 的接口和java差不多，但是接口的属性不一样，kotlin接口中的属性是抽象的。

interface a {
  val x: int
}

class b: a {
  override val x: int = 10
}

object

kotlin 没有静态类， 可以用object实现静态类的效果。

object b {
  fun foo() {
    // do something
  }
}

class a {
  fun bar() {
   b.foo()
  }
}

感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！