Kotlin编程语言官方文档概览

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

"Kotlin Language Documentation 是一本详细阐述 Kotlin 编程语言的官方文档，涵盖了从基础语法到高级特性的方方面面。它适用于多种平台开发，包括服务器端、Android、JavaScript 和原生应用。文档更新至了 Kotlin 1.2 版本，提供了最新的语言特性介绍。" Kotlin 是一种现代、静态类型的编程语言，被广泛应用于 Android 开发，同时也适用于服务器端、Web 开发和跨平台应用。以下是一些主要的知识点： 1. **概述**：Kotlin 的设计目标是提供简洁、安全和可互操作的代码。它与 Java 兼容，并且可以在 JVM 上运行。 2. **服务器端开发**：Kotlin 支持函数式编程特性，如高阶函数和 lambda 表达式，使服务器端编程更加高效。它还提供了类型安全的构建器，减少样板代码。 3. **Android 开发**：Kotlin 成为了 Android 官方推荐的开发语言，提供了空安全、扩展函数和数据类等功能，简化了 Android 应用的编写。 4. **Kotlin JavaScript**：Kotlin 可以编译为 JavaScript，使得开发 Web 应用成为可能，同时保留了 Kotlin 的强类型特性。 5. **Kotlin/Native**：Kotlin/Native 允许开发者编写原生应用程序，无需虚拟机，直接在 iOS、macOS、Windows 等平台上运行。 6. **新特性**：Kotlin 1.1 引入了协程（Coroutines），用于处理异步操作，而 Kotlin 1.2 增加了多平台项目的支持，允许共享代码库。 7. **基本语法**：包括变量声明（Basic Types）、包管理（Packages）、控制流（Control Flow）、函数和类等。 8. **类与对象**：Kotlin 支持类继承、接口、可见性修饰符（Visibility Modifiers）以及委托（Delegation）。 9. **数据类**：简化了创建具有默认行为（如 equals()、hashCode() 和 toString()）的类。 10. **密封类**：限制了子类的扩展，常用于枚举或有限状态机的实现。 11. **泛型**：允许在类、接口和函数中使用类型参数，提高了代码的复用性。 12. **内联函数**：可以减少运行时开销，提升性能，尤其是在处理高阶函数时。 13. **协程**：用于处理异步编程，避免回调地狱，提高代码可读性。 14. **类型检查与转换**：'is' 检查类型，'as' 进行安全或强制类型转换。 15. **异常处理**：Kotlin 提供了异常捕获和抛出机制，增强了错误处理能力。 16. **反射**：允许程序在运行时检查和修改其自身的结构和行为。 17. **多平台项目**：Kotlin 支持跨平台开发，可以创建可复用的代码库。 18. **集合操作**：Kotlin 提供了丰富的集合操作，如列表（List）、集（Set）和映射（Map）的操作。以上只是 Kotlin 语言文档中的一部分内容，实际文档详细地讲解了每一个主题，包括实例、最佳实践和编码约定，是学习和精通 Kotlin 的宝贵资源。无论是初学者还是经验丰富的开发者，都能从中受益。

val list1 = listOf("a", "b")

val list2 = listOf("x", "y", "z")

val minSize = minOf(list1.size, list2.size)

val longestList = maxOf(list1, list2, compareBy { it.size })

Similar to the Array constructor, there are now functions that create List and MutableList instances and initialize each

element by calling a lambda:

val squares = List(10) { index -> index * index }

val mutable = MutableList(10) { 0 }

This extension on Map returns an existing value corresponding to the given key or throws an exception, mentioning which key

was not found. If the map was produced with withDefault , this function will return the default value instead of throwing an

exception.

val map = mapOf("key" to 42)

// returns non-nullable Int value 42

val value: Int = map.getValue("key")

val mapWithDefault = map.withDefault { k -> k.length }

// returns 4

val value2 = mapWithDefault.getValue("key2")

// map.getValue("anotherKey") // <- this will throw NoSuchElementException

These abstract classes can be used as base classes when implementing Kotlin collection classes. For implementing read-only

