深入学习Kotlin编程

需积分: 5 190 浏览量更新于2024-07-17 收藏 2.34MB PDF 举报

"编程Kotlin——一本面向已有的Java开发者，旨在了解JVM另一种语言的深入指南。由Stefan Bocutiu和Stephen Samuel撰写，本书涵盖了Kotlin的各种特性，包括命令行编译运行、Kotlin运行时、交互式REPL、脚本支持、与Gradle和Maven的集成、在IntelliJ IDEA与Eclipse中的使用，以及Java和Kotlin混用的项目实践。" 在《Programming Kotlin》这本书中，作者Stefan Bocutiu和Stephen Samuel为那些已经熟悉Java的开发者们提供了一条探索Kotlin语言的新路径。这本书详细介绍了Kotlin的各项功能，帮助读者从入门到精通。第一章"Getting Started with Kotlin"首先引导读者熟悉Kotlin的基础操作。这包括如何使用命令行编译和运行Kotlin代码，了解Kotlin的运行时环境，以及利用Read-Eval-Print Loop (REPL)进行快速的代码测试和实验。此外，还讨论了Kotlin在脚本编写中的应用，以及如何在构建工具Gradle和Maven中集成Kotlin，以实现更高效的项目管理。对于IDE用户，书中详细介绍了IntelliJ IDEA和Eclipse中设置Kotlin的步骤，并且探讨了如何在一个项目中混合使用Java和Kotlin。第二章"Kotlin Basics"深入讲解了Kotlin的基础语法。这部分涵盖了变量（vals和vars）、类型推断、基本数据类型（如数字、布尔值、字符和字符串）以及数组。书中还介绍了注释、包管理和导入机制，包括通配符导入和导入重命名。此外，读者将学习到Kotlin的字符串模板、范围操作、循环结构、异常处理机制，以及类的实例化。同时，书中详细阐述了引用相等性和结构相等性，`this`表达式的用法，作用域以及访问修饰符（如public、private、protected等）的概念。此书内容丰富，不仅适合初学者，也对有一定经验的开发者具有很高的参考价值，能够帮助他们快速上手Kotlin，并将其融入现有的Java开发工作中。通过阅读本书，读者将能够全面理解Kotlin语言的特性和用法，从而提升自己的编程能力。

[ 6 ]
Downloading the color images of this book 
We also provide you with a PDF file that has color images of the screenshots/diagrams used
in this book. The color images will help you better understand the changes in the output.
You can download this file from h t t p s ://w w w . p a c k t p u b . c o m /s i t e s /d e f a u l t /f i l e s /d o w n
l o a d s /P r o g r a m m i n g K o t l i n _ C o l o r I m a g e s . p d f .
Errata
Although we have taken every care to ensure the accuracy of our content, mistakes do
happen. If you find a mistake in one of our books—maybe a mistake in the text or the
code—we would be grateful if you could report this to us. By doing so, you can save other
readers from frustration and help us improve subsequent versions of this book. If you find
any errata, please report them by visiting h t t p ://w w w . p a c k t p u b . c o m /s u b m i t - e r r a t a ,
selecting your book, clicking on the Errata Submission Form link, and entering the details
of your errata. Once your errata are verified, your submission will be accepted and the
errata will be uploaded to our website or added to any list of existing errata under the
Errata section of that title.
To view the previously submitted errata, go to h t t p s ://w w w . p a c k t p u b . c o m /b o o k s /c o n t e n
t /s u p p o r t and enter the name of the book in the search field. The required information will
appear under the Errata section.

Getting Started with Kotlin

[ 8 ]

Using the command line to compile and run

Kotlin code

To write and execute code written in Kotlin, you will need its runtime and the compiler. At

the time of writing, version 1.1 milestone 4 is available (the stable release is 1.0.6). Every

runtime release comes with its own compiler version. To get your hands on it, navigate to h

t t p s ://g i t h u b . c o m /J e t B r a i n s /k o t l i n /r e l e a s e s /t a g /v 1. 1- M 04, scroll to the bottom of

the page, and download and unpack the ZIP archive kotlin-compiler-1.1-M04.zip to

a known location on your machine. The output folder will contain a subfolder bin with all

the scripts required to compile and run Kotlin on Windows, Linux, or OS X. Now you need

to make sure the bin folder location is part of your system PATH in order to call the

kotlinc without having to specify the full path.

If your machine runs Linux or OS X, there is an even easier way to install the compiler by

using sdkman. All you need to do is execute the following commands in a terminal:

$ curl -s https://get.sdkman.io | bash

$ bash

$ sdk install kotlin 1.1-M04

Alternatively, if you are using OS X and you have homebrew installed, you could run these

commands to achieve the same thing:

$ brew update

$ brew install kotlin@1.1-M04

Now that all of this is done, we can finally write our first Kotlin code. The application we

will be writing does nothing else but display the text Hello World! on the console. Start

