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

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

"《Kotlin in Action》是一本由Manning Publications在2016年发行的MEAP（Manning Early Access Program）版本书籍，它专注于介绍Kotlin编程语言。Kotlin作为一款新兴的语言，因其实用、安全、简洁和与Java的高度互操作性而备受开发者喜爱。该书面向已经熟悉Java的开发者，无论是服务器端开发人员还是Android应用开发者，旨在帮助他们平滑地过渡到Kotlin，减少学习曲线，并通过提供工具支持加速生产力提升。 Kotlin的一大亮点是其对Java的兼容性。读者可以考虑在新项目中尝试Kotlin，同时也可以逐步将其引入到现有的Java代码库中，无需彻底重构。此外，书中还提供了交互式学习方式，如在控制台中体验Kotlin语言的新特性，这使得学习过程更为直观且易于上手。通过《Kotlin in Action》，读者将了解到如何用更少的代码实现项目，提高抽象层次，减少编程中的繁琐。书中的内容涵盖了Kotlin的基础语法、设计模式、函数式编程特性、以及如何利用Kotlin优化Android开发流程。随着Kotlin使用范围的不断扩大，本书不仅适合希望深入学习Kotlin的专业人士，也对那些寻求语言升级的开发者具有很高的参考价值。要获取更多关于这本书和Manning其他出版物的信息，访问www.manning.com。购买MEAP版本意味着读者可以尽早接触到最新内容，并参与到Kotlin语言的探索之旅中。《Kotlin in Action》是提升编程技能，尤其是Java开发者转向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页未读，继续阅读

bitiwangui

粉丝: 1
资源: 3

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

Kotlin In Action中英版

Kotlin in Action pdf 高清

kotlin in action pdf中文版

kotlin菜鸟教程

Kotlin 学习资源

kotlin入门语法教程推荐一下

kotlin学习书目

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

Kotlin+.netCore相关的参考文献

kotlin AppWidgetProvider获取Intent

最新资源