Kotlin Jetpack 实战 | Kotlin 编程的三重境界

时间  2020-07-06
标签 kotlin jetpack 实战 编程 三重 境界 繁體版
原文   原文链接

简介

本文假设各位已经有了 Kotlin 基础，对 Kotlin 还不熟悉的小伙伴能够去看我以前发的文章-->《Kotlin Jetpack 实战》。html

本文将带领各位用 Kotlin 一步步重构咱们的 Demo 工程，顺便一窥Kotlin 编程的三重境界。java

说明：本系列文章都只探讨 Kotlin JVM，Kotlin JS/Native 都不在探讨范围内。node

主要内容

前期准备

第一重境界：用 Java 视角写 Kotlin

第二重境界：用 Kotlin 视角写 Kotlin

第三重境界：用 Bytecode 视角写 Kotlin

结尾

前期准备

  • 将 Android Studio 版本升级到最新
  • 将咱们的 Demo 工程 clone 到本地，用 Android Studio 打开： github.com/chaxiu/Kotl…
  • 切换到分支：chapter_03_kotlin_refactor_training
  • 强烈建议各位小伙伴小伙伴跟着本文一块儿实战，实战才是本文的精髓

为工程添加 Kotlin 支持

上一章咱们已经将 Groovy 改为了 Kotlin DSL，但工程自己还不支持咱们用 Kotlin 写 Android App。因此咱们还须要作一些配置：android

Libs.kt 增长如下依赖常量：git

const val kotlinStdLib = "org.jetbrains.kotlin:kotlin-stdlib-jdk8:${Versions.kotlinVersion}"
const val ktxCore = "androidx.core:core-ktx:${Versions.ktxCore}"
复制代码

根目录下的 build.gradle.kt 新增：程序员

dependencies {
    ...
    classpath(kotlin("gradle-plugin", version = Versions.kotlinVersion))
}
复制代码

app/build.gradle.kt 新增：github

plugins {
    ...
    kotlin("android")
    kotlin("android.extensions")
}

dependencies {
    ...
    implementation(Libs.kotlinStdLib)
    implementation(Libs.ktxCore)
}
复制代码

注意事项：纯 Kotlin 开发的话作以上配置就够，但若是有 Java 混合开发的话，最好加上如下编译器参数配置，防止出现兼容性问题： app/build.gradle.kt 新增：web

android {
    ...
    // Configure Java compiler compatible with Java 1.8
    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_1_8
        targetCompatibility = JavaVersion.VERSION_1_8
    }
    // Configure Kotlin compiler target Java 1.8 when compile Kotlin to bytecode
    kotlinOptions {
        this as KotlinJvmOptions
        jvmTarget = "1.8"
    }
}
复制代码

以上配置的做用，分别是：数据库

  • 配置 Java 编译器兼容 Java 1.8
  • 配置 Kotlin 编译器以 Java 1.8 的规范生成字节码

以上修改的具体细节能够看我这个 GitHub Commit。编程

接下来咱们进入正题，用 Kotlin 重构 Java 代码。

正文

我一直认为 Kotlin 是一门易学难精的语言：入门易，精通难。若是要为 Kotlin 程序员划分境界，我以为能够划分三重境界。

1. 第一重境界：用 Java 视角写 Kotlin

这几乎是每一个 Kotlin 程序员都会经历的境界(包括曾经的我)。我曾觉得学会 Kotlin 的语法就能写好 Kotlin 代码，然而我只是把脑子里的 Java/C 代码用 Kotlin 语法翻译一遍写出来了而已。

接下来我就以第一重境界的"功力"，来重构咱们的 Demo 工程。你们看看热闹就行，千万别学进脑子里啊。[狗头]

我如今伪装本身是个新手，刚学会 Kotlin 语法。正所谓，柿子要挑软的捏，我们重构代码固然也从最简单的开始。因而我找到 Demo 工程里的 User.java，一咬牙，就你了：

