Kotlin也没那么难(一)

微信扫一扫,分享到朋友圈

Kotlin也没那么难(一)
do not speak,show my code...

基本概念

函数

kotlin:
fun functionName(parameter1: Int, parameter2: Int): Int {
    //该函数返回两者最大值
    return if (parameter1 > parameter2) parameter1 else parameter2
}
java:
Integer functionName(Integer parameter1, Integer parameter2) {
    //该函数返回两者最大值
    return parameter1 > parameter2 ? parameter1 : parameter2;
}

要点:

  1. kotlin中没有基本数据类型(int,float等),都是以对象形式存在(Int,Float),kotlin也没有数组,以Array类存在
  2. kotlin以 fun 关键字开头,而java以 返回类型 开头,kotlin的 返回类型:返回类型 的形式衔接在函数声明括号后
  3. kotlin的所有变量声明都是 变量名: 变量类型 ,java则是 变量类型 变量名
  4. kotlin也有三目运算符,不过写法是 if (表达式) 表达式正确时的值 else 表达式错误时的值 ,java则是 表达式 ? 表达式正确时的值 : 表达式错误时的值
  5. kotlin语句末尾可以省略分号

表达式函数体

kotlin中if是表达式,而不是语句。语句是没有自己的值,而表达式是有值的。表达式可以作为其他表达式的一部分也可以作为函数的返回值。在kotlin中除了循环(for、do、while)以外大多数控制结构都是表达式。

所以上面的函数就可以简化成以下代码:

fun functionStruct(parameter1: Int, parameter2: Int) = 
  if (parameter1 > parameter2) parameter1 else parameter2

细心的朋友可能发现了上面的函数没有声明返回类型,因为对于返回一个表达式的函数来说,编译器会自动分析返回类型,术语叫 类型推导

变量

kotlin不会以变量类型开头,因为有些的变量声明的类型是可以省略的

var number0 = 100
val number1 = 100
val number2 : Int = 100
val number3 //编译不通过
val number4 : Int //编译不通过

var表示该变量是可变变量,可以重新赋值

val表示该变量是不可变变量,不可以重新赋值

字符串模板 "...${变量}..."

eg: var age = "my age is ${number0}" ,这种情况下大括号可以省略

如果是java会写成
String age = "my age is " + number0;

eg: "...${list.get(0)}..." 这个时候大括号不能省

类和属性

kotlin中默认public修饰符

kotlin定义一个类最简单的方法就是
class People(var name: String, val age: Int)

以上代码定义了一个People类,该类有两个属性name和age

由于name被var修饰,所以kotlin会为name创建一个getter和一个setter方法

由于age被val修饰,所以kotlin会为name创建一个getter方法

使用起来很简单

val my = People("name", 20)
my.name = "new Name"
println("my name is ${my.name} and my age is ${my.age}")

要点:

  1. kotlin创建对象是 Xxx() ,java是** new Xxx();**
  2. kotlin调用属性的getter方法直接 xxx.property
  3. kotlin调用属性的setter方法直接 xxx.property = value

注意:

如果写成 class People(name: String, age: Int) ,即省略了var和val,则这两个变量都只是构造函数用的临时变量,也就是说kotlin不会再自动给People类创建name和age变量

自定义getter和setter方法

class People(var name: String, val age: Int) {
    var desc: String = "这是我的个人描述"
        get() {
            print("调用了getter方法")
            return "my name is $name and my age is $age"
        }
        set(value) {
            print("调用了setter方法")
            field = value
        }
}

需要注意的是这里有个 field 变量,这个变量术语叫做 幕后变量 ,这个后面我们会深入了解,这里只需要知道把要更新的值赋予给该变量就OK啦

目录和包

kotlin的包声明形式和java一样: package com.example.ice.kotlindemo ,不过有意思的是kotlin不强制包声明和文件路径一致,也就是说该kotlindemo.kt文件不必强制放在com/example/ice/目录下。

kotlin文件可以同时声明多个类,甚至还可以声明函数和变量!java中只能在类中声明函数,并且一个java文件只能有一个 public class 的而且该class类名还必须和文件名一致

