Kotlin:娶妻当娶贤,嫁夫则嫁能

606 阅读11分钟

先来说个故事:

先来说个故事: 在万恶的旧社会,青年谷某当年迫于父母(市场)之命,取Oracle家长女java为妻。婚后虽不甜蜜也倒还相敬如宾。没过几年,谷某在生意场上风生水起,java娘家见此不禁眼红。打了好几场官司要讨回那些年谷某忘了给的彩礼。每每搞得谷某头大不已,借酒浇愁。 直至那晚回廊前红灯下,笙歌散后酒初醒,院也深来夜也深,月儿静来人也静。 后才得知,彼时佳人乃是JetBrains家的小女Kotlin。谷某见之倾心,不能自拔。而JetBrains看谷某丰神俊朗,又兼着谷氏所有商号掌柜之掌柜(大大掌柜?),真真是人中龙凤;倒也乐见其成。 再后来,坊间风声渐走。JetBrains便寻了谷某,要他给kotlin一个名份。谷某想着Java一日夫妻百日恩,虽说丈人家心狠也怨不得她。但若就此拖着kotlin岂不给天下人看了笑话去。牙一咬,心一横。在一年一次的谷氏大宴宣布:宴乃婚宴,妻乃平妻。 众人哗然,欢喜者有之;厌恶者有之,后悔当初没能及时结交上JetBrains者亦有之。 也是至此,谷家大宅院正式成为了J、K二凰争锋的大舞台......
作者:君莫笑
链接:https://www.zhihu.com/question/25289041/answer/174134423
来源:知乎

以上是转自知乎的一个段子,因为oracle的步步紧逼,谷歌爸爸终于在2017年5月18日宣布宣布Kotlin成为Android开发一级语言,自此Kotlin正式进入众多开发者的眼中。
那为什么是Kotlin?
下面是官网给的解释

那么Google中意Kotlin究竟为哪般呢?

兼容性

  1. Kotlin与JDK6完全兼容,确保Kotlin应用程序可以在较旧的Android设备上运行,无任何问题。
  2. Kotlin与Android构建系统兼容,并且在出来的Android Studio3.0预览版中已经完全不需要插件的形式进行Kotlin开发,可以实现Java代码一键转为Kotlin代码了。

性能

Kotlin应用程序运行速度与Java类似,非常类似的字节码结构。随着Kotlin对内联函数的支持,使用lambdas的代码通常比使用Java编写的代码运行得更快。

互操作性

Kotlin可与Java进行100%互操作,允许在Kotlin应用程序中使用所有现有的Android库。 包括注释处理,所以Data Binding和Butter Knife也是一样。

占用空间

Kotlin有一个非常紧凑的运行时库,可以通过使用ProGuard进一步减少。在真实的应用程序中,Kotlin运行时只添加了几百种方法,并且小于等于100K的.apk文件的大小。

编译性能

Kotlin支持高效的增量编译,因此,对于清理构建来说,增加的构建通常与Java一样快或更快。

Kotlin的基本语法,看这一篇就够啦~

函数定义

函数定义使用关键字fun,参数格式为:参数:类型

fun sum(a: Int, b: Int): Int {   // Int 参数,返回值 Int
    return a + b
}

表达式作为函数体时,返回类型自动判断

fun sum(a: Int, b: Int) = a + b

注意

// public 方法则必须明确写出返回类型
public fun sum(a: Int, b: Int): Int = a + b   

无返回值的函数(类似Java中的void):

fun printSum(a: Int, b: Int): Unit { 
    print(a + b)
}


// 如果是返回 Unit类型,则可以省略(对于public方法也是这样):
public fun printSum(a: Int, b: Int) { 
    print(a + b)
}

常量定义和变量定义

  1. 可变变量定义:var关键字
var <标识符> : <类型> = <初始化值>
  1. 不可变变量定义:val 关键字,只能赋值一次的变量(类似Java中final修饰的变量)
val <标识符> : <类型> = <初始化值>

常量与变量都可以没有初始化值,但是在引用前必须初始化 编译器支持自动类型判断,即声明时可以不指定类型,由编译器判断。

示例:

val a: Int = 1
val b = 1       // 系统自动推断变量类型为Int
val c: Int      // 如果不在声明时初始化则必须提供变量类型
c = 1           // 明确赋值


var x = 5        // 系统自动推断变量类型为Int
x += 1           // 变量可修改

注释

和java类似,支持单行注释和多行注释,不同的是,Kotlin中的块注释允许嵌套

// 这是一个单行注释

/* 这是一个多行的
   块注释。 */

字符串模板

表示一个变量名或者变量值varName 表示变量值 ${varName.fun()} 表示变量的方法返回值

var a = 1
// 模板中的简单名称:
val s1 = "a is $a" 

a = 2
// 模板中的任意表达式:
val s2 = "${s1.replace("is", "was")}, but now is $a"

NULL 检查机制

Kotlin的空安全设计对于声明可为空的参数,在使用时要进行空判断处理,有两种处理方式,字段后加!!像Java一样抛出空异常,另一种字段后加?可不做处理返回值为 null或配合?:做空判断处理

//类型后面加?表示可为空
var age: String? = "23" 
//抛出空指针异常
val ages = age!!.toInt()
//不做处理返回 null
val ages1 = age?.toInt()
//age为空返回-1
val ages2 = age?.toInt() ?: -1

区间

区间表达式由具有操作符形式 .. 的 rangeTo 函数辅以 in 和 !in 形成。 区间是为任何可比较类型定义的,但对于整型原生类型,它有一个优化的实现。以下是使用区间的一些示例:

    for (i in 1..4) print("$i ")    //输出1 2 3 4
    println()
    for (i in 4..1) print("$i ")    //什么也不输出4
    println()
    for (i in 4 downTo 1) print("$i ")    //倒序应该用downTo
    println()

    for (i in 1..10) {
        // 等同于 1 <= i && i <= 10
        //[1,10]
        print("$i ")
    }
    println()

    // 使用 until 函数排除结束元素
    for (i in 1 until 10) {
        // 等同于 1 <= i && i < 10
        //[1,10)
        print("$i ")
    }
    println()

    for (i in 1..4 step 2) print("$i ")         //输出1 3
    println()

    for (i in 4 downTo 1 step 2) print("$i ")   //输出4 2
    println()

Kotlin基本数据类型

| 类型 | 位宽度 | | -------- | -----:
| Double | 64
| Float | 32
| Long | 64
| Int | 32
| Short | 16 | Byte | 8

比较两个数字

在 Kotlin 中,三个等号 === 表示比较对象地址,两个 == 表示比较两个值大小。

fun main(args: Array<String>) {
    val a: Int = 10000
    println(a === a) // true,值相等,对象地址相等

    //经过了装箱,创建了两个不同的对象
    val boxedA: Int? = a
    val anotherBoxedA: Int? = a

    //虽然经过了装箱,但是值是相等的,都是10000
    println(boxedA === anotherBoxedA) //  false,值相等,对象地址不一样
    println(boxedA == anotherBoxedA) // true,值相等
}

类型转换

每种数据类型都有下面的这些方法,可以转化为其它的类型:

toByte(): Byte
toShort(): Short
toInt(): Int
toLong(): Long
toFloat(): Float
toDouble(): Double
toChar(): Char

例如:

val b: Byte = 1 // OK, 字面值是静态检测的
val i: Int = b.toInt() // OK

Kotlin条件控制

Kotlin中表达条件控制的有两种表达式

  1. if表达式
  2. when表达式

if表达式的用法

其实个人感觉对于if的用法,java和kotlin并没有什么区别,有点不太一样的就是可以把if表达式的结果赋值给一个变量,如下:

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

所以也就可以有下面这样的写法了

val c = if (condition) a else b

when表达式的用法

when表达式就和java里面的switch类似,最简单的形式如下:

when (x) {
    1 -> print("x == 1")
    2 -> print("x == 2")
    else -> { // 注意这个块
        print("x 不是 1 ,也不是 2")
    }
}

在when语句中,else同switch语句中的default,如果其他分支都不满足条件将会进入else分支,当然,如果很多分支需要相同的处理方式,可以把多个分支条件放在一起,用逗号分隔,例如:

when (x) {
    0, 1 -> print("x == 0 or x == 1")
    else -> print("otherwise")
}

我们也可以检测一个值在(in)或者不在(!in)一个区间或者集合中:

when (x) {
    in 1..10 -> print("x is in the range")
    in validNumbers -> print("x is valid")
    !in 10..20 -> print("x is outside the range")
    else -> print("none of the above")
}

另一种可能性是检测一个值是(is)或者不是(!is)一个特定类型的值。注意: 由于智能转换,你可以访问该类型的方法和属性而无需 任何额外的检测。

fun hasPrefix(x: Any) = when(x) {
    is String -> x.startsWith("prefix")
    else -> false
}

实例:

fun main(args: Array<String>) {
    val x = 0
    if (x > 0) {
        println("x大于0")
    } else if (x == 0) {
        println("x等于0")
    } else {
        println("小于0")
    }

    val a = 1
    val b = 2
    val c = if (a >= b) a else b
    println("c的值为 $c")

    when (x) {
        0, 1 -> println("x==0 or x==1")
        else -> println("otherwise")

    }

    when (x) {
        1 -> println("x==1")
        2 -> println("x==2")
        else -> {
            println("x 不是1,也不是2")
        }
    }

    when (x) {
        in 0..10 -> println("x在该区间范围内")
        else -> println("x不在该区间范围内")
    }
}

Kotlin循环控制

和Java一样,kotlin循环也有三种形式,for循环,while循环和do....while循环。但是用法却有些不同。

for循环

基本用法如下:

for (item: Int in ints) {
    // ……
}

实例如下:

fun main(args: Array<String>) {
    val items = listOf("apple", "banana", "kiwi")
    for (item in items) {
        println(item)
    }

    for (index in items.indices) {
        println("item at $index is ${items[index]}")
    }
}

执行结果如下:

apple
banana
kiwi
item at 0 is apple
item at 1 is banana
item at 2 is kiwi

注意!!

在kotlin中使用的for循环语句和java里面的for循环语句相类似,但是不可以使用 for(int i=0;i<n;i++)这样的语句

while循环和do...while循环

while循环是最基本的循环方式,基本结构为:

while( 布尔表达式 ) {
 //循环内容
}

do...while 循环的基本结构为:

do {
       //代码语句
}while(布尔表达式);

理解起来和Java里面的while循环和do...while循环一致,参考实例如下:

fun main(args: Array<String>) {
    println("----while 使用-----")
    var x = 5
    while (x > 0) {
        println( x--)
    }
    println("----do...while 使用-----")
    var y = 5
    do {
        println(y--)
    } while(y>0)
}

输出结果:

----while 使用-----
5
4
3
2
1
----do...while 使用-----
5
4
3
2
1

循环返回和跳转

Kotlin 有三种结构化跳转的表达式:

  1. return
  2. break
  3. continue 理解起来和Java中的一样,基本用法也一致,但是在kotlin中break和continue有新的用法

Break 和 Continue 标签

在 Kotlin 中任何表达式都可以用标签(label)来标记。 标签的格式为标识符后跟 @ 符号,例如:abc@、fooBar@都是有效的标签。 要为一个表达式加标签,我们只要在其前加标签即可。

loop@ for (i in 1..100) {
    for (j in 1..100) {
        if (……) break@loop
    }
}

标签限制的 break 跳转到刚好位于该标签指定的循环后面的执行点。 continue 继续标签指定的循环的下一次迭代。

通过指定标签就可以明确的指定出在什么时候退出哪一个循环

Kotlin类和对象

Kotlin类中可以包含以下几个东西:

  1. 构造函数和初始化代码块
  2. 成员函数
  3. 属性
  4. 内部类
  5. 对象声明

Kotlin中使用关键字***class***声明类,后面紧跟类名,在类中可以定义成员函数,格式如下:

class Temp{
    //类名为Temp
    //大括号里面是类体构成
    fun f(){
        println("这是成员函数")
    }
}

类的属性

类的属性用关键字***var***声明为可变的,否则就用***val***声明为不可变

class Temp{
    var name: String = ……
    var url: String = ……
    var city: String = ……
}