public class User {
    // 工程简单到没有数据库，因此将 API 请求写死缓存到这里
    public static final String CACHE_RESPONSE = "{"login":"JakeWharton","id":66577,"node_id":"MDQ6VXNlcjY2NTc3","avatar_url":"https://avatars0.githubusercontent.com/u/66577?v=4","gravatar_id":"","url":"https://api.github.com/users/JakeWharton","html_url":"https://github.com/JakeWharton","followers_url":"https://api.github.com/users/JakeWharton/followers",小伙伴"following_url":"https://api.github.com/users/JakeWharton/following{/other_user}","gists_url":"https://api.github.com/users/JakeWharton/gists{/gist_id}","starred_url":"https://api.github.com/users/JakeWharton/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/JakeWharton/subscriptions","organizations_url":"https://api.github.com/users/JakeWharton/orgs","repos_url":"https://api.github.com/users/JakeWharton/repos","events_url":"https://api.github.com/users/JakeWharton/events{/privacy}","received_events_url":"https://api.github.com/users/JakeWharton/received_events","type":"User","site_admin":false,"name":"Jake Wharton","company":"Square","blog":"https://jakewharton.com","location":"Pittsburgh, PA, USA","email":null,"hireable":null,"bio":null,"twitter_username":null,"public_repos":104,"public_gists":54,"followers":57849,"following":12,"created_at":"2009-03-24T16:09:53Z","updated_at":"2020-05-28T00:07:20Z"}";

    private String id;
    private String login;
    private String avatar_url;
    private String name;
    private String company;
    private String blog;
    private Date lastRefresh;

    public User() { }

    public User(@NonNull String id, String login, String avatar_url, String name, String company, String blog, Date lastRefresh) {
        this.id = id;
        this.login = login;
        this.avatar_url = avatar_url;
        this.name = name;
        this.company = company;
        this.blog = blog;
        this.lastRefresh = lastRefresh;
    }

    public String getId() { return id; }
    public String getAvatar_url() { return avatar_url; }
    public Date getLastRefresh() { return lastRefresh; }
    public String getLogin() { return login; }
    public String getName() { return name; }
    public String getCompany() { return company; }
    public String getBlog() { return blog; }

    public void setId(String id) { this.id = id; }
    public void setAvatar_url(String avatar_url) { this.avatar_url = avatar_url; }
    public void setLastRefresh(Date lastRefresh) { this.lastRefresh = lastRefresh; }
    public void setLogin(String login) { this.login = login; }
    public void setName(String name) { this.name = name; }
    public void setCompany(String company) { this.company = company; }
    public void setBlog(String blog) { this.blog = blog; }
复制代码

一顿操做，我把这个 Java Bean 用 Kotlin 语法翻译成了这样：

class User {

    companion object {
        val CACHE_RESPONSE = "..."
    }

    private var id: String? = null
    private var login: String? = null
    private var avatar_url: String? = null
    private var name: String? = null
    private var company: String? = null
    private var blog: String? = null
    private var lastRefresh: Date? = null
    
    constructor() {}
    constructor(id: String, login: String?, avatar_url: String?, name: String?, company: String?, blog: String?, lastRefresh: Date?) {
        this.id = id
        this.login = login
        this.avatar_url = avatar_url
        this.name = name
        this.company = company
        this.blog = blog
        this.lastRefresh = lastRefresh
    }

    fun getId(): String? { return id }
    fun getAvatar_url(): String? { return avatar_url }
    fun getLastRefresh(): Date? { return lastRefresh }
    fun getLogin(): String? { return login }
    fun getName(): String? { return name }
    fun getCompany(): String? { return company }
    fun getBlog(): String? { return blog }

    fun setId(id: String?) { this.id = id }
    fun setAvatar_url(avatar_url: String?) { this.avatar_url = avatar_url }
    fun setLastRefresh(lastRefresh: Date?) { this.lastRefresh = lastRefresh }
    fun setLogin(login: String?) { this.login = login }
    fun setName(name: String?) { this.name = name }
    fun setCompany(company: String?) { this.company = company }
    fun setBlog(blog: String?) { this.blog = blog }
}
复制代码

我看着本身一行一行写出来的 Kotlin 代码，内心成就感满满。So easy！[狗头]

为了让工程可以模拟 Kotlin/Java 混编，咱们让 ImagePreviewActivity 继续维持 Java 状态，因此接下来就剩下 MainActivity.java 的重构了。咱们先看 MainActivity 的 Java 代码。

public class MainActivity extends AppCompatActivity {
    public static final String TAG = "Main";
    public static final String EXTRA_PHOTO = "photo";