collections there are AbstractCollection , AbstractList , AbstractSet and AbstractMap , and for mutable collections there

are AbstractMutableCollection , AbstractMutableList , AbstractMutableSet and AbstractMutableMap . On JVM these

abstract mutable collections inherit most of their functionality from JDK's abstract collections.

The standard library now provides a set of functions for element-by-element operations on arrays: comparison ( contentEquals

and contentDeepEquals ), hash code calculation ( contentHashCode and contentDeepHashCode ), and conversion to a string

( contentToString and contentDeepToString ). They're supported both for the JVM (where they act as aliases for the

corresponding functions in java.util.Arrays ) and for JS (where the implementation is provided in the Kotlin standard library).

val array = arrayOf("a", "b", "c")

println(array.toString()) // JVM implementation: type-and-hash gibberish

println(array.contentToString()) // nicely formatted as list

Kotlin has now the option of generating Java 8 bytecode ( -jvm-target 1.8 command line option or the corresponding options

in Ant/Maven/Gradle). For now this doesn't change the semantics of the bytecode (in particular, default methods in interfaces

and lambdas are generated exactly as in Kotlin 1.0), but we plan to make further use of this later.

Array-like List instantiation functions

Map.getValue()

Abstract collections

Array manipulation functions

JVM Backend

Java 8 bytecode support

Java 8 standard library support

There are now separate versions of the standard library supporting the new JDK APIs added in Java 7 and 8. If you need access

to the new APIs, use kotlin-stdlib-jre7 and kotlin-stdlib-jre8 maven artifacts instead of the standard kotlin-stdlib .

These artifacts are tiny extensions on top of kotlin-stdlib and they bring it to your project as a transitive dependency.

Kotlin now supports storing parameter names in the bytecode. This can be enabled using the -java-parameters command

line option.

The compiler now inlines values of const val properties into the locations where they are used.

The box classes used for capturing mutable closure variables in lambdas no longer have volatile ﬁelds. This change improves

performance, but can lead to new race conditions in some rare usage scenarios. If you're aﬀected by this, you need to provide

your own synchronization for accessing the variables.

Kotlin now integrates with the javax.script API (JSR-223). The API allows to evaluate snippets of code at runtime:

val engine = ScriptEngineManager().getEngineByExtension("kts")!!

engine.eval("val x = 3")

println(engine.eval("x + 2")) // Prints out 5

See here for a larger example project using the API.

To prepare for Java 9 support, the extension functions and properties in the kotlin-reflect.jar library have been moved to

the package kotlin.reflect.full . The names in the old package ( kotlin.reflect ) are deprecated and will be removed in

Kotlin 1.2. Note that the core reﬂection interfaces (such as KClass ) are part of the Kotlin standard library, not kotlin-reflect ,

and are not aﬀected by the move.

A much larger part of the Kotlin standard library can now be used from code compiled to JavaScript. In particular, key classes

such as collections ( ArrayList , HashMap etc.), exceptions ( IllegalArgumentException etc.) and a few others

( StringBuilder , Comparator ) are now deﬁned under the kotlin package. On the JVM, the names are type aliases for the

corresponding JDK classes, and on the JS, the classes are implemented in the Kotlin standard library.

JavaScript backend now generates more statically checkable code, which is friendlier to JS code processing tools, like miniﬁers,

optimisers, linters, etc.

If you need to access a class implemented in JavaScript from Kotlin in a typesafe way, you can write a Kotlin declaration using the

external modiﬁer. (In Kotlin 1.0, the @native annotation was used instead.) Unlike the JVM target, the JS one permits to use

external modiﬁer with classes and properties. For example, here's how you can declare the DOM Node class:

Parameter names in the bytecode

Constant inlining

Mutable closure variables

javax.script support

kotlin.reect.full

JavaScript Backend

Unied standard library

Better code generation

The external modier

Multiplatform projects

Other language features

Standard library

JVM backend

JavaScript backend

Multiplatform projects are a new experimental feature in Kotlin 1.2, allowing you to reuse code between target platforms

