Kotlin属性和字段与基本语法

Kotlin属性和字段与基本语法

Kotlin是一门与Swift类似的静态类型JVM语言，由JetBrains设计开发并开源。与Java相比，Kotlin的语法更简洁、更具表达性，而且提供了更多的特性，比如，高阶函数、操作符重载、字符串模板。它与Java高度可互操作，可以同时用在一个项目中。

Kotlin属性和字段

Declaring Properties 声明属性

Kotlin中使用var关键字声明可变属性，或者用val关键字声明只读属性，属性的类型在后面，变量名在签名，中间加冒号和空格。

public class Student {
public var name: String = ...
public var glass: String = ...
public var city: String = ...
public var state: String? = ...
public var grade: String = ...
}

只需要将成员变量定义成是 public 变量，编译器会自动生成 getter 和 setter 方法。所以上面的属性编译器默认添加了getter 和 setter 方法。

调用的时候与Java一样，通过变量名直接使用一个属性

fun recordStudent(student: Student): Student {
val result = Student() // there's no 'new' keyword in Kotlin
result.name = student.name
result.street = student.glass
// ...
return result
}

上面对属性的访问，并不是像Java里面一样，直接访问属性的本身，而是默认调用了getter 和 setter 方法。

Getter和Setter

语法中的初始化语句，getter和setter都是可选的,声明属性的完整语法如下:

var <propertyName>: <PropertyType> [= <property_initializer>]
[<getter>]
[<setter>]

其中initializer, getter 和 setter都是可选的。var是允许有getter 和 setter方法，如果变量是val声明的，它类似于Java中的final，所以如果以val声明就不允许有setter方法。

自定义访问器(getter)和自定义setter，setter的参数名默认是value，也可以自定义

val isClassSix: Boolean //val 类似于Java中的final
get() = this.class == 6

var stringRepresentation: String
get() = this.toString()
set (value) {
setDataFormString(value) // 格式化字符串,并且将值重新赋值给其他元素
}

对于属性，如果你想改变访问的可见性或者是对其进行注解，但是又不想改变它的默认实现，那么你就可以定义set和get但不进行实现。

var setterStudentName: String = "美国队长史爱民" // Initializer required, not a nullable type
private set // the setter is private and has the default implementation

var setterWithAnnotation: Any?
@Inject set // annotate the setter with Inject

备用字段(Backing Fields)

在上面例子中定义的Student类里面，属性的get和set方法里面使用了一个field，它是一个自动的返回字段，代表的就是属性。

Kotlin中的类并不允许使用字段，在自定义getter和setter的时候，可以使用field来起到局部变量的作用。

var counter = 0 //初始化值会直接写入备用字段
get() = field
set(value) {
if (value >= 0)
field  = value
}

field只有在访问的时候才会产生，其他时候是不会产生的。

如果Backing Fields不适用的话，其实可以直接使用返回属性就可以了。

注意：field标识符只允许在属性的访问器函数内使用.

备用属性(Backing Properties)

备用属性，可以看作是备用变量(Backing Fields)的变种，其实际上也是隐含试的对属性值的初始化声明，避免了空指针。

private var _table: Map<String, Int>? = null
public val table: Map<String, Int>
get() {
if (_table == null)
_table = HashMap() // Type parameters are inferred
return _table ?: throw AssertionError("Set to null by another thread")
}

不管是备用变量或者备用属性，都是Kotlin对于空指针的一种解决方案，可以避免函数访问私有属性而破坏它的结构。

编译时常量(Compile-Time Constants)

那些在编译时就能知道具体值的属性可以使用const修饰符标记为编译时常量. 这种属性需要同时满足以下条件:

顶层或对象的成员(Top-level or member of an object)

以String或基本类型进行初始化

没有自定义getter

const val SUBSYSTEM_DEPRECATED: String = "This subsystem is deprecated"
@Deprected(SUBSYSTEM_DEPRECATED) fun foo() { ... }

Top-level(顶级)

Top-level属性或者方法，与class同级，如下面所示，类名是Kot

package foo.bar

val prop: String = "top-level-prop"
fun demo() {
loge("top-level", "top-level-demo()")
}

class Kot {
fun v() {
loge("top-level", prop)
demo()
}
}

在编译成class的时候，会把Top-level的属性和函数创建到以类名+Kt为名的class文件中

Top-level调用的时候类似于调用扩展函数那样，直接调用属性或者函数。

延迟初始化属性(Late-Initialized Properties)

在Kotlin中，声明为具有非空类型的属性必须在构造函数中初始化，但是往往不希望在构造函数中初始化，例如在通过依赖注入或单元测试的设置方法来初始化属性的时候，不能在构造器中提供一个非空的初始化语句，为了处理这种情况，就要在属性上加lateinit关键字来延迟初始化。

public class MyTest {
lateinit var subject: TestSubject

@SetUp fun setup() {
subject = TestSubject()
}

@Test fun test() {
subject.method()  // dereference directly
}
}

lateinit只能够在var类型的属性中，不能用于构造函数，而且属性不能有自定义的getter和setting，这些属性必须是非空类型，并且不能是基本类型。

如果在一个延迟初始化的属性初始化前调用,会导致一个特定异常,调用的时候值还没有初始化.

参考文章：Kotlin官方英文文档

接下来，我们来学习Kotlin的基本语法

Kotlin的基本语法

1，定义包名(Basic Syntax)

