探索Kotlin：安全、简洁的编程新选择

2星需积分: 3 95 浏览量更新于2024-07-19 收藏 6.91MB PDF 举报

"《Kotlin in Action》是Manning Publications出版的一本关于Kotlin编程语言的英文书籍，适用于学习和提升编程技能，但不适用于商业开发。本书旨在介绍Kotlin，这是一种面向实用、安全、简洁且与Java高度互操作的编程语言。Kotlin能够帮助开发者用更少的代码、更高的抽象层次实现项目，减少编程中的烦恼。本书针对已经熟悉Java的开发者，无论是服务器端开发者还是Android应用开发者，从Java转向Kotlin的过程非常平滑，学习曲线不陡峭，并有多种工具辅助快速上手。Kotlin的一大优势是与Java的强大互操作性，允许你在新项目或现有Java代码库中轻松引入Kotlin，甚至可以在交互式控制台中尝试语言特性。" 在《Kotlin in Action》这本书中，作者将详细探讨以下知识点： 1. **Kotlin基础**：Kotlin的基础语法，包括变量声明、数据类型、控制流语句、函数和类的定义，以及与其他面向对象语言的异同。 2. **安全性**：Kotlin通过非空类型系统和可空性注解来避免空指针异常，这是其显著的安全特性。书中会讲解如何利用这些机制来编写安全的代码。 3. **类型系统**：Kotlin的静态类型系统和类型推断，如何使用泛型、接口和枚举等高级类型特性。 4. **函数与lambda表达式**：Kotlin支持高阶函数和内联函数，以及简洁的lambda表达式，使代码更加简洁高效。 5. **扩展函数与属性**：Kotlin允许在已有类上添加新的函数和属性，而无需继承或使用装饰者模式。 6. **互操作性**：Kotlin与Java的无缝集成，如何在Kotlin项目中调用Java代码，以及反过来在Java项目中使用Kotlin组件。 7. **Anko库**：Kotlin社区开发的Anko库可以简化Android开发，书中可能会介绍如何使用它来替代部分XML布局和Java boilerplate代码。 8. **协程（Coroutines）**：Kotlin提供的轻量级并发解决方案，适用于处理长时间运行的任务，如异步I/O，同时保持线程资源的有效管理。 9. **Android开发**：针对Android应用开发者，书中会介绍如何在Android平台上使用Kotlin，包括构建用户界面、处理生命周期和响应式编程。 10. **测试与调试**：Kotlin的单元测试、集成测试以及调试技巧，帮助开发者确保代码质量。 11. **工具支持**：IntelliJ IDEA和Android Studio等IDE对Kotlin的集成，以及Gradle构建系统的使用。 12. **最佳实践**：提供实际项目中的最佳实践和经验分享，帮助读者掌握编写高质量Kotlin代码的方法。通过阅读《Kotlin in Action》，读者不仅可以深入了解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页未读，继续阅读

billy14

粉丝: 9
资源: 6

探索Kotlin：安全、简洁的编程新选择

Kotlin In Action中英版

Kotlin in Action pdf 高清

Kotlin in Action

Kotlin in Action + 源碼

Kotlin in Action.pdf

基于Qt开发的截图工具- 支持全屏截图， 支持自定义截图，支持捕获窗口截图，支持固定大小窗口截图，颜色拾取，图片编辑

毕业设计&课设_ 校园活动管理系统，优化校园活动组织流程，涵盖多方面功能模块的便捷平台.zip

毕业设计基于ASP.NET技术的班级展示网站构建(源代码+论文).zip

基于springboot的流浪动物管理系统源码数据库文档.zip

基于springboot+vue的实践性教学系统源码数据库文档.zip

最新资源

基于Qt开发的截图工具- 支持全屏截图，支持自定义截图，支持捕获窗口截图，支持固定大小窗口截图，颜色拾取，图片编辑