Kotlin学习1

Kotlin

官方文档

官方中文

kotlin语法与Java的不一样

1. 变量定义： 变量名在前，类型在后，区分可变和不可变, 赋值时可自动推断类型

val y: Int = 1		//不可变
var x: String =""   //可变

2. 语句： 无分号

3. 函数定义 fun，类型在后，能够有默认值，单个表达式能够不写括号个return , 函数能够在类外面

fun xxx( x: String, y: Int = 1): Boolean {
	return true
}

fun a( x: Int) : Int = 1+x      //

4.类定义 ： 构造函数 写成 contructor , 函数体用 init, 继承关系用 : 代替java的 extends

class ABC contructor(xxxx) : PARENT {
	init {
		
	}
}

5. 强制的非空检查，凡是没有 ？的类型变量都不能 =null, 凡是可能 =null 的变量 使用 点号时要加？，不然编译不经过

val a:String  = null 	// error
val a:TT? = null       //有？,能够 = null
a.fff()	//error 
a?.fff()  //ok   等价于    if( a != null ) { a.fff();  }

6. 类的属性，自动生成 getXXX() 和setXXX（）方法, field表明属性自己，value表明set函数的参数

class A {
	var x: String
		get() {
			return field
		}
		set() { 
			field = value
		}
}

7. 条件语句能够有值返回, { } 块的最后一行做为返回值

val  x = if ( y <1 ) { 
		1
	} else {
		2 
	}

8. 条件语 没有 switch, 取代的是 when , 功能同样， 和 if 同样能够有值

when( x ) {
	1  -> {  doSomething1()  }
	2 ->  {  doSomething2()  }
	else -> { doSomething3() }    	// 和 default: 功能同样
}

9. inline fun 表示内联函数， 内联函数是特殊的函数，其调用并不是真的调用， 而是编译器在调用处将代码展开，所以没有函数调用的开销

10. 扩展函数，能够给已知的java类增长其本来不存在的方法。

//  A 是java类， 只有 a(), 没有 b() 方法
//  val x = A();  x.b() 是错误的
// 
// 定义扩展函数
fun   A.b() {
}
// 而后
val x = A()
x.b()   // OK

11. 字符串中填数据 用 ${} : {} 内部能够填任何表达式

val   x = 5
val y = "y=${ x + 6 }"   //字符串值为 "y=11"

12. 没有 x ? y : z 表达式，只有 ?: 运算符

a = b ?: c 等价于

if ( b != null) { a = b }
else { a = c }

13. 运算符能够重载， 即从新定义 +, -, *, / 等基本运算符的行为

详情

14. 函数能够做为参数和变量，

class A {
 fun f1 () { }
}
a = A()
x = a::f1   //将 A的方法 f1() 传给 x
x ()			// = 调用 a.f1()

15. 闭包。java 叫作 Lamda 表达式 ( java8)

java 的 Lamda 表达式

a  =  （  String a1, int a2 ) -> {
	return a1 + a2
}
// a 能够当函数调用
y =  a ( "x" , 1)		// y = "x1"

kotlin:

a = { a1: String, a2: Int ->
	a1 + a2
}
// a 能够当函数调用
y =  a ( "x" , 1)		// y = "x1"

括号的位置与java不一样， 没有 return 语句，最后一行就是返回值

只有一个参数时，参数能够不写，默认为 it

16. 函数内部能够在定义函数, 函数能够做为返回值

fun  f1() {
	fun  fx( x: Int) {
		return 1+ x
	}
	
	return 5 + fx( 1 )
}

17. object对象： 等同于 java Object

若有某java接口 IA

java

newA = new Object() entends IA {
	//...
}

kotlin

newA = object : IA {
	// ...
}

18. 没有静态变量和方法，能够用 伴生对象和 object对象实现静态方法和单例模式

class A {
	companion {
		fun y1() { }     //每一个类只有一个companion对象
	}
}

object B {
	val x1: Int = 1
}
// 能够这样调用, 不须要调用构造函数
A.y1()
x = B.x1

19. 函数的类型：

（参数1类型，参数2类型, ...)->返回值类型

20. 函数的参数能够不按照定义是的顺序来，只要写上参数明就行，这样表示更清楚，有默认值的参数能够不写

fun f1( x: Int , y: String, z: Float = 10f ) {
	return y + x 
}
// 打乱 x, y 的调用顺序
f1( y = "hello", x = 5 )

21. 函数的最后一个参数是函数或闭包类型时，最后的参数能够写在括号 () 外面

如启动线程作某事

thread( start = true, { 
	doSomething()
})

===>

thread( strat=true ) {
	doSomething()
}

下一篇 kotlin学习2