Kotlin编程实战：打造高效应用

需积分: 9 19 浏览量更新于2024-07-18 收藏 3.62MB PDF 举报

"Kotlin in Action 是一本2017年的英文MEAP（Manning Early Access Program）版书籍，专注于教授读者如何使用Kotlin语言进行高效且高质量的应用程序开发。这本书特别针对有经验的Java开发者，深入探讨了包括构建领域特定语言（DSL）在内的高级主题。由于作者是Kotlin的核心开发者，因此书中的内容具有极高的权威性和准确性。" Kotlin是一种现代化的编程语言，由JetBrains公司设计，旨在提供一种更加实用、安全、简洁且与Java高度互操作的替代方案。Kotlin的出现让开发者能够用更少的代码、更高的抽象级别以及较少的冗余和困扰编写项目。对于已经熟悉Java的开发者来说，从Java过渡到Kotlin是一个平滑的过程，无需陡峭的学习曲线。在Kotlin的众多优势中，其与Java的强交互性尤其突出。这意味着开发者可以在新项目中尝试Kotlin，也可以将其逐步引入现有的Java代码库，而不会遇到太大的兼容性问题。此外，Kotlin还支持轻松试用新特性，使得在现有项目中添加Kotlin功能变得简单。书中详细介绍了Kotlin的各种核心概念和特性，例如： 1. 类和对象：Kotlin提供了更简洁的类定义和对象表达式，支持接口和默认实现，以及带有伴生对象的单例模式。 2. 函数和属性：Kotlin的函数和属性声明更加灵活，可以包含类型推断和可空性注解，减少运行时错误。 3. 高级类型系统：包括类型别名、类型投影和泛型，帮助开发者编写更加清晰和安全的代码。 4. 扩展函数和属性：允许在不修改原有类的情况下增加功能，保持类的原始结构。 5. 面向表达式的语法：许多语句可以作为表达式，使得代码更紧凑，更易于阅读。 6. null 安全性：Kotlin通过强制类型的非空性来防止空指针异常，提高了代码的安全性。 7. lambda 表达式和函数式编程：Kotlin 支持高阶函数和lambda表达式，便于进行函数式编程和操作集合。 8. 嵌套类和匿名类：使得复杂的代码结构得以简化，提高代码可读性。 9. 反射和元编程：允许在运行时检查和修改对象的结构，增强了语言的灵活性。通过阅读本书，读者将全面了解Kotlin语言，并能熟练掌握其在实际项目中的应用。无论你是服务器端开发者还是Android应用开发者，Kotlin都能帮助你提升开发效率，减少维护成本。同时，由于Kotlin与Java的无缝集成，你还可以在现有的Java项目中逐渐引入Kotlin，享受到它的诸多优点。

because of that, treating IDE support as an afterthought isn’t an option. In the case of

Kotlin, the IntelliJ IDEA plug-in was developed in lockstep with the compiler, and

language features were always designed with tooling in mind.

The IDE support also plays a major role in helping you discover the features of

Kotlin. In many cases, the tools will automatically detect common code patterns that can

be replaced by more concise constructs, and offer to fix the code for you. By studying the

language features used by the automated fixes, you can learn to apply those features in

your own code as well.

1.4.2 Concise

It’s common knowledge that developers spend more time reading existing code than

writing new code. Imagine you’re a part of a team developing a big project, and you need

to add a new feature or fix a bug. What are your first steps? You look for the exact

section of code that you need to change, and only then do you implement a fix. You read

a lot of code to find out what you have to do. This code might have been written recently

by your colleagues, or by someone who no longer works on the project, or by you, but

long ago. Only after understanding the surrounding code can you make the necessary

modifications.

The simpler and more concise the code is, the faster you’ll understand what’s going

on. Of course, good design and expressive names play a significant role here. But the

choice of the language and its conciseness are also important. The language is concise if

its syntax clearly expresses the intent of the code you read and doesn’t obscure it with

boilerplate required to specify how the intent is accomplished.

In Kotlin, we’ve tried hard to ensure that all the code you write carries meaning, and

isn’t just there to satisfy conventions. A lot of the standard Java boilerplate, such as

getters, setters, and the logic for assigning constructor parameters to fields, is implicit in

Kotlin and doesn’t clutter your source code.

Another reason code can be unnecessarily long is having to write explicit code to

perform common tasks, such as locating an element in a collection. Just like many other

modern languages, Kotlin has a rich standard library that lets you replace these long,

repetitive sections of code with library method calls. Kotlin’s support for lambdas makes

it easy to pass small blocks of code to library functions. This lets you encapsulate all the

common parts in the library and keep only the unique, task-specific portion in the user

code.

At the same time, Kotlin doesn’t try to collapse the source code to the smallest

number of characters possible. For example, even though Kotlin supports operator

overloading, users can’t define their own operators. Therefore, library developers can’t

replace the method names with cryptic punctuation sequences. Words are typically easier

to read than punctuation and easier to find documentation on, even if they’re somewhat

longer.

More concise code takes less time to write and, more important, less time to read.

This improves your productivity and lets you get things done faster.

1.4.3 Safe

In general, when we speak of a programming language as safe, we mean its design

prevents certain kinds of errors in a program. Of course, this isn’t an absolute quality; no

language prevents all possible errors. In addition, preventing errors usually comes at a

cost. You need to give the compiler more information about the intended operation of the

program, so the compiler can then verify that the information matches what the program

does. Because of that, there’s always a trade-off between the level of safety you get and

the loss of productivity required to put in more detailed annotations.

With Kotlin, we’ve attempted to achieve a higher level of safety than in Java, with a

smaller overall cost. Running on the JVM already provides a lot of safety guarantees: for

example, memory safety, preventing buffer overflows, and other problems caused by

incorrect use of dynamically allocated memory. As a statically typed language on the

JVM, Kotlin also ensures the type safety of your applications. This comes at a smaller

cost than with Java: you don’t have to specify all the type declarations, because in many

cases the compiler infers the types automatically.

Kotlin also goes beyond that, meaning more errors can be prevented by checks at

compile time instead of failing at runtime. Most important, Kotlin strives to remove the

NullPointerException

from your program. Kotlin’s type system tracks values that can

and can’t be null and forbids operations that can lead to a NullPointerException at

runtime. The additional cost required for this is minimal: marking a type as nullable takes

only a single character, a question mark at the end:

May be null

May not be null

In addition, Kotlin provides many convenient ways to handle nullable data. This helps

greatly in eliminating application crashes.

Another type of exception that Kotlin helps avoid is the ClassCastException. It

happens when you cast an object to a type without first checking that it has the right type.

In Java, developers often leave out the check, because the type name must be repeated in

val s: String? = null

val s2: String = ""

the check and in the following cast. In Kotlin, on the other hand, the check and the cast

are combined into a single operation: once you’ve checked the type, you can refer to

members of that type without any additional casts. Thus, there’s no reason to skip the

check, and no chance to make an error. Here’s how this works:

Checks the type

Uses the method of the type

1.4.4 Interoperable

Regarding interoperability, your first concern probably is, "Can I use my existing

libraries?" With Kotlin, the answer is, "Yes, absolutely." Regardless of the kind of APIs

the library requires you to use, you can work with them from Kotlin. You can call Java

methods, extend Java classes and implement interfaces, apply Java annotations to your

Kotlin classes, and so on.

Unlike some other JVM languages, Kotlin goes even further with interoperability,

making it effortless to call Kotlin code from Java as well. No tricks are required: Kotlin

classes and methods can be called exactly like regular Java classes and methods. This

gives you the ultimate flexibility in mixing Java and Kotlin code anywhere in your

project. When you start adopting Kotlin in your Java project, you can run the Java-to-

Kotlin converter on any single class in your codebase, and the rest of the code will

continue to compile and work without any modifications. This works regardless of the

role of the class you’ve converted.

Another area where Kotlin focuses on interoperability is its use of existing Java

libraries to the largest degree possible. For example, Kotlin doesn’t have its own

collections library. It relies fully on Java standard library classes, extending them with

additional functions for more convenient use in Kotlin. (We’ll look at the mechanism for

this in more detail in section XREF ID_extension_functions.) This means you never need

to wrap or convert objects when you call Java APIs from Kotlin, or vice versa. All the

API richness provided by Kotlin comes at no cost at runtime.

The Kotlin tooling also provides full support for cross-language projects. It can

compile an arbitrary mix of Java and Kotlin source files, regardless of how they depend

on each other. The IDE features work across languages as well, allowing you to do things

like the following:

Navigate freely between Java and Kotlin source files

Debug mixed-language projects and step between code written in different languages

if (value is String)

println(value.toUpperCase())

your application.

In most real-life cases, you’ll be using a build system such as Maven, Gradle, or Ant

to compile your code. Kotlin is compatible with all those build systems, and we’ll discuss

the details in appendix A. All of those build systems also support mixed-language

projects that combine Kotlin and Java in the same codebase. Maven and Gradle also take

care of including the Kotlin runtime library as a dependency of your application.

1.5.2 Plug-in for IntelliJ IDEA and Android Studio

The IntelliJ IDEA in for Kotlin has been developed in parallel with the language itself,

and it’s the most full-featured development environment available for Kotlin. It’s mature

and stable, and it provides a complete set of tools for Kotlin development.

The Kotlin plug-in is included out of the box with IntelliJ IDEA 15 and later versions,

so no additional setup is necessary. You can use either the free, open source IntelliJ

IDEA Community Edition or IntelliJ IDEA Ultimate. Select Kotlin in the New Project

dialog, and you’re good to go.

If you’re using Android Studio, you can install the Kotlin plug-in from the plug-in

manager. In the Settings dialog, select Plugins, then click the Install JetBrains Plugin

button, and select Kotlin from the list.

1.5.3 Interactive shell

If you want to quickly try out small fragments of Kotlin code, you can do that using the

interactive shell (the so-called REPL). In the REPL, you can type Kotlin code line by line

and immediately see the results of its execution. To start the REPL, you can either run the

kotlinc command with no arguments or use the corresponding menu item in the IntelliJ

IDEA plug-in.

1.5.4 Eclipse plug-in

If you’re an Eclipse user, you also have the option to use Kotlin in your IDE. The Kotlin

Eclipse plug-in provides essential IDE functionality such as navigation and code

completion. The plug-in is available in the Eclipse Marketplace. To install it, choose the

Help > Eclipse Marketplace menu item, and search for Kotlin in the list.

1.5.5 Online playground

The easiest way to try Kotlin doesn’t require any installation or configuration. At

https://try.kotl.in/, you can find an online playground where you can write, compile, and

run small Kotlin programs. The playground has code samples demonstrating the features

of Kotlin, as well as a series of exercises for learning Kotlin interactively.

剩余363页未读，继续阅读

Cloudiver

粉丝: 0
资源: 1

Kotlin编程实战：打造高效应用

Kotlin in Action 英文正式版非MEAP

Kotlin In Action中英版

Kotlin实战：MEAP版

Kotlin_in_Action_v12_MEAP_javaprogramming_kotlin_identityl3j_

Kotlin实战v12 MEAP：探索新编程语言的高效实践

Kotlin编程实践：英文版带书签与个人笔记

Kotlin实战：新一代编程语言

探索Kotlin实战：高效编程新选择

Kotlin实战：迈向高效编程的捷径

Kotlin实战：面向Java开发者的全新选择

最新资源