变量

Kotlin和Java一样是静态语言，所有表达式类型在编译期已经确定，public为默认可见性

变量由 var/val+变量名[: 数据类型][?][ = 值] 组成，如

var a = 1

var b: Int
b = 3

var s: String? = null

val language = arrayListOf("java")
language.add("Kotlin")

• 无需显示声明每个变量的类型，自动类型推导
• 若变量未初始化则需要显示指定类型
• ?标记变量可以为空，若无则不可为空
• val为不可变变量，初始化后不能再次赋值，对应Java的final，但其指向的对象可以改变

函数

函数组成为 fun 函数名(参数名: 参数类型, …): 返回值{}

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

上面称为代码块函数体，当函数体由单个表达式构成时，可简化为表达式函数体（自动会推导出返回类型）

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

参数

如定义一个格式化输出集合的函数

fun <T> joinToString(
    collection: Collection<T>,
    separator: String,
    prefix: String,
    postfix: String
): String {
    val result = StringBuilder(prefix)
    for ((index, element) in collection.withIndex()) {
        if (index > 0)
            result.append(separator)
        result.append(element)
    }
    result.append(postfix)
    return result.toString()
}


val list = listOf("1", "2", "3")
println(joinToString(list, "-", "[", "]"))

在常规调用中，必须按照参数顺序给定参数，通过带默认值的参数可以省略后面的参数传递，默认参数被编码到被调用的函数内部

fun <T> joinToString(
    collection: Collection<T>,
    separator: String = "",
    prefix: String = "",
    postfix: String = ""
): String {
    val result = StringBuilder(prefix)
    for ((index, element) in collection.withIndex()) {
        if (index > 0)
            result.append(separator)
        result.append(element)
    }
    result.append(postfix)
    return result.toString()
}

println(joinToString(list, "-"))

Java需要显式传递所有参数，若需要调用上面的函数，可以用@JvmOverloads注解，会生成

String joinToString(Collection<T> collection, String separator, String prefix, String postfix);
String joinToString(Collection<T> collection, String separator, String prefix);
String joinToString(Collection<T> collection, String separator);
String joinToString(Collection<T> collection);

如果使用命名参数可以省略中间的参数，按照任意顺序给定参数

println(joinToString(list, prefix = "[", postfix = "]"))

顶层函数和属性

如新建一个test.kt文件，创建max()方法，其不属于任何类

package com.demo.demo1

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

会被编译Java的静态函数

public class TestKt {
    public static int max(int a, int b) {
        if (a > b)
            return a;
        else
            return b;
    }
}

如果需要修改顶层函数生成的类的名称，可以在包名前添加注解

@file:JvmName("MyTest")

package com.demo.demo1

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

同理，test.kt文件存放属性

package com.demo.demo1

var a = 0
val b = 1
const val c = 2

会被编译Java的静态域

public class TestKt {
    public static int a = 0;
    public static int b = 1;
    public static final int c = 2;
}

扩展函数和属性

把要扩展的类/接口的名称放到即将添加的函数前面，如下扩展String类新增lastChar()方法

• 可省略this
• 能访问被扩展类的public方法和属性
• 不在同一包的文件需要import扩展函数，若出现命名冲突，可以使用as重命名
• 不能被子类重写
• 如果扩展函数和成员函数有相同签名，会优先调用成员函数

fun String.lastChar(): Char = this.get(this.length - 1)

println("Kotlin".lastChar())

在Java中访问扩展函数（放在test.kt）

TestKt.lastChar("Kotlin");

如下定义扩展属性，因为String内容不可变，所以没有setter()

val String.lastChar: Char
    get() = this.get(length - 1)

var java.lang.StringBuilder.lastChar: Char
    get() = get(length - 1)
    set(value: Char) {
        setCharAt(length - 1, value)
    }

当Java中访问扩展属性（放在test.kt），需要显示调用getter()

TestKt.getLastChar("Java");

字符串模板

可在字符串中通过$引用变量

fun main(args: Array<String>) {
    val name = if (args.size > 0) args[0] else "Kotlin"
    println("Hello,$name")
}

还可以用${}引用表达式

fun main(args: Array<String>) {
    if (args.size > 0) {
        println("Hello,${args[1]}")
    }
}

fun main(args: Array<String>) {
    println("Hello,${if (args.size > 0) args[0] else "Kotlin"} ")
}

类

只有数据没有其他代码的对象通常叫做值对象，如JavaBean

public class Person {
    private String name;

    private final int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }
}

使用过程如下

Person person = new Person("java", 8);

person.setName("kotlin");
System.out.println(person.getName());
System.out.println(person.getAge());

将上述Java复制到代码.kt文件，会触发自动转换（.kt不要求类名和文件名一致，可将多个类放到同一文件，且文件名随意）

转换后的代码如下，name为var变量（默认带有getter和setter），而age为val变量（只有getter）

class Person(
    var name: String,
    val age: Int
) 

使用方法如下

val person = Person("java", 8);

person.name = "kotlin"
println(person.name)
println(person.age)

如果一个属性可以根据其他属性计算，可使用自定义getter

class Rectangle(val height: Int, val width: Int) {
    val isSquare: Boolean
        get() {
            return height == width
        }
}