/**
* fun 表示 声明一个函数
* 参数类型写在它名称后面，变量声明同
* 函数不需要定义在类中
* 数组就是类，kotlin没有声明数组类型和特殊语法
*
*/
fun main(args: Array<String>) {
println("hello,Kotlin")
}
函数
/**
* max 函数名称
* (a: Int, b: Int)参数列表
* Int：返回类型
* return if (a > b) a else b函数体
*
*在kotlin中，if不是作为语句，而是有结果的表达式
*/
fun max(a: Int, b: Int): Int {
return if (a > b) a else b
}
//简化
fun max(a: Int, b: Int): Int {
return if (a > b) a else b
}
//再次简化，省略返回类型（只有表达式体函数返回类型可以省略，对于有返回值的代码块函数体必须显式的写出返回类型和return语句）
fun max(a: Int, b: Int) =if (a > b) a else b
变量
/**
* val 不可变引用。声明后不能在初始化之后再次赋值。对应java的final变量(不可变的变量)，可看作只读
* var 声明变量值不可以被改变，对应java普通变量（非final）,也可看作可读可写
*/
val kotlin = "kotlin" //类型隐藏
val kotlinNumber=42
var kotlinNumberto:Int=42//显示声明类型
字符串模板
val name =if(args.size>0) args[0] else "kotlin"
//等同"hello"+name+"!"
println("hello,$name！")
//变种
println("hello,${if (args.size > 0) args[0] else "kotlin"}!")
类和属性
class Person(val name:String,
var isMarried:Boolean) {
}
//调用
fun main(args: Array<String>) {
val persion = Person("小白", false);
println(persion.name)
println(persion.isMarried)
//重新赋值
persion.isMarried = true
}
自定义访问器
class Rectangle(val hegiht: Int, val width: Int) {
val isSquare: Boolean
// get(){
// return hegiht==width
// }
//简化
get() = hegiht == width;
}
//调用
fun main(args: Array<String>) {
val rect = Rectangle(20, 20)
println(rect.isSquare)
}
目录和包
和java类似，但是kotlin不区分导入的是类还是函数，能导入任何种类声明，可以直接导入顶层函数名称去使用
package test
import java.util.*
class Rectangle(val hegiht: Int, val width: Int) {
val isSquare: Boolean
// get(){
// return hegiht==width
// }
//简化
get() = hegiht == width
}
fun createRandomRectangle(): Rectangle {
val random = Random()
return Rectangle(random.nextInt(), random.nextInt())
}
//调用
package main
import test.createRandomRectangle //直接导入了函数
fun main(args: Array<String>) {
println(createRandomRectangle().isSquare)
}
枚举
//简单枚举
enum class Color {
RED,ORANGE,YELLOW,GREEN,BLUE,INDIGO,VIOLET
}
//带属性的枚举类
//（....）声明枚举常量属性
enum class Color(val r: Int, val g: Int, val b: Int) {
//每个常量创建时候给定属性值
RED(255,0,0),ORANGE(255,165,0),YELLOW(255,255,0),GREEN(0,255,0),
BLUE(0,0,255),INDIGO(75,0,130),VIOLET(238,130,238);
//给枚举定义一个方法
fun rgb()=(r*256+g)*256+b
}
//调用
fun main(args: Array<String>) {
//调用
println(Color.BLUE.rgb())
}
when
when好比java中的switch，但远比switch要强大
fun getMnemonic(color: Color) = //直接返回when表达式
when (color) {
Color.RED -> "Red"
Color.ORANGE -> "orange"
Color.YELLOW -> "yellow"
Color.GREEN -> "blue"
Color.INDIGO -> "indigo"
else -> {
"noColor"
}
}
//when分支合并多个选项
fun getMnemonic(color: Color) =
when (color) {
Color.RED, Color.ORANGE -> "Red and orange"
Color.YELLOW, Color.GREEN -> "yellow and blue"
Color.INDIGO -> "indigo"
else -> "noColor"
}
/**
* when分支使用不同对象
* setof函数能创建出一个set,它会包含所有指定函数实参的对象
* set这种集合条目 顺序不重要，所以setOf(RED, BLUE)等同于setOf(BLUE,RED)
*/
fun mix(c1: Color, c2: Color) =
when (setOf(c1, c2)) {
setOf(RED, BLUE) -> ORANGE
setOf(YELLOW, BLUE) -> GREEN
setOf(BLUE, VIOLET) -> INDIGO
else -> throw Exception("no color")
}
//不带参数的when（不推荐此写法）
fun mixOptimized(c1: Color, c2: Color) =
when {
(c1==RED&&c2==YELLOW)||(c1==YELLOW&&c2==RED) -> ORANGE
...
else -> throw Exception("no color")
}
"is"和"as"
is相当于java中的instanceOf,不同的是"is"在kotlin中检查过一个变量是某种类型，后面就不需要转换，可以直接当作检查过的类型使用（前提是变量在is检查后不会在发生变化），这种行为也能称为智能转换
as 是类型转换
val number = 42.0 as Double
While循环
fun whileTest(){
//满足条件进入while循环
while (...){
...
}
循环体第一次无条件执行，此后满足条件后执行
do {
}while (...)
}
迭代数字：区间和数列
/**
* 使用..运算符表示区间，1表示起始值，10表示结束值
* 区间是包含或者是闭合的，即第二个值是始终是区间的一部分
*/
val oneToTen = 1..10
//数字迭代测试
fun iterationTest(i: Int) = when {
i % 15 == 0 -> "hello,kotlin"
i % 3 == 0 -> "hello"
i % 5 == 0 -> "kotlin"
else -> "$i"
}
fun main(args: Array<String>) {
//迭代0到100
for (i in 1..100) {
println(iterationTest(i))
}
/**
* 0 -100倒着迭代，并只需要偶数
* (i in 100 downTo 1 step 2)带步长的数列，它允许跳过一些数字
* 步长也可以是负数（这种情况下表明数列是递减而不是递增）
* 100 downTo 1 是递减，step把步长绝对值变成2（即步长改变成了-2）
*/
for (i in 100 downTo 1 step 2){
println(iterationTest(i))
}
}
/**
* ..区间始终包含创建值和结束值（..右边值），而许多情况下我们迭代不包含指定 结束值半闭合区间
* 使用 for(i in 0 until size)等同于for (i in 0..size-1)和java的for(int i = 0;i<size-1;i++)
*/
for (i in 0 until 100){
println(i)
}
迭代map
val binaryReps = TreeMap<Char, String>()
fun main(args: Array<String>) {
//使用字符区间迭代A到Z的字符
for (c in 'A'..'Z') {
val binary = Integer.toBinaryString(c.toInt()) //转成二进制
//map[key]可以直接读取值，map[key]=vaule设置值
binaryReps[c] = binary //根据键c存储对应的二进制值中
}
/**
* for循环允许展开迭代中集合元素
* letter是键，binary是值
*/
for ((letter, binary) in binaryReps) {
println("$letter=$binary")
}
}
我们也可以使用for循环展开语法迭代集合跟踪索引，不需要单独创建变量来存储索引
val list= arrayListOf("hello","kotlin","hello,kotlin!")
fun main(args: Array<String>) {
for ((index,vaule)in list.withIndex()){
println("$index:$vaule")
}
}
使用"in"检查集合和区间成员
fun isLatter(c:Char)=c in 'a'..'z'||c in 'A'..'Z'
fun isNumberChar(c:Char)=c in '0'..'9'
//是否不在区间
fun isNumberStr(c:Char)=c !in '0'..'9'
fun main(args: Array<String>) {
println(isLatter('X'))
println(isNumberChar('X'))
println(isNumberStr('X'))
}
//也可以用in检查作为when分支
fun main(args: Array<String>) {
println(recognize('B'))
}
fun recognize(c: Char) = when (c) {
in '0'..'9' -> "is NumberChar"
in 'a'..'z', in 'A'..'Z' -> "is Letter"
else ->"sorry"
}
区间也不仅局限于字符，假如有一个支持实例比较操作的任意类（实现java.lang.Comparable接口），就能创建这种对象区间，但是并不能列举出这个区间所有对象，只能检查这个对象是否属于这个区间
println("Kotlin" in "Java".."Scala")
//试用于集合
println("Kotlin" in setOf("Java","Scala"))
