前语
从谨慎地在项目中引进kotlin到悉数转为kotlin开发咱们用了大概半年的时刻。这中心阅历了从在一个小功用中测验运用到完全运用kotlin完成了大版别开发的进程。运用办法也从仅仅地用java风格写kotlin代码,慢慢地变成运用kotlin风格去编写代码。 转载请注明来源「申国骏」
到目前为止,kotlin的引进至少没有给咱们带来不必要的麻烦,在慢慢品尝kotlin语法糖的进程中,咱们领会到了能给开发者真实带来好处的一些特性。本文就是对这些咱们认为是精华的一些特性的进行总结,期望能给还在犹疑是否要开端学习kotlin或许刚开端编写kotlin可是不知道该如何运用kotlin的人们先一睹kotlin的高雅风貌。
Kotlin规划哲学
KotlinConf 2018 – Conference Opening Keynote by Andrey Breslav 上讲的Kotlin规划理念: Kotlin具有强大的IDE厂商Intellij和Google的支撑,确保了其务实、简练、安全和与JAVA互操作的良好规划理念。
其间务实表明了Kotlin并没有首创一些当时没有或群众不太熟悉的规划理念,而是吸收了许多其他言语的精华,而且供给强大的IDE支撑,能真实便利开发者运用到实践项目之中。
简练首要指的是Kotlin支撑隐藏例如getter、setter等Java样板代码,而且有许多的标准库以及灵敏的重载和扩展机制,来使代码变得愈加直观和简练。
安全首要是说空值安全的控制以及类型自动检测,帮助削减NullPointerException以及ClassCastException。
与Java互操作认为这能够与Java彼此调用、混合调试以及同步重构,一起支撑Java到kotlin代码的自动转化。
空值安全
Kotlin类型分为可空和非可空,赋值null到非可空类型会编译犯错
fun main() {
var a: String = "abc"
a = null // compilation error
var b: String? = "abc"
b = null // ok
}
对空的操作有以下这些
运用安全调用运算符 ?:
能够防止Java中许多的空值判别。以下是一个比照的比如:
// 用Java完成
public void sendMessageToClient(
@Nullable Client client,
@Nullable String message,
@NotNull Mailer mailer
) {
if (client == null || message == null) return;
PersonalInfo personalInfo = client.getPersonalInfo();
if (personalInfo == null) return;
String email = personalInfo.getEmail();
if (email == null) return;
mailer.sendMessage(email, message);
}
// 用Kotlin完成
fun sendMessageToClient(
client: Client?,
message: String?,
mailer: Mailer
){
val email = client?.personalInfo?.email
if (email != null && message != null) {
mailer.sendMessage(email, message)
}
}
扩展
扩展函数
扩展函数是Kotlin精华特点之一,能够给别人的类添加办法或许特点,使得办法调用愈加天然和直观。经过扩展函数的特性,Kotlin内置了许多的辅佐扩展办法,十分有用。下面咱们经过这个比如看一下
fun main() {
val list = arrayListOf<Int>(1, 5, 3, 7, 9, 0)
println(list.sortedDescending())
println(list.joinToString(
separator = " | ",
prefix = "(",
postfix = ")"
) {
val result = it + 1
result.toString()
})
}
其间sortedDescending
以及joinToString
都是Kotlin内置的扩展办法。
上述的函数会输出
Kotlin内部的完成如下
public fun <T : Comparable<T>> Iterable<T>.sortedDescending(): List<T> {
return sortedWith(reverseOrder())
}
public fun <T> Iterable<T>.joinToString(separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: ((T) -> CharSequence)? = null): String {
return joinTo(StringBuilder(), separator, prefix, postfix, limit, truncated, transform).toString()
}
可见sortedDescending
和joinToString
都是对Iterable<T>
类目标的一个扩展办法。
咱们也能够自己完成一个自界说的扩展函数如下:
fun Int.largerThen(other: Int): Boolean {
return this > other
}
fun main() {
println(2.largerThen(1))
}
上述代码输出为true
经过扩展函数咱们以十分直观的办法,将某个类目标的东西类直接运用该类经过"."
办法调用。
当然扩展函数是一种静态的完成办法,不会对本来类目标的办法进行掩盖,也不会有正常函数的子类办法掩盖父类办法现象。
扩展特点
扩展特点与扩展函数类似,也是能够直接给类目标添加一个特点。例如:
var StringBuilder.lastChar: Char
get() = get(length -1)
set(value: Char) {
this.setCharAt(length -1, value)
}
fun main() {
val sb = StringBuilder("kotlin")
println(sb.lastChar)
sb.lastChar = '!'
println(sb.lastChar)
}
无论是扩展函数仍是扩展特点,都是对Java代码中utils办法很好的改变,能够防止多处类似功用的util界说以及使得调用更为直观。
调集
经过扩展的办法,Kotlin对调集类供给了十分丰富且有用的许多东西,只有你想不到,没有你做不到。下面咱们经过 Kotlin Koans 上的一个比如来阐明一下:
data class Shop(val name: String, val customers: List<Customer>)
data class Customer(val name: String, val city: City, val orders: List<Order>) {
override fun toString() = "$name from ${city.name}"
}
data class Order(val products: List<Product>, val isDelivered: Boolean)
data class Product(val name: String, val price: Double) {
override fun toString() = "'$name' for $price"
}
data class City(val name: String) {
override fun toString() = name
}
以上是数据结构的界说,咱们有一个超市,超市有许多顾客,每个顾客有许多笔订单,订单对应着一定数量的产品。下面咱们来经过调集的操作来完成以下使命。
操作符 | 作用 |
---|---|
filter | 将调集里的元素过滤,并回来过滤后的元素 |
map | 将调集里的元素一一对应转化为另一个元素 |
“` | |
// 回来商铺中顾客来自的城市列表 | |
fun Shop.getCitiesCustomersAreFrom(): Set = customers.map { it.city }.toSet() |
// 回来住在给定城市的一切顾客 fun Shop.getCustomersFrom(city: City): List = customers.filter { it.city == city }
操作符 | 作用
---|---
all | 判别调集中的一切元素是否满意某个条件,都满意回来true
any | 判别调集中是否有元素满意某个条件,有则回来true
count | 回来调集中满意某个条件的元素数量
find |查找调集中满意某个条件的一个元素,不存在则回来null
// 假如超市中一切顾客都来自于给定城市,则回来true fun Shop.checkAllCustomersAreFrom(city: City): Boolean = customers.all { it.city == city }
// 假如超市中有某个顾客来自于给定城市,则回来true fun Shop.hasCustomerFrom(city: City): Boolean = customers.any{ it.city == city}
// 回来来自于某个城市的一切顾客数量 fun Shop.countCustomersFrom(city: City): Int = customers.count { it.city == city }
// 回来一个住在给定城市的顾客,若无回来null fun Shop.findAnyCustomerFrom(city: City): Customer? = customers.find { it.city == city }
操作符 | 作用
---|---
flatMap | 将调集的元素转化为别的的元素(非一一对应)
// 回来一切该顾客购买过的产品调集 fun Customer.getOrderedProducts(): Set = orders.flatMap { it.products }.toSet()
// 回来超市中至少有一名顾客购买过的产品列表 fun Shop.getAllOrderedProducts(): Set = customers.flatMap { it.getOrderedProducts() }.toSet()
操作符 | 作用
---|---
max | 回来调集中以某个条件排序的最大的元素
min | 回来调集中以某个条件排序的最小的元素
// 回来商铺中购买订单次数最多的用户 fun Shop.getCustomerWithMaximumNumberOfOrders(): Customer? = customers.maxBy { it.orders.size }
// 回来顾所购买过的最贵的产品 fun Customer.getMostExpensiveOrderedProduct(): Product? = orders.flatMap { it.products }.maxBy { it.price }
操作符 | 作用
---|---
sort | 根据某个条件对调集元素进行排序
sum | 对调集中的元素依照某种规矩进行相加
groupBy | 对调集中的元素依照某种规矩进行组合
// 依照购买订单数量升序回来商铺的顾客 fun Shop.getCustomersSortedByNumberOfOrders(): List = customers.sortedBy { it.orders.size }
// 回来顾客在商铺中购买的一切订单价格总和 fun Customer.getTotalOrderPrice(): Double = orders.flatMap { it.products }.sumByDouble { it.price }
// 回来商铺中居住城市与顾客的映射 fun Shop.groupCustomersByCity(): Map<City, List> = customers.groupBy { it.city }
操作符 | 作用
---|---
partition | 根据某种规矩将调集中的元素分为两组
fold | 对调集的元素依照某个逻辑进行一一累计
// 回来商铺中未送到订单比送达订单要多的顾客列表 fun Shop.getCustomersWithMoreUndeliveredOrdersThanDelivered(): Set = customers.filter { val (delivered, undelivered) = it.orders.partition { it.isDelivered } undelivered.size > delivered.size }.toSet()
// 对一切顾客购买过的产品取交集,回来一切顾客都购买过的产品列表 fun Shop.getSetOfProductsOrderedByEveryCustomer(): Set { val allProduct = customers.flatMap { it.orders }.flatMap { it.products }.toSet()
return customers.fold(allProduct) { orderedByAll, customer ->
orderedByAll.intersect(customer.orders.flatMap { it.products })
}
}
归纳运用:
// 回来顾客一切送达产品中最贵的产品 fun Customer.getMostExpensiveDeliveredProduct(): Product? { return orders.filter { it.isDelivered }.flatMap { it.products }.maxBy { it.price } }
// 回来商铺中某件产品的购买次数 fun Shop.getNumberOfTimesProductWasOrdered(product: Product): Int { return customers.flatMap { it.orders }.flatMap { it.products }.count{it == product} }
Kotlin对调集供给了简直你能想到的一切操作,经过对这些操作的组合削减调集操作的复杂度,进步可读性。以下是Java和Kotln对调集操作的比照
```java
// 用Java完成
public Collection<String> doSomethingStrangeWithCollection(
Collection<String> collection
) {
Map<Integer, List<String>> groupsByLength = Maps.newHashMap();
for (String s : collection) {
List<String> strings = groupsByLength.get(s.length());
if (strings == null) {
strings = Lists.newArrayList();
groupsByLength.put(s.length(), strings);
}
strings.add(s);
}
int maximumSizeOfGroup = 0;
for (List<String> group : groupsByLength.values()) {
if (group.size() > maximumSizeOfGroup) {
maximumSizeOfGroup = group.size();
}
}
for (List<String> group : groupsByLength.values()) {
if (group.size() == maximumSizeOfGroup) {
return group;
}
}
return null;
}
// 用Kotlin完成
fun doSomethingStrangeWithCollection(collection: Collection<String>): Collection<String>? {
val groupsByLength = collection.groupBy { s -> s.length }
val maximumSizeOfGroup = groupsByLength.values.map { group -> group.size }.max()
return groupsByLength.values.firstOrNull { group -> group.size == maximumSizeOfGroup }
}
运算符
运算符重载
仍是举 Kotlin Koans 上的运算符重载比如。假定咱们需求完成以下功用:
enum class TimeInterval { DAY, WEEK, YEAR }
data class MyDate(val year: Int, val month: Int, val dayOfMonth: Int) : Comparable<MyDate> {
override fun compareTo(other: MyDate): Int {
if (year != other.year) return year - other.year
if (month != other.month) return month - other.month
return dayOfMonth - other.dayOfMonth
}
override fun toString(): String {
return "$year/$month/$dayOfMonth"
}
}
fun main() {
val first = MyDate(2018, 10, 30)
val last = MyDate(2018, 11, 1)
for (date in first..last) {
println(date)
}
println()
println(first + DAY)
println()
println(first + DAY * 2 + YEAR * 2)
}
输出为以下:
只需完成以下运算符重载既可:
operator fun MyDate.rangeTo(other: MyDate): DateRange = DateRange(this, other)
operator fun MyDate.plus(timeInterval: TimeInterval): MyDate = this.addTimeIntervals(timeInterval, 1)
operator fun TimeInterval.times(num: Int): RepeatTimeInterval = RepeatTimeInterval(this, num)
operator fun MyDate.plus(repeatTimeInterval: RepeatTimeInterval): MyDate =
this.addTimeIntervals(repeatTimeInterval.timeInterval, repeatTimeInterval.num)
class RepeatTimeInterval(val timeInterval: TimeInterval, val num: Int)
class DateRange(override val start: MyDate, override val endInclusive: MyDate) : ClosedRange<MyDate>, Iterable<MyDate> {
override fun iterator(): Iterator<MyDate> = DateIterator(start, endInclusive)
}
class DateIterator(first: MyDate, private val last: MyDate) : Iterator<MyDate> {
private var current = first
override fun hasNext(): Boolean {
return current <= last
}
override fun next(): MyDate {
val result = current
current = current.nextDay()
return result
}
}
fun MyDate.nextDay(): MyDate = this.addTimeIntervals(DAY, 1)
fun MyDate.addTimeIntervals(timeInterval: TimeInterval, number: Int): MyDate {
val c = Calendar.getInstance()
c.set(year + if (timeInterval == TimeInterval.YEAR) number else 0, month - 1, dayOfMonth)
var timeInMillis = c.timeInMillis
val millisecondsInADay = 24 * 60 * 60 * 1000L
timeInMillis += number * when (timeInterval) {
TimeInterval.DAY -> millisecondsInADay
TimeInterval.WEEK -> 7 * millisecondsInADay
TimeInterval.YEAR -> 0L
}
val result = Calendar.getInstance()
result.timeInMillis = timeInMillis
return MyDate(result.get(Calendar.YEAR), result.get(Calendar.MONTH) + 1, result.get(Calendar.DATE))
}
Kotlin支撑运用指定的扩展函数来完成运算符的重载,运算符对应的办法名详细拜见官方文档 Operator overloading
infix
符号为infix的办法,能够类似于二元运算符运用,举个比如
infix fun Int.plus(other: Int): Int {
return this + other
}
fun main() {
// 成果会输出7
println(3 plus 4)
}
infix办法履行的优先级低于管用运算符、类型转化type case以及rangTo运算符,可是高于布尔、is、in check等其他运算符。
运用infix的扩展函数能够完成自界说的二元运算符号。
整齐Kotlin风格
在《Kotlin in Action》一书中有归纳了一些Kotlin比照Java的整齐语法如下:
常规语法 | 整齐语法 | 用到的功用 |
---|---|---|
StringUtil.capitalize(s) | s.capitalize() | 扩展函数 |
1.to(“one”) | 1 to “one” | 中缀函数 infix |
set.add(2) | set += 1 | 运算符重载 |
map.get(“key”) | map[“key”] | get办法约好 |
file.use({f -> f.read}) | file.use { it.read() } | 括号内lambda外移 |
sb.append(“a”) sb.append(“b”) | with(sb) { append(“a”) append(“b”)} | 带接收者的lambda |
整齐语法换句话来说也是Kotlin的一种编程风格,其他约好俗成的整齐Kotlin编程风格可见官方文档 Idioms。十分建议咱们看看Idioms这个文档,里边涵盖了十分Kotlin的运用办法,包括: |
- 运用默许参数代替办法重载
- String模板(在Android中是否推荐仍值得商讨)
- lambda运用it代替传入值
- 运用下标办法拜访map
- 懒初始化特点
- 运用rangs规模遍历
- if when表达式回来值
- 等等
办法参数
Kotlin中的function是一等公民,具有和变量相同的界说以及传参办法,如以下比如:
fun SQLiteDatabase.inTransaction(func: (SQLiteDatabase) -> Unit) {
beginTransaction()
try {
func(this)
setTransactionSuccessful()
} finally {
endTransaction()
}
}
// 调用的时分就能够如下办法进行调用
db.inTransaction {
it.db.delete("users", "first_name = ?", arrayOf("Jake"))
}
带接收者的lambda表达式
lambda表达式能够声明具有接收者,例如:
val isEven: Int.() -> Boolean = {
this % 2 == 0
}
fun main() {
print(2.isEven())
}
这种带接收者的lambda实践上也是一种办法界说,不过其优先级比扩展办法要低,假如一起有扩展函数(如下)具有相同名字,则会优先调用扩展办法。
fun Int.isEven(): Boolean {
return this % 2 != 0
}
let run with apply also
这几个关键字其实都是Kotlin的特殊办法,他们能够让lambda里边的代码在相同的接收者中运转,防止冗余代码,他们的声明如下:
public inline fun <T, R> T.let(block: (T) -> R): R {
return block(this)
}
public inline fun <R> run(block: () -> R): R {
return block()
}
public inline fun <T, R> with(receiver: T, block: T.() -> R): R {
return receiver.block()
}
public inline fun <T> T.apply(block: T.() -> Unit): T {
block()
return this
}
public inline fun <T> T.also(block: (T) -> Unit): T {
block(this)
return this
}
从声明中能够看出他们有以下差异,假定在以下代码中运转
class MyClass {
fun test() {
val str: String = "..."
val result = str.xxx {
print(this) // 接收者this
print(it) // lambda参数it
42 // 回来成果
}
}
}
办法 | 接收者this | lambda参数it | 回来成果 |
---|---|---|---|
let | this@MyClass | String(“…”) | Int(42) |
run | String(“…”) | N\A | Int(42) |
with(*) | String(“…”) | N\A | Int(42) |
apply | String(“…”) | N\A | String(“…”) |
also | this@MyClass | String(“…”) | String(“…”) |
DSL构建
以下是DSL和API调用办法的差异
// DSL
dependencies {
compile("junit")
compile("guice")
}
// API
project.dependencies.add("compile", "junit")
project.dependencies.add("compile", "guice")
比照下DSL办法更为简练且易读。经过上述对lambda的介绍能够发现Kotlin能够完美地支撑DSL办法编程,只需少数的扩展办法以及lambda界说既可完成以下办法来构建一段html表格
html {
table {
tr (color = getTitleColor()){
this.td {
text("Product")
}
td {
text("Price")
}
td {
text("Popularity")
}
}
val products = getProducts()
for ((index, product) in products.withIndex()) {
tr {
td(color = getCellColor(index, 0)) {
text(product.description)
}
td(color = getCellColor(index, 1)) {
text(product.price)
}
td(color = getCellColor(index, 2)) {
text(product.popularity)
}
}
}
}
}
详细界说如下:
import java.util.ArrayList
open class Tag(val name: String) {
val children: MutableList<Tag> = ArrayList()
val attributes: MutableList<Attribute> = ArrayList()
override fun toString(): String {
return "<$name" +
(if (attributes.isEmpty()) "" else attributes.joinToString(separator = "", prefix = " ")) + ">" +
(if (children.isEmpty()) "" else children.joinToString(separator = "")) +
"</$name>"
}
}
class Attribute(val name : String, val value : String) {
override fun toString() = """$name="$value" """
}
fun <T: Tag> T.set(name: String, value: String?): T {
if (value != null) {
attributes.add(Attribute(name, value))
}
return this
}
fun <T: Tag> Tag.doInit(tag: T, init: T.() -> Unit): T {
tag.init()
children.add(tag)
return tag
}
class Html: Tag("html")
class Table: Tag("table")
class Center: Tag("center")
class TR: Tag("tr")
class TD: Tag("td")
class Text(val text: String): Tag("b") {
override fun toString() = text
}
fun html(init: Html.() -> Unit): Html = Html().apply(init)
fun Html.table(init : Table.() -> Unit) = doInit(Table(), init)
fun Html.center(init : Center.() -> Unit) = doInit(Center(), init)
fun Table.tr(color: String? = null, init : TR.() -> Unit) = doInit(TR(), init).set("bgcolor", color)
fun TR.td(color: String? = null, align : String = "left", init : TD.() -> Unit) = doInit(TD(), init).set("align", align).set("bgcolor", color)
fun Tag.text(s : Any?) = doInit(Text(s.toString()), {})
特点署理
Kotlin供给对特点署理的支撑,能够将特点的get set操作署理到外部履行。署理的好处有三个:
- 懒初始化,只在第一次调用进行初始化操作
- 完成对特点的观察者形式
- 便利对特点进行保存等管理
下面来看比较常用的懒初始化比如:
val lazyValue: String by lazy {
println("computed!")
"Hello"
}
fun main() {
println(lazyValue)
println(lazyValue)
}
以上代码会输出
computed!
Hello
Hello
证明懒加载模块只在第一次调用被履行,然后会将得到的值保存起来,后边拜访特点将不会继续核算。这也是在Kotlin中完成单例形式的办法。这种懒初始化的进程也是线程同步的,线程同步办法有以下几种:
public enum class LazyThreadSafetyMode {
/**
* 加锁单一线程初始化Lazy实例
*/
SYNCHRONIZED,
/**
* 初始化代码块会被多次调用,但只有首次初始化的值会赋值给Lazy实例
*/
PUBLICATION,
/**
* 没有线程安全,不确保同步,只能在确保单线程环境中运用
*/
NONE,
}
解构
解构是十分有用的Kotlin供给的将一个目标特点分离出来的特性。
内部完成原理是经过声明为componentN()
的操作符重载完成。对Kotlin中的data
类会自动生成component
函数,默许支撑解构操作。以下是解构比较有用的一个比如:
for ((key, value) in map) {
// 运用该 key、value 做些工作
}
协程Coroutine
先占个位,等我看懂了再来补充 :) 先po一个协程和Rxjava的比照吸引下咱们
// RxJava
interface RemoteService {
@GET("/trendingshows")
fun trendingShows(): Single<List<Show>>
}
service.trendingShows()
.scheduleOn(schedulers.io)
.subscribe(::onTrendingLoaded, ::onError)
// Coroutine
interface RemoteService {
@GET("/trendingshows")
suspend fun trendingShows(): List<Show>
}
val show = withContext(dispatchers.io) {
service.trendingShows()
}
在Android中运用
findViewById
经过引进import kotlinx.android.synthetic.main.
完成直接获取xml中ui组件。
anko
anko供给了许多东西类,帮助开发者在Android中更好地运用Kotlin。anko供给了以下有用东西:
- 方便Intent:
startActivity(intentFor<SomeOtherActivity>("id" to 5).singleTop())
- 方便toast、dialog:
toast("Hi there!")
- 方便log:
info("London is the capital of Great Britain")
- 方便协程:
bg()
- layout DSL构建
- 等等
ktx
android-ktx 供给了一系列Andrdoid办法的简练完成。
与Java不太相同的地方
-
static 与 伴生目标
在Kotlin中并没有static
这个关键字,假如想要完成类似于Java中static
的用法,需求声明伴生目标companion object。运用object
声明的类实践上是一个单例,能够支撑直接调用其间的特点与办法。运用了companion
润饰的object实践上是能够放在其他类内部的单例,因而能够完成类似于Java中static
的作用。至于为什么Kotlin要这样规划,原因是Kotlin期望一切特点都是一个类目标,不做差异化处理,这也是为什么Java中的int、long等根本数据类型在Kotlin中也用Int、Long处理的原因。 -
默许都是final,除非声明为open
在Kotlin中一切办法默许都是制止掩盖的,这样的好处是标准了接口规划的安全性,仅敞开那些确真实规划中期望子类掩盖的办法。 -
默许是public,多了internal
在Java中,假如不加可见性润饰的话默许是包内可见,Kotlin中默许都是public。一起Kotlin加入了internal关键字,代表着是模块内可见。这个可见性弥补了运用Java进行模块规划的进程中,可见性规划的缺点。假如要想在Java中完成仅敞开某些办法给外部模块运用,可是这些办法又能在内部模块自由调用,那只能是把这些办法都放到一个包内,显然是一个很不好的包结构规划。Kotlininternal
关键字能够完美处理这个问题。要想在Java调用的时分完全荫蔽Kotlin的办法,能够加上@JvmSynthetic
。 -
泛型
Java中运用extends
和super
来区分泛型中生产者和消费者,俗称PEST,在Kotlin中对应的是out
和in
。一起Java与Kotlin都会对泛型进行运转时擦除,Kotlin不相同的是能够对inline
办法运用reified
关键字来供给运转时类型。 -
本地办法
由于在Kotlin言语中办法是一等公民,因而能够声明局部生命周期的本地办法,如下比如:
fun dfs(graph: Graph) {
val visited = HashSet<Vertex>()
fun dfs(current: Vertex) {
if (!visited.add(current)) return
for (v in current.neighbors)
dfs(v)
}
dfs(graph.vertices[0])
}
学习资源
Kotlin online try
Kotlin官方文档
kotlin in action
Android Development with kotlin
Kotlin for Android Developers
问题
在Java项目中引进kotlin在大多数情况下都是无痛的,且能够马上带给咱们不相同的方便高效体验。假如硬是要说出一点Kotlin的问题,我觉得会有几个:
- Kotlin加入会添加办法数以及不多的代码体积,这在大多数情况下不会产生太大的问题
- 写法太灵敏,较难一致。由于Kotlin答应程序员选择传统的Java风味或许Kotlin风味来编写代码,这种灵敏性或许导致混合风味的代码出现,且较难一致。
- 过多的大括号层级嵌套。这是由于lambda以及办法参数带来的,其初衷是期望咱们能够用DSL的代码风格,假如没把握DSL办法的话或许会写出比较丑陋的多层级嵌套Java风味代码,影响代码可读性。
最后
Kotlin是一门优异的言语,值得咱们测验。