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

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

"Kotlin_in_Action 英文带完整书签和个人批注笔记" 《Kotlin in Action》是一本详细介绍Kotlin编程语言的书籍，适用于已经熟悉Java的开发者，无论是服务器端开发者还是Android应用开发者。该书通过Manning Early Access Program (MEAP) 提供，意味着读者可以提前获取到还在开发中的内容，并随着版本更新获得最新的知识。 Kotlin是一种实用、安全、简洁且与Java高度互操作的编程语言。它旨在减少代码量，提高抽象层次，消除编程中的常见烦恼。对于Java开发者来说，转向Kotlin的过程是平滑的，学习曲线相对平缓，而且有许多工具可以帮助这个转换过程，预期能快速提升开发者使用Kotlin的生产力。书中强调了Kotlin与Java的强交互性，这意味着你可以在一个新的项目中尝试Kotlin，也可以逐步将其引入现有的Java代码库中。此外，Kotlin的特性可以在交互式控制台或在线环境中轻松试用，这为学习和探索提供了便利。 Kotlin的一些关键特性包括： 1. **类型安全**：Kotlin是一种静态类型的语言，编译器可以在编译时检查错误，减少了运行时错误。 2. **空安全**：Kotlin对null进行了严格的处理，避免了空指针异常，增强了代码的安全性。 3. **扩展函数与属性**：Kotlin允许为类添加非侵入性的功能，而无需继承或使用装饰者模式。 4. **高阶函数**：支持将函数作为参数传递和返回，便于编写函数式编程风格的代码。 5. **协程（Coroutines）**：提供了一种轻量级的并发机制，解决了异步编程中的复杂性问题。 6. **Anko库**：Kotlin社区提供的一个库，简化了Android开发中的许多任务，如DSL（领域特定语言）用于创建XML布局等。 7. **Interoperability with Java**：Kotlin可以无缝地与Java代码集成，允许在同一个项目中混合使用两种语言。书中会详细讲解这些概念，并通过实例和作者的批注笔记帮助读者理解和掌握Kotlin。对于想要提升编程效率、探索新语言特性的Java开发者来说，这本书是一份宝贵的资源。

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页未读，继续阅读

devilist

粉丝: 8
资源: 5

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

Kotlin in Action 英文正式版非MEAP

Manning.Kotlin.in.Action.

Kotlin_in_Action_v12_MEAP_javaprogramming_kotlin_identityl3j_

kotlin_in_action

Flutter开发语言dart_in_action, android开发_kotlin_in_action

kotlin_in_chinese

Kotlin_for_Android_Developers_kotlin_android_easy_

Kotlin_LiveData_DataBinding_Retrofit_MVVM：Kotlin_LiveData_DataBinding_Retrofit_MVVM

阿里云java短信验证码源码-easy_kotlin_chapter_1:easy_kotlin_chaptor_1

EventsCalendar_kotlinandroid_kotlin_

最新资源