    StringRequest stringRequest;
    RequestQueue requestQueue;

    private ImageView image;
    private ImageView gif;
    private TextView username;
    private TextView company;
    private TextView website;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        init();
    }

    private void init() {
        image = findViewById(R.id.image);
        gif = findViewById(R.id.gif);
        username = findViewById(R.id.username);
        company = findViewById(R.id.company);
        website = findViewById(R.id.website);

        display(User.CACHE_RESPONSE);
        requestOnlineInfo();
    }

    private void requestOnlineInfo() {
        requestQueue = Volley.newRequestQueue(this);
        String url ="https://api.github.com/users/JakeWharton";
        stringRequest = new StringRequest(Request.Method.GET, url,
                new Response.Listener<String>() {
                    @Override
                    public void onResponse(String response) {
                        display(response);
                    }
                }, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                Toast.makeText(MainActivity.this, error.getMessage(), Toast.LENGTH_SHORT).show();
            }
        });
        stringRequest.setTag(TAG);
        requestQueue.add(stringRequest);
    }

    private void display(@Nullable String response) {
        if (TextUtils.isEmpty(response)) { return; }

        Gson gson = new Gson();
        final User user = gson.fromJson(response, User.class);
        if (user != null){
            Glide.with(this).load("file:///android_asset/bless.gif").into(gif);
            Glide.with(this).load(user.getAvatar_url()).apply(RequestOptions.circleCropTransform()).into(image);
            this.username.setText(user.getName());
            this.company.setText(user.getCompany());
            this.website.setText(user.getBlog());

            image.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    gotoImagePreviewActivity(user);
                }
            });
        }
    }

    private void gotoImagePreviewActivity(User user) {
        Intent intent = new Intent(this, ImagePreviewActivity.class);
        intent.putExtra(EXTRA_PHOTO, user.getAvatar_url());
        startActivity(intent);
    }

    @Override
    protected void onStop () {
        super.onStop();
        if (requestQueue != null) {
            requestQueue.cancelAll(TAG);
        }
    }
}
复制代码

一通操做，我把 MainActivity 重构成了这样：

class MainActivity : AppCompatActivity() {
    companion object {
        val TAG = "Main"
        val EXTRA_PHOTO = "photo"
    }

    var stringRequest: StringRequest? = null
    var requestQueue: RequestQueue? = null

    private var image: ImageView? = null
    private var gif: ImageView? = null
    private var username: TextView? = null
    private var company: TextView? = null
    private var website: TextView? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        init()
    }

    private fun init() {
        image = findViewById(R.id.image)
        gif = findViewById(R.id.gif)
        username = findViewById(R.id.username)
        company = findViewById(R.id.company)
        website = findViewById(R.id.website)
        display(User.CACHE_RESPONSE)
        requestOnlineInfo()
    }

    private fun requestOnlineInfo() {
        requestQueue = Volley.newRequestQueue(this)
        val url = "https://api.github.com/users/JakeWharton"
        stringRequest = StringRequest(Request.Method.GET, url,
                object: Response.Listener<String> {
                    override fun onResponse(response: String?) {
                        display(response)
                    }
                }, object: Response.ErrorListener {
            override fun onErrorResponse(error: VolleyError?) {
                Toast.makeText(this@MainActivity, error?.message, Toast.LENGTH_SHORT).show()
            }
        })
        stringRequest!!.tag = TAG
        requestQueue!!.add(stringRequest)
    }

    private fun display(response: String?) {
        if (TextUtils.isEmpty(response)) {
            return
        }
        val gson = Gson()
        val user = gson.fromJson(response, User::class.java)
        if (user != null) {
            Glide.with(this).load("file:///android_asset/bless.gif").into(gif!!)
            Glide.with(this).load(user.getAvatar_url()).apply(RequestOptions.circleCropTransform()).into(image!!)
            username!!.text = user.getName()
            company!!.text = user.getCompany()
            website!!.text = user.getBlog()
            image!!.setOnClickListener(object: View.OnClickListener{
                override fun onClick(v: View?) {
                    gotoImagePreviewActivity(user)
                }
            })
        }
    }

    private fun gotoImagePreviewActivity(user: User) {
        val intent = Intent(this, ImagePreviewActivity::class.java)
        intent.putExtra(EXTRA_PHOTO, user.getAvatar_url())
        startActivity(intent)
    }

    override fun onStop() {
        super.onStop()
        if (requestQueue != null) {
            requestQueue!!.cancelAll(TAG)
        }
    }
}
复制代码