也可以像使用普通函数那样使用构造函数创建类实例:

val temp= Temp() // Kotlin 中没有 new 关键字

想要使用一个属性,只需要用名称引用即可

temp.name
temp.url

这里需要注意的是,kotlin中并没有new关键字,实例化一个对象的时候不需要像java一样通过new关键字实例化。

getter和setter

getter和setter属性都是可选的,用法和c#中的get和set方法类似 如果属性类型可以从初始化语句或者类的成员函数中推断出来,那就可以省去类型

注意!!! val不允许设置setter函数,因为该函数是只读的。

var allByDefault: Int? // 错误: 需要一个初始化语句, 默认实现了 getter 和 setter 方法
var initialized = 1    // 类型为 Int, 默认实现了 getter 和 setter
val simple: Int?       // 类型为 Int ,默认实现 getter ,但必须在构造函数中初始化
val inferredType = 1   // 类型为 Int 类型,默认实现 getter

实例

下面实例定义了一个Person类,包含两个可变变量 lastName 和 no,lastName 修改了 getter 方法,no 修改了 setter 方法。

class Person {

    var lastName: String = "zhang"
        get() = field.toUpperCase()   // 将变量赋值后转换为大写
        set

    var no: Int = 100
        get() = field                // 后端变量
        set(value) {
            if (value < 10) {       // 如果传入的值小于 10 返回该值
                field = value
            } else {
                field = -1         // 如果传入的值大于等于 10 返回 -1
            }
        }

    var heiht: Float = 145.4f
        private set
}

// 测试
fun main(args: Array<String>) {
    var person: Person = Person()

    person.lastName = "wang"

    println("lastName:${person.lastName}")

    person.no = 9
    println("no:${person.no}")

    person.no = 20
    println("no:${person.no}")

}

输出结果为:

lastName:WANG
no:9
no:-1

Kotlin 中类不能有字段。提供了 Backing Fields(后端变量) 机制,备用字段使用field关键字声明,field 关键词只能用于属性的访问器

主构造器和次构造器

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

class Person constructor(firstName: String) {}

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

class Person(firstName: String) {}

主构造器

主构造器中不能包含任何代码,初始化代码可以当在初始化代码段中,用init关键字作为前缀

class Person constructor(firstName: String) {
    init {
        System.out.print("FirstName is $firstName")
    }
}

实例:

class Runoob  constructor(name: String) {  // 类名为 Runoob
    // 大括号内是类体构成
    var url: String = "http://www.runoob.com"
    var country: String = "CN"
    var siteName = name

    init {
        println("初始化网站名: ${name}")
    }

    fun printTest() {
        println("我是类的函数")
    }
}

fun main(args: Array<String>) {
    val runoob =  Runoob("菜鸟教程")
    println(runoob.siteName)
    println(runoob.url)
    println(runoob.country)
    runoob.printTest()
}

次构造函数

类也可以有二级构造函数,并且可以有多个,需要加前缀constructor

class Person { 
    constructor(parent: Person) {
        parent.children.add(this) 
    }
}

如果类有主构造函数,每个次构造函数都要,或直接或间接通过另一个次构造函数代理主构造函数。在同一个类中代理另一个构造函数使用 this 关键字:

class Person(val name: String) {
    constructor (name: String, age:Int) : this(name) {
        // 初始化...
    }
}

实例:

class Runoob  constructor(name: String) {  // 类名为 Runoob
    // 大括号内是类体构成
    var url: String = "http://www.runoob.com"
    var country: String = "CN"
    var siteName = name

    init {
        println("初始化网站名: ${name}")
    }
    // 次构造函数
    constructor (name: String, alexa: Int) : this(name) {
        println("Alexa 排名 $alexa")
    }

    fun printTest() {
        println("我是类的函数")
    }
}

fun main(args: Array<String>) {
    val runoob =  Runoob("菜鸟教程", 10000)
    println(runoob.siteName)
    println(runoob.url)
    println(runoob.country)
    runoob.printTest()
}

Kotlin继承

kotlin中所有的类都继承Any类,如果一个类要被继承,需要使用open关键字进行修饰

