Kotlin系列一(基本语法)

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/yangyin3096/article/details/79955610

前言

Google在2017年的IO大会上宣布,将Kotlin编程语言定义为Android开发的官方语言,作为一名Android开发者,我们必须尽快了解和使用Kotlin语言。

不过Kotlin毕竟是语言级别的新事物,比起Java来说,从编程思想到代码细节都有不少变化。学习一门语言,我们最好先对这门语言有个整体的基本的了解,然后再去学习和使用,这样才能高效地掌握这门语言。

Kotlin的出现

Kotlin是基于JVM设计的编程语言,算是Java的改良版语言,它是一个开源项目的成果,拥有很高的声望,很多公司、组织、业界大犇都很喜欢她,Square公司的Jake大神(Dagger、ButterKnife、Retrofit、OkHttp…之父)就专门写了篇Using Project Kotlin for Android为Kotlin站台。

相对Java来说,Kotlin在编写代码时有如下优势:代码简洁高效、函数式编程、空指针安全、支持lambda表达式、流式API等。在执行效率上,Kotlin和Java具有同样的理论速度(都是编译成JVM字节码)。

另外,Kotlin和Java是互相完美兼容的,两种代码文件可以并存,代码可以互相调用、文件可以互相转换,库文件也可以无障碍地互相调用,使用Kotlin基本不会带来额外的成本负担。

Kotlin的特点

Kotlin作为Java的改良,在Android开发中有很多优势:

1)简化findViewById

我们知道,Android的架构里,xml布局文件和Activity是松耦合的,Activity中要使用界面元素,必须借助R文件对xml控件的记录,用findViewById找到这个元素。
Kotlin提供一种激进的方法,通过在gradule中引用applyplugin:’kotlin-android-extensions’,彻底取消findViewById这个函数,在Activity中可以直接根据id使用界面元素。

2)没有“;”

在Kotlin语法里,代码行不需要用“;”结尾,什么都不写就好

3)重要的“:”

在Java里,“:”主要在运算符里出现(for/switch/三元运算符等)。
在Kotlin里,“:”的地位大大提升了,它的用途非常广泛,包括:
定义变量类型:
var name: String = “my name” //变量name为String类型

定义参数的类型:

fun makeTool(id: Int){ //参数id为Int类型

}

定义函数的返回值:

fun getAddr(id: Int):String{ //返回值为String类型

}

声明类/接口的继承:

class KotlinActivityUI: AnkoComponent{//继承AnkoComponent接口

使用Java类:

val intent = Intent(this, MainActivity::class.java) //需要用::来使用Java类,注意是两个“”

4)没有“new”

Kotlin实例化一个对象时不需要new关键字

var list = ArrayList()

5)变量、常量、类型推断

用var定义变量

var name: String = “my name”

用val定义常量(相当于final)

val TAG: String = “ClassName”

上面两个例子用:String来定义了数据类型,这个是可以省略的,Kotlin支持类型推断,这两句话你可以写成

var name = “my name”
val TAG = “ClassName”

6)初始化和延迟加载

在Java里,我们定义一个变量,可以不赋值(int和boolean会有默认值),但是Kotlin里必须为变量赋值,如果只写一个变量,却不赋值,像下面这样:
var name
编译器会报错,提示你未初始化,你必须赋值为0或者null,或者别的什么值。

不过,我们有时候就是不能在定义变量时就初始化它,比如在Android中我们经常预定义一个View控件而不初始化,但是直到onCreate或onCreateView时才初始化它。
针对这种情况,Kotlin提供了懒加载lazy机制来解决这个问题,在懒加载机制里,变量只有在第一次被调用时,才会初始化:
val对象,使用lazy懒加载,
var对象,使用lateinit延时加载

7)空指针安全

在Kotlin里,可以用“?”表示可以为空,也可以用“!!”表示不可以为空。

空指针安全并不是不需要处理空指针,你需要用“?”声明某个变量是允许空指针的,例如:
var num: Int? =null
声明允许为空时,不能使用类型推断,必须声明其数据类型

空指针虽然安全了,但对空指针的处理还是要视情况而定,有时候不处理,有时候做数据检查,有时候还需要抛出异常,这三种情况可以这样写:

val v1 = num?.toInt() //不做处理返回 null

val v2 = num?.toInt() ?:0 //判断为空时返回0

