Kotlin学习笔记——概览、类和对象

更多文章可以访问我的博客Aengus | Blog

概览OverView

  • Kotlin的变量或方法声明和Java相比是“反”的，也就是类型声明在后，变量或方法名在前；
  • Kotlin更严格，这点体现在方法声明时就确定变量是否可变，类默认不可继承；
  • Kotlin更安全，变量声明的类都是非空的，如果允许为空，则需要在类后面加?；
  • Kotlin用println()函数进行打印，并且每行结束不用加;；
  • Kotlin注释格式与Java相同；
  • Kotlin支持字符串模板表达式，使用"${expression}"的格式可以对expression进行运算并将其转为字符串；

变量与函数

Kotlin变量声明格式如下：

val/var a: Type = someThing

其中val代表不可变，对应Java中的final Type；var代表可变变量，就等同于Java中普通的变量。Type是变量类型，不可空，如果允许为空，则用Type?表示。在声明时便要求声明变量为val或var，是Kotlin安全性上的体现，一般情况下，不可变对象都是线程安全的。

Kotlin一般函数声明如下：

fun funcationName(arg: Type): ReturnType {
    // 函数体
}

可以看到参数的声明也是后置类型，ReturnType是函数的返回类型，也可以不写返回类型代表无返回值。Kotlin函数还有很多用法，我们将在后面再提到。

在变量或函数声明最开始都可以加private等关键字进行修饰。

循环、List和Map

Kotlin只有for循环和Java稍有不同，for循环基本结构为：

for (item: Type in collection) { /* ... */ } // 可以省略类型

若使用数字迭代，则常用以下两种方式：

// 区间，左闭右闭。下面i = 1,2,3
for (i in 1..3) { /* ... */ }
// until函数，左闭右开，符合常用习惯。下面i = 1,2
for (i in 1 until 3) { /* ... */ }
// 可以用 step 和 downTo 控制步长与顺序。下面i = 10,8,6,4,2
for (i in 10 downTo 2 step 2) { /* ... */ }

Kotlin使用listOf()生成List，使用MapOf()生成Map，用法如下：

val list = listOf<String>("a", "b", "c")
print(list[1]) // b
val map = mapOf<String, Int>("key1" to 1, "key2" to 2)
print(map["key1"]) // 1

之后会对集合进行更详细说明。

一切皆对象

Kotlin相对于Java面向对象的程度更高。在Kotlin中，Java的boolean,int,char,double等数据类型的首字母全部变成大写，即Boolean,Int,Char等，这意味着这些数据类型都是对象，可以使用下面这种方法进行操作：

1.toChar()
true.and(false)
1.2.compareTo(1)

类Class

在Java中，所有对象都继承自Object，而在Kotlin中，所有对象均继承自Any（如果可能是null，则继承Any?）。Any类中有三个方法，分别为hashCode()，equals()与toString()。类声明与创建方法如下：

class Name {
  // 类主体
}
// 如果类中没有body体，可以用这种方式
class Empty
// 创建类，Kotlin中没有 new 关键字
val person: Person = Person()
// Kotlin拥有类型推导机制，可以省略变量类型声明
val person = Person()

构造函数Constructor

每个类都可以有一个主构造函数和次构造函数。

主构造函数

主构造函数如下所示：

class Person constructor(firstName: String) { /* ... */ }
// 构造函数无注解时也可以省略 constructor 关键字
class Person(firstName: String) { /* ... */ }
// 若有注解，则 constructor 关键字不能省略
class Person public @Inject constructor(firstName: String) { /* ... */ }

// 推荐使用
class Person(val firstName: String) { /* ... */ }
// 或者
class Person(private val firstName: String) { /* ... */ }

主构造函数没有函数体，如果想进行初始化工作（就像Java中的构造函数一样），可以放在init块中，init块中的函数会在创建对象时被调用：

class Person(firstName: String) {
    init {
        println("构造函数")
    }
}

Kotlin的主构造函数有点像是语法糖，当你调用构造函数时，Kotlin编译器会自动将参数赋值给主构造函数中的声明的参数，这个过程类似于Java中的：

