Kotlin开发的一些实用小技巧总结

前言

随着google i/o大会的召开，google宣布将支持kotlin作为android的开发语言，最近关于kotlin的文章、介绍就异常的活跃。

本文主要给大家介绍了关于kotlin开发的一些实用小技巧，分享出来供大家参考学习，下面话不多说了，来一起看看详细的介绍吧。

1.lazy loading（懒加载）

延迟加载有几个好处。延迟加载能让程序启动时间更快，因为加载被推迟到访问变量时。 这在使用 kotlin 的 android 应用程序而不是服务器应用程序中特别有用。对于 android 应用，我们自然希望减少应用启动时间，以便用户更快地看到应用内容，而不是等待初始加载屏幕。

懒加载也是更有效率的内存，因为我们只需要调用资源才能将资源加载到内存中。例如：

val gankapi: gankapi by lazy {
 val retrofit: retrofit = retrofit.builder()
  .baseurl(api_url)
  .addconverterfactory(moshiconverterfactory.create())
  .build()
 retrofit.create(gankapi::class.java)
}

如果用户从没有调用 gankapi ，则永远不会加载。因此也不会占用所需资源。

当然懒加载也能较好的用于封装初始化：

val name: string by lazy {
 log.d(tag, "executed only first time")
 "double thunder"
}

如果你不担心多线程问题或者想提高更多的性能，你也可以使用

lazy(lazythreadsafemode.none){ ... }

2. 自定义 getters/setters

kotlin 会自动的使用 getter/setter 模型，但也有一些情况（倒如 json）我们需要用自定制 getter 和 setter。例如：

@parseclassname("book")
class book : parseobject() {

 // getstring() and put() are methods that come from parseobject
 var name: string
 get() = getstring("name")
 set(value) = put("name", value)

 var author: string
 get() = getstring("author")
 set(value) = put("author", value)
}

3. lambdas

button.setonclicklistener { view ->
 startdetailactivity()
}

toolbar.setonlongclicklistener { 
 showcontextmenu()
 true
}

4.data classes(数据类)

数据类是一个简单版的 class，它自动添加了包括 equals(), hashcode(), copy(), 和 tostring() 方法。将数据与业务逻辑分开。

data class user(val name: string, val age: int)

如果使用gson解析json的数据类，则可以使用默认值构造函数：

// example with gson's @serializedname annotation
data class user(
 @serializedname("name") val name: string = "",
 @serializedname("age") val age: int = 0
)

5. 集合过滤

val users = api.getusers()
// we only want to show the active users in one list
val activeusersnames = items.filter { 
 it.active // the "it" variable is the parameter for single parameter lamdba functions
}
adapter.setusers(activeusers)

6. object expressions(对象表达式)

object expressions 允许定义单例。例如：

package com.savvyapps.example.util

import android.os.handler
import android.os.looper

// notice that this is object instead of class
object threadutil {

 fun onmainthread(runnable: runnable) {
 val mainhandler = handler(looper.getmainlooper())
 mainhandler.post(runnable)
 }
}

threadutil 则可以直接调用静态类方法：

threadutil.onmainthread(runnable)

以类似的方式，我们创建对象而不是匿名内部类：

viewpager.addonpagechangelistener(object : viewpager.onpagechangelistener {
 override fun onpagescrollstatechanged(state: int) {}

 override fun onpagescrolled(position: int, positionoffset: float, positionoffsetpixels: int) {}

 override fun onpageselected(position: int) {
  binduser(position)
 }
});

这两个都基本上是相同的事情 - 创建一个类作为声明对象的单个实例。

7. companion object(伴生对象)

kotlin 是没有静态变量与方法的。相对应的，可以使用伴生对象。伴生对象允许定义的常量和方法，类似于 java 中的 static。有了它，你可以遵循 newinstance 的片段模式。

class viewuseractivity : appcompatactivity() {

 companion object {

  const val key_user = "user"

  fun intent(context: context, user: user): intent {
   val intent = intent(context, viewuseractivity::class.java)
   intent.putextra(key_user, user)
   return intent
  }
 }
 