open class Base(p: Int)           // 定义基类

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

构造函数

子类有主构造函数,则基类必须在主构造函数中立即初始化

open class Person(var name : String, var age : Int){// 基类

}

class Student(name : String, age : Int, var no : String, var score : Int) : Person(name, age) {

}

// 测试
fun main(args: Array<String>) {
    val s =  Student("Runoob", 18, "S12346", 89)
    println("学生名: ${s.name}")
    println("年龄: ${s.age}")
    println("学生号: ${s.no}")
    println("成绩: ${s.score}")
}

子类中没有主构造函数

如果子类没有主构造函数,则必须在每一个二级构造函数中用 super 关键字初始化基类,或者在代理另一个构造函数。初始化基类时,可以调用基类的不同构造方法。

/**用户基类**/
open class Person(name:String){
    /**次级构造函数**/
    constructor(name:String,age:Int):this(name){
        //初始化
        println("-------基类次级构造函数---------")
    }
}

/**子类继承 Person 类**/
class Student:Person{

    /**次级构造函数**/
    constructor(name:String,age:Int,no:String,score:Int):super(name,age){
        println("-------继承类次级构造函数---------")
        println("学生名: ${name}")
        println("年龄: ${age}")
        println("学生号: ${no}")
        println("成绩: ${score}")
    }
}

fun main(args: Array<String>) {
    var s =  Student("Runoob", 18, "S12345", 89)
}

重写

如果允许子类重写,那么就要手动添加open修饰,重写的方法用override关键词修饰:

/**用户基类**/
open class Person{
    open fun study(){       // 允许子类重写
        println("我毕业了")
    }
}

/**子类继承 Person 类**/
class Student : Person() {

    override fun study(){    // 重写方法
        println("我在读大学")
    }
}

fun main(args: Array<String>) {
    val s =  Student()
    s.study();

}

如果有多个相同的方法(继承或者实现自其他类,如A、B类),则必须要重写该方法,使用super范型去选择性地调用父类的实现。

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

interface B {
    fun f() { print("B") } //接口的成员变量默认是 open 的
    fun b() { print("b") }
}

class C() : A() , B{
    override fun f() {
        super<A>.f()//调用 A.f()
        super<B>.f()//调用 B.f()
    }
}

fun main(args: Array<String>) {
    val c =  C()
    c.f();

}

Kotlin接口

在kotlin中接口和java8中的用法类似,都是用interface关键字定义接口,允许有默认方法的实现。

接口中的方法

实例:

interface MyInterface {
    fun bar()
    fun foo() {
        // 可选的方法体
        println("foo")
    }
}
class Child : MyInterface {
    override fun bar() {
        // 方法体
        println("bar")
    }
}
fun main(args: Array<String>) {
    val c =  Child()
    c.foo();
    c.bar();
}

接口中的属性

接口中的属性只能是抽象的,不允许初始化值,接口不会爆粗 属性值,实现接口的时候,必须重写属性。 实例:

interface MyInterface {
    var name:String //name 属性, 抽象的
    fun bar()
    fun foo() {
        // 可选的方法体
        println("foo")
    }
}
class Child : MyInterface {
    override var name: String = "runoob" //重载属性
    override fun bar() {
        // 方法体
        println("bar")
    }
}
fun main(args: Array<String>) {
    val c =  Child()
    c.foo();
    c.bar();
    println(c.name)
 
}

函数重写

接口中的方法的重写和继承类中的方法重写类似,实例如下:

interface A {
    fun foo() { print("A") }   // 已实现
    fun bar()                  // 未实现,没有方法体,是抽象的
}
 
interface B {
    fun foo() { print("B") }   // 已实现
    fun bar() { print("bar") } // 已实现
}
 
class C : A {
    override fun bar() { print("bar") }   // 重写
}
 
class D : A, B {
    override fun foo() {
        super<A>.foo()
        super<B>.foo()
    }
 
    override fun bar() {
        super<B>.bar()
    }
}
 
fun main(args: Array<String>) {
    val d =  D()
    d.foo();
    d.bar();
}

开发IDE : IDEA / Android Studio
参考:Kotlin 语言中文站