因为 MainActivity 重构成了 Kotlin，ImagePreviewActivity.java 须要对应作一些调整。缘由是 Java 还不能很好的识别伴生对象。

修改前：

public class ImagePreviewActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ...
        String url = intent.getStringExtra(MainActivity.EXTRA_PHOTO);
        ...
    }
}
复制代码

修改后：

public class ImagePreviewActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ...
        String url = intent.getStringExtra(MainActivity.Companion.getEXTRA_PHOTO());
        ...
    }
}
复制代码

小结

这个境界的特色是：一行 Kotlin 对应一行 Java，还不会运用 Kotlin 独有的特性。

以上修改的具体细节能够看我这个 GitHub Commit。

各位小伙伴千万别看到这里就走了啊，请看我下一个境界是怎么写(演)的。

2. 第二重境界：用 Kotlin 视角写 Kotlin

到第二重境界，我就是个成熟的 Kotlin 程序员了。我会用一些 Kotlin 独有特性去改善 Java 代码里的逻辑。

2-1 Data Class

咱们仍是从最简单的 User.kt 开始，看过《写给 Java 开发者的 Kotlin 入坑指南》的小伙伴必定知道 Data Class，咱们来将 User.kt 重构成 Data Class，真的会省很多代码：

data class User(
        var id: String? = null,
        var login: String? = null,
        var avatar_url: String? = null,
        var name: String? = null,
        var company: String? = null,
        var blog: String? = null,
        var lastRefresh: Date? = null
) {
    companion object {
        val CACHE_RESPONSE = "..."
    }
}
复制代码
小结

Data Class 能够节省咱们编写 Java Bean 的时间。

2-2 lateinit

接下来看 MainActivity.kt，咱们从最上面的变量开始。以前咱们定义的变量都是可为空的(Nullable)，致使这些变量在使用的时候都须要判空，或者使用非空断言!!。这很不Kotlin。解决这个问题的办法不少，这里我先用 lateinit 来解决网络请求的两个变量。

修改前：

class MainActivity : AppCompatActivity() {
    ...
    var stringRequest: StringRequest? = null
    var requestQueue: RequestQueue? = null

    private fun requestOnlineInfo() {
        ...
        stringRequest!!.tag = TAG
        requestQueue!!.add(stringRequest)
    }
}
复制代码

修改后：

class MainActivity : AppCompatActivity() {
    ...
    private lateinit var stringRequest: StringRequest
    private lateinit var requestQueue: RequestQueue

    private fun requestOnlineInfo() {
        ...
        stringRequest.tag = TAG
        requestQueue.add(stringRequest)
    }
}
复制代码

小结

通常来讲，咱们定义不为空的变量须要在构造函数或者 init 代码块里赋值，这样编译器才不会报错。但不少时候咱们的变量赋值并不能在以上状况下完成赋值，好比：findViewById。

lateinit 的做用是告诉编译器，我定义的这个不为空的变量，虽然目前没有对它赋值，但我在使用它以前，必定会对它赋值，确定不为空，你没必要报错。

2-3 Kotlin-Android-Extensions

KTX 是 Android 官方提供的一个 Gradle 插件，可以为开发者提供便利，它最著名的功能就是可以省掉 findViewById。以前咱们在工程里已经添加了这个插件，接下来直接使用就能够了。

直接将控件的申明和赋值都删掉，而后在调用的地方咱们按 option + return 选择 import：

修改前:

private var image: ImageView? = null
private var gif: ImageView? = null
private var username: TextView? = null
private var company: TextView? = null
private var website: TextView? = null

image = findViewById(R.id.image)
gif = findViewById(R.id.gif)
username = findViewById(R.id.username)
company = findViewById(R.id.company)
website = findViewById(R.id.website)

...
username!!.text = user.name
company!!.text = user.company
website!!.text = user.blog
复制代码

修改后：

// 注意这里
import kotlinx.android.synthetic.main.activity_main.*

// private var image: ImageView? = null
// private var gif: ImageView? = null
// private var username: TextView? = null
// private var company: TextView? = null
// private var website: TextView? = null

// image = findViewById(R.id.image)
// gif = findViewById(R.id.gif)
// username = findViewById(R.id.username)
// company = findViewById(R.id.company)
// website = findViewById(R.id.website)

...
username.text = user.name
company.text = user.company
website.text = user.blog
复制代码

小结

  • KTX 提供的便利固然不止是替代 findViewById，后面咱们慢慢讲
  • KTX 提供便利的同时其实有必定隐患，咱们后面再讲

2-4 Lambda

如下代码 Android Studio 会提示 Convert to lambda 咱们只须要按 option + return，Android Studio 就会帮咱们重构。

修改前：

...
stringRequest = StringRequest(Request.Method.GET, url,
        object : Response.Listener<String> {
            override fun onResponse(response: String?) {
                display(response)
            }
        }, object : Response.ErrorListener {
    override fun onErrorResponse(error: VolleyError?) {
        Toast.makeText(this@MainActivity, error?.message, Toast.LENGTH_SHORT).show()
    }
})     
...
image.setOnClickListener(object : View.OnClickListener {
    override fun onClick(v: View?) {
        gotoImagePreviewActivity(user)
    }
})
复制代码

修改后：

...
stringRequest = StringRequest(Request.Method.GET,
        url,
        Response.Listener { response ->
            display(response)
        },
        Response.ErrorListener { error ->
            Toast.makeText(this@MainActivity, error?.message, Toast.LENGTH_SHORT).show()
        })
...
image.setOnClickListener { gotoImagePreviewActivity(user) }
...
复制代码

小结

  • Kotlin Lambda 要讲清楚能专门写一本书，本文暂时只管怎么用
  • 在这里使用 Lambda 做为接口实现，最大的好处实际上是提升了代码的可读性

2-5 扩展函数

使用 Kotlin 的扩展函数能消灭一切 xxUtils.java。Kotlin 标准函数就已经为咱们提供了相关扩展函数，帮助咱们消灭 TextUtils。

修改前：

...
if (TextUtils.isEmpty(response)) {
    return
}
复制代码

修改后：

...
if (response.isNullOrBlank()) {
    return
}
复制代码

上面修改后的代码看起来像是 response 有一个成员方法: isNullOrBlank()，这样作有不少好处：

  • 写代码更流畅，一个类有哪些能够调用的方法，IDE 会自动提示，而不用去找 xxUtils
  • 代码可读性更好

2-6 标准函数 apply

Kotlin 提供了一系列标准函数，好比: let, also, with, apply 帮助开发者简化逻辑。这里咱们使用 apply，它的做用解释起来很麻烦，看代码更明了：

修改前：

if (user != null) {
    ...
    username.text = user.name
    website.text = user.blog
    image.setOnClickListener { gotoImagePreviewActivity(user) }
}
复制代码

修改后：

user?.apply {
    ...
    username.text = name
    website.text = blog
    image.setOnClickListener { gotoImagePreviewActivity(this) }
}
复制代码

小结

这个境界的特色是：

  • 一行 Kotlin 代码能对应多行 Java 代码
  • 代码可读性加强
  • 代码健壮性更好

具体细节能够看这个 Github Commit。

第三重境界：用 Bytecode 视角写 Kotlin

Kotlin 号称 Java 100% 兼容，就是由于 Kotlin 最终会被编译成字节码(Bytecode)。经过查看 Kotlin 编译后的字节码，咱们既能了解 Kotlin 的原理，也能探索出一些 Kotlin 编程的 Tips。