 override fun oncreate(savedinstancestate: bundle?) {
  super.oncreate(savedinstancestate)
  setcontentview(r.layout.activity_cooking)
  
  val user = intent.getparcelableextra<user>(key_user)
  //...
 }
}

我们熟悉的使用：

val intent = viewuseractivity.intent(context, user)
startactivity(intent)

8.global constants（全局常量）

kotlin 允许跨越整个应用的全局常量。通常，常量应尽可能减少其范围，但是全局都需要这个常量时，这是一个很好的方式。

const val presentation_mode_presenting = "presenting"
const val presentation_mode_editing = "editing"

9.optional parameters(可选参数)

可选参数使得方法调用更加灵活，而不必传递 null 或默认值。 例如：这在定义动画时：

fun view.fadeout(duration: long = 500): viewpropertyanimator {
 return animate()
   .alpha(0.0f)
   .setduration(duration)
}
icon.fadeout() // fade out with default time (500)
icon.fadeout(1000) // fade out with custom time

10. extensions（扩展属性）

例如：在 activity 调用键盘的隐藏

fun activity.hidekeyboard(): boolean {
 val view = currentfocus
 view?.let {
  val inputmethodmanager = getsystemservice(context.input_method_service) 
    as inputmethodmanager
  return inputmethodmanager.hidesoftinputfromwindow(view.windowtoken,
    inputmethodmanager.hide_not_always)
 }
 return false
}

推荐一个收集 extensions 的网站 。 kotlinextensions.com

11. lateinit

对于 null 的检查是 kotlin 的特点之一，所以在数据定义时，初始化数据。但有一些在 android 中某些属性需要在 oncreate() 方法中初始化。

private lateinit var madapter: recycleradapter<transaction>

override fun oncreate(savedinstancestate: bundle?) {
 super.oncreate(savedinstancestate)
 madapter = recycleradapter(r.layout.item_transaction)
}

如果是基础数据类型：

var count: int by delegates.notnull<int>()
var name:string by delegate()

如果使用 butter knife:

@bindview(r.id.toolbar) lateinit var toolbar: toolbar
override fun oncreate(savedinstancestate: bundle?) {
  super.oncreate(savedinstancestate)
  setcontentview(r.layout.activity_main)
  butterknife.bind(this)
  // you can now reference toolbar with no problems!
  toolbar.settitle("hello there")
}

12. safe typecasting(安全转换)

在 android 中需要安全类型转换。当您首先在 kotlin 中进行类型转换时，您可以这样实现：

var feedfragment: feedfragment? = supportfragmentmanager
 .findfragmentbytag(tag_feed_fragment) as feedfragment

但实际上这样只能导致崩溃。当调用『as』时，它将进行对象转换，但如果转换的对象为『null』时，则会报错。正确的使用方式应该是用『as?』:

var feedfragment: feedfragment? = supportfragmentmanager
 .findfragmentbytag(tag_feed_fragment) as? feedfragment
if (feedfragment == null) {
 feedfragment = feedfragment.newinstance()
 supportfragmentmanager.begintransaction()
   .replace(r.id.root_fragment, feedfragment, tag_feed_fragment)
   .commit()
}

13. let 操作符

『let』操作符：如果对象的值不为空，则允许执行这个方法。

//java
if (currentuser != null) {
 text.settext(currentuser.name)
}

//instead kotlin
user?.let {
 println(it.name)
}

14. isnullorempty | isnullorblank

我们需要在开发 android 应用程序时多次验证。 如果你没有使用 kotlin 处理这个问题，你可能已经在 android 中发现了 textutils 类。

if (textutils.isempty(name)) {
 // alert the user!
}
public static boolean isempty(@nullable charsequence str) {
 return str == null || str.length() == 0;
}

如果 name 都是空格，则 textutils.isempty 不满足使用。则 isnullorblank 可用。

public inline fun charsequence?.isnullorempty(): boolean = this == null || this.length == 0