val v3 = num!!.toInt() //抛出空指针异常(用“!!”表示不能为空)

更多空指针异常处理,有一篇NullPointException 利器 Kotlin 可选型介绍的比较全面,值得借鉴

8)定义函数

在Kotlin语法里,定义函数的格式是这样的
fun 方法名(参数名:类型,参数名:类型…) :返回类型{

}

所以,一般来说,函数是这样写的
fun getAddress(id:Int,name:String): String{
return “got it”
}

由于Kotlin可以对函数的返回值进行类型推断,所以经常用“=”代替返回类型和“return”关键字,上面这段代码也可以写成
fun getAddress(id: Int, name: String) = { //用“=”代替return,返回String类型则交给类型推断
“got it” //return被“=”代替了
}

如果函数内代码只有一行,我们甚至可以去掉{}
fun getAddress(id:Int,name:String) = “got it” //去掉了{}

函数也允许空指针安全,在返回类型后面增加“?”即可
fun getAddress(id:Int,name:String) : String? = “got it”

有时候,函数的返回类型是个Unit,这其实就是Java中的void,表示没有返回
fun addAddress(id: Int, name: String): Unit{ //相当于java的void

}

不过,在函数无返回时,一般不写Unit
fun addAddress(id: Int, name: String){ //相当于java的void

}

9)用is取代了instance of

代码很简单
if(obj is String)…

10)in、区间和集合

Kotlin里有区间的概念,例如1..5表示的就是1-5的整数区间