supported by Kotlin – JVM, JavaScript and (in the future) Native. In a multiplatform project, you have three kinds of modules:

common

module contains code that is not speciﬁc to any platform, as well as declarations without implementation of

platform-dependent APIs.

platform

module contains implementations of platform-dependent declarations in the common module for a speciﬁc

platform, as well as other platform-dependent code.

A regular module targets a speciﬁc platform and can either be a dependency of platform modules or depend on platform

modules.

When you compile a multiplatform project for a speciﬁc platform, the code for both the common and platform-speciﬁc parts is

generated.

A key feature of the multiplatform project support is the possibility to express dependencies of common code on platform-

speciﬁc parts through expected and actual declarations. An expected declaration speciﬁes an API (class, interface,

annotation, top-level declaration etc.). An actual declaration is either a platform-dependent implementation of the API or a

typealias referring to an existing implementation of the API in an external library. Here's an example:

In common code:

// expected platform-specific API:

expect fun hello(world: String): String

fun greet() {

// usage of the expected API:

val greeting = hello("multi-platform world")

println(greeting)

}

expect class URL(spec: String) {

open fun getHost(): String

open fun getPath(): String

}

In JVM platform code:

actual fun hello(world: String): String =

"Hello, $world, on the JVM platform!"

// using existing platform-specific implementation:

actual typealias URL = java.net.URL

See the documentation for details and steps to build a multiplatform project.

What's New in Kotlin 1.2

Table of Contents

—

Multiplatform Projects (experimental)

—

Other Language Features

Array literals in annotations

Starting with Kotlin 1.2, array arguments for annotations can be passed with the new array literal syntax instead of the arrayOf

function:

@CacheConfig(cacheNames = ["books", "default"])

public class BookRepositoryImpl {

// ...

}

The array literal syntax is constrained to annotation arguments.

The lateinit modiﬁer can now be used on top-level properties and local variables. The latter can be used, for example, when

a lambda passed as a constructor argument to one object refers to another object which has to be deﬁned later:

// A cycle of three nodes:

lateinit var third: Node<Int>

val second = Node(2, next = { third })

val first = Node(1, next = { second })

third = Node(3, next = { first })

You can now check whether a lateinit var has been initialized using isInitialized on the property reference:

println("isInitialized before assignment: " + this::lateinitVar.isInitialized)

lateinitVar = "value"

println("isInitialized after assignment: " + this::lateinitVar.isInitialized)

Inline functions are now allowed to have default values for their inlined functional parameters:

inline fun <E> Iterable<E>.strings(transform: (E) -> String = { it.toString() }) =

map { transform(it) }

val defaultStrings = listOf(1, 2, 3).strings()

val customStrings = listOf(1, 2, 3).strings { "($it)" }

The Kotlin compiler can now use information from type casts in type inference. If you’re calling a generic method that returns a

type parameter T and casting the return value to a speciﬁc type Foo , the compiler now understands that T for this call needs

to be bound to the type Foo .

This is particularly important for Android developers, since the compiler can now correctly analyze generic findViewById calls in

Android API level 26:

val button = findViewById(R.id.button) as Button

When a variable is assigned from a safe call expression and checked for null, the smart cast is now applied to the safe call

receiver as well:

Lateinit top-level properties and local variables

Checking whether a lateinit var is initialized

Inline functions with default functional parameters

Information from explicit casts is used for type inference

Smart cast improvements

剩余240页未读，继续阅读

ctrigger

粉丝: 1494
资源: 95

Kotlin编程语言官方文档概览

Kotlin Language Documentation

Kotlin 官方参考文档 中文版

Kotlin 1.1 官方文档 中文版

Kotlin - Kotlin Language Documentation 2.0.0

Kotlin documentation

kotlin language document 全英文版.pdf

Kotlin Programming Language

Kotlin 1.9.20 documentation (PDF)

kotlin语言官方文档 英文

kotlin-language-server：使用语言服务器协议的任何EditorIDE的智能Kotlin支持

最新资源

Kotlin 官方参考文档中文版

Kotlin 1.1 官方文档中文版

kotlin语言官方文档英文