public inline fun charsequence?.isnullorblank(): boolean = this == null || this.isblank()

// if we do not care about the possibility of only spaces...
if (number.isnullorempty()) {
 // alert the user to fill in their number!
}

// when we need to block the user from inputting only spaces
if (name.isnullorblank()) {
 // alert the user to fill in their name!
}

15. 避免 kotlin 类的抽象方法

也是尽可能的使用 lambdas 。这样可以实现更简洁直观的代码。例如在 java 中的点击监听为：

public interface onclicklistener {
 void onclick(view v);
}

在 java 中使用：

view.setonclicklistener(new view.onclicklistener() {
 @override
 public void onclick(view view) {
  // do something
 }
});

而在 kotlin 中：

view.setonclicklistener { view ->
 // do something
}

//同时也可以为
view.setonclicklistener {
 // do something
}

view.setonclicklistener() {
 // do something
}

如果在 kotlin 是使用单抽象方法的话：

view.setonclicklistener(object : onclicklistener {
 override fun onclick(v: view?) {
  // do things
 }
})

下面是另一种方法：

private var onclicklistener: ((view) -> unit)? = null
fun setonclicklistener(listener: (view: view) -> unit) {
 onclicklistener = listener
}

// later, to invoke
onclicklistener?.invoke(this)

16. with 函数

with 是一个非常有用的函数，它包含在 kotlin 的标准库中。它接收一个对象和一个扩展函数作为它的参数，然后使这个对象扩展这个函数。这表示所有我们在括号中编写的代码都是作为对象（第一个参数） 的一个扩展函数，我们可以就像作为 this 一样使用所有它的 public 方法和属性。当我们针对同一个对象做很多操作的时候这个非常有利于简化代码。

with(helloworldtextview) {
 text = "hello world!"
 visibility = view.visible
}

17. static layout import

android 中最常用的代码之一是使用 findviewbyid() 来获取对应 view。

有一些解决方案，如 butterknife 库，可以节省很多代码，但是 kotlin 采取另一个步骤，允许您从一个导入的布局导入对视图的所有引用。

例如，这个 xml 布局：

<?xml version="1.0" encoding="utf-8"?>
<relativelayout xmlns:android="http://schemas.android.com/apk/res/android"
 xmlns:tools="http://schemas.android.com/tools"
 android:layout_width="match_parent"
 android:layout_height="match_parent"
 >

 <textview
  android:id="@+id/tvhelloworld"
  android:layout_width="wrap_content"
  android:layout_height="wrap_content"/>
</relativelayout>

在 activity 中：

//导入对应的 xml
import kotlinx.android.synthetic.main.activity_main.*

class mainactivity : appcompatactivity() {

 override fun oncreate(savedinstancestate: bundle?) {
  super.oncreate(savedinstancestate)
  setcontentview(r.layout.activity_main)
  //直接使用
  tvhelloworld.text = "hello world!"
 }
}

18. 用 kotlin 实现 pojo 类

在 java 中

public class user {
 private string firstname;
 private string lastname;

 public string getfirstname() {
  return firstname;
 }
 public void setfirstname(string firstname) {
  this.firstname = firstname;
 }

 public string getlastname() {
  return lastname;
 }
 public void setlastname(string lastname) {
  this.lastname = lastname;
 }
}

而在 kotlin 中可以简化成：

class user {
 var firstname: string? = null
 var lastname: string? = null
}

19. 减少 asynctash 的使用

搭配 anko lib 使用。后台和主线程的切换特别直观和简单。uithread 在主线程上运行，并且我们不需要关心 activity 的生命周期（pause 与 stop）， 所以也不会出错了。

doasync {
 var result = expensivecalculation()
 uithread {
  toast(result)
 }
}

20.apply 函数

它看起来于 with 很相似，但是是有点不同之处。apply 可以避免创建 builder 的方式来使用，因为对象调用的函数可以根据自己的需要来初始化自己，然后 apply 函数会返回它同一个对象：

user = user().apply {
 firstname = double
 lastname = thunder
}

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对的支持。