与Java定义包名一样，在源文件的开头定义包名：

//包名和文件夹路径可以不一致：源文件可以放在项目的任意位置。
package my.demo

import java.util.*

// ...

定义函数(Defining functions)

与Java定义函数的区别在于：Kotlin在定义函数的时候要加个fun关键词，函数的返回值前后不同，Java的在前面，而Kotlin的话，要在后面写返回值。

//Java
private int getResult(int a, int b) {
return a + b;
}

//Kotlin
private getResult(a: Int, b: Int): Int {
return a + b
}

如果一个函数只有一个并且是表达式函数体并且是返回类型自动推断的话，可以直接这样写

fun getResult(a: Int, b: Int) = a + b

```

如果函数返回一个无意义的值，相当于Java的void，则可以这样写：

```
fun getResult(a: Int, b: Int): Unit {
print(a + b)
}

Uint 的返回类型可以省略，则上述可以写成

fun getResult(a: Int, b: Int) {
print(a + b)
}

定义局部变量(Defining local variables)

Kotlin声明变量与Java声明变量有些不一样，Java变量类型在前，变量名在后，而Kotlin则相反，变量名在前，变量类型在后，中间加:(冒号)，并且Kotlin可以自动判断变量的类型。

声明局部常量（常量使用val关键字，val类似于java中的final）

val a: Int = 1
val b = 1   // 自动判断出Int类型
val c: Int  // 当没有初始化值的时候要声明类型，全局变量不能这样写
c = 1       // 赋值

声明变量（变量使用var关键字）

var x = 5 // 自动推断出Int类型
x += 1

注释(Comments)

Kotlin的注释与Java一样， 支持单行注释和块注释。

使用字符串模版(Using string templates)

使用${变量}，如变量为args: Array”，使用的时候可以这样写

fun main(args: Array<String>) {
if (args.size == 0) return

print("First argument: ${args[0]}")
}

而不用再去用加号加起来，gradle里面也是支持的

fun main(args: Array<String>) {
if (args.size == 0) return

print("First argument: " + args[0])
}

使用条件表达式(Using conditional expressions)

使用if表达式的时候这样写

fun max(a: Int, b: Int): Int {
if (a > b) {
return a
} else {
return b
}
}

也可以写成：

fun max(a: Int, b: Int) = if (a > b) a else b

使用可空变量和空置检查(Using nullable values and checking for null)

当一个变量、函数可能出现空值的时候，应该指出该引用可空，如：

fun getResult(a: Int, b: Int): Int? { // 设置函数返回类型可空
print(a + b)
return null
}

使用类型检查和自动转换(Using type checks and automatic casts)

is运算符是检查一个表达式是否是某个类型的实例，如果为不可变局部变量或属性进行类型检查，则无需显式转换

fun getStringLength(obj: Any): Int? {
if (obj is String) {
// `obj`在这个分支中自动转换为`String`类型
return obj.length
}

// `obj`仍然是`Any`类型
return null
}

或者

fun getStringLength(obj: Any): Int? {
if (obj !is String) return null

// `obj`在这个分支中自动转换为`String`类型
return obj.length
}

也可以这样

fun getStringLength(obj: Any): Int? {
// `obj` 自动转换成`String`类型，并且在&&后面生效
if (obj is String && obj.length > 0) {
return obj.length
}

return null
}

使用for循环(Using a for loop)

与Java相比，Kotlin使用for循环要更加的简洁,这点和Python的简洁很相似

fun main(args: Array<String>) {
for (arg in args) { // in操作符可以判断是否arg是否在args里面
print(arg)
}
}

或者这样写

for (i in args.indices) {
print(args[i])
}

使用while循环(Using a while loop)

while循环与Java一样

fun main(args: Array<String>) {
var i = 0
while (i < args.size) {
print(args[i++])
}
}

使用when表达式(Using when expression)

when表达式就相当于Java的switch表达式，省去了case和break，并且支持各种类型。

fun cases(obj: Any) {
when (obj) {
1          -> print("One") //如果obj的值为1
"Hello"    -> print("Greeting") // 如果obj的值为hello
is Long    -> print("Long") // 如果obj的类型是Long类型
!is String -> print("Not a string") // 如果obj的类型不属于String类型
else       -> print("Unknown") // 默认，相当于switch的default
}
}

使用ranges(Using ranges)

使用in运算符检查数字是否在范围内

if (x in 1..y-1) { //1..y-1表示1到y-1的范围
print("OK")
}
for (i in 1..100) { ... }  //  1到100范围
for (i in 1 until 100) { ... } // 半开范围，不包括100，相当于[1,100)
for (x in 2..10 step 2) { ... } // 每次夸2，内容为2,4,6,8,10
for (x in 10 downTo 1) { ... } // 返序
if (x in 1..10) { ... }

使用!in运算符检查数值是否在范围外

if (x !in 0..array.lastIndex) {
print("Out")
}

使用集合(Using collections)

循环输出一个集合里面的值或者判断集合里面是否包含某个变量

for (name in names) { // 将会调用nemes.contains(name)方法
println(name)
}

使用lambda表达式过滤和映射集合

// it表示name
names
.filter { it.startsWith("A") }
.sortedBy { it }
.map { it.toUpperCase() }
.forEach { print(it) }

好了结合了Kotlin的属性和字段与基础语法，现在是不是让你有了打开了新世界大门的感触？