Kotlin实战：MEAP版

需积分: 0 3 浏览量更新于2024-07-17 收藏 3.78MB PDF 举报

"Kotlin in Action 是一本由 Manning Publications 出版的早期访问程序（MEAP Edition）书籍，专为已熟悉 Java 的开发者介绍 Kotlin 这一编程语言。本书旨在展示 Kotlin 如何作为一个实用、安全、简洁且与 Java 兼容的替代选项。通过学习 Kotlin，开发者可以使用更少的代码、更高的抽象层次以及较少的烦恼来实现项目。" 在本书中，作者假设读者已经具备 Java 开发的基础，无论是作为服务器端开发者还是 Android 应用程序开发者。从 Java 迁移到 Kotlin 的过程非常平滑，没有陡峭的学习曲线，并且有多种工具协助这一过渡。预期读者能在短时间内掌握 Kotlin 并提高开发效率。 Kotlin 的一大优势在于其与 Java 强大的互操作性。开发者可以在新的项目中尝试 Kotlin，也可以将其逐步引入到现有的 Java 代码库中。此外，还可在交互式控制台或在线环境中轻松尝试 Kotlin 语言的各种特性，体验其灵活与便捷。 Kotlin 的主要知识点包括： 1. **类型系统**：Kotlin 拥有静态类型系统，强制类型声明有助于避免运行时错误。它支持基本类型和引用类型，并且拥有空安全特性，防止了因未检查 null 引用而导致的异常。 2. **表达式和函数**：Kotlin 语言鼓励使用表达式而非语句，这使得代码更简洁。函数是第一类公民，可以作为参数传递，也可以作为返回值。 3. **类和对象**：Kotlin 提供了类、接口、继承和多态等面向对象特性，同时支持函数式编程的扩展函数和高阶函数。 4. **属性和字段**：Kotlin 将字段和 getter/setter 包装在属性中，允许自定义访问器，提供更细粒度的控制。 5. **lambda 表达式和匿名函数**：Kotlin 的 lambda 表达式使得编写简洁的回调函数成为可能，增强了代码的可读性和可维护性。 6. **数据类**：为简化数据对象的创建，Kotlin 提供了数据类，自动生成 equals(), hashCode() 和 toString() 方法。 7. **协程**：Kotlin 的协程支持异步编程，允许编写非阻塞的并发代码，提高了资源利用率。 8. **空安全**：Kotlin 通过可空类型和智能转换来处理空指针异常，降低了编程中的常见错误。 9. **类型别名**：允许为现有类型创建别名，提高代码的可读性。 10. **Interoperability with Java**：Kotlin 可以无缝地与 Java 代码一起工作，可以直接调用 Java 类库，也可以在 Java 项目中使用 Kotlin 文件，这使得迁移和协作变得更加容易。通过 "Kotlin in Action" 这本书，读者将深入了解这些概念，并学习如何利用 Kotlin 的这些特性来改进现有的开发实践，提升开发效率和代码质量。书中的示例和练习将帮助读者快速上手，并在实际项目中应用所学知识。

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.

1.5.6 Java-to-Kotlin converter

Getting up to speed with a new language is never effortless. Fortunately, we’ve built a

nice little shortcut that lets you speed up your learning and adoption by relying on your

existing knowledge of Java. This tool is the automated Java-to-Kotlin converter.

When you start learning Kotlin, the converter can help you express something when

you don’t remember the exact syntax. You can write the corresponding snippet in Java

and then paste it into a Kotlin file, and the converter will automatically offer to translate

the code into Kotlin. The result won’t always be the most idiomatic, but it will be

working code, and you’ll be able to make progress with your task.

The converter is also great for introducing Kotlin into an existing Java project. When

you need to write a new class, you can do it in Kotlin right from the beginning. But if you

need to make significant changes to an existing class, you may also want to use Kotlin in

the process. That’s where the converter comes into play. You convert the class into

Kotlin first, and then you add the changes using all the benefits of a modern language.

Using the converter in IntelliJ IDEA is extremely easy. You can either copy a Java

code fragment and paste it into a Kotlin file, or invoke the Convert Java File to Kotlin

File action if you need to convert an entire file. The converter is accessible in Eclipse and

online as well.

1.6 Summary

Kotlin is statically typed and supports type inference, allowing it to maintain correctness

and performance while keeping the source code concise.

Kotlin supports both object-oriented and functional programming styles, enabling

higher-level abstractions through first-class functions and simplifying testing and

multithreaded development through the support of immutable values.

It works well for server-side applications, fully supporting all existing Java frameworks

and providing new tools for common tasks such as HTML generation and persistence.

It works for Android as well, thanks to a compact runtime, special compiler support for

Android APIs, and a rich library providing Kotlin-friendly functions for common

Android development tasks.

It’s free and open source, with full support for the major IDEs and build systems.

Kotlin is pragmatic, safe, concise, and interoperable, meaning it focuses on using proven

solutions for common tasks, preventing common errors such as `NullPointerException`s,

supporting compact and easy-to-read code, and unrestricted integration with Java.

剩余362页未读，继续阅读

woxinqidai

粉丝: 19
资源: 9

Kotlin实战：MEAP版

kotlin_in_action

Kotlin in Action 英文正式版非MEAP

Kotlin in Action.pdf

kotlin in action pdf中文版

kotlin菜鸟教程

Kotlin 学习资源

kotlin入门语法教程推荐一下

kotlin学习书目

kotlin中data class的主构造器和次构造器实例

Kotlin+.netCore相关的参考文献

最新资源