受限于本文的篇幅，咱们暂且不谈 Kotlin 的实现原理，也不去详细探讨 Kotlin 编程的 Tips。咱们继续专一于实战。现阶段的项目中，咱们已经尝试加入了一些 Kotlin 的特性，咱们只研究现阶段用到的这些 Kotlin 特性。

3-1 如何查看 Kotlin 对应的 字节码？

Tools -> Kotlin -> Show Kotlin Bytecode 通常咱们状况下咱们只须要查看 Kotlin 等价的 Java 代码便可，所以咱们能够在字节码弹窗的左上角找到 Decompile 按钮，这样就能看到 Kotlin 等价的 Java 代码了。

3-2 尽量消灭可变性(Mutability)

Java 中被 final 修饰的变量一旦赋值后就没法被修改。这在 Java 中也是很好的习惯，咱们在 Kotlin 中也应该沿用。Kotlin 没有 final，可是有 val。

咱们仍是先从 User.kt 开始。

data class User(
        var id: String? = null,
        var login: String? = null,
        var avatar_url: String? = null,
        var name: String? = null,
        var company: String? = null,
        var blog: String? = null,
        var lastRefresh: Date? = null
) {
    companion object {
        val CACHE_RESPONSE = "..."
    }
}
复制代码

User.kt 反编译成 Java 后：

...
public final class User {
   @Nullable
   private String id;
   ...
   @NotNull
   private static final String CACHE_RESPONSE = "...";
   public static final User.Companion Companion = new User.Companion((DefaultConstructorMarker)null);

   @Nullable
   public final String getId() {
      return this.id;
   }

   public final void setId(@Nullable String var1) {
      this.id = var1;
   }
   ...
   public static final class Companion {
      @NotNull
      public final String getCACHE_RESPONSE() {
         return User.CACHE_RESPONSE;
      }

      private Companion() {
      }

      // $FF: synthetic method
      public Companion(DefaultConstructorMarker $constructor_marker) {
         this();
      }
   }
}
复制代码

咱们将 User.kt 里面的 var 都替换成 val：

data class User(
        val id: String? = null,
        val login: String? = null,
        val avatar_url: String? = null,
        val name: String? = null,
        val company: String? = null,
        val blog: String? = null,
        val lastRefresh: Date? = null
) {
    companion object {
        val CACHE_RESPONSE = "..."
    }
}
复制代码

它反编译成 Java 代码变成了这样：

public final class User {
   @Nullable
   private final String id; // 多了 final
   ...
   @NotNull
   private static final String CACHE_RESPONSE = "...";
   public static final User.Companion Companion = new User.Companion((DefaultConstructorMarker)null);

   @Nullable
   public final String getId() {
      return this.id;
   }
   // setId() 没有了
   ...

   public static final class Companion {
      @NotNull
      public final String getCACHE_RESPONSE() {
         return User.CACHE_RESPONSE;
      }

      private Companion() {
      }

      // $FF: synthetic method
      public Companion(DefaultConstructorMarker $constructor_marker) {
         this();
      }
   }
}
复制代码

小结：

  • Kotlin 基于 JVM，因此从前 Java 的编程经验也是有用的
  • 将 Data Class 的 var 改为 val 后，它的成员变量就有 final 修饰了，同时set 方法也没了，一个 Data Class 在被实例化后，就没法再被修改了
  • 若是要修改 Data Class 的成员变量怎么办？用 copy 方法

3-3 尽量缩小变量的做用域(Scope)

这一点在 Java 和 Kotlin 中一样有用。MainActivity.kt 中有两个成员变量，其中的 stringRequest 实际上是能够改成局部变量的。

修改前：

class MainActivity : AppCompatActivity() {
    ...
    private lateinit var stringRequest: StringRequest
    private lateinit var requestQueue: RequestQueue
}
复制代码

修改后：

class MainActivity : AppCompatActivity() {
    ...
// private lateinit var stringRequest: StringRequest
    private lateinit var requestQueue: RequestQueue
    