class Person {
   private String name;
  
    public Person(String name) {
        this.name = name;
    }
}
Person person = new Person("Bob");

所以，Kotlin主构造函数中的参数可以在类body中任意的地方使用。Kotlin中类，字段和函数默认修饰符都是public，protected和private关键字作用和Java中保持一致，但是使用internal表示同一module下可见。

如果没有指定主构造函数，则编译器会为其自动生成一个无参的主构造函数，这点和Java是一致的。

次构造函数

次构造函数是在类body中使用constructor函数进行表示：

class Person {
    constructor(name: String) { /* ... */ }
}

一个类可以有多个次构造函数，但只能有一个主构造函数。如果一个类既有主构造函数又有次构造函数，那么每个次构造函数必须直接或间接调用主构造函数，使用this关键字：

class Person(val name: String) {
      constructor(name: String, age: Int) : this(name) { /* ... */ }
      constructor(name: String, age: Int, sex: String) : this(name, age) { /* ... */ }
}

主构造函数调用在此构造函数之前。注意，只有主构造函数中的参数可以在类body中的任何地方调用，此构造函数的参数只能在构造函数中使用。下面是一个较为完整的例子：

class Person(val name: String) {
    init {
        println("name: ${this.name}")
    }
    constructor(name: String, age: Int) : this(name) {
        println("name: $name, age: $age")
    }
    constructor(name: String, age: Int, sex: String) : this(name, age) {
        println("name: $name, age: $age, sex: $sex")
    }
}

fun main() {
  val person = Person("张三")
}
// 输出：
// name: 张三
// name: 张三, age: 18
// name: 张三, age: 18, sex: 男

Kotlin构造函数参数支持默认值，如下：

class Person(val name: String = "李四") {
    init {
        println("name: ${this.name}")
    }
    constructor(name: String = "王五", age: Int = 20) : this(name) {
        println("name: $name, age: $age")
    }
    constructor(name: String = "赵六", age: Int = 21, sex: String = "男") : this(name, age) {
        println("name: $name, age: $age, sex: $sex")
    }
}
fun main() {
    val person = Person()
    val person1 = Person(name="甲")
    val person2 = Person(name="乙", age=10)
    val person3 = Person(age=30)
    val person4 = Person(sex="女")
}
// 第一行代码输出：
// name: 李四
// 第二行代码输出：
// name: 甲
// 第三行代码输出：
// name: 乙
// name: 乙, age: 10
// 第四行代码输出：
// name: 王五
// name: 王五, age: 30
// 第五行代码输出：
// name: 赵六
// name: 赵六, age: 21
// name: 赵六, age: 21, sex: 女

可以看到Kotlin会优先使用参数较少的构造方法，当传入的参数不在此构造方法时，Kotlin才会选择参数更多的构造方法。注意次构造函数中参数不允许使用val/var修饰。

继承Inheritance

上面已经说到，所有的类都直接或间接继承自Any类。在Kotlin中，所有的类默认都是final的，因为类默认是不可继承的，如果允许其被其他类继承，则需要使用open关键字进行修饰：

open class Person { /* ... */ }

父类指定了主或次构造函数时：如果子类有主构造函数，则父类必须被在继承时立即初始化：

open class Father(val lastName: String) {
    init {
        println("父亲姓 ${lastName}")
    }
}

class Son(val lastNameSon: String) : Father(lastNameSon) {
    init {
        println("儿子姓 $lastNameSon")
    }
}

父类指定了主或次构造函数时：如果子类没有主构造函数，那么它的每个次构造函数都必须使用super初始化父类，或者委派给另外一个有此功能的此构造函数：

open class Father(val lastName: String)

class Son : Father {
    constructor(familyName: String) : super(familyName) {
        println("这里用的是父类的字段lastName=$lastName")
    }
    // 委派给子类的第一个次构造函数
    constructor(familyName: String, age: Int) : this(familyName) {
        println("通过儿子的姓我们知道父亲姓 $lastName，儿子 $age 岁了")
    }
}

