二、Kotlin 基础程序结构
1、Val和Var
1.1、val=value，值类型 ，类似Java的final修饰，不可以重复赋值
ps：类似于java的中的final关键字修饰的 ，所以一般val 修饰的词为Final类型值
val定义的是常量
val FINAL_HELLO_CHINA = “hello china” //类型推导（Java中需要必须写明final和修饰关键字）
在Java中含有final关键字修饰的变量，变量FINAL_HELLO_WORLD为编译期常量，在用到这个变量的时候，编译器一律把 “对这个变量的引用都会自动换成 它的值类型进行使用”，提高代码运行效率。
public String FINAL_HELLO_WORLD =“...“;
ex：
～运行时常量；val x =getX（）
～编译期常量： const val x:值类型=值
1.2、 var = variable 临时变量
ex：
var x = “HelloWorld “ //定义变量
x = “ hiWolrd “ //再次赋值
类型推导
val String = “hello” //推导出String类型
val int = 5 //Int类型
var x = getString() + 5 //String 类型
2、函数 Function
什么是函数？
以特定功能组织起来的代码块
fun[函数名]（参数列表）：[返回值类型] { 函数体}
fun[函数名]（参数列表） = 表达式
ex:
fun sayFuck( name: String ) : String{ println(“fuck,$name”) }
fun sayFuck( name: String ) = println(“fuck,$name")
什么是匿名函数？
fun（参数列表），必须赋值给一个变量否则无法识别，如上例2
值类型返回值要加参数类型 ，默认返回类型是Unit
fun main(args: Array<String>) {
val arg1 = args[0].toInt()
val arg2 = args[1].toInt()
println("$arg1+$arg2= ${sum(arg1, arg2)}")
}
fun sum(arg1: Int, arg2: Int): Int {
return arg1 + arg2
}
kotlin简便写法：
fun sum(arg1: Int, arg2: Int) = arg1 + arg2
思考：方法一定有名字嘛？
答：用一个变量接收一个方法就不需要有名字了：
也就是一个变量的值是一个函数的返回值
val int2 = fun(x:Int ) : Long {
return x.toLong()
}
注意事项
- 方法要功能单一
- 函数名顾名思义
- 参数列表不要太复杂
3、类
ex:
public class JavaA {
private int b = 0;
public int getB() {
System.out.println("some one tyies to get b");
return b;
}
public void setB(int b) {
System.out.println("some one tyies to set b");
this.b = b;
}
}
class A {
在kotlin方法中get()、set()是默认实现的版本，想要实现必须得复写get or set方法
var b = 0;
get() {
println("...")
return field //field 这里指代b后面真正的值,只在get/set访问器中才能访问到
}
set(value){
field = value ; //相当于java中的this .b=b；
}
}
lateinit 延时初始化 and by lazy 懒加载
lateinit var c:String
延时初始化，在需要的时候进行初始化，禁止初始化之前使用
lateinit val e:x is false
var 可以使用 lateinit 进行延时初始化，也只能使用在var上 ，
但val的延时初始化需要用下面的操作：
val e ： X by lazy {
… //适合于val的懒加载模式
}
当var xx:String ?= null //初始化为null并且可空类型
在使用的时候不可使用，因为没有向编译器保证该值不能为null
解决办法：
println(cc ?. length) or println(cc !!. length)
类成员
属性：或者说成员变量，类范围内的变量
方法：或者说成员函数，类范围内的函数
构造方法 参数中 val / var 修饰的都是属性，没有就只是构造方法的参数
1、val 没有set()方法因为是不可变的final的
2、 属性的初始化尽量在构造方法中完成。
3、无法在构造方法中完成初始化，尝试降级为局部变量
4、var用lateinit延迟初始化，val用lazy
5、可空类型谨慎用null直接初始化 （!!or?）
4、修饰符
kotlin 语言的修饰符 存放在kotlin源码工程的kotlin/grammar/src/modifiers.grm 文件中，完整定义在kotlin/compiler/frontend/src/org/jetbrains/kotlin/lexer/KtToken.java源码中
/**
## Modifiers
*/
modifiers
: (modifier| annotations)*
typeModifiers
: (suspendModifier| annotations)*
modifier
: classModifier
: accessModifier
: varianceAnnotation
: memberModifier
: parameterModifier
: typeParameterModifier
: functionModifier
: propertyModifier
classModifier 类修饰符
: "abstract" 抽象类
: "final" 不可被继承final类
: "enum" 枚举类
: "open" 可继承open类
: "annotation" 注解类
: "sealed" 密封类
: "data" 数据类
memberModifier
: "override" 重写函数
: "open" 可被重写
: "final" 不可被重写
: "abstract" 抽象函数
: "lateinit" 后期初始化
accessModifier 访问权限控制, 默认是public
: "private"
: "protected"
: "public"
: "internal" 整个模块内（模块(module)是指一起编译的一组 Kotlin 源代码文件: 例如，一个 IntelliJ IDEA 模块，一个 Maven 工程, 或 Gradle 工程，通过 Ant 任务的一次调用编译的一组文件等）可访问;
varianceAnnotation 泛型可变性
: "in"
: "out"
parameterModifier
: "noinline"
: "crossinline"
: "vararg" 变长参数
typeParameterModifier
: "reified"
functionModifier
: "tailrec" 尾递归
: "operator"
: "infix"
: "inline"
: "external"
: suspendModifier
propertyModifier
: "const"
suspendModifier
: "suspend"
5、关键字 keywords
一些常见的关键字：
KtKeywordToken PACKAGE_KEYWORD = KtKeywordToken.keyword("package");
KtKeywordToken AS_KEYWORD = KtKeywordToken.keyword("as");
KtKeywordToken TYPE_ALIAS_KEYWORD = KtKeywordToken.keyword("typealias");
KtKeywordToken CLASS_KEYWORD = KtKeywordToken.keyword("class");
KtKeywordToken THIS_KEYWORD = KtKeywordToken.keyword("this");
KtKeywordToken SUPER_KEYWORD = KtKeywordToken.keyword("super");
KtKeywordToken VAL_KEYWORD = KtKeywordToken.keyword("val");
KtKeywordToken VAR_KEYWORD = KtKeywordToken.keyword("var");
KtKeywordToken FUN_KEYWORD = KtKeywordToken.keyword("fun");
KtKeywordToken FOR_KEYWORD = KtKeywordToken.keyword("for");
KtKeywordToken NULL_KEYWORD = KtKeywordToken.keyword("null");
KtKeywordToken TRUE_KEYWORD = KtKeywordToken.keyword("true");
KtKeywordToken FALSE_KEYWORD = KtKeywordToken.keyword("false");
KtKeywordToken IS_KEYWORD = KtKeywordToken.keyword("is");
KtModifierKeywordToken IN_KEYWORD = KtModifierKeywordToken.keywordModifier("in");
KtKeywordToken THROW_KEYWORD = KtKeywordToken.keyword("throw");
KtKeywordToken RETURN_KEYWORD = KtKeywordToken.keyword("return");
KtKeywordToken BREAK_KEYWORD = KtKeywordToken.keyword("break");
KtKeywordToken CONTINUE_KEYWORD = KtKeywordToken.keyword("continue");
KtKeywordToken OBJECT_KEYWORD = KtKeywordToken.keyword("object");
KtKeywordToken IF_KEYWORD = KtKeywordToken.keyword("if");
KtKeywordToken TRY_KEYWORD = KtKeywordToken.keyword("try");
KtKeywordToken ELSE_KEYWORD = KtKeywordToken.keyword("else");
KtKeywordToken WHILE_KEYWORD = KtKeywordToken.keyword("while");
KtKeywordToken DO_KEYWORD = KtKeywordToken.keyword("do");
KtKeywordToken WHEN_KEYWORD = KtKeywordToken.keyword("when");
KtKeywordToken INTERFACE_KEYWORD = KtKeywordToken.keyword("interface");
// Reserved for future use:
KtKeywordToken TYPEOF_KEYWORD = KtKeywordToken.keyword("typeof");
...
KtKeywordToken FILE_KEYWORD = KtKeywordToken.softKeyword("file");
KtKeywordToken FIELD_KEYWORD = KtKeywordToken.softKeyword("field");
KtKeywordToken PROPERTY_KEYWORD = KtKeywordToken.softKeyword("property");
KtKeywordToken RECEIVER_KEYWORD = KtKeywordToken.softKeyword("receiver");
KtKeywordToken PARAM_KEYWORD = KtKeywordToken.softKeyword("param");
KtKeywordToken SETPARAM_KEYWORD = KtKeywordToken.softKeyword("setparam");
KtKeywordToken DELEGATE_KEYWORD = KtKeywordToken.softKeyword("delegate");
KtKeywordToken IMPORT_KEYWORD = KtKeywordToken.softKeyword("import");
KtKeywordToken WHERE_KEYWORD = KtKeywordToken.softKeyword("where");
KtKeywordToken BY_KEYWORD = KtKeywordToken.softKeyword("by");
KtKeywordToken GET_KEYWORD = KtKeywordToken.softKeyword("get");
KtKeywordToken SET_KEYWORD = KtKeywordToken.softKeyword("set");
KtKeywordToken CONSTRUCTOR_KEYWORD = KtKeywordToken.softKeyword("constructor");
KtKeywordToken INIT_KEYWORD = KtKeywordToken.softKeyword("init");
KtModifierKeywordToken ABSTRACT_KEYWORD = KtModifierKeywordToken.softKeywordModifier("abstract");
KtModifierKeywordToken ENUM_KEYWORD = KtModifierKeywordToken.softKeywordModifier("enum");
KtModifierKeywordToken OPEN_KEYWORD = KtModifierKeywordToken.softKeywordModifier("open");
KtModifierKeywordToken INNER_KEYWORD = KtModifierKeywordToken.softKeywordModifier("inner");
KtModifierKeywordToken OVERRIDE_KEYWORD = KtModifierKeywordToken.softKeywordModifier("override");
KtModifierKeywordToken PRIVATE_KEYWORD = KtModifierKeywordToken.softKeywordModifier("private");
KtModifierKeywordToken PUBLIC_KEYWORD = KtModifierKeywordToken.softKeywordModifier("public");
KtModifierKeywordToken INTERNAL_KEYWORD = KtModifierKeywordToken.softKeywordModifier("internal");
KtModifierKeywordToken PROTECTED_KEYWORD = KtModifierKeywordToken.softKeywordModifier("protected");
KtKeywordToken CATCH_KEYWORD = KtKeywordToken.softKeyword("catch");
KtModifierKeywordToken OUT_KEYWORD = KtModifierKeywordToken.softKeywordModifier("out");
KtModifierKeywordToken VARARG_KEYWORD = KtModifierKeywordToken.softKeywordModifier("vararg");
KtModifierKeywordToken REIFIED_KEYWORD = KtModifierKeywordToken.softKeywordModifier("reified");
KtKeywordToken DYNAMIC_KEYWORD = KtKeywordToken.softKeyword("dynamic");
KtModifierKeywordToken COMPANION_KEYWORD = KtModifierKeywordToken.softKeywordModifier("companion");
KtModifierKeywordToken SEALED_KEYWORD = KtModifierKeywordToken.softKeywordModifier("sealed");
KtModifierKeywordToken DEFAULT_VISIBILITY_KEYWORD = PUBLIC_KEYWORD;
KtKeywordToken FINALLY_KEYWORD = KtKeywordToken.softKeyword("finally");
KtModifierKeywordToken FINAL_KEYWORD = KtModifierKeywordToken.softKeywordModifier("final");
KtModifierKeywordToken LATEINIT_KEYWORD = KtModifierKeywordToken.softKeywordModifier("lateinit");
KtModifierKeywordToken DATA_KEYWORD = KtModifierKeywordToken.softKeywordModifier("data");
KtModifierKeywordToken INLINE_KEYWORD = KtModifierKeywordToken.softKeywordModifier("inline");
KtModifierKeywordToken NOINLINE_KEYWORD = KtModifierKeywordToken.softKeywordModifier("noinline");
KtModifierKeywordToken TAILREC_KEYWORD = KtModifierKeywordToken.softKeywordModifier("tailrec");
KtModifierKeywordToken EXTERNAL_KEYWORD = KtModifierKeywordToken.softKeywordModifier("external");
KtModifierKeywordToken ANNOTATION_KEYWORD = KtModifierKeywordToken.softKeywordModifier("annotation");
KtModifierKeywordToken CROSSINLINE_KEYWORD = KtModifierKeywordToken.softKeywordModifier("crossinline");
KtModifierKeywordToken OPERATOR_KEYWORD = KtModifierKeywordToken.softKeywordModifier("operator");
KtModifierKeywordToken INFIX_KEYWORD = KtModifierKeywordToken.softKeywordModifier("infix");
KtModifierKeywordToken CONST_KEYWORD = KtModifierKeywordToken.softKeywordModifier("const");
KtModifierKeywordToken SUSPEND_KEYWORD = KtModifierKeywordToken.softKeywordModifier("suspend");
KtModifierKeywordToken HEADER_KEYWORD = KtModifierKeywordToken.softKeywordModifier("header");
KtModifierKeywordToken IMPL_KEYWORD = KtModifierKeywordToken.softKeywordModifier("impl");
this 关键字
- 持有当前对象的引用，使用this来引用变量或是成员函数，亦可以使用return this，来返回某个类的引用
- 在类的成员中，this指向的是该类的当前对象
- 在扩展函数或者带接收者的函数字面值中，this表示在点左侧传递的 接收者参数
- 如果this没有限定符，它指的是最内层的包含它的作用域；如果引用其他作用域中的this，可以使用this@label标签
小示例：
class Outer {
val oh = "Oh!"
inner class Inner {
fun m() {
val outer = this@Outer
val inner = this@Inner
val pthis = this
println("outer=" + outer)
println("inner=" + inner)
println("pthis=" + pthis)
println(this@Outer.oh)
val fun1 = hello@ fun String.() {
val d1 = this // fun1 的接收者
println("d1" + d1)
}
val fun2 = { s: String ->
val d2 = this
println("d2=" + d2)
}
"abc".fun1()
fun2
}
}
}
6、基本运算（操作）符
- 运算符方法重载的定义，任何类可以定义或是重载基本运算符
- 通过运算符对应的具名函数来定义，要求方法名字必须一致对的上，fun前面加上operator 关键字
- 参数的个数对的上，类型和返回类型不作要求
- 不能像Scala一样定义任意运算符
6.1、操作符优先级
级别由上到下 ，由高到低
后缀 Postfix : “++” , " - - “ ,” .” ,” ?.” ,” ?"
前缀 Prefix ： "- " ,"+ ", "++ ", " - - " , “！” ,”labelDefinition@"
右手类型运算 RHS：” ：" , " as " , "as?"
乘除取余 Multiplicative ： "* “ , “ / “ , “%"
加减 Additive : “+” , “-"
区间范围 Range : " ..”
Infix 函数 ： 给Int 定义扩展 infix fun Int .shl( x:Int ) :Int {…} —>调用 1 shl 2 ，等同于1.shl(2)
Elvis 操作符 ：“ ？：”
命名检查符号 Named checks： “in" , "!in”, “is”, “!is"
比较大小 Compariosn ： “<“ , “>” ,”<=“ , “>="
相等性判断 Equality ： “==“ , “!=="
与 Conjunction : “&&"
或 DIsjunction : “||"
最低 赋值 Assignment ： “ = “ , “+= “ ,” -= “ , “*=“, ”/=“ , “%="
6.2 、递增 or 递减
inc () / dec () 函数必须返回一个值，用于赋值给使用 ++ or — 操作的变量
a ++ ： a.inc() 返回值 a
a - - ： a.dec () 返回值 a
++ a ： a.inc() 返回值 a+1
—a : a.dec() 返回值是 a-1
解析：
编译器执行以下步骤来解析后缀表达式的操作符，例如：后缀形式a++
1、确定a的类型 ，令其解析为T
2、查找一个适用于类型为T的接收者的、带有operator修饰符的无参数函数inc()
3、检查函数的返回类型是T的子类型
表达式计算步骤：
1、把a的初始值存储到临时存储a _ 中
2、把a.inc ( ) 结果赋值给 a
3、把a_ 作为表达式的结果返回
对于前缀形式：
++a 和 —a解析步骤类似，返回值不同是取的新值来返回
把 a.inc () 结果赋值给a
把 a的新值 a+1 作为表达式结果返回
6.3 、算术运算符
a + b : a.plus ( b )
a - b : a.minus ( b )
a * b : a.times ( b )
a / b : a.div ( b )
a & b : a.rem ( b ) a.mod ( b )
a .. b : a .rangTo ( b )
6.4 、in 操作符
a in b : b.contains ( a )
a !in b : !b.contains ( a )
6.5 、计算并赋值
a += b : a .plusAssign ( b )
a -= b : a .minusAssign ( b )
a *= b : a .timesAssign ( b )
a /= b : a .divAssign ( b )
a %= b : a.modAssign ( b )
编译器操作 a += b ： 生成a = a+b 的代码，a+b 的类型必须是a的子类
6.6、相等 与 不等操作符
-
引用相等 "===" , " ！==“ ————》两个引用指向同一对象————〉不能重载！！！
- 结构相等 “ == “ , “ != “ ————> 使用 equals() 判断
a == b : a ?.equals ( b ) ?: ( b === null )
a != b : ! ( a ?.equals ( b ) ?: ( b === null ) )
在这里 == 操作符 特殊性：被翻译成一个复杂的表达式，用于筛选 null 值；
也就是说如果 a不是null，则调用 equals ( Any )函数并返回其值 ，否则 （ a === null ） 就计算 （ b === null ）的值并返回
当与 null 显示 比较时候， a == null 会被自动转换为 a === null
6.7 、 Elvis 操作符 ？：
在kotlin 中， Elvis 操作符 特定是跟null 比较 ，也就是说用来做null安全检查
y = x ?: 0 ——>二元
等价于==》
val y = if ( x !== null ) x else 0 ）——>kotlin 三元运算符
？： 这是一个二元运算符 ，如果第一个操作数为真，则返回第一个操作数，否则将计算并返回其第二个操作数
注意：
用( ?: ) 可以把带有默认值的if/else 结构写的精简，不用检查null，也不用重复变量
6.8 、中缀操作符
通过自定义infix函数来实现中缀操作符
示例：
data class Person ( val name :String .val age :Int )
infix fun Person.grow ( years:Int ) :Person{
return Person ( name ,age +years )
}
test:
@RunWith(Junit4::Class )
class InfixFunctionTest {
@Test
fun testInfixFuntion ( ){
val person = Person (“son” ,25)
println ( person .grow (2 ) )
println ( person grow 2 )
}
结果：
name = son, /n age = 27
小示例
加法：
class Complex(var real: Double, var imaginary: Double) {
//定义一个加法函数
operator fun plus(other: Complex): Complex {
return Complex(real +other.real, imaginary + other.imaginary)
}
operator fun plus(other: Int): Complex {
return Complex(real + other, imaginary)
}
override fun toString(): String {
return "$real+${imaginary} i"//实部+虚部
}
//取模方法
operator fun invoke() :Double{
return Math.hypot(real, imaginary)
}
class Book {
//中缀表达式 infix
infix fun on(any: Any): Boolean {
return false
}
}
fun main(args: Array<String>) {
val c1 = Complex(3.0, 4.0) //3+4i
val c2 = Complex(2.0, 7.5) //2+7.5i
println(c1 + c2) //5+11.5i—>toString() 需要用到
println(c1 + 4)
println(c1) //（3的平方+4的平方） 再开方
//-name <Name> //args contains name,如果包含的话就取后面的Name
if ("-name" in args) { //in表示Array<out T>.contains(element: T): Boolean，
// 实际上返回的是indexOf >=0,如果indexOf有这个元素，返回的就是它的位置如果没有返回 -1
println(args[args.indexOf("-name") + 1])//返回-name在args里面的后面一个位置的值
}
if(Book() on Desk()) { … }//DSL里常见 中缀表达式替换.()方法
}
}
7、Lambda表达式 *****
本质：匿名函数（可以赋值和传递）
lambda表达式返回值 ：表达式最后一行表达式的值
Lambda表达式（匿名函数）
写法：{ [参数列表]->[函数体,最后一行时返回值] }
ex：
普通函数表达式：fun sum( arg1:Int, arg2:Int ) = arg1 + arg2
lambda 表达式 : val sum ={ arg1:Int ,arg2 :Int -> arg1+arg2 }
参数列表：arg1:Int ,arg2 :Int
函数体，返回值最后一行：arg1+arg2
-> xxx ：lambda表达式返回值是表达式最后一行的值
val/var xxx = {函数体} ps：arg1:Int,arg2:Int ->arg1+arg2
arg1:Int 表示参数返回类型
arg1+arg2:函数返回值
->:用右箭头链接
lambda表达式可以作为参数传递！
print(sum(1, 2))=== print(sum.invoke(1,3))是一个意思！—【invoke ：运算符重载】
在kotlin中数组的遍历两种写法：
for( i in args) { … } or for ( i in array.indices) {...} //在Program arguments里: 添加参数中间用空格隔开
args.forEach( {…lambda...} )
注意：函数如果最后一个参数是lambda表达式，可以将括号内的内容移动到括号外面，若括号内无内容可直接删除。
forEach: Array的扩展方法 ，返回值是Unit类型，使用action调用传递的Array里面的元素作为参数
Array<out T> .forEach (action : (T) -> Unit ) :Unit {for (element in this ) action (element) }
action : (T):参数的类型
->Unit :lambda 表达式返回的类型
(action : (T) -> Unit )==lambda
args.forEach( {println(it)} ) === args.forEach(){ println(it) }====>
注意：若参数的最后一个是lambda表达式，可以将（ ） 移动到lambda表达式外面
args.forEach(::println) //[若传入的函数和lambda表达式类型完全一样]
将println函数作为参数传递 ，println的参数是Any，接收任何对象都可以
args.forEachForEach@{
if(i=x) return@ForEach
println(it)
}
println(...)
终断lambda表达式的迭代。以上做法可以跳出lambda表达式内的执行继续执行lambda表达式下面的内容
@ForEach:接收Array<T>类型
Lambda表达式的类型举例
main(args:Array<String>) 函数
—— 传入参数 Array<String> -> Unit
println(…)
——传入(Any?可空的any）-> 返回Unit
()->Unit
——无参，返回值Unit
(Int)->Int
——传入整型，返回一个整型
(String,(String) ->String)->Boolean
——传入字符串，lambda表达式，返回一个boolean
println(::printUsage is () -> Unit) :参数为0的Function0 ()————具名函数printUsage()
invoke多少参数就是Function几，最多可以Function0-22
lambda表达式的调用
- 用（）进行调用
- 等价于invoke（）
ex : val sum = {a:Int ,b:int -> a+b}
// in P1，in P2 out R ，传入两个int返回一个int ，Function0-22均调用invoke(参数列表)
sum(2,3) ——————> sum.invoke(2,3)
lambda表达式的简化特点
- 函数参数调用时最后一个lambda表达式可以移出去
- 函数参数只有一个lambda，调用时小括号可以省略
- lambda只有一个参数可默认为it
- 入参、返回值与形参一致的函数可以用函数引用的方式作为实参传入(forEach里面传入一个printnln [::println])
8、表达式 -中缀表达式、分支表达式、when表达式
8.1、中缀表达式
只有一个参数，且用infix修饰的函数
ex：
class Book {
infix fun on ( place :String){
…}
}
Book() on “My desk”()
8.2、 分支表达式
传统的分支使用方法：
var max = a
if ( a < b )
max = b
搭配else 的使用：
var max : Int
if ( a > b )
max = a
else
max = b
kotlin 中的分支表达式：
8.2.1 、if表达式 ：
if…else :
- 表达式与完备性
- if（boolean）
var x = if (b <0) 0 else b
var x = if (b <0) 0//错误 ，赋值时，分支必须完备
if max = if ( a >b ) {
a
}
else {
b
}
val mode = if (args.isNotEmpty() && args[0] == "1") {
//if表达式有返回值所以可以做为代码块，每个分支里面的最后一句话是其段的返回值
DEBUG
} else {
USER
}
注意：
1、在kotlin中没有没有 java中的这一种写法： true ? 1:0 三元表达式或是说正则，对应的kotlin写法是：
if( boolean ) 1 else 0
2、如果if 表达式 只有一个分支， 或者分支结果返回Unit ，其值也是Unit
3、else 和 else if 同时出现，else要再else if 之后
4、如果有多条else if 语句同时出现，那么如果有一条else if 语句表达式测试成功，那么就会忽略掉其他所有else if 和else分支
5、如果出现多个if ，只有一个else情形，那么else子句归属于最内层的if语句
8.2.2 、when表达式
- when表达式 ：
加强版 switch，支持任意类型，不用写break
支持纯表达式条件分支 类型if
表达式与完备性
when 既可以被当作表达式使用也可以被当作语句使用；当被当作表达式，符合条件的分支的值就是整个表达式的值，如果当作语句使用，则忽略单个分支的值
fun pause() {
when (state) {
Player.State.BUFFERING -> {}
Player.State.PAUSED -> {}
Player.State.PLAYING -> {}
}
}
fun main(args: Array<String>) {
val x = 5
when (x) {
is Int -> println("Hello $x")
in 1..100 -> println("$x is in 1..100")
!in 1..100 -> println("$x is not in 1..100")
args[0].toInt() -> println("x == args[0”)
}
}
注意：
1、else 在when 分支里相当于default 其他分支都不满足条会到else分支里
2、分支处理方式相同，用逗号分隔
3、分支条件可以是常量也可以是表达式
8.3、循环表达式
8.3.1 、for循环实例： for（element in elements 任何提供迭代器的集合）… for{ :. keyword }
遍历一个简单的数组 or list ：
for ( i in array.indices )
println ( array [i] )
等同于 下面的 i in args
A：
for (arg in args) { //for ( i in array.indices) {...}
println(arg)
}
B：库函数 withIndex
for ((index, value) in args.withIndex()) {
println("$index->$value")
//0 -> a 1-> b 2-> c 3-> d
}
C：结果和B一模一样
for (indexedValue in args.withIndex()) {
println("${indexedValue.index}->${indexedValue.value}”)
//0 -> a 1-> b 2-> c 3-> d
}
解析：返回一个IndexValue 类型
public fun <T> Array<out T>.withIndex(): Iterable<IndexedValue<T>> {
return IndexingIterable { iterator() }
}
public data class IndexedValue<out T>(public val index: Int, public val value: T)
8.3.2、 while循环实例：while(…) / do {...} while(…)...
var x = 5
//1、首先判断条件，接着执行循环体
while (x > 0) {
println(x)
x--
}
//2、先执行一次循环体，再判断条件是否继续执行
do {
println()
x--
} while (x > 0)
8.3.3、 continue、break 跳出循环实例
continue：跳过当前循环 ，直接进入循环体的下次循环；
break：终止最近的封闭循环 用break
class Student {
fun isNotClothedProperly(): Boolean {
return false
}
fun main(args: Array<String>) {
val you = Student()
val students = ArrayList<Student>()
for (students in students) {
if (students == you) continue //当条件满足时候 ，跳过循环
if (students.isNotClothedProperly()) {
break//当条件满足时候，跳出循环
}
}
}
}
8.3.4、 return 返回
在java，c语言中，return语句使用我们在常见不过了。虽然在Scala、groovy语言中，函数的返回值可以不需要在显示的用return 来制定，但是我们仍然认为，使用return 的编码风格更加容易阅读
在kotlin中，除了表达式的值，有返回值的函数都要求显示使用return 来返回其值
小示例：
fun sum(a: Int ,b :Int ) :Int {
return a + b
}
fun max ( a:Int , b:Int ) :Int {
if ( a >b ) returna else returnb
}
or 在kotlin 中可以直接使用 = 符号 直接返回一个函数体的值
fun sum ( a:Int , b :Int ) = a +b
fun max ( a:Int , b:Int ) = if ( a >b ) returna else b
注意：
-
在koltin中 return 语句会从最近的函数 或 匿名函数中 返回，但是在Lambda表达式中遇到return ，则直接返回最近的外层函数
-
在非全局的返回只支持内部方法，如果我们只是需要跳出内部方法，就必须标记它并且返回这个标签
ex1:
fun return_1( ){
val Array1 = intArrayOf( 1,2,3,4,5)
Array1.forEach {
if( it ==3 ) return
println(it)
}
}
结果：在遇到3的时候会直接返回 println结果： 1 2
用一个方法表达式替代内部匿名方法，在方法内部声明一个return{ :. keyword} 将从其内部返回
ex2:
fun return2( ){
val intArray = intArrayOf (1,2,3,4,5)
intArray.forEach (
fun (a:Int ) {
if (a == 3) return
println(a)
})
}
结果：在运行时候遇到3会跳过它继续执行，输出结果：1 2 4 5
需要在返回的时候带有一个值：
ex3:
return @ a1
结果：在标签@a 上返回1，而不是“返回一个带标签的表达式（@a 1）”
8.4、 标签 label
在kotlin中 任何表达式都可以用标签来标记。标签的格式为标识符后跟 @ 符号；作用是用标签来控制 return/break/continue的跳转行为
在lambda表达式开头处添加标签here@ ，可以理解为 该标签相当于记录了Lambda入口地址，然后在表达式内部使用了return@here来跳转至lambda表达式该地址处
接收该Lambda表达式的函数是forEach ，所以可以直接使用return@ForEach，来跳转到此处执行下一轮循环；如果使用break在循环体中，是跳出最外层的循环
多层循环嵌套的终止结合标签使用：
Outter@for (…) {
Inner@while ( i < 0) {
if( …)
// break ：若没有@Outter 这里是把while循环给break掉，继续执行for循环
break@Outter // 将for循环也给break 掉
}
}
8.5、 throw
throw 用来标记无返回的函数，它的类型是特殊类型Nothing。该类没有值。和void 类似
fun fail (msg :String) :Noting {
throw IllegalArgumentException(msg)
}
throw 表达式赋值给一个变量，需要显示声明类型：Nothing
val ex:Nothing = throw Exception(“xxxxxx")
注意：该ex变量是Noting类型，没有任何值，无法当作参数传递给函数
8.6、课后小栗子：
自定义一个迭代器，实现数组的添加or 删除功能
fun main(args: Array<String>) {
val list=MyIntList()
list.add(1)
list.add(2)
list.add(3)
}
class MyIterator(val iterator: Iterator<Int>) {
operator fun next(): Int {
return iterator.next()
}
operator fun hasNext(): Boolean {
return iterator.hasNext()
}
}
class MyIntList {
private val list = ArrayList<Int>()
fun add(int: Int) {
list.add(int)
}
fun remove(int: Int) {
list.remove(int)
}
//定义operator 运算符
operator fun iterator(): MyIterator {
return MyIterator(list.iterator())
}
}
8、异常捕获
try{…}catch(e:xxxx){...}finally{…} 表达式，可以用来赋值
val result = try{ … }catch(e:xxx){ … }
注意：
先执行finally 代码在返回 return
return try { x/y
}catch (e: Exception ){
0
}finally{
…
}
9、具名参数、变长参数、默认参数
具名参数：指定实参的方式 ，在使用的时候需要赋值在括号里(...)
fun sum( arg1: Int ,arg2: Int ) =arg1+arg2
sum ( arg1 = 2 ,arg2 =3) //参数位置可以互换
变长参数：某个参数可以接受多个值；可以不为最后一个参数；参数时候有歧义需要使用具名参数
args:Array<String> —> varargargs:String 两者完全一样
hello(1, 2, 3, 4, 5, string = "hello”)
//将hello赋值给string，在这里使用具名参数，将1-5赋值给ints，后面复制给string
ex：
fun hello(vararg ints: Int, string: String) {
ints.forEach(::println)
println(string)
}
Spread Operator——变长参数场景
特点：
- *array :表示把array展开（只支持array数组），变成一个个元素传入使用
- 该类仅支持变长参数的实参
- 不能重载
- 只能使用array数组 ，不能使用list 等其他集合
val array = intArrayOf (1 ,2 ,3,4)
hello( 3.0, *array ,string = “hello”)
默认参数：可以指定给参数列表的任意一个参数，如果把默认参数指定给一个比较靠前位置的参数，其后面的参数需要使用具名参数的形式表示
一个简单的命令行计算器：
/**
* 一个极简的命令行计数器
* */
fun main(args: Array<String>) {
while (true) {
try {
println("请输入算式数据,比如：1+1")
val input = readLine() ?: break
val splits = input.trim().split(" “) //空格分隔符，并去掉string首尾空字符
if (splits.size < 3) {
throw IllegalArgumentException("参数个数异常")
}
val arg1 = splits[0].toDouble()
val op = splits[1] //运算符
val arg2 = splits[2].toDouble()
println(
"$arg1 $op $arg2=${
Operator(op).invoke(arg1, arg2)
}”
) //将op运算符赋值给等式
} catch (e: NumberFormatException) {
println("类型格式异常:" + e)
} catch (e: IllegalArgumentException) {
println("输入是否为三个参数的一般计算:" + e)
}
println("是否再来一次[Y]")
val cmd = readLine()
if (cmd == null || cmd.toLowerCase() == "y") {
println("输入有误请查看")
break
}
}
}
//定义一个运算类
class Operator(op: String) {
val opFun: (left: Double, right: Double) -> Double
//初始化opFun
init {
opFun = when(op) {
"+" -> { l, r -> l + r }
"-" -> { l, r -> l - r }
"*" -> { l, r -> l * r }
"/" -> { l, r -> l / r }
"%" -> { l, r -> l % r }
else -> {//when表达式的完备性
throw UnsupportedOperationException(op)
}
}
}
fun invoke(left: Double, right: Double): Double {
return opFun(left, right)
}
}
Kotlin导出执行程序
在根目录 ，build.gradle中添加依赖：
apply plugin: ‘application'
mainClassName = “包名.类名kt”
CMD: cd build/instal/下包名
授予权限：chmod 755 bin/下包名
bin/下包名