Kotlin编程入门：函数与基本语法

需积分: 9 69 浏览量更新于2024-07-18 收藏 1.1MB PDF 举报

"Kotlin英文教程" 这篇教程涵盖了Kotlin编程语言的基础知识，包括入门、基本语法、习惯用法、编码规范以及Kotlin 1.1版本的新特性。以下是一些核心概念的详细说明： 1. **包(Packages)**: 包在Kotlin中用于组织代码，其定义应放在源文件的顶部。包名不一定需要与文件系统的目录结构匹配，源文件可以任意放置。了解如何使用`package`关键字创建和引用包是学习Kotlin的关键。 2. **基本类型(Basic Types)**: Kotlin有多种内置的基本类型，如`Int`用于整数。在定义函数时，我们可以指定参数和返回类型的类型，例如`sum`函数接受两个`Int`参数并返回一个`Int`。 3. **函数(Functions)**: 函数是执行特定任务的代码块。有两种函数声明方式：带有显式返回类型的和表达式体函数。例如，`sum`函数可以简洁地写作一行表达式，Kotlin会自动推断其返回类型。函数也可以没有返回值，此时返回类型为`Unit`，可省略不写。 4. **控制流(Control Flow)**: Kotlin支持常见的控制流结构，如条件语句（`if`，`when`）、循环（`for`，`while`）以及跳转语句（`return`，`break`，`continue`）。这些在编写逻辑时非常有用。 5. **类和对象(Classes and Objects)**: 类是面向对象编程的基础，它们可以包含属性、方法和初始化器。继承允许子类继承父类的特征。Kotlin还有接口（Interfaces）来定义行为规范。 6. **属性和字段(Properties and Fields)**: 属性是类中的变量，可以有访问器(getter)和修改器(setter)。字段是类内部的私有变量，通常与属性一起使用。 7. **可见性修饰符(Visibility Modifiers)**: Kotlin提供了`public`, `private`, `protected`, `internal`等修饰符来控制成员的访问级别。 8. **扩展(Extensions)**: 扩展允许你在已有类上添加功能而无需继承或使用装饰者模式。 9. **数据类(Data Classes)**: 数据类简化了创建具有`equals()`, `hashCode()`, 和 `toString()`等默认实现的类的过程。 10. **泛型(Generics)**: 泛型允许函数和类在操作的数据类型上具有灵活性，提供类型安全。 11. **嵌套类(Nested Classes)**: 嵌套类是定义在另一个类内部的类，可以访问外部类的成员。 12. **枚举类(Enum Classes)**: 枚举类用于定义有限的、已知数量的实例。 13. **对象表达式和声明(Object Expressions and Declarations)**: 在Kotlin中，你可以创建匿名对象，也可以声明单例对象。 14. **委托(Delegation)**: 委托允许一个类的某些行为或属性依赖于其他对象。 15. **委托属性(Delegated Properties)**: 这是Kotlin的一种特性，允许你将属性的存储和行为委托给其他对象，例如懒加载属性。此外，教程还涉及到： - **集合(Collections)**: 如列表、映射和集合的操作。 - **范围(Ranges)**: 用于表示数值范围的表达式。 - **类型检查和转换(Type Checks and Casts)**: 检查变量是否属于特定类型，并进行类型转换。 - **此表达式(This Expression)**: 在类或对象中引用当前上下文。 - **运算符重载(Operator Overloading)**: 允许自定义运算符的行为。 - **空安全性(Null Safety)**: Kotlin通过非空断言和可空类型来防止空指针异常。 - **异常(Exceptions)**: 如何抛出、捕获和处理异常。 - **注解(Annotations)**: 用于元数据，可以影响编译器行为或供运行时使用。 - **反射(Reflection)**: 让代码能检查和操作类、对象、属性和方法的机制。 - **类型安全的构建器(Type-Safe Builders)**: 提供一种更安全的代码结构创建方式。 - **与其他语言的互操作性(Interoperability)**: 如与Java和JavaScript的互操作。教程还包含了使用Maven、Ant和Gradle构建Kotlin项目，以及关于Kotlin与OSGi的集成等内容。对于Kotlin初学者，这是一份全面且深入的学习资料。

The KEEP document provides an extended description of the coroutine functionality.

Note that coroutines are currently considered an experimental feature, meaning that the Kotlin team is not committing to

supporting the backwards compatibility of this feature after the ﬁnal 1.1 release.

A type alias allows you to deﬁne an alternative name for an existing type. This is most useful for generic types such as

collections, as well as for function types. Here are a few examples:

typealias FileTable<K> = MutableMap<K, MutableList<File>>

typealias MouseEventHandler = (Any, MouseEvent) -> Unit

Read the KEEP for more details.

You can now use the :: operator to get a member reference pointing to a method or property of a speciﬁc object instance.

Previously this could only be expressed with a lambda. Here's an example:

val numberRegex = "\\d+".toRegex()

val numbers = listOf("abc", "123", "456").filter(numberRegex::matches)

// Result is list of "123", "456"

Read the KEEP for more details.

Kotlin 1.1 removes some of the restrictions on sealed and data classes that were present in Kotlin 1.0. Now you can deﬁne

subclasses of a sealed class anywhere in the same ﬁle, and not just as nested classes of the sealed class. Data classes can

now extend other classes. This can be used to deﬁne a hierarchy of expression classes nicely and cleanly:

sealed class Expr

data class Const(val number: Double) : Expr()

data class Sum(val e1: Expr, val e2: Expr) : Expr()

object NotANumber : Expr()

fun eval(expr: Expr): Double = when (expr) {

is Const -> expr.number

is Sum -> eval(expr.e1) + eval(expr.e2)

NotANumber -> Double.NaN

}

Read the sealed class and data class KEEPs for more detail.

You can now use the destructuring declaration syntax to unpack the arguments passed to a lambda. Here's an example:

map.mapValues { (key, value) -> "$value!" }

Read the KEEP for more details.

For a lambda with multiple parameters, you can use the _ character to replace the names of the parameters you don't use:

Other Language Features

Type aliases

Bound callable references

Sealed and data classes

Destructuring in lambdas

Underscores for unused parameters

class ResourceLoader<T>(id: ResourceID<T>) {

operator fun provideDelegate(thisRef: MyUI, property: KProperty<*>): ReadOnlyProperty<MyUI, T> {

checkProperty(thisRef, property.name)

... // property creation

}

private fun checkProperty(thisRef: MyUI, name: String) { ... }

}

fun <T> bindResource(id: ResourceID<T>): ResourceLoader<T> { ... }

class MyUI {

val image by bindResource(ResourceID.image_id)

val text by bindResource(ResourceID.text_id)

}

The provideDelegate method will be called for each property during the creation of a MyUI instance, and it can perform the

necessary validation right away.

It is now possible to enumerate the values of an enum class in a generic way:

enum class RGB { RED, GREEN, BLUE }

print(enumValues<RGB>().joinToString { it.name }) // prints RED, GREEN, BLUE

The @DslMarker annotation allows to restrict the use of receivers from outer scopes in a DSL context. Consider the canonical

HTML builder example:

table {

tr {

td { +"Text" }

}

In Kotlin 1.0, code in the lambda passed to td has access to three implicit receivers: the one passed to table , to tr and to

td . This allows you to call methods that make no sense in the context - for example to call tr inside td and thus to put a

<tr> tag in a <td> .

In Kotlin 1.1, you can restrict that, so that only methods deﬁned on the implicit receiver of td will be available inside the lambda

passed to td . You do that by deﬁning your annotation marked with the @DslMarker meta-annotation and applying it to the

base class of the tag classes:

@DslMarker

annotation class HtmlTagMarker

@HtmlTagMarker

abstract class Tag(val name: String) { ... }

class TD() : Tag("td") { ... }

fun Tag.td(init: TD.() -> Unit) {

}

Now that the implicit receiver of the init lambda passed to the td function is a class annotated with @HtmlTagMarker , so the

outer receivers of types which also have this annotation will be blocked.

Read the KEEP for more details.

Generic enum value access

Scope control for implicit receivers in DSLs

The mod operator is now deprecated, and rem is used instead. See this issue for motivation.

There is a bunch of new extensions on the String class to convert it to a number without throwing an exception on invalid

number: String.toIntOrNull(): Int? , String.toDoubleOrNull(): Double? etc.

Also integer conversion functions, like Int.toString() , String.toInt() , String.toIntOrNull() , each got an overload with

radix parameter, which allows to specify the base of conversion.

onEach is a small, but useful extension function for collections and sequences, which allows to perform some action, possibly

with side-eﬀects, on each element of the collection/sequence in a chain of operations. On iterables it behaves like forEach but

also returns the iterable instance further. And on sequences it returns a wrapping sequence, which applies the given action

lazily as the elements are being iterated.

These are two general-purpose extension functions applicable to any receiver.

also is like apply : it takes the receiver, does some action on it, and returns that receiver. The diﬀerence is that in the block

inside apply the receiver is available as this , while in the block inside also it's available as it (and you can give it another

name if you want). This comes handy when you do not want to shadow this from the outer scope:

fun Block.copy() = Block().also { it.content = this.content }

takeIf is like filter for a single value. It checks whether the receiver meets the predicate, and returns the receiver, if it does

or null if it doesn't. Combined with an elvis-operator and early returns it allows to write constructs like:

val outDirFile = File(outputDir.path).takeIf { it.exists() } ?: return false

// do something with existing outDirFile

val index = input.indexOf(keyword).takeIf { it >= 0 } ?: error("keyword not found")

// do something with index of keyword in input string, given that it's found

This API can be used to group a collection by key and fold each group simultaneously. For example, it can be used to count the

frequencies of characters in a text:

val frequencies = words.groupingBy { it }.eachCount()

These functions can be used for easy copying of maps:

class ImmutablePropertyBag(map: Map<String, Any>) {

private val mapCopy = map.toMap()

}

These functions can be used to ﬁnd the minimum and maximum of two given numbers.

rem operator

Standard library

String to number conversions

onEach()

takeIf() and also()

groupingBy()

Map.toMap() and Map.toMutableMap()

minOf() and maxOf()

Array-like List instantiation functions

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

element by calling a lambda:

List(size) { index -> element }

MutableList(size) { index -> element }

This method 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 method will return the default value instead of throwing an

exception.

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.

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.

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). See here for an example project using the API.

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.

Map.getValue()

Abstract collections

JVM Backend

Java 8 bytecode support

Java 8 standard library support

Parameter names in the bytecode

Constant inlining

Mutable closure variables

javax.scripting support

JavaScript Backend

Unied standard library

剩余151页未读，继续阅读

刘在兵

粉丝: 0
资源: 1

Kotlin编程入门：函数与基本语法

Kotlin Apprentice v1.0 PDF (Kotlin学徒入门教程 - 英文版)

android kotlin 中英文文档

Kotlin In Action中英版

Kotlin编程语言官方文档英文版

kotlin-for-android-developers中文版

利用kotlin实现统计文件字符个数的方法示例

android 中文教程和最新英文API

Kotlin入门指南：Android开发者必备

权威入门：Kotlin编程实战与基础

轻松学习Android开发：Kotlin实战指南

最新资源