Kotlin简明教程

Kotlin精简教程,包含基本数据类型、控制语句以及函数,并且包含面向对象的相关类、继承和接口的定义以及实现等。本文旨在帮助想快速体验Kotlin的同学快读上手,在最短的时间内掌握更多的知识。Kotlin成为Android的官方语言后,毕竟带来一场新的变革,让我们拭目以待吧,当然手来还是要有东西的,赶紧安装一个Kotlin,顺着本手册快速过一遍吧。

1 基础篇

1.1  数据类型

Kotlin基本数据类型: 数值、字符、布尔和数组。

1.1.1 数字类型

Type Bit width
Double 64
Float 32
Long 64
Int 32
Short 16
Byte 8

1.1.2 字符类型

字符类型用Char声明。例如 ‘1’。

1.1.3 布尔类型

Boolean声明布尔类型,布尔类型有两个值:true 和 false。内置运算符布包括 ||(或)、&&(与)、!(非)。

1.1.4 数组

在Kotlin中的数组通过 Array 类声明,并且具有 getset 方法,以及size属性。我们可以通过arrayOf(1, 2, 3)来创建一个数组。

1.1.5 字符串

字符串使用String来声明,字符串是不可变的。数组中的元素就是字符,可以通过s[i]访问。

var a : Int = 1000
var b : Char = 'b'
var c : IntArray = intArrayOf(1, 2, 3, 5)
var d : String = "Hello world!"
var e : Boolean = true

1.2 控制语句

1.2.1 IF表达式

在kotlin中,if是一个表达式,带返回值。

if (a < b) max = b 

if (a > b) {
    max = a
} else {
    max = b
}
 
val max = if (a > b) a else b

1.2.2 WHEN表达式

WHEN代替了SWITCH。

when (x) {
    1 -> print("x == 1")
    2 -> print("x == 2")
    else -> { // Note the block
        print("x is neither 1 nor 2")
    }
}

1.2.3 FOR循环

for (i in array.indices) {
    print(array[i])
}

1.2.4 WHILE循环

Kotlin支持while和do…while

while (x > 0) {
    x--
}

do {
    val y = retrieveData()
} while (y != null) // y is visible here!

1.3 函数

1.3.1 函数声明

在Kotlin中使用fun声明函数。这真是一件有趣的事情。

fun double(x: Int): Int {
}

1.3.2 函数调用

val result = double(2)

1.3.3 参数

函数的参数采用Pasical风格name:type。参数之间用逗号隔开。参数必须指定类型。参数可以指定默认值。

fun read(b: Array, off: Int = 0, len: Int = b.size()) {
...
}

可变参数可以通过vararg声明

fun read(vararg ts:Int) {
...
}

如果参数较多,可以通过命名参数来调用函数

fun reformat(str: String,
             normalizeCase: Boolean = true,
             upperCaseFirstLetter: Boolean = true,
             divideByCamelHumps: Boolean = false,
             wordSeparator: Char = ' ') {
...
}
//命名调用
reformat(str, wordSeparator = '_')

1.3.4 单行函数

如果函数只是返回一个表达式,那就可以直接用等号

fun double(x: Int): Int = x * 2

1.3.5 返回值

函数可返回Unit(即什么都不返回)或者准确数据类型。

fun printHello(name: String?): Unit {
    if (name != null)
        println("Hello ${name}")
    else
        println("Hi there!")
    // `return Unit` or `return` is optional
}

//等价于
fun printHello(name: String?) {

}

2、面向对象

2.1 类与继承

2.1.1 类

在Kotlin中类通过class来声明

class Invoice {
}

2.1.1.1 类的构造方法

Kotlin的构造方法有主构造方法和多个副构造方法。在类名后边的为主构造方法,此处可以省略constructor关键字,类中的constructor为副构造方法。

class Person(val name: String) {
    constructor(name: String, parent: Person) : this(name) {
        parent.children.add(this)
    }
}

2.1.1.2 类的实例化

Kotlin没有new关键字,所以如下实例化。

val customer = Customer("Joe Smith")

2.1.2 继承

Kotlin的所有类都有一个公共的超类 Any

class Example // 隐式继承自Any

继承一个类,只需要将父类放到子类的后边即可,有点类似于定义方法的返回值。

open class Base(p: Int)

class Derived(p: Int) : Base(p)

如果父类有主构造方法,需要正确的初始化;如果父类有副构造方法,需要使用super关键字初始化。

class MyView : View {
    constructor(ctx: Context) : super(ctx)

    constructor(ctx: Context, attrs: AttributeSet) : super(ctx, attrs)
}

open关键字和java中的final关键字相反,它允许其他类继承此类。在Kotlin中所有的类默认均为final类型。

2.1.2.1 重写方法

重写方法时,子类类的方法必须是通过open关键字限定的,并且子类的相应方法也默认被继承为open类型,如果需要禁止,可以通过final关键字来限定。重写方法使用关键字overwrite。

open class Base {
    open fun v() {}
    fun nv() {}
}
class Derived() : Base() {
    override fun v() {} //此处可以在开始加上final,来禁止次方法被重写
}

2.1.2.2 重写属性

重写属性和重写方法类似。

open class Foo {
    open val x: Int get { ... }
}

class Bar1 : Foo() {
    override val x: Int = ...
}

2.1.2.3 重写规则

Kotlin,实现继承的规则是: 如果类继承自多个相同成员的实现,子类必须重写这些成员并提供自己的实现(或者是继承其中一个)。此处可以使用super关键字,例如super<Base>

open class A {
    open fun f() { print("A") }
    fun a() { print("a") }
}

interface B {
    fun f() { print("B") } // interface members are 'open' by default
    fun b() { print("b") }
}

class C() : A(), B {
    // The compiler requires f() to be overridden:
    override fun f() {
        super<A>.f() // call to A.f()
        super<B>.f() // call to B.f()
    }
}

2.1.3 抽象类

抽象类用abstract声明。由于抽象类不涉及到具体实现,所以抽象类及其方法不需要用open限定就可以重写。此外我们也可以将一个非抽象类中的open成员写成抽象的。

open class Base {
    open fun f() {}
}

abstract class Derived : Base() {
    override abstract fun f()
}

2.2 接口

可以使用interface定义接口

interface MyInterface {
    fun bar()
    fun foo() {
      // optional body
    }
}

2.2.1 接口实现

类或者对象都可以显示类。

class Child : MyInterface {
    override fun bar() {
        // body
    }
}

更多内容请 参考手册

我来评几句
登录后评论

已发表评论数()