    private fun requestOnlineInfo() {
    ...
    val stringRequest = StringRequest(Request.Method.GET,
            url,
            Response.Listener { response ->
                display(response)
            },
            Response.ErrorListener { error ->
                Toast.makeText(this@MainActivity, error?.message, Toast.LENGTH_SHORT).show()
            })
    ...
    }
}
复制代码

3-4 巧用 by lazy

MainActivity 只剩下一个成员变量 requestQueue，它仍是用的 var 修饰的，咱们能不能把它改成 val 呢？固然能够，但咱们须要借助 by lazy，委托。

修改后:

class MainActivity : AppCompatActivity() {
    ...
    private val requestQueue: RequestQueue by lazy { 
        Volley.newRequestQueue(this)
    }
}
复制代码

让咱们看看它等价的 Java 代码，它的初始化交给了 LazyKt.lazy：

private final Lazy requestQueue$delegate = LazyKt.lazy((Function0)(new Function0() {
  // $FF: synthetic method
  // $FF: bridge method
  public Object invoke() {
     return this.invoke();
  }

  public final RequestQueue invoke() {
     return Volley.newRequestQueue((Context)MainActivity.this);
  }
}));
复制代码

再看看 LazyKt.lazy 的实现，其实是 SynchronizedLazyImpl：

public actual fun <T> lazy(initializer: () -> T): Lazy<T> = SynchronizedLazyImpl(initializer)
复制代码

再看看 SynchronizedLazyImpl:

private class SynchronizedLazyImpl<out T>(initializer: () -> T, lock: Any? = null) : Lazy<T>, Serializable {
    private var initializer: (() -> T)? = initializer
    @Volatile private var _value: Any? = UNINITIALIZED_VALUE
    // final field is required to enable safe publication of constructed instance
    private val lock = lock ?: this

    override val value: T
        get() {
            val _v1 = _value
            if (_v1 !== UNINITIALIZED_VALUE) {
                @Suppress("UNCHECKED_CAST")
                return _v1 as T
            }

            return synchronized(lock) {
                val _v2 = _value
                if (_v2 !== UNINITIALIZED_VALUE) {
                    @Suppress("UNCHECKED_CAST") (_v2 as T)
                } else {
                    val typedValue = initializer!!()
                    _value = typedValue
                    initializer = null
                    typedValue
                }
            }
        }

    override fun isInitialized(): Boolean = _value !== UNINITIALIZED_VALUE

    override fun toString(): String = if (isInitialized()) value.toString() else "Lazy value not initialized yet."

    private fun writeReplace(): Any = InitializedLazyImpl(value)
}
复制代码

果真，和咱们以前文章提到的同样，by lazy 默认状况下会使用同步的方式进行初始化。但咱们当前项目并不须要，毕竟多线程同步也是有开销的。

修改后：

private val requestQueue: RequestQueue by lazy(LazyThreadSafetyMode.NONE) {
    Volley.newRequestQueue(this)
}
复制代码

3-5 不要用错伴生对象

因为 Java 没法识别 Kotlin 里面的伴生对象，因此咱们在 Java 里访问的时候比较别扭。

class MainActivity : AppCompatActivity() {
    companion object {
        ...
        val EXTRA_PHOTO = "photo"
    }
}
复制代码

在 Java 中访问：

public class ImagePreviewActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        ...
        String url = intent.getStringExtra(MainActivity.Companion.getEXTRA_PHOTO());
        ...
    }
}
复制代码

反编译后：

...
@NotNull
private static final String EXTRA_PHOTO = "photo";
public static final MainActivity.Companion Companion = new MainActivity.Companion((DefaultConstructorMarker)null);

...
public static final class Companion {
  @NotNull
  public final String getEXTRA_PHOTO() {
     return MainActivity.EXTRA_PHOTO;
  }

  private Companion() {
  }

  // $FF: synthetic method
  public Companion(DefaultConstructorMarker $constructor_marker) {
     this();
  }
}
复制代码

咱们能够看到，默认状况下，Kotlin 为伴生对象里的变量生成了 get 方法，Java 代码里要访问这个变量必须这样： MainActivity.Companion.getEXTRA_PHOTO()，这很不友好。

为了让 Java 可以更好的识别伴生对象里的变量和方法，咱们能够这么作：

