一、常量与变量（val,var)
- 1.什么是常量？
1 .val = value ,值类型;
2.类似Java的final;
3.不能重复赋值；
4.举例：
运行时常量：val x = getX(); 也就是程序运行时才赋值；
编译期常量：const val x = 2 ;也就是在编译时期就赋值了；
- 2.什么是变量？
1.var=variable ;
2.可以再次赋值；
3.举例：
var x = "HelloWorld"//定义变量
x = "HiWorld"//再次赋值
示例如下：
/**
* 常量
* 带const为编译期的常量
* 不带const的val为运行期常量
* 不能再次赋值
*/
const val FINAL_HELLO_WORLD:String = "Hello world"
//变量 能够再次赋值
var helloworld:String = FINAL_HELLO_WORLD
二、类型推导
val string = "Hello"//推导出String类型
val int = 5 //Int类型
var x = getString()+5 //String类型，加号在这里是连接符
三、函数--单一原则:
1.任何函数都是以fun开头的，紧接着的是方法名字，紧接着的是参数列表，紧接着的是返回值，紧接着是函数体；
fun <MethodName>(<ParamsName>:<ParamsType>):<returnValue>{}
2.如果无返回值，可以写：Unit或者在参数列表后什么都写；Unit类型Java中的void;
3.如果参数有多个，以逗号分开；
4.如果一个函数只是返回一个函数的表达式的值，直接可以等于表达式即可；
5.函数的名字不是必须的，如果有个变量接受返回值即可编译通过；--请看下面的例子
6.函数作为类型的一种出现的，可以被用来赋值与传递的；
/**
* 函数
* methodName
* param1,param2是参数名
* String Int 是参数类型
* 备注：
* 1.任何函数都是以fun开头的；
* 2.如果参数有多个，以逗号分开；
* 3没有返回值在参数后添加：Unit，也可以不写，这个Unit相当于java里面的void；
* 4如果一个函数只是返回一个函数的表达式的值，直接可以等于表达式即可；
*/
fun methodName(param1:String,param2:Int):Unit {
}
//带返回值的函数
fun testMethod(args:String):String{
return args
}
/**
* 如果一个函数只是返回一个函数的表达式的值，直接可以等于表达式即可
*/
fun returnFun0(param1: Int, param2: Int):Int {
return param1+param2
}
//上面的等价于下面的写法：
fun returnFun(param1:Int,param2:Int) = param1+param2
/**
* 函数可以没有名字的，如果有一个变量来接收的话即可
*/
val resultValue = fun(x: Int):Int {
return x
}
四、Lambda表达式
1.也就是匿名函数；函数作为类型的一种出现的，可以被用来赋值与传递的；
2.写法：{[参数列表] ->[函数体，最后一行是返回值]}
3.（） -> Unit
--无参，返回值为Unit；
4.(Int) -> Int
--有参-传入Int类型，返回一个整数；
5.（String,(String) -> String） -> Boolean
--传入字符串、Lambda表达式，返回Boolean；
- 1.Lambda表达式的调用
1.用括号（）来表示方法的调用，是Kotlin中的运算符，等价于invoke();这个invoke其实是运算符重载的方法
2.Lambda表达式如果没有参数，箭头 （->）就不用写了；
3.Lambda表达式不是只有一行的，它的返回值是它表达式的最后一行的值；
val sum = {a:Int,b:Int ->a+b}
//用括号（）来调用，等价于invoke();
sum(2,3)
或者使用：sum.invoke(2,3)，二者完全等价；
//Lambda表达式没有参数，箭头可以不写，如下：
val printHello = {
println("hello")//相当于函数的函数体
}
//Lambda表达式不是只有一行的，它的返回值是它表达式的最后一行的值
val sum = {a:Int,b:Int ->
println("$a + $b = ${a+b}")//这一行也是表达式，不过返回的是Unit类型
a+b//这一行最为Lambda的最后一行，它的值也是Lambda的返回值；
}
- 2.Lambda表达式的简化
- 1.函数参数调用时最后一个Lambda可以移出去；也就是说如果一个函数调用时，最后一个参数是Lambda表达式，我们传入参数时，那么这个参数可以被移出去；
- 2.函数的参数只有一个Lambda，调用时小括号可以省略；
- ３.如果一个Lambda只有一个参数，可以不写，可默认为it；
- 4.入参、返回值与形参一致的函数可以用函数引用的方式作为实参传入；
val sum = {a:Int,b:Int ->a+b}
//Lambda表达式在没有参数时，箭头就不用写了，如下：
//如下面的写法，因为没有参数，箭头就不用写了：
val printHello = {
println("hello")//相当于函数的函数体
}
//看下面的数组遍历：
arg.forEach{element -> println(element) }
//如果一个Lambda传入的参数只有一个，可以不写，可默认为it；上面的等价于：
arg.forEach{ println(it) }
//函数的参数只有一个Lambda表达式时，调用时可以将大括号移到小括号外面；
//上面的等价于下面的：
arg.forEach(){println(it)}
//这个小括号没有什么用，可以把这个小括号省略
arg.forEach{println(it)}
//如果函数的参数和返回值与action的参数和返回类型一致，就可以用函数引用的方式，如下：
arg.forEach(::println)
五、循环语句
for循环如下：
for (i in args) {
println("输出的是：$i")
}
for ((index, value) in args.withIndex()) {
println("$index -> $value")
}
for (indexValue in args.withIndex()) {
println("${indexValue.index}---->${indexValue.value}")
}
//或者使用下面的方式
args.forEach{
println(it)
}
}
//看下面的一个方法，return会把函数截断，无法执行到最后一行
fun main(args: Array<String>) {
args.forEach {
if (it == "c") return
println(it)
}
//你会发现如果上面的if条件触发了 ，将跳出for循环，并且执行不到下面的代码，原因是：
//上面的是表达式，而不是一个简单的遍历，return会调出整个函数的执行
println("The End")
}
//如果想只跳出it=="c"这个条件，循环继续进行，整个函数执行完毕，可以如下：
fun main(args: Array<String>) {
args.forEach ForEach@ {
if (it == "c") return@ForEach
println(it)
}
println("The End")
}
while循环
var int = 5
while (int > 0) {
println("int---->$int")
int--
}
do {
println("int---->$int")
int--
}while (int>5)
如何跳出 或 跳过循环？
跳出或终止循环：break
跳过循环：continue
多层嵌套循环的终止需要结合标签来实现
Outter@ for (i in args) {
Inner@while (i.toInt() > 0) {
break@Outter //这里只是跳出外层的for循环 break和@Outter之间不能有空格
}
}
六、异常捕获（try catch finally）
kotlin里面的异常捕获和Java中的异常捕获用法一样，最后都会调用finally;但Kotlin中的try、catch也是表达式，这点与Java中的不一样，它可以有返回值，返回值是表达式的最后一行的值；
- catch分支匹配异常类型；
- 它是一个表达式，可以用来赋值，与if else when 表达式是完全类似的；
- finally 无论try catch 是否抛出异常都会执行到；
注意此行代码代表的含义：
return try{ x/y } catch（e:Exception){ 0 } finally{...}
代表：先执行finally里面的代码，再返回；如果无异常，返回x/y；如果有异常，返回0；
//kotlin中的try catch也是表达式，可以有返回值；返回值是表达式的最后一行的值；
val result = try {
args[0]
} catch (e: Exception) {
println("jinlaile")
0
} finally {
println("进入finally代码块")
}
println(result)
输出结果：
jinlaile
进入finally代码块
0
七、成员方法、成员变量
- 属性：或者说是成员变量，类范围内的变量；构造方法中val/var修饰的都是属性；类内部也是可以定义属性的的；
/**
* aField和anotherField是类Hello的两个属性；
* 而notField不是属性，只是普通构造方法的参数；
*/
class Hello(val aField: Int, notField: Int){
val anotherField:String = "hello"
}
- 方法：或者说是成员函数，类范围内的函数；
在kotlin的类中，自动为var修饰成员变量实现了get、set方法，val修饰的只有get方法，因为val修饰的是不可变的；如果想要在get、set方法中注入部分逻辑，需要我们重写其get、set方法，如下；
/**
* Created by serenitynanian on 2017/6/27.
*/
class ClassMemberAndField {
//默认访问控制是public
var b = 0
get() {
println("执行打印逻辑")
//这个filed其实是上面b后真正的值0，这个filed只有在get、set方法中才能访问的到
return field
}
/**
* 类型java中的set方法
*
* public void setB（int b）{
*
* this.b = b ；
* }
*/
set(value) {
println("执行打印逻辑")
field = value
}
}
如果想要控制get、set的访问权限，可以在get、set方法前加访问限制符，比如protected
protected set(value) {
println("logic")
field = value
}
如果说get、set中没有部分逻辑，只是想要修改访问控制符，只需要如下写即可：
class ClassMemberAndField {
//默认访问控制是public
protected var b = 0
// get() {
// //这个filed其实是上面b后真正的值0，这个filed只有在get、set方法中才能访问的到
// return field
// }
// /**
// * 类型java中的set方法
// *
// * public void setB（int b）{
// *
// * this.b = b ；
// * }
// */
// protected set(value) {
// println("logic")
// field = value
// }
//如果只想要控制访问权限，只需要这样写即可：
protected get
protected set
}
在kotlin中声明成员变量时，编译器提醒你必须初始化，否则报错；与java不同的时，java会自动给你初始化初始值；但初始值也占内存的，所以有时我们只需要在使用时才想初始化，这样怎么办呢？
只需要在声明成员变量时指定一个lateinit特殊字符就行了；但是在使用之前必须进行初始化，否则报错；
var age:Int = 0
//如果不指定lateinit 编译器会提醒必须初始化或者abstract，
//指定后就是告诉编译器，我后面会进行初始化；
//如果你在初始化它之前就使用这个变量，会报错的；
lateinit var name:String
但是lateinit只能放在var修饰的可变变量前面，不能放在val修饰的变量前面；如果想要达到延迟初始化必须使用delegate,如下：
/**
* lazy需要传入一个lambda表达式，一个无参的表达式返回一个T类型，
* 这个T类型就是下面的String类型；
*/
val address:String by lazy {
"dsfa"
}
总结下属性访问控制：
var修饰的有get、set方法；
val修饰的只有get方法，没有set方法，因为val修饰的变量是不可变的；
总结下属性初始化：
属性的初始化尽量在构造方法中进行初始化完成；
无法在构造方法中初始化，尝试降级为局部变量；
var用lateinit延迟初始化，val用lazy；
可空类型谨慎使用null直接初始化；
八、表达式（中缀表达式、分支表达式、when表达式）
- 中缀表达式
- 只有一个参数，且用infix修饰的函数；
class Book {
infix fun on(place: String) {
}
}
fun main(args: Array<String>) {
//函数前没有使用infix关键字，必须像平常调用函数一样使用
Book().on("my desk")
//如果函数前面使用了infix，不用在方法前加. 不用在方法后加括号
Book() on "my dest"
}
-
2.使用了中缀表达式后，在调用时，可以直接使用[对象] <函数名> [参数对象] 如上示例；
-
分支表达式(if)，而不只是分支语句
分支表达式是可以有返回值的，返回值是分支语句中最后一行的值 ；
private const val DEBUG = 1
private const val USER = 0
fun main(args: Array<String>) {
// var mode = USER
// if (args.isNotEmpty() && args[0] == "1") {
// mode = DEBUG
// }
/**
* 从下面可以看出来if可不只是一个简单的分支语句，
* 它还是一个表达式，它是有返回值的，返回值是是分支表达式中最后一行的值；
* 在上面的分支语句中，只能定义var的mode，因为后面要修改；
* 如果使用分支表达式，就直接可以使用val修饰的mode了，使用如下:
*/
val mode =
if (args.isNotEmpty() && args[0] == "1") {
DEBUG
}else{
USER
}
println("请输入用户名：")
val username = readLine()
println("请输入密码：")
val password = readLine()
if (mode == DEBUG && username == USERNAME && password == PASSWORD) {
println("超管登录成功")
} else if (username == USERNAME && password == PASSWORD) {
println("普通用户登录成功")
} else {
println("登录失败")
}
}
- when表达式
类似Java中的switch语句，由于case语句中只能判断String，enum，byte，int等，并且在每个分支语句中都要写break；在kotlin中没有了switch语句了，使用了when表达式来代替了；
public void pause() {
switch (state) {
case BUFFERING:
case PLAYING:
doPause();
break;
default:
//什么都不做
}
}
//下面是kotlin中的when表达式
fun pause() {
when (state) {
PlayerKt.State.BUFFERING, PlayerKt.State.PLAYING -> doPause()
else -> {
}
}
}
when分支表达式只要第一个分支语句执行了，不用使用break，后面的分支语句就不会执行了
fun main(args: Array<String>) {
var x = 5
//when表达式只要第一个分支语句执行了，不用使用break,后面的就不会执行了
when (x) {
is Int -> println("Hello $x")
in 1..100 -> println("$x is in 1..100")//x的值是否在[1,100]
!in 1..100 -> println("$x is not in 1..100")//x的值不在[1,100]
in 1 until 5 -> println("$x is in[0,5）")//x的值是否在[0,5)之间，取不到5
args[0].toInt() -> println("x == args[0]")//这个是说args[0]是否与x一样
}
}
//when与if一样，也有返回值，都是每一个分支最后一行表达式的值；
val mode = when {
args.isNotEmpty()&& args[0] == "1" -> 1
else -> 0
}
表达式总结：
- if ... else ...这个用法基本和Java中一致；
- 表达式必须具备完整性,如果只有if没有else编译报错；
var b = if (mode == 0) {
0
}
//如果没有下面的分支语句，编译报错
//赋值时，分支必须完备
else {
1
}
- when表达式，加强版的switch，支持任意类型，也不用写break；
支持纯表达式条件分支（类似if）
val mode = when {
args.isNotEmpty()&& args[0] == "1" -> 1
else -> 0
}
必须具备完备性；
九、具名参数，变长参数，默认参数
- 具名参数：就是在给函数传入实参的时候，把形参也赋值上，也就是下面在调用sum函数时，在传入实参的时候，把arg1 和 arg2也附带上（arg1 = 1，arg2 = 2）；
具名参数的顺序可以不是固定的；
class ForDemo {
fun sum(arg1:Int,arg2:Int) = arg1 + arg2
}
fun main(args: Array<String>) {
var forDemo = ForDemo()
/**
* 在使用函数传入实参的时候，把形参也赋上;
* 因为是具名参数，所以形参的顺序可以不固定
* 也就是明确告诉编译器这个2是给arg2的，1是给arg1的
*/
forDemo.sum(arg2 = 2, arg1 = 1)
}
- 变长参数
某个参数可以接收多个值；
变长参数可以不为最后一个参数；但是传入实参时，可以放在最后用具名参数表示即可；
如果传参有歧义，需要使用具名参数指定某个特定参数；
最常见的就是main函数，它里面是个数组，我们可以将它改变为变长参数；它的使用和数组完全一样
var array = intArrayOf(1,23,43,25,56)
hello(3.0,1,123,321,2,string = "hello")
//*：Spread Operator这个符号现在只支持变长参数，且只支持array，不支持list
hello(3.0,*array,string = "hello")
fun hello(double:Double,vararg ints: Int,string:String) {
ints.forEach { ::println }
}
在Java中变长参数只能是函数的最后一个参数，否则编译器无法识别的；
在kotlin中因为存在具名函数，因此它可以放在任意位置；在传入实参的时候可以用具名函数放在最后一个位置；
*：Spread Operator 这个不是一般的运算符；
只支持展开Array;
只用于变长参数列表的实参；
不能重载；
- 默认参数
1.就是在函数编写时，可以给函数任意位置的形参一个默认值；在实际调用函数时，这个参数可以不传；
2.但是如果该默认参数不是最后一个，其他参数使用具名参数即可，不用写默认的；
3.传参出现歧义时，也就是编译器报错，需要使用具名函数，具体请看第二条；
hello(3.0,1,123,321,2,string = "hello")
//* 这个符号现在只支持变长参数，且只支持array，不支持list
hello(ints = *array,string = "hello")
fun hello(double:Double = 3.0 ,vararg ints: Int,string:String) {
ints.forEach { ::println }
}
网友评论