枚举和When

enum

enum class Color {
    BLUE, RED, GREEN
}

kotlin中enum是 软关键字 ,只有出现在class面前才有特殊意义,其他情况你甚至可以当一个变量使用 val enum: Color = Color.BLUE

when

when有点类似java中的switch,但是when是表达式

kotlin:
fun testWhen(enum: Color) =
        when (enum) {
            Color.BLUE -> "blue"
            Color.RED -> "red"
            Color.GREEN -> "green"
            else -> "default"
        }
java:
public String testWhen(Color color) {
    String returnValue;
    switch (color) {
        case RED:
            returnValue = "red";
            break;
        case BLUE:
            returnValue = "blue";
            break;
        case GREEN:
            returnValue = "green";
            break;
        default:
            returnValue = "default";
            break;
    }
    return returnValue;
}

要点:

  1. when不用java中的 break
  2. when用 -> 替代 java中的 case
  3. when用 else 替代java中的 default
  4. when是表达式不是语句块

在when分支上合并多个选项

when (enum) {
    Color.BLUE, Color.RED -> "blue or red"
    Color.GREEN -> "green"
    else -> "default"
}

when结构中可以使用任意对象

var people1: People = People("name1", 20)
var people2: People = People("name2", 20)
fun testWhen2(people: People) =
        when (people) {
            people1 -> "is people1"
            people2 -> {
                "is people2"
            }
            else -> "no match"
        }

要点:

  1. when表达式会把最后一行代码的结果当为返回值(见people2的情况,没有写return,但是会返回”is people2″)
  2. when表达式某种情况下只有返回语句可以省略大括号(见people1的情况)

不带参数的when

fun testWhen3() =
        when {
            1 > 2 -> print("1 > 2")
            2 > 1 -> print("2 > 1")
            else -> throw ArithmeticException("error")
        }

类型转换

kotlin使用 is 代替java的 instanceof 进行类型判断

kotlin使用
as 进行显示转换
var num = 100 as Float

注意:as也可以用于导入语句 import xxx.xxx.People as P 这样P就代表了People

循环

kotlin的循环比较于java来说没有很大的改变,但是多了一些关键字需要我们注意

var i = 0
for (i in 0..100) { //打印 01234..100
//for (i in 0 until 100) { //打印 01234..99
//for (i in 100 downTo 0 step 2) { //打印 1009896..0
    print(i)
}

in 常常用来迭代list或map

val list = listOf(1, 2, 3)
for (i in list) {
    print(i)
}

kotlin中使用 listOf 方法可以创建一个list

如果你想迭代list的同时获取当前的index,可以使用如下写法
for ((index, value) in list.withIndex()) {
//(index,value)的写法专业术语叫做解构声明,后面我们会深入了解
    print("index = $index and value = $value")
}

in 也可以用来判断对象是否在集合中

if (2 in list) {
    print("2 exist in list")
}

!in 关键字

Emm,这个看前面一个 ! 就知道是和 in 相反的结果了

try catch finally

  1. kotlin没有 throws 关键字(想起java被throws支配的恐惧了么)
  2. try也是一个表达式
val myAge = try {
    1 / 0
} catch (e: Exception) {
    print(e)
} finally {
    100
}

函数

集合创建

listOf(1, 2, 3)
mutableListOf(1, 2, 3)

setOf(1, 2, 3)
mutableSetOf(1, 2, 3)

mapOf(1 to "1", 2 to "2", 3 to "3")
mutableMapOf(1 to "1", 2 to "2", 3 to "3")

有mutable前缀的方法创建的集合,元素是可以增添、移除、修改的

默认参数

fun defaultParaFun(para1: Int = 0, para2: Int, para3: Int) = para1 + para2 + para3
defaultParaFun(para2 = 2, para3 = 4)

我们给参数para1设置了默认值0

在调用该函数的时候我们对传入的值进行了显示的声明参数,比如2就是参数para2的值,3就是参数para3的值,此时函数返回值为5(0+2+3)

有意思的是如果我们给所有参数都加默认值:

fun defaultParaFun(para1: Int = 0, para2: Int = 1, para3: Int = 2) = para1 + para2 + para3
defaultParaFun() // 0+1+2
defaultParaFun(para3 = 5) // 0+1+5
defaultParaFun(para2 = 5) // 0+5+2
defaultParaFun(para1 = 5, para2 = 5) // 5+5+2

同时java是不支持默认参数的,所以我们可以给方法加上@JvmOverloads注解。这样的话kotlin编译器会将该方法生成一系列重载方法

result.png

由于我这个例子中 defaultParaFun 是直接写在 KotlinDemo.kt 文件中的(术语叫顶级函数),所以java调用要使用 KotlinDemoKt.defaultParaFun 形式,顶级函数是不是很像java中的静态函数(kotlin是没有static关键字的!)?

扩展函数

fun Int.add2(): Int {
    return this + 2
}
print(0.add2())

要点:

  1. 我们定义了一个add2函数用于将一个 数+2 并返回
  2. add2函数面前使用 Int. 表示该函数是对Int类的扩展(就像是Int类本身的方法一样)
  3. add2函数体内的this其实就是调用该方法的对象(本例中this就是0)
  4. this可以省略,就变成了 return +2
  5. java中调用就得写成 KotlinDemoKt.add2(0) 其实就是被编译成了静态函数
  6. 如果Int类也有add2则优先调用Int类的add2函数,即成员方法优先调用
  7. 如果子类和基类有同名的扩展函数,调用哪个扩展函数由调用对象的声明类型决定
  8. 除了有扩展函数也有扩展属性,不过扩展属性必须要有getter函数,同时也不能初始化

可变参数

fun varargFun(vararg list: Int) {
    print(list[0])
}
fun varargFun2(array: Array) {
    listOf(*array)
}
varargFun(1, 2, 3)

vararg关键字表示该参数是可变参数

*关键字是展开运算符,在该例中把array展开为多个对象并用于构造list

中缀调用

细心的朋友可能看到了之前我们定义map时用的是
mapOf(1 to "1", 2 to "2", 3 to "3")

这里的 to 其实就是中缀调用,实际上就是一个to函数,中缀调用就是把方法名称放在两个参数中间,记得空格

我们可以看源码
infix fun A.to(that: B): Pair = Pair(this, that)

其中尖括号里的是泛型,Pair是一个有两个成员变量的类(一个叫first一个叫second)

我们先把infix关键字盖住,其实这就是一个扩展函数对不对!

我们在加上infix关键字,这个扩展函数就可以中缀调用了

需要注意的是,infix只能用于只有一个参数的函数上

解构声明

val (para1, para2) = 1 to "1"

在这个例子中,para1就是1,para2就是”1″

其实我们在之前循环的章节就有用到过解构声明

for ((index, value) in list.withIndex()) {
    print("index = $index and value = $value")
}

解构声明不仅可以用在Pair和List也可以用在Map,我们会在后面的文章中深入了解解构规则

字符串

var string1 = "\"
var string2 = """"""

其实string1和string2都是表示

只不过普通的字符串包含转义, 就是个转义字符,所以 \ 才能代表

而在多重引号字符串中就不包含转义,所以可以直接用 来表示

注:多重引号字符串用来写正则特别方便

局部函数

这是我最喜欢的语法糖之一:函数里可以再定义函数

fun outer(){
    print("outer invoke")
    fun inner(){
        print("inner invoke")
    }
    inner()
}

局部函数中可以访问外部函数中的所有参数和变量(记得定义在局部函数之前哦)!

结语

通过本篇文章的学习我们已经算 入门kotlin 了,下篇文章我会写 类和接口,lambda编程以及可空性 相关。基本上这两篇文章内容熟练掌握就可以应对开发需求,之后会有篇幅讲Kotlin的高阶使用:反射、泛型等。

最后祝大家国庆Happy~

微信扫一扫,分享到朋友圈

Kotlin也没那么难(一)

小钢炮 Plus!Phanteks MG 210G 装机作业

上一篇

绕开引流难关,前期布局公众号,实现后期躺赚日入700+

下一篇

你也可能喜欢

Kotlin也没那么难(一)

长按储存图像,分享给朋友