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