by creating a new file named HelloWorld.kt and type the following:

fun main(args: Array<String>) {

println("Hello, World!")

}

From the command line, invoke the compiler to produce the JAR assembly (include-

runtime is a flag for the compiler to produce a self-contained and runnable JAR by

including the Kotlin runtime into the resulting assembly):

kotlinc HelloWorld.kt -include-runtime -d HelloWorld.jar

Now you are ready to run your program by typing the following on your command line; it

is assumed your JAVA_HOME is set and added to the system path:

Getting Started with Kotlin

[ 9 ]

$ java -jar HelloWorld.jar

The code is pretty straight forward. It defines the entry point function for your program,

and in the first and only line of code, it prints the text to the console.

If you have been working with the Java or Scala languages, you might raise an eyebrow

because you noticed the lack of the typical class that would normally define the standard

static main program entry point. How does it work then? Let's have a look at what

actually happens. First, let's just compile the preceding code by running the following

command. This will create a HelloWorld.class in the same folder:

$ kotlinc HelloWorld.kt

Now that we have the bytecode generated, let's look at it by using the javap tool available

with the JDK (please note that the file name contains a suffix Kt):

$ javap -c HelloWorldKt.class

Once the execution completes, you should see the following printed on your terminal:

Compiled from "HelloWorld.kt"

public final class HelloWorldKt {

public static final void main(java.lang.String[]);

Code:

0: aload_0

1: ldc #9 // String args

3: invokestatic #15 // Method

kotlin/jvm/internal/Intrinsics.checkParameterIsNotNull:(Ljava/lang/Ob

ject;Ljava/lang/String;)V

6: ldc #17 // String Hello, World!

8: astore_1

9: nop

10: getstatic #23 // Field

java/lang/System.out:Ljava/io/PrintStream;

13: aload_1

14: invokevirtual #29 // Method

java/io/PrintStream.println:(Ljava/lang/Object;)V

17: return

}

You don't have to be an expert in bytecode to understand what the compiler has actually

done for us. As you can see on the snippet, a class has been generated for us, and it contains

the program entry point with the instructions to print Hello World! to the console.

I would not expect you to work with the command line compiler on a daily basis; rather,

you should use the tools at hand to delegate this, as we will see shortly.

Getting Started with Kotlin

[ 10 ]

Kotlin runtime

When we compiled Hello World! and produced the JAR, we instructed the compiler to

bundle in the Kotlin runtime. Why is the runtime needed? Take a closer look at the

bytecode generated, if you haven't already. To be more specific, look at line 3. It invokes a

method to validate that the args variable is not null; thus, if you compile the code without

asking for the runtime to be bundled in and try to run it, you will get an exception.

$ kotlinc HelloWorld.kt -d HelloWorld.jar

$ java -jar HelloWorld.jar

Exception in thread "main" java.lang.NoClassDefFoundError:

kotlin/jvm/internal/Intrinsics at HelloWorldKt.main(HelloWorld.kt)

Caused by: java.lang.ClassNotFoundException:

kotlin.jvm.internal.Intrinsics

The runtime footprint is very small; with ~800 K one can't argue otherwise. Kotlin comes

with its own standard class library (Kotlin runtime), which is different from the Java

library. As a result, you need to merge it into the resulting JAR, or provide it in the

classpath:

$ java -cp $KOTLIN_HOME/lib/kotlin-runtime.jar:HelloWorld.jar HelloWorldKt

If you develop a library for the exclusive use of other Kotlin libraries or applications, then

you don't have to include the runtime. Alternatively there is a shorter path. This is done via

a flag passed to the Kotlin compiler:

$kotlinc -include-runtime HelloWorld.kt -d HelloWorld

The REPL

These days, most languages provide an interactive shell, and Kotlin is no exception. If you

want to quickly write some code that you won't use again, then the REPL is a good tool to

have. Some prefer to quickly test their methods, but you should always write unit tests

rather than using the REPL to validate that the output is correct.

You can start the REPL by adding dependencies to the classpath in order to make them

available within the instance. To give an example, we will use the Joda library to deal with

the date and time. First, we need to download the JAR. In a terminal window, use the

following commands:

$ wget

https://github.com/JodaOrg/joda-time/releases/download/v2.9.4/joda-time-2.9

.4-dist.tar.gz

剩余406页未读，继续阅读

Scottchow

粉丝: 2
资源: 2

深入学习Kotlin编程

Programming Kotlin.pdf.zip

Programming Kotlin(pdf+epub+mobi+code_file).zip

Programming Kotlin epub

Programming Kotlin mobi

Programming Kotlin-Packt

Programming Kotlin azw3 0分

Programming Kotlin(pdf+mobi+epub+code_files).zip

Java开发者转向Kotlin：《Programming Kotlin》全面指南

Programming_Kotlin

Reactive Programming in Kotlin PDF

最新资源