1.常量与变量
val修饰的称为常量,只能赋值一次,类似java中的final
var修饰的称为变量，可以赋值n次
kotlin编译器具有类型推导，可以不指定类型
val FINAL_HELLO_CHINA = "HelloChina"
2.函数
任何函数都以fun修饰
没有返回值的函数其实返回的是Unit,相当于java中的void
函数的参数(参数名:参数类型)
fun sum(arg1: Int, arg2: Int): Int{
return arg1 + arg2
}
kotlin中可以更简洁
fun sum(arg1: Int, arg2: Int)=arg1 + arg2
kotlin 还可以这样定义函数
val int2Long = fun(x: Int): Long {
return x.toLong()
}
调用int2Long(3)
kotlin中函数也可以作为参数传给另一个函数
3.Lambda表达式
有参数
val sum = { arg1: Int, arg2: Int ->
println("$arg1 + $arg2 = ${arg1 + arg2}")
arg1 + arg2
}
Lambda表达式最后一行即为函数返回值
无参
val printlnHello = {
println("Hello")
}
打印0到100的数组里面的值
java代码
int[] list=new int[100];
//赋值操作忽略
for (int i=0;ikotlin代码
var list= 0..100
list.forEach(::println)
lambda表达式函数的中断
以下代码不会打印aaaa
fun breakLambda(){
var list= 0..100
list.forEach {
if (it==9){
return
}
}
println("aaaa")
}
以下代码可以打印aaaa
fun breakLambda(){
var list= 0..100
list.forEach {
if (it==9){
return@forEach
}
}
println("aaaa")
}
lambda表达式的简化
函数参数调用时最后一个lambda可以移除出去
函数参数只有一个lambda，调用时小括号可以省略
lambda只有一个参数可默认为it
入参，返回值与形参一致的函数可以用函数引用的方式作为实参传入
4.类成员(成员方法,成员变量)
class Bean {
var message:String?=null
}
kotlin默认生成get，set方法
可以用下面的方式进行重写
class Bean {
var message:String?=null
get() {
println("aaaa")
return field
}
set(value) {
println("bbbb")
field=value
}
}
如果要修改set,get的访问权限,成员变量相应也需要修改
class Bean {
private var message:String?=null
private get() {
println("aaaa")
return field
}
private set(value) {
println("bbbb")
field=value
}
}
5.基本运算符
kotlin支持运算符重载，可以自定义运算符算法
class Complex(var real: Double, var imaginary: Double) {
//operator操作符方法
operator fun plus(other: Complex): Complex {
return Complex(real + other.real, imaginary + other.imaginary)
}
}
fun main(args: Array) {
var c1=Complex(3.0,4.0)
var c2=Complex(3.0,4.0)
println(c1+c2)
}
运算符重载,需要遵从如下规则：
1.任意类可以定义或者重载父类的基本运算符
2.operator修饰
3.入参个数需要相同，入参以及返回值类型没有要求
4.操作符对应的方法名要相同
+a->a.unaryPlus()
-a->a.unaryMinus()
!a->a.not()
a++ ->a.inc()
a-- ->a.dec()
a+b ->a.plus(b)
a-b->a.minus(b)
a*b ->a.times(b)
a/b ->a.div(b)
a..b ->a.rangeTo(b)
a in b -> b.contains(b)
6.表达式(中缀表达式,分支表达式,when表达式等)
中缀表达式（只有一个参数，且用infix修饰的函数）
class Book{
infix fun on(place: String): Boolean{
return false
}
}
class Desk
fun main(args: Array) {
if(Book() on "Desk"){
println()
}
}
分支表达式（kotlin里面不是分支语句，而是表达式）
kolin里面if是作为分支表达式，是具有返回值的，返回值为判断分支最后一行，例如
val printText=if (args.isEmpty()){
args[0]="hhh"
args[0]
}else{
args[0]
}
println(printText)
kotlin里面没有switch,有when表达式（相当于加强版switch,支持任意类型）
val text="4"
val print=when(text){
"4" ->"aaaa"
else ->"bbbb"
}
注意 作为表达式的时候必须写else
7.循环语句(for循环,while循环,continue,break)
for循环
写法一
for (arg in args){
println(arg)
}
写法二 index是下标，value是集合里面的实际值
for((index, value) in args.withIndex()){
println("$index -> $value")
}
写法三 indexedValue.index是下标，indexedValue.value是集合里面的实际值
for(indexedValue in args.withIndex()){
println("${indexedValue.index} -> ${indexedValue.value}")
}
while循环 跟java用法一致
var x = 5
while(x > 0){
println(x)
x--
}
do{
println(x)
x--
}while (x > 0)
continue,break用法跟java一致
val students = ArrayList()
val you = Student()
for (student in students){
if(student == you) continue
if(student.isNotClothedProperly()){
break
}
}
8.异常捕获(try,catch,finally)
fun main(args: Array) {
try {
val arg1 = args[0].toInt()
val arg2 = args[1].toInt()
println("$arg1 + $arg2 = ${sum(arg1, arg2)}")
}catch (e: NumberFormatException){
println("您确定输入的是整数吗？")
}
}
同时try，catch也是支持表达式赋值
fun main(args: Array) {
var text=try {
val arg1 = args[0].toInt()
val arg2 = args[1].toInt()
0
}catch (e: Exception){
println("您确定输入的是整数吗？")
1
}finally {
println("谢谢您使用我们的加法计算器")
2
}
println(text)
}
输出
您确定输入的是整数吗？
谢谢您使用我们的加法计算器
1
9.具名参数,变长参数,默认参数
具名参数：给函数的实参赋上形参
例如
fun sum(arg1: Int, arg2: Int): Int{
return arg1 + arg2
}
调用sum(arg2 = 1,arg1 = 2) 具名参数传参可以不按顺序
变长参数 :参数个数不确定
fun main(vararg args: String) {
}
java中变长参数只能是方法体最后一个参数,kotlin没有此限制,可以是任意位置
fun hello(vararg ints: Int, string: String ){
println(string)
}
调用 hello(1,2,3,string = "hhhhh")
如何将数组赋值变长参数，使用SpreadOperator *(无法重载)
val array = intArrayOf(1,3,4,5)
hello(3.0, *array)
默认参数：给函数的参数赋一个默认值
fun hello(vararg ints: Int, string: String = "Hello"){
println(string)
}