fun main() {
    val son = Son("王")
    val son2 = Son("王", 20)
}
// 第一行代码输出：
// 这里用的是父类的字段lastName=王
// 第二行代码输出：
// 这里用的是父类的字段lastName=王
// 通过儿子的姓我们知道父亲姓 王，儿子 20 岁了

父类没有指定主或次构造函数时：如果子类没有指定主构造函数和次构造函数，那么在继承时使用父类默认的构造函数；否则在主构造函数处继承父类构造函数或者次构造函数处使用super实例化父类：

open class Father

class Son : Father()
class Son2 : Father {
    constructor() : super() { /* ... */ }
}

Kotlin与Java一样，仅仅支持单继承，但是可以实现多个接口。

重写override

在Java中重写父类方法使用的是@Override注解，而在Kotlin中则使用override关键字，除此以外函数默认也是final的，如果需要被在子类中重写同样需要使用open关键字进行修饰：

open class Father {
    open fun eat() { /* ... */ }
    fun sleep() { /* ... */ }
}
class Son : Father() {
    override fun eat() { /* .... */ }
}

使用final关键字可以使方法不再次被子类重写（只被自己重写）:

class Son : Father() {
    final override fun eat() { /* .... */ }
}

Kotlin也支持属性重写，用法和函数重写类似：

open class Father() {
    open val age: Int = 40
}
class Son1(override val age: Int = 22) : Father() // age不可更改
class Son2 : Father() {
    override var age = 20;  // age此时可以更改
}

抽象类Abstract Class

Kotlin中的抽象类与Java类似，使用abstract关键字进行修饰，需要注意的是当继承抽象类时，需要对父类（抽象类）进行实例化：

abstract class Father
class Son : Father()

抽象类默认也是open的。

接口Interface

Kotlin使用interface声明接口，接口中的方法默认为open，且支持默认方法实现；接口中也可以有属性：

interface Worker {
    val count: Int  // 抽象的属性，不允许赋值
    fun run() {
       println("Worker中的方法")
   }
}

注意，实现类中对接口中的属性进行重写，不可以将var属性变为val属性，但可以将val变为var。

当子类同时实现或继承接口与父类时，重写规则如下：

open class Machine {
    open fun run() {
        println("Machine中的方法")
    }
}
class Computer : Machine(), Worker {
    val app = "QQ"
    override fun run() {
        println("Computer中的方法")
    }
    fun runAll() {
        run()
        // 通过这种方式调用父类或接口的方法
        super<Machine>.run()
        super<Worker>.run()
    }
}
fun main() {
    val com = Computer()
    com.runAll()
}
// 输出
// Computer中的方法
// Machine中的方法
// Worker中的方法

内部类Inner Class

嵌套类就是在类中的类：

class Computer {
    val app = "QQ"
    class Desktop {
        fun print() {
          println("嵌套类中的方法")
        }
    }
}

嵌套类无法访问外部类的方法或属性，但是使用inner关键字修饰嵌套类时，嵌套类就变成了内部类，此时就可以访问到外部类的属性或方法了，这是因为此时内部类含有一个外部类的引用（编译器自动生成的）：

open class Machine {
    open fun playOuter() {
        println("父类方法")
    }
}
class Computer : Machine() {
    val app = "QQ"
    override fun playOuter() {
        println("外部类的方法")
    }
    inner class Desktop {
        fun print() {
            println(app)
        }
        fun play() {
            playOuter()  // 调用外部类方法
            super@Computer.playOuter() // 调用外部类的父类的方法
        }
    }
}
fun main() {
    val desktop = Computer().Desktop()
    desktop.print()
    desktop.play()
}
// 输出：
// QQ
// 外部类的方法
// 父类方法

数据类Data Class

在Java中写JavaBean时，我们常常需要对其重写equals(),hashCode(),toString()等方法以便于使用，但这些都是一些重复的工作，我们也可以借助Lombok中的@Data注解帮我们完成这些工作，而在Kotlin中，这些工作都可以借助关键字data帮我们实现。数据类的声明如下：

data class User(val name: String, val age: Int)

另外，数据类还给我们提供了函数copy()帮我们实现数据类的复制，copy()函数会针对每个数据类生成其对应的构造方法，以上面的数据类为例，它生成的copy()方法与调用方式如下：

