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

转载于:https://my.oschina.net/u/181909/blog/1795415