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一起工作
}