copy(val name: String, val age: Int)
// 如何使用
val oldUser: User = User("李四", 20)
val newUser: User = oldUser.copy(name="王五")

数据类还提供了componentN()函数返回数据类的第N个属性，以上面的数据类为例，componentN()函数使用如下：

val user = User("张三", 20)
val name1 = user.component1() // name1 = "张三"
val age1 = user.component2()    // age1 = 20
// 或者（这里的component1(),component2()被自动调用）
val (name2, age2) = user        // (name2 = "张三", age2 = 20)
// 还可以这么用
val collection = listOf(User("a", 1), User("b", 2), User("3", 3))
for ((name, age) in collection) {
    println("name is $name")
    println("age is $age")
}

数据类也可以有类body，我们同样可以使用自己的方式重写toString()等方法。如果想让数据类拥有无参的构造方法，可以给所有参数指定默认值。如果不想让编译器自动将参数添加到构造方法中，可以将其放在body中：

data class User(val name: String) {
    var age: Int = 18
}

数据类目前有以下几种限制：

  • 主构造函数中至少有一个参数；

  • 主构造函数中的参数必须使用val/var修饰；

  • 数据类的父类中的final方法不会被重写；

  • 数据类不能被abstract,open,sealed或inner修饰；

  • 若父类有open componentN()并且返回兼容的类型，则会被重写；若返回不兼容类型，则报错；

密封类Sealed Class

密封类只能被和它同文件的类可见，对其他文件的类都不可见（但是它的子类可以被其他文件中的类可见）。密封类使用sealed关键字修饰：

sealed class Example

密封类是抽象的，而且不可以被实例化，但是可以拥有抽象属性。密封类不允许有非private的构造方法。

下面的是常用用途：

sealed class Expr
data class Const(val number: Double) : Expr()
data class Sum(val e1: Expr, val e2: Expr) : Expr()
data class Other(val number: Double) : Expr()
// when相当于Java中的switch，但是有更强大的功能如类型转换，我们将在函数一节中说明
fun eval(expr: Expr): Double {
    return when(expr) {
        is Const -> expr.number
        is Sum -> eval(expr.e1) + eval(expr.e2)
        else -> Double.NaN
    }
}

单例类Object Class

在Java中使用单例类是常用的操作，在这里我们就不给出Java中单例的实现（可以看这篇）。Kotlin中原生支持了单例类的实现：

object Singleton {
    fun doSomeThing() { /* ... */ }
}

这种方式声明的对象是线程安全的，且在第一次访问时才会被实例化，由JVM保证单例。

调用其方法可以通过类似Java中的静态访问的方式进行：

Singleton.doSomeThing()

单例类也可以继承其他父类。单例类可以作为嵌套类在其他类中，但是不可以在内部类中（即不能在inner class）：

class Test {
    object Singleton1         // 可以
    inner class Inner {
        object Singleton2 // 不可以
    }
    class Inner2 {
        object Singleton3 // 可以
    }
}

object关键字还有一个作用是作为匿名内部类的生成，用法如下：

interface Teacher {
    fun speak()
}

fun giveAClass(t: Teacher) {
    t.speak()
}

fun main() {
    giveAClass(object : Teacher {
        override fun speak() {
            println("临时老师开始说话")
        }
    })
    // 还可以这么用
    val point = object {
        var x: Int = 100
        var y: Int = 100
    }
    println(point.x)
}

这种通过匿名内部类间接实现传输函数的方法在Java中比较常见，但是Kotlin中还有刚好的方法，我们将在函数一节中继续说明。

除此之外，object还可以作为伴生类的关键字。

伴生类Companion Class

伴生类的声明方法如下：

class MyClass {
    companion object Factory {
        val type = "A"
        fun create(): MyClass {
            return MyClass()
        }
    }
}

伴生类可以让我们用类似Java中静态方法调用的形式掉用某些方法，上面的例子中我们就可以这样调用：

val type = MyClass.type
val instance = MyClass.create()
// 或者
val type = MyClass.Factory.type
val instance = MyClass.Factory.create()

