原文地址:https://juejin.im/post/595360495188250d9017dfd3
作者介绍:刘高轩,美团点评Android工程师,2年Android开发经验,现在是美团点评点餐团队的一员。
前言
本文主要介绍了新晋Android官方开发语言Kotlin的语法基础和实用特性,并加以简单的快速实践,给出了Kotlin相比Java的开发效率优势,非常适合对Kotlin感兴趣的Android开发人员进行阅读。
本文较长(6000字左右),建议阅读时间: 30min+
目录
- 1 背景
- 2 语法速看
- 2.1 变量类型与符号
- 2.2 函数与方法
- 2.3 类与继承
- 2.4 逻辑语句
- 3 实用特性
- 3.1 空指针安全
- 3.2 扩展方法和属性
- 3.3 简洁数据类
- 3.4 Anko
- 4 快速实践
- 4.1 配置AS
- 4.2 Demo
- 5 结语
背景
今年的Google I/O 2017,Kotlin正式成为Android的官方开发语言。这门被称为“The Swift of Android”的语言(具体对比可参考Swift is like Kotlin),自Jetbrains推出至今已有六年时间,而首个官方稳定版本却是去年2月才发布的。也正是从去年开始,Kotlin的使用度迎来了爆炸式的增长,这里有一张官方的GIF图可以看出其2016年的发展速度。
Kotlin好处都有啥?谁说对了都给他。作为一个旨在取代Android开发人员基数众多的Java语言的新兴语言,完全与Java老大哥割裂开,那日后的推广肯定是步履维艰。Kotlin巧妙地作为一个静态JVM语言诞生,与Java完全兼容,又比Java要更加简洁,同时也处理了让无数开发者头疼的NullPointerException问题,显得很有吸引力。对于一个有经验的Android开发者来说,学习Kotlin的曲线相当平缓,可以几乎零成本去改造已有Android项目的部分代码。面对这充满了新特性的语言,谁会不动心呢?
Kotlin语言主要有以下几个特点:
- 高度兼容Java:Kotlin也可以调用传统Java语言的各种类库。由于最终都是编译为JVM字节码运行,Kotlin可以与Java存在于同一个项目中,互相调用。开发者可以部分改造项目中的代码,尝试其新语言特性。官方提供Java代码到Kotlin代码的转换工具。开发者可以把现有的Java/Android项目一键转换为Kotlin项目,实现零成本的改造。
- 代码简洁高效:语法精炼,无处不在的类型推断,自动生成通用方法,支持Lamda表达式,使Kotlin的代码行数远低于传统Java代码。而代码量的压缩,客观上会提高开发效率。
- 空指针安全:通过符号“?”定义对象的nullable,让开发者不用为了避免NPE而写太多防御性代码。
- 函数式编程:支持让函数作为参数或者返回的高阶函数用法,支持流式API,支持扩展方法。
2 语法速看
2.1 变量、类型与符号
基础类型
java中存在int,float,boolean等基础类型,这些基础类型在Kotlin里将全部以对象的形式继续存在。随之而来使用上也发生一些变化,有几点需要注意下:
// Int无法自动转换为Double, 需要自己先做类型转换(as Double, toDouble(), 方式很多)
var a: Int = 2
var b: Double = a.toDouble()
// Char不能直接等值于其对应的ASCII码值,需要类型转换
var c: Char = 'a'
var ca: Int = c.toInt()
变量声明
Kotlin中使用var定义变量(和js很像),使用val定义常量(相当于java当中的final)。定义变量时既可以指定类型,也可以不指定,Kotlin支持类型推断。
var name = "me" // 类型为String
var name: String = "me" // 类型为String
val TAG: String = "KotClassA"
需要注意的是,你不能直接写一个var num丢在代码里不初始化值,编译器会无法推断它的类型
var name // 编译器报错
var name: String // 类型为String
行尾标识
与Java中以“;”符号区分每行的结尾不同,Kotlin中不再需要在每行代码的结束位置写“;”。当然如果你一时改不了写Java时的习惯,IDE也并不会报错,只会友好地把“;”置灰并下划线,提示你这是多余之举。
类型声明
Java语言中,“:”符号主要出现于三元运算符“A ? B : C”中,for循环时遍历列表项和switch的每种情形分支。而在Kotlin语言中,“:”被广泛用于变量类型的定义。
// 定义变量类型
fun common() {
var ka: KClassA
var kb: KClassB
}
// 定义函数的参数和返回值
fun helloStr(str: String): String {
var strHello: String = "hello"
strHello += str
return strHello
}
“:”还被用于声明类继承或接口实现。
interface KInterfaceA {
...
}
open class KClassA(n: Int): KInterfaceA {
...
}
class KClassB(n: Int): KClassA(n) {
...
}
此外,如果你想在Kotlin代码中使用Java类,也需要用到“:”符号。连续两个“:”表明对Java类的调用。
val intent = Intent(this, MainActivity::class.java)
类型检测
Java语言中使用instanceof来判断某变量是否为某类型,而Kotlin中使用更短小更直观的is来进行类型检测。
if (num instanceof Double) { ... } // Java代码
if (num is Double) { ... } // Kotlin代码
字符串模板
Java中使用字符串模板会比较麻烦,而且不太直观。而Kotlin里使用则异常便捷好用。
// Java中字符串模板两种常用形式
String name = "我";
int age = 25;
String.format("%s今年%d岁", name, age);
MessageFormat.format("{0}今年{1}岁", name, age);
// Kotlin中更直观的字符串模板形式
var name = "我"
var age = 25
"${name}今年${age}岁"
2.2 函数与方法
Kotlin中的函数通过关键字fun定义的,具体的参数和返回值定义结构如下。
fun test(para1: Int, para2: String): String { ... }
Kotlin中的函数可以是全局函数,成员函数或者局部函数,甚至还可以作为某个对象的扩展函数临时添加,这个作为Kotlin的一大实用特性,下文会有具体讲解。
Kotlin函数参数还有默认值和可变参数的特性,分别来看一下:
对Kotlin函数中的某个参数可以用“=”号指定其默认值,调用函数方法时可不不传这个参数,但其他参数需要用“=”号指定。下文例子中没有传递参数para2,其实际值为默认值"para2"
fun test(para1: Int, para2: String = "para2", para3: String): String { ... }
test(22, para3 = "hello")
可变参数值的话,需要用关键字vararg来定义。这里需要注意的是,一个函数仅能有一个可变参数。该可变参数不一定得是最后一个参数,但当这种情况下时,调用该方法,需要给其他未指明具体值的参数传值。
fun test(vararg para1: String, para2: String): String { ... }
test("para1", "para4", "para5", para2 = "hello")
2.3 类与继承
Kotlin中也使用class关键字定义类,所有类都继承于Any类,类似于Java中Object类的概念。类实例化的形式也与Java一样,但是去掉了new关键字。
构造函数
类的构造函数分为primary constructor和secondary constructor,前者只能有一个,而后者可以有多个。如果两者都未指定,则默认为无参数的primary constructor。
primary constructor是属于类头的一部分,用constructor关键字定义,无可见性字段定义时可省略。初始化代码需要单独写在init代码块中,方法参数只能在init代码块和变量初始化时使用。
secondary constructor也是用constructor关键字定义,必须要直接或间接代理primary constructor。
class Student(name: String) { // primary constructor
var mName: String = name
init {
println("Student is called " + name)
}
constructor(age: Int, name: String):this(name) {
println("Student is ${age} years old")
}
}
继承
类继承使用符号“:”表示,接口实现也一样,不做原本Java中的extends和implement关键字区分。Kotlin有一点与Java大为不同,即Java中类默认可被继承,只有被final关键字修饰的类才不能被继承。而Kotlin中直接取消了final关键字,所有类均默认不可被继承。神马?这还怎么面向对象编程?先别急,Kotlin中新增了open关键字,仅有被open修饰的类才可以被继承。
单例与伴随对象
日常开发中写一个单例类是很常见的行为,Kotlin中直接将这种设计模式提升到语言级别,使用关键词object定义单例类。这里需要注意,是全小写。Kotlin中区分大小写,Java中原本指所有类的父类Object已弃用。单例类访问直接使用类名,无构造函数。
object Shop(name: String) {
fun buySomething() {
println("Bought it")
}
}
Shop.buysomething()
Java中使用static标识一个类里的静态属性或方法,可以被这个类的所以实现使用。Kotlin改为使用伴随对象,用companion修饰单例类object,来实现静态属性或方法功能。
class Mall(name: String) {
companion object Shop {
val SHOP_NAME: String = "McDonald" // 等同于Java中写public static String
fun buySomething() { // 等同于Java中写public static void
println("Bought it")
}
}
}
Mall.buySomething()
2.4 逻辑语句
if-else语句
Kotlin中的if-else语句与Java一致,结构上都是if (条件A) { 条件A为真要执行的操作 } else { 条件A为假要执行的操作 }
这里主要要介绍的是Kotlin的一个特点,即if-else语句可以作为一个逻辑表达式使用。不仅如此,逻辑表达式还可以以代码块的形式出现,代码块最后的表达式作为该块的值。
// 逻辑表达式的使用
fun maxNum(x: Int, y: Int): Int {
var max = if (x > y) x else y
return max
}
// 代码块形式的逻辑表达式
fun maxNumPlus(x: Int, y: Int): Int {
var max = if (x > y) {
println("Max number is x")
x
} else {
println("Max number is y")
y
}
return max
}
when语句
Kotlin中的when语句取代了Java中的switch-case语句,功能上要强大许多,可以有多种形式的条件表达。与if-else一样,Kotlin中的when也可以作为逻辑表达式使用。
// 逻辑表达式的使用
fun judge(obj: Any) {
when (obj) {
1 -> println("是数字1")
-1, 0 -> println("是数字0或-1")
in 1..10 -> println("是不大于10的正整数")
"abc" -> println("是字符串abc")
is Double -> println("类型是双精度浮点数")
else -> println("其他操作")
}
}
标签
Kotlin中可以对任意表达式进行标签标记,形式为abc@,xyz@。而这些标签,可以搭配return、break、continue等跳转行为来使用。
fun labelTest() {
la@ for (i in 1..10) {
println("outer index " + i)
for (j in 1..10) {
println("inner index " + j )
if ( inner % 2 == 0) {
break@la
}
}
}
}
其他
for语句、while语句、continue语句和break语句等逻辑都与Java基本一致,这里不再赘述。
3 实用特性
3.1 空指针安全
在写Java代码时,最常出现在线上的crash问题大概就是NullPointerException了。技术上来说这样的问题修复起来很快,没什么难度,但往往由于日常开发中没有写足够多的防御性代码,导致此类问题一直困扰着我们。Java作为一个古老的语言并没有空指针安全功能,这使得当对象层级套用的时候,想要获取最里面的某个属性,需要从外到内依次做一遍非空判断来避免NPE。相似的场景太多,导致这在代码成本上是很大的。
Kotlin中,当我们定义一个变量时,其默认就是非空类型。如果你直接尝试给他赋值为null,编译器会直接报错。Kotlin中将符号“?”定义为安全调用操作符。变量类型后面跟?号定义,表明这是一个可空类型。同样的,在调用子属性和方法时,也可以用字符?进行安全调用。Kotlin的编译器会在写代码时就检查非空情况,因此下文例子中,当s2有前置条件判断为非空后,即便其本身是可空类型,也可以安全调用子属性或方法。对于ifelse结构的逻辑,Kotlin还提供了“?:”操作符,极大了简化了代码量又不失可读性。Kotlin还提供“!!”双感叹号操作符来强制调用对象的属性和方法,无视其是否非空。这是一个挺危险的操作符,除非有特殊需求,否则为了远离NPE,还是少用为妙。
var s1: String = "abc"
s1 = null // 这里编译器会报错
var s2: String? = "abc"
s2 = null // 编译器不会报错
var l1 = s1.length // 可正常编译
var l2 = s2.length // 没有做非空判断,编译器检查报错
if (s2 != null) s2.length // Java式的判空方案
s2?.length // Kotlin的安全调用操作符?。当s2为null时,s2?.length也为null
if (s2 != null) s2.length else -1 // Java式判空的ifelse逻辑
s2?.length ?: -1 // Kotlin的elvis操作符
s2!!.length // 可能会导致NPE
3.2 扩展方法和属性
相信作为一个Java/Android开发者,大家都写过很多Base类,继承原生父类的同时,封装一些通用方法,供子类使用。亦或是把这类通用方法,专门放置到一个XXUtils类里,作为工具类出现。这样做是为了代码结构的清晰,但也是一种无奈。由于无法修改原生类的内容,我们只能借助继承或者以面向方法的思维来写工具类。这点在Kotlin里得到了完美解决。Kotlin支持在包范围内对已存在的类进行方法和属性扩展。
我们以Android最常用的showToast方法举个扩展方法的例子,以lastIndex属性举个扩展属性的例子,如下。在这样强大的特性下,写代码都成了一种享受。
// 扩展方法
fun Context.showLongToast(msg: String) {
Toast.makeText(this, msg, Toast.LENGTH_LONG).show()
}
// 扩展属性
val <T> ArrayList<T>.lastIndex: Int get() = size -1
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
showLongToast("hello") // 给Context类扩展了showToast方法,可以在任何有context的地方直接调用了
var mList = ArrayList<String>()
mList.lastIndex // 任何ArrayList均可以调用该属性
...
}
...
}
这里需要注意两点:1.扩展需要在包级范围内进行,如果写在class内是无效的。2.已经存在的方法或属性,是无法被扩展的,依旧会调用已有的方法。
3.3 简洁数据类
相信大家都写过数据类,或者自动化生成的数据model,通常都是由多个属性和对应的getter、setter组成。当有大量多属性的数据类时,不仅这些类会因为大量的getter和setter方法而行数爆炸,也使整个工程方法数骤增。Kotlin中也做了这层特性优化,提供了数据类的简单实现。不用再写get和set方法,这些都由编译器背后去做,你得到的是一个清爽干净的数据类。具体使用参考下面的例子。
data class Student (
var name: String,
var age: Int,
var hobby: String?,
var university: String = "NJU"
)
fun printInfo() {
var s: Student = Student("Ricky", 25, "playing Gwent")
println("${s.name} is from ${s.university}, ${s.age} years old, and likes ${s.hobby}")
}
3.4 Anko
Anko是Jetbrains官方提供的一个让Kotlin开发更快速简单的类库,旨在使代码书写更加清晰易懂,形式上为DSL编程。
No findViewById
Android开发过程一定都写过大量的findViewById。这本身就是个消耗资源的方法,编码时还极为不便,需要强制转换为具体的View类型才能调用其方法。通过引入支持注解的库,可以使这个过程略微简单化一些。
// 传统Android中的View内容初始化
TextView tvName = (TextView) this.findViewById(R.id.tv_name);
tvName.setText("Ricky");
// 注解方式
@BindView(R.id.tv_name)
TextView tvName;
tvName.setText("Ricky");
这样还是显得不够简洁,而Kotlin给出了一种最为简便的方式。
import kotlinx.android.synthetic.main.activity_main.* // activity_main为具体的布局xml文件名
...
tvName.text = "Ricky";
你只需要在具体的页面中按照上面的格式import下,就可以在整个页面里很方便的使用xml里的view操作了。不需要类型转换,不需要新建变量,不需要findViewById,孰优孰劣,相信大家心中都有了答案。
Simple startActivity
通常,在Android里,当我想打开一个新页面,并给它传递一些参数时,我需要按照如下的方式编码。
Intent intent = new Intent(LoginActivity.this, MainActivity.class);
intent.putExtra("userid", 10001);
intent.putExtra("username", "ricky");
startActivity(intent);
而强大的Anko给我们提供了一种极为方便的写法。无论是无参还是有参,还是需要RequestCode,都非常简洁易懂,是不是一看就特别心动?
startActivity<MainActivity>()
startActivity<MainActivity>("userid" to 10001, "username" to "ricky")
startActivityForResult<MainActivity>(101, "userid" to 10001, "username" to "ricky")
DSL Layout
上面说到不再使用findViewById,还是基于使用xml来编写Android页面这个基础。倘若你想彻底革新写法,换一种更直观的DSL方式来写Android页面呢?Anko就提供了这样的方案。相比之下,除了可读性增加之外,也节约了解析xml文件消耗的资源。
inner class LoginAnkoUI : AnkoComponent<LoginActivity> {
override fun createView(loginAnkoUI: AnkoContext<LoginActivity>): View {
return with(loginAnkoUI) {
verticalLayout {
val textView = textView("用户名") {
textSize = sp(15).toFloat()
textColor = context.resources.getColor(R.color.black)
}.lparams {
margin = dip(10)
height = dip(40)
width username= matchParent
}
val username = editText("输入...")
button("登录") {
onClick { view ->
toast("Hello, ${username.text}!")
}
}
}
}
}
}
只要最后在Activity里加一句调用,便可以使用Anko写的页面了。是不是看上去更直观了呢?
LoginAnkoView().setContentView(this@LoginActivity)
4 快速实践
4.1 配置Android Studio
作为官方开发语言,在Android Studio 3.0版本中,已经内嵌了对Kotlin的支持。和笔者一样还在使用2.x版本开发的小伙伴们,也不用担心需要花时间升级AS才能体验到Kotlin。JetBrains提供了完善的插件支持,直接打开Preferences去配置插件,找到Kotlin下载安装下就好啦。
插件安装完毕,还需要build.gradle里添加下依赖。
如果你不清楚当前最新的kotlin版本是什么的话,这里也有一个更简便的方法来给项目添加kotlin依赖。
首先你的项目中要有一份java代码,然后在插件安装正常的情况下,你可以在Code菜单看到一键把Java代码转换为Kotlin的功能。
转换完毕后,当你尝试修改这个.kt代码文件时,Android Studio便会提醒你Kotlin尚未配置。
这个自动化配置过程,可以看到目前插件支持到的最新的Kotlin版本。换言之插件及时最新的话,你这里就可以选择到最新的Kotlin版本。这里也可以选择只将某个模块配置为支持Kotlin,或者全局支持。
配置完毕后,我们可以看到build.gradle文件里已经自动添加了依赖代码,Sync一下就ok了。
由于要充分发挥Kotlin的特性,将Anko的相关代码依赖也引入进来
4.2 Demo
下面会给大家展示一个小Demo的核心代码,完整代码可以查看KotlinDemo。Demo将分别用Java写法和Kotlin写法编写同样的页面,以此对比出优劣。
Demo包含一个Java实现的公共首页,首页中有两个按钮入口,分别跳转到用Java编写的列表页和用Kotlin编写的列表页。各自的列表页都会实现一个Item点击跳转到详情页的功能,并在详情页显示具体信息。
Java实现效果:Kotlin实现效果:
列表页代码
// Java实现
public class JListActivity extends AppCompatActivity implements View.OnClickListener, AdapterView.OnItemClickListener {
// View
private ListView listView;
private Button btnClearData;
private Button btnUpdateData;
// Data
private ArrayList<JStudent> studentList = new ArrayList<>();
private JListAdapter listAdapter;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_list_java);
initView();
initData();
}
private void initData() {
listAdapter = new JListAdapter(studentList);
listView.setAdapter(listAdapter);
}
private void initView() {
listView = (ListView) findViewById(R.id.java_list_view);
btnClearData = (Button) findViewById(R.id.java_clear_btn);
btnUpdateData = (Button) findViewById(R.id.java_update_btn);
listView.setDividerHeight(0);
listView.setOnItemClickListener(this);
btnClearData.setOnClickListener(this);
btnUpdateData.setOnClickListener(this);
}
@Override
public void onClick(View view) {
if (view == btnClearData) {
studentList.clear();
listAdapter.notifyDataSetChanged();
showShortToast("已清空");
} else if (view == btnUpdateData) {
studentList.addAll(FakeServer.randomJavaResponse());
listAdapter.notifyDataSetChanged();
showShortToast("已更新10条数据");
}
}
@Override
public void onItemClick(AdapterView<?> adapterView, View view, int i, long l) {
Intent intent = new Intent(JListActivity.this, JInfoActivity.class);
intent.putExtra("stu_name", studentList.get(i).getName());
intent.putExtra("stu_age", studentList.get(i).getAge());
intent.putExtra("stu_hobby", studentList.get(i).getHobby());
intent.putExtra("stu_university", studentList.get(i).getUniversity());
startActivity(intent);
}
private void showShortToast(String msg) {
Toast.makeText(this, msg, Toast.LENGTH_SHORT).show();
}
}
// Kotlin实现
class KListActivity : AppCompatActivity() {
var studentList: ArrayList<KStudent> = ArrayList()
var listAdapter: KListAdapter = KListAdapter(studentList)
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
ListUI().setContentView(this@KListActivity)
}
fun clearList() {
studentList.clear()
listAdapter.notifyDataSetChanged()
showShortToast("已清空")
}
fun updateList() {
studentList.addAll(FakeServer.randomKotlinResponse())
listAdapter.notifyDataSetChanged()
showShortToast("已更新10条数据")
}
fun gotoItemInfo(position: Int) {
var student = studentList[position]
startActivity<KInfoActivity>("stu_name" to student.name, "stu_age" to student.age, "stu_hobby" to student.hobby, "stu_university" to student.university)
}
}
数据类代码
// Java实现
public class JStudent {
private int id;
private String name;
private int age;
private String hobby;
private String university;
public JStudent(int id, String name, int age, String hobby, String university) {
setId(id);
setName(name);
setAge(age);
setHobby(hobby);
setUniversity(university);
}
public int getId() {
return id;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public String getHobby() {
return hobby;
}
public String getUniversity() {
return university;
}
public void setId(int id) {
this.id = id;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public void setHobby(String hobby) {
this.hobby = hobby;
}
public void setUniversity(String university) {
this.university = university;
}
}
// Kotlin实现
data class KStudent(var id: Int, var name: String, var age: Int, var hobby: String, var university: String)
上面的代码对比已经能看出一些惊人的差距,我们再统计一下用两种方式编写的具体代码行数,以评判两者的开发效率。
Java Part/LOC | Kotlin Part/LOC | |
---|---|---|
ListActivity | 85 | 38 |
ListUI | 52 | 62 |
InfoActivity | 62 | 29 |
InfoUI | 114 | 120 |
ListAdapter | 71 | 33 |
ListItemUI | 48 | 67 |
Student Data Class | 64 | 1 |
Total | 496 | 350 |
可以看到,使用了Anko编写的Kotlin页面UI,在代码行数上甚至比xml编写还要多一点。但是由于不再需要findViewById,对应Activity中减少了很多逻辑,代码行也少了很多。同时,这种写法也节约了CPU去解析xml生成页面的资源和时间。
最终此Demo中使用Java和Kotlin编写相同的页面功能,Kotlin比Java少了30%的代码开发量。再加上空指针安全等特性,表现可以说是非常亮眼。
5 结语
Kotlin作为一个JVM上的新语言,充分兼容了老大哥Java的诸多功能,又构建了很多自身优秀特性,提供了大量便捷易懂、结构清晰的开发形式。笔者作为一个Android开发,非常乐于在今后的开发中尝试完全化的Kotlin项目。本文限于篇幅,仅能展现出其诸多特点的一点皮毛,更多新特性还需要各位看官自己在实际使用中挖掘。
套用刘禹锡的一句诗来结束本文吧。“芳林新叶催陈叶,流水前波让后波”,期待吸收了Java之长的Kotlin,能在未来有更好的表现。