可以用in判断数字是否在某个区间
if(x in 1..5){ …//检查x数值是否在1到5区间

可以用in判断集合中是否存在某个元素
if(name in list){…//检查list中是否有某个元素(比Java简洁多了)

可以用in遍历整个集合
for(i in 1..5){ …//遍历1到5
for(item in list){…//遍历list中的每个元素(相当于Java的for(String item : list))

另外,in在遍历集合时功能相当强大:
在遍历集合时,可以从第N项开始遍历
for(i in 3..list.size-2){…相当于for (int i = 3; i <= list.size()-2; i++)

可以倒序遍历
for(i in list.size downTo 0) {…相当于for (int i = list.size(); i >= 0; i–)

可以反转列表
for(i in (1..5).reversed())

可以指定步长
for(i in 1.0..2.0 step 0.3) //步长0.3

Kotlin里的集合还都自带foreach函数
list.forEach {…

11)用when取代了switch

switch在Java里一直不怎么给力,在稍老一些的版本里,甚至不支持String,Kotlin干脆用强大的when取代了switch

12)字符串模板

在Java里使用字符串模板没有难度,但是可读性较差,代码一般是
MessageFormat.format(“{0}xivehribuher{1}xhvihuehewogweg”,para0,para2);

在字符串较长时,你就很难读出字符串想表达什么,在kotlin里,字符串模板可读性更好
para0xivehribuher{para1}xhvihuehewogweg”

13)数据类

数据类是Kotlin相对Java的一项重大改进,我们在Java里定义一个数据Model时,要做的事情有很多,例如需要定义getter/setter(虽然有插件代写),需要自己写equals(),hashCode(),copy()等函数(部分需要手写),但是在Kotlin里,你只需要用data修饰class的一行代码

data class Client(var id: Long, var name: String, var birth: Int, var addr: String)

Kotlin会自动帮你实现前面说的那些特性。

数据模型里经常需要一些静态属性或方法,Kotlin可以在数据类里添加一个companion object(伴随对象),让这个类的所有对象共享这个伴随对象(object在Kotlin中用来表示单例,Kotlin用Any来表示所有类的基类)

14)单例模式

单例是很常见的一种设计模式,Kotlin干脆从语言级别提供单例,关键字为object,如果你在扩展了Kotlin的IDE里输入singleton,IDE也会自动帮你生成一个伴随对象,也就是一个单例

如果一个类需要被定义为class,又想做成单例,就需要用上一节中提到的companion object

15)为已存在的类扩展方法和属性

为了满足开放封闭原则,类是允许扩展,同时严禁修改的,但是实现扩展并不轻松,在Java里,我们需要先再造一个新的类,在新类里继承或者引用旧类,然后才能在新类里扩展方法和属性,实际上Java里层层嵌套的类也非常多。

在Kotlin里,这就简洁优雅地多,她允许直接在一个旧的类上做扩展,即使这是一个final类。

例如,Android中常见的Toast,参数较多,写起来也相对繁琐,我们一般是新建一个Util类去做一个相对简单的函数,比如叫做showLongToast什么的,我们不会想在Activity或Fragment中扩展这个函数,因为太麻烦,我们需要继承Activity做一个比如叫ToastActivity的类,在里面扩展showLongToast函数,然后把业务Activity改为继承这个ToastActivity…

16)类的家族结构

Kotlin关于类的家族结构的设计,和Java基本相似,但是略有不同:

Object:取消,在Java里Object是所有类的基类,但在Kotlin里,基类改成了Any

Any:新增,Kotlin里所有类的基类

object:新增,Kotlin是区分大小写的,object是Kotlin中的单例类

new:取消,Kotlin不需要new关键字

private: 仍然表示私有

protected: 类似private,在子类中也可见

internal: 模块内可见

inner:内部类

public: 仍然表示共有,但是Kotlin的内部类和参数默认为public

abstract:仍然表示抽象类

interface:仍然表示接口

final:取消,Kotlin的继承和Java不同,Java的类默认可继承,只有final修饰的类不能继承;Kotlin的类默认不能继承,只有为open修饰的类能继承

open:新增,作用见上一条

static:取消!Java用static去共享同一块内存空间,这是一个非常实用的设计,不过Kotlin移除了static,用伴随对象(前面提到过的compaion object)的概念替换了static,伴随对象其实是个单例的实体,所以伴随对象比static更加灵活一些,能去继承和扩展。

继承:在Kotlin里,继承关系统一用“:”,不需要向java那样区分implement和extend,在继承多个类/接口时,中间用“,”区分即可,另外,在继承类时,类后面要跟()。所以在Kotlin里,继承类和接口的代码一般是这样的:

class BaseClass: Activity(), IBinder{ //示例

17)构造函数

在Java里,类的构造函数是这样的

public 类名作为函数名 (参数) {…}

Java里有时会重载多个构造函数,这些构造函数都是并列的

在Kotlin里,类也可以有多个构造函数(constructor),但是分成了1个主构造函数和N个二级构造函数,二级构造函数必须直接或间接代理主构造函数,也就是说,在Kotlin里,主构造函数有核心地位

主构造函数一般直接写在类名后面,像这么写

class ClientInfo(id: Long, name: String, addr: String){

这其实是个缩写,完全版本应该是

class ClientInfo constructor(id: Long, name: String, addr: String){

主构造函数的这个结构,基本决定了,在这个主构造函数里,没法写初始化代码…

而二级构造函数必须代理主构造函数,写出来的效果是这样的二级构造函数

18)初始化模块init

上一节提到过,主构造函数里不能写代码,这就很麻烦了,不过还好,Kotlin提供了初始化模块,基本上就是用init修饰符修饰一个{},在类初始化时执行这段儿代码

19)其他

Kotlin还有很多其他的语言特性,本文主要是为了建立对Kotlin的大概印象,更多细节就不再列举了,建议仔细阅读Kotlin官方文档,并且多动手写一些代码。

部分代码

新建类:

定义类使用class关键字

//类名称是KotlinDemo.kt
class KotlinDemo {

}

定义方法:

定义方法使用fun关键字

//无参 无返回值
fun method1() {
    //方法体
}

//有参(一个Int类型,一个String类型参数),无返回值
fun method2(i: Int, s: String) {
    //方法体
}

//有参,有返回值(Int类型返回值)
fun method3(i1: Int, i2: Int): Int {
    return i1 + i2
}

//有参,有返回值(没有方法体,直接在方法上返回)
fun method4(i1: Int, i2: Int): Int = i1 + i2

定义常量:

变量用val声明

//常量名称:TAG,数据类型:String
val TAG: String = "MainActivity"

定义变量:

变量用var声明

//变量名称:value, 数据类型:Int
var value: Int
value = 1

比较运算符:

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

fun method2() {
   val a = 1
   val b = 1
   val c = 2
   val d = 2
   Log.d(TAG, "a == b : ${a == b}") //打印结果 true
   Log.d(TAG, "a == c : ${a == c}") //打印结果 false
   Log.d(TAG, "a != c : ${a != c}") //打印结果 true
   Log.d(TAG, "a == b || a == c : ${a == b || a == c}") //打印结果 true
   Log.d(TAG, "a == c || b == d : ${a == c || b == d}") //打印结果 false
   Log.d(TAG, "a == b && c == d : ${a == b && c == d}") //打印结果 true
   Log.d(TAG, "a == b && a == c : ${a == b && a == c}") //打印结果 false

   val aa = "hello"
   val bb = "hello"
   val cc = "world"
   val dd = "world"
   Log.d(TAG, "aa === bb : ${aa === bb}") //打印结果 true
   Log.d(TAG, "aa === cc : ${aa === cc}") //打印结果 false
   Log.d(TAG, "aa !== cc : ${aa !== cc}") //打印结果 true
   Log.d(TAG, "aa === bb || aa === cc : ${aa === bb || aa === cc}") //打印结果 true
   Log.d(TAG, "aa === cc || bb === dd : ${aa === cc || bb === dd}") //打印结果 false
   Log.d(TAG, "aa === bb && cc === dd : ${aa === bb && cc === dd}") //打印结果 true
   Log.d(TAG, "aa === bb && aa === cc : ${aa === bb && aa === cc}") //打印结果 false
}

创建数组:

//创建Int类型数组
val arr: IntArray = intArrayOf(11, 12, 13)

数组遍历:

//数组遍历方式一
for (index in arr.indices) {
    Log.d(TAG, "index:$index,arr[index]:${arr[index]}")
}

//数组遍历方式二
for (value in arr) {
    Log.d(TAG, "value:$value")
}

//数组遍历方式三
for ((index, value) in arr.withIndex()) {
    Log.d(TAG, "index:$index, value:$value")
}

//数组遍历方式四
arr.forEach {
    Log.d(TAG, "forEach,value:$it")
}

创建集合:

//创建ArrayList集合
var dataList = ArrayList<DataBean>()
for (i in 0..20){
   dataList.add(DataBean("TestDat:$i"))
}

集合遍历:

//集合遍历方式一
for (index in dataList.indices) {
    Log.d(TAG, "index:$index,arr[index]:${dataList[index]}")
}

//集合遍历方式二
for (value in dataList) {
    Log.d(TAG, "value:$value")
}

//集合遍历方式三
for ((index, value) in dataList.withIndex()) {
    Log.d(TAG, "index:$index, value:$value")
}

//集合遍历方式四
dataList.forEach {
    Log.d(TAG, "forEach,value:$it")
}

循环语句:

//在02范围内递增循环
for (i in 0..2) {
    //在20范围内递减循环
    for (j in 2 downTo 0) {
        Log.d(TAG, "i:$i, j:$j")
    }
}

when语句:

//匹配具体的值
val a = 1
when (a) {
    1 -> Log.d(TAG, "a is:$a")
    11 -> Log.d(TAG, "a is:$a")
    else -> Log.d(TAG, "default") //以上匹配不为真默认执行的语句
}

//匹配范围
val a = 4
when (a) {
    in 1..5 -> Log.d(TAG, "$a in 1..5")
    !in 1..5 -> Log.d(TAG, "$a !in 1..5")
    else -> Log.d(TAG, "default") //以上匹配不为真默认执行的语句
}

//匹配数据类型
val a: Any = 4
when (a) {
    is String -> Log.d(TAG, "a is String")
    is Int -> Log.d(TAG, "a is Int")
    else -> Log.d(TAG, "default") //以上匹配不为真默认执行的语句
}

类的继承:

//父类
open class SuperClass {
    fun method() {

    }
}

//继承SuperClass
class SubClass: SuperClass() {
    fun method2() {
        //调用父类的方法
        super.method();
    }
}

定义接口,和接口的抽象方法:

interface SuperInterface {
    //接口的抽象方法
    fun method()
}

接口的实现:

//定义接口
interface SuperInterface {
    //接口的抽象方法
    fun method()
}

//实现SuperInterface
class SubClass: SuperInterface {
    //实现接口的方法
    override fun method() {
        //方法体

    }
}

类的构造方法:

class SubClass(i: Int, s: String) {
    private var mI: Int = i
    private var mS: String = s
}

data class:

//数据类
data class DataBean(var name: String)

//添加数据
DataBean("TestData")

//获取数据
DataBean.name
阅读更多
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页