伴生类的类名声明时可以去掉，这时候Kotlin会自动用Companion作为伴生类的名称。注意，一个类中只能有一个伴生类。伴生类同样可以继承。

内联类Inline Class

内联类目前还在测试中，可能之后会有变化。内联类表示如下：

inline class Wrapper(val value: Type)

在业务中，有时候因为业务逻辑需要对某些“东西”进行抽象，而单独创建对象表示这种“东西”在运行时可能又比较重，加大了系统负担，内联类便是用来解决这种问题的，内联类可以看作一种包装（Wrapper），它是对需要包装的东西的抽象，在编译时，Kotlin会为其生成一个包装器，在运行时，它要么用这个包装器代表，要么用它主构造函数中的参数类型代表，因此内联类有且只能有一个主构造函数属性，这个属性将可能在运行时代替这个内联类。有个简单的例子：

inline class Password(val vaule: String)

这样便为密码字符串生成了一个内联类，既可以方便开发，又不用增加系统创建对象的开销。关于“代表”也有个例子，比如Kotlin中的Int，它既可以用Java中的原始类型int表示，也可以用Integer表示。

内联类可以继承其他类，但是不能被其他类所继承，内联类中可以定义函数或者其他属性，但是这些调用在运行时都将变成静态调用。

委派Delegation

Kotlin原生支持委派模式，所谓委派模式，是指将一个对象的工作委派给另一个对象，在Kotlin中，委派有类委派与属性委派，通过by关键字实现，通过委派，我们可以将父类的初始化工作交给子类接受的参数：

interface Base {
    val value: Int
    fun printValue()
    fun print()
}
class BaseImpl : Base {
    override val value = 10
    override fun printValue() {
        println("BaseImpl value=${this.value}")
    }
    override fun print() {
        println("BaseImpl print")
    }
}
class Delegation(val base: Base) : Base by base {
    override val value = 20
    override fun print() {
        println("Delegation print")
    }
}
fun main() {
    val baseImpl = BaseImpl()
    val delegation = Delegation(baseImpl)
    delegation.printValue()
    delegation.print()
}
// 输出：
// BaseImpl value=10
// Delegation print

可以看到使用委派对象后，调用方法时会优先调用重写的方法，但是委派对象只能访问自己的接口成员（虽然在Delegation中重写了接口成员，但是委派对象在调用printValue()时只能访问自己的接口成员，并不能访问Delegation中的接口成员）。

Kotlin提供了函数lazy()实现了属性委托，通过by lazy({...})的方式为属性提供委托并实现了懒加载：

val lazyValue: String by lazy {
    println("进行某些操作")
    "Hello"
}

这里lazy使用了lambda表达式，如果你还不清楚lambda表达式，这里你可以简单的理解为当代码运行到这里时，会自动执行块中的代码，并将最后一行的值作为块的返回值。通过lazy函数进行委托，只有在第一次访问lazyValue时才会对其进行初始化并记住其值，之后的访问将会直接返回这个值。

lazy()函数默认是线程安全的，如果需要多个线程同时访问可以传参LazyThreadSafetyMode.PUBLICATION；如果不需要线程同步可以传参LazyThreadSafetyMode.NONE。

还有一个常用的委派方法是使用Map进行传参，这个方法常常用于解析JSON，用法如下：

class User(val map: Map<String, Any?>) {
    val name: String by map
    val age: Int by map
}
val user = User(mapOf(
    "name" to "张三",
    "age" to 20
))
println(user.name) // 张三
println(user.age)  // 20
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 212,222评论 6赞 493
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 90,455评论 3赞 385
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 157,720评论 0赞 348
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 56,568评论 1赞 284
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 65,696评论 6赞 386
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 49,879评论 1赞 290
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 39,028评论 3赞 409
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 37,773评论 0赞 268
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 44,220评论 1赞 303
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,550评论 2赞 327
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,697评论 1赞 341
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 34,360评论 4赞 332
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 40,002评论 3赞 315
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,782评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,010评论 1赞 266
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 46,433评论 2赞 360
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 43,587评论 2赞 350