使用 const：

class MainActivity : AppCompatActivity() {
    companion object {
        ...
        const val EXTRA_PHOTO = "photo"
    }
}
复制代码

或者使用 @JvmField 注解：

class MainActivity : AppCompatActivity() {
    companion object {
        ...
        @JvmField
        val EXTRA_PHOTO = "photo"
    }
}
复制代码

在 Java 中访问：

public class ImagePreviewActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        ...
        String url = intent.getStringExtra(MainActivity.EXTRA_PHOTO);
        ...
    }
}
复制代码

以上两种状况反编译成 Java 的代码以下：

...
@NotNull
public static final String EXTRA_PHOTO = "photo";
public static final MainActivity.Companion Companion = new MainActivity.Companion((DefaultConstructorMarker)null);

...
public static final class Companion {
  @NotNull
  public final String getTAG() {
     return MainActivity.TAG;
  }

  private Companion() {
  }

  // $FF: synthetic method
  public Companion(DefaultConstructorMarker $constructor_marker) {
     this();
  }
}
复制代码

很多博客讲伴生对象到这里就结束了。@JvmField，const，@JvmStatic，这些确实是使用伴生对象须要注意的。

但是，我们的代码到这里是否是就完美了？并不。

咱们能够看到，即便咱们加上了 @JvmField 或者 const，伴生对象仍然为常量生成了 get 方法，同时也定义了一个 Companion 的类，还有一个 instance。然而咱们最初的需求只是要定义一个 public static final String 的常量而已。

这个小结的标题是不要用错伴生对象。它的前提是什么？它的前提是：该不应用。在这里我不由要问一句：这种状况下，真的须要伴生对象吗？答案是：不须要。

MainActivity 中的 TAG 不须要在类之外被访问，所以能够直接定义为成员变量：

class MainActivity : AppCompatActivity() {
    private val TAG = "Main"
}
复制代码

如今只剩下 EXTRA_PHOTO，咱们应该怎么处理？在 Java 中，咱们常常会定义一个类来专门存放常量，Kotlin 中咱们一样能够借鉴：

让咱们建立一个 Constant.kt:

//注意这里，它要放到 package 的前面
@file:JvmName("Constant")

package com.boycoder.kotlinjetpackinaction

const val EXTRA_PHOTO = "photo"

const val CACHE_RESPONSE = "..."
复制代码

在 Kotlin 中能够直接这样使用：

// Kotlin 中甚至能够省略掉 Constant，由于 CACHE_RESPONSE 是顶层常量。
display(CACHE_RESPONSE)
复制代码

在 Java 中要这样使用：

// 因为 @file:JvmName("Constant") 的存在，Java 中也能很好的访问 Constant.EXTRA_PHOTO
String url = intent.getStringExtra(Constant.EXTRA_PHOTO);
复制代码

Constant.kt 反编译成 Java 后是这样的：

public final class Constant {
  @NotNull
  public static final String EXTRA_PHOTO = "photo";
  @NotNull
  public static final String CACHE_RESPONSE = "...";
}
复制代码

因此说，若是只是须要定义静态常量，哪用得上 Kotlin 的伴生对象？

以上修改的具体细节能够看我这个 Github Commit。

总结：

  • Java 的编程经验在 Kotlin 中也是有用的，但咱们又不能被 Java 里的经验禁锢
  • Kotlin 中引入了 Java 所没有的特性和概念，咱们在使用前最好能用清楚底层实现
  • 网上博客写的最佳实践不必定对(包括本文)，要独立思考

4. 结尾

本文只是借助咱们的 Demo 一窥 Kotlin 编程的三重境界，让你们对 Kotlin 编程总体有个了解。后面我也许会写专题文章来说《Kotlin 编译器漫游指南》，《Kotlin 最佳实践指北》，也许吧。

文章写到这已经接近尾声了，那咱们的 Demo 工程改到这个程度是否是已经完美了呢？固然没有。但我不想写了，欢迎各位小伙伴留言一块儿讨论还有哪些地方能改进。

咱们下一篇文章再见。

回目录-->《Kotlin Jetpack 实战》

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程