kotlin是什么？

Kotlin在兼容Java的基础上还能大大提升开发效率，去掉了很多无用的java代码，java程序猿可以快速的将代码替换成kotlin。kotlin语法简洁，并且安全，能够静态检测常见的陷阱。如：引用空指针。
Kotlin 的优点之一是其 100% 的 Java 互操作性。该语言适用于 Java 本身，及所有相关工具和框架，提供了丰富的生态系统。这也使得可以选择逐渐迁移到 Kotlin ，或者在同一个项目中同时使用这两种语言。

kotlin配置

首先是给android studio下载kotlin语言插件，如下图

image.png

Android Studio->Preferences->Plugins->搜索kotlin
现在新建文件时，已经出现新建kotlin的选项了

image.png

也可以将java文件转换为kotlin文件，同样非常简单

image.png

仅仅转换了文件，是不能运行kotlin程序的，还要配置gradle
首先是项目的build.gradle文件

项目的build.gradle

然后是module的build.gradle

module的build.gradle

基础语法

类

//主构造器直接定义在类名后
//主构造器会执行类中 init 代码块中得所有语句，所以每实例化一个对象，上述例子都会打印一条语句
//主构造器中可以使用默认参数，如上述的 from
//主构造器中定义的参数可以是 val 也可以是 var，定义的参数会自动转换为该类的成员属性
//主构造器中的参数也可以不加 var 或 val，此时如果类中的方法有用到该参数，则此参数转换为成员属性，否则会被忽略
//主构造器也可以被声明为 private，这样就只能通过辅助构造器来实例化该对象

class User(
val name: String,
val pwd: String)

class Counter {
private var value = 0
var defaultValue = 1
public var publicValue: Int = 2

fun increment(): Unit {
    value += 1
}

fun current() = value
}
//Empty 类没有类的实体，可以用于表示概念
class Empty

class Man(val name: String, val age: Int, private var from: String = "USA", description: String = "none") {
init {
    println("sentences in primary constructor")
}
}

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

一、定义变量

    //一次赋值（只读）局部变量
    val a: Int = 1
    val b = 1 //  推断为Int类型
    val c: Int  // 如果没有初始化就要求说明类型,全局变量必须初始化
    c = 1 // 明确赋值
    //可变变量
    var x = 1;
    x += 1;

    val str = """
    one
    two
        """
    //等价于
    val str2 = "one\ntwo"
    val str3 = "one" + "\n" + "two"

    print("str1:" + str)
    print("str2:" + str2)
    print("str3:" + str3)

    print("max1:" + max(5, 11))
    print("max2:" + printSum1(2, 55))
    print("getStringLength(ddd):" + getStringLength("dddd"))
    print("getStringLength(1222):" + getStringLength2(1222))

二、数组+循环

    val fixedSizeArray = arrayOfNulls<Int>(5)
    fixedSizeArray.set(0, 99)
    fixedSizeArray.set(1, 299)
    fixedSizeArray.set(2, 399)
    fixedSizeArray.set(3, 499)
    fixedSizeArray.set(4, 599)
    printArray(fixedSizeArray)

    var array = arrayOf("1", "22", "333", "4444")
    printTemp(array)
    var array2 = arrayListOf("brina", "tiny", "pany", "tony", "brian");
    printArrayStr(array2)
    printArrayStr2(array2)

    var e: Long = 11111111111111;
    when1(e)

    check1(5, 4)

三、对象

    //一个 Kotlin 源文件中可以包含多个类。
    //声明为 public 的成员必须显示指定类型。
    val user = User("brian", "111111")
    print("username:" + user.name + " pwd:" + user.pwd)
    //实例化对象，实例化对象时不使用关键字new
    val counter = Counter()
    counter.increment()
    //println(counter.value)    can not access
    println(counter.publicValue)
    println(counter.defaultValue)

}

//函数带有两个int类型参数，并且返回int类型值
fun sum(a: Int, b: Int): Int {
    return a + b;
}

//函数体可以是个表达式，并可以从中推断出返回值类型
fun sum2(x: Int, y: Int) = x + y

//返回值使用条件表达式
fun max(a: Int, b: Int) = if (a > b) a else b

//函数也可以返回无意义的值
fun printSum1(a: Int, b: Int): Unit {
    print(a + b)
}

//Unit返回值类型可以省略
fun printSum2(a: Int, b: Int) {
    print(a + b)
}

//使用字符串模板
fun printTemp(array: Array<String>) {
    if (array.size == 0)
        return
    print("第一个参数:${array[0]}")
}

//类型检查和自动类型转换
//is操作符检查表达式是否类型实例。如果对不可变局部的变量或属性进行特定类型检查了，就不需要明确的类型转换。
fun getStringLength(obj: Any): Int? {
    if (obj is String) {
        return obj.length
    }
    return 0
}

fun getStringLength2(obj: Any): Int? {
    if (obj !is String) {
        return null
    }
    return obj.length
}

//数组循环1 for
fun printArrayStr(array: ArrayList<String>) {
    print("数组循环1 for" + array.toString())
    for (str in array) {
        print(str)
    }
}

//数组循环2 for
fun printArrayStr2(array: ArrayList<String>) {
    print("数组循环2 for" + array.toString())
    for (str in 0..array.lastIndex) {
        print("数组循环2 " + str)
    }
}

//数组循环2 while
fun printArray(array: Array<Int?>) {
    print("数组循环2 while" + array.toString())
    var i: Int = 0
    while (i < array.size) {
        print(array[i++])
    }
}

//when
fun when1(obj: Any) {
    when (obj) {
        1 -> print(1)
        "a" -> print("字符")
        is Long -> print("long")
        !is String -> print("非字符串")
        else -> print("不是字符 不是int  不是long ")
    }
}

fun check1(a: Int, b: Int) {
    if (a in 1..b) {
        print("a在1-" + b + "的范围内")
    } else
        print("a不在1-" + b + "的范围内")
}

//区间内循环,倒序 print "4321"
fun downto(i: Int) {
    for (i in 10 downTo 1) {
        print(i)
    }
    //step可以进行任意数量的迭代，而不是每次变化都是1
    for (i in 1..4 step 2) print(i) // prints "13"
}

fun testException() {
    val result = try {
        throw ArithmeticException("test exception")
    } catch (e: ArithmeticException) {
        throw IllegalStateException(e)
    }
    // 和result一起工作
}