探索Kotlin实战：高效编程语言，安全替代Java

需积分: 10 14 浏览量更新于2024-07-19 1 收藏 3.18MB PDF 举报

"《Kotlin in Action》是一本由Manning Early Access Program (MEAP) 发布的关于Kotlin编程语言的专业书籍，第11版于2016年由Manning Publications出版。Kotlin被设计为一种既实用又安全、简洁且与Java高度兼容的编程语言，旨在帮助开发者减少代码量，提升抽象层次，并降低开发中的繁琐工作。对于那些已经熟悉Java的开发者，无论是服务器端开发人员还是Android应用开发者，转向Kotlin的过程通常是平滑的，无需过多学习成本。作者鼓励读者在新项目中尝试Kotlin，但同时也提供了逐步将Kotlin引入现有Java项目的选择，以实现平稳过渡。Kotlin的强大之处在于它对Java的深度集成，允许开发者在保持代码库稳定的同时，享受新语言带来的优势。此外，书中还介绍了如何通过交互式控制台或在线环境轻松探索和试用Kotlin的新特性。这使得快速上手和提高生产力成为可能。由于Kotlin旨在成为Java的替代选项，所以即使对于资深Java开发者，学习和掌握Kotlin也是提高职业竞争力的重要一步。《Kotlin in Action》是一本理想的资源，不仅适合希望全面了解Kotlin的初学者，也适合希望扩展技术栈并在Java与Kotlin之间无缝切换的开发者。通过阅读本书，读者可以深入了解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页未读，继续阅读

wei36999

粉丝: 0
资源: 4

探索Kotlin实战：高效编程语言，安全替代Java

kotlin-in-action中文版

kotlin in action高清pdf mobi epub azw3

Kotlin In Action中英版

Kotlin in Action + 源碼

Kotlin in Action.pdf

Kotlin in Action pdf 高清

Kotlin in Action.mobi

教师节主题班会.pptx

学生网络安全教育主题班会.pptx

世界环境日主题班会.pptx

最新资源