淺談Kotlin語法篇之基礎語法(一)

時間 2019-11-06

標籤淺談 kotlin 語法基礎简体版

原文原文鏈接

Kotlin的基本語法的介紹，先從總體上體會kotlin的編程風格。java

1、包的聲明

在Kotlin中定義包與Java有點不一樣，在Kotlin中目錄與包結構無需匹配，Kotlin的源碼能夠在磁盤上的任意位置。python

一、包的聲明

源文件的一般是以包的聲明的開頭和Java同樣。android

package com.mikyou.hellokotlin

/** * Created by mikyou on 2018/4/1. */
fun main(args: Array<String>) {
    println("Hello Kotlin")
}
複製代碼

二、包的默認導入

有多個包會默認導入到每一個Kotlin文件中。編程

2、函數的定義

一、函數的定義使用關鍵字"fun",函數參數格式爲: "參數:類型",函數返回值類型 "fun(...): Int"

fun sum(a: Int, b: Int, c: Int): Int {
    return a + b + c
}
複製代碼

二、表達式做爲函數體，返回值的類型能夠省略，能夠利用Kotlin的類型推導功能，推測出函數返回值的類型。

fun sum(a: Int, b: Int, c: Int) = a + b + c
複製代碼

三、無返回值的函數(相似Java中的void空類型返回值)

fun printSum(a: Int, b: Int, c: Int): Unit {
	println(a + b + c)
}
複製代碼

或者省略Unit類型數組

fun printSum(a: Int, b: Int, c: Int) {
	println("sum = ${a + b + c}")
}
複製代碼

四、可變長參數函數可使用"vararg"關鍵字標識相似Java中的public void setData(Object... objects)。

fun vars(vararg args: Int) {
	for (arg in args) {
		print(arg)
	}
}
複製代碼

五、lambda(匿名函數)

val sumLambda: (Int, Int, Int) -> Int = { a, b, c -> a + b + c }
複製代碼

測試安全

println("sum = ${sumLambda(1, 6, 7)}")
複製代碼

3、常量和變量

常量與變量均可以沒有初始化值,可是在引用前必須初始化編譯器支持自動類型判斷,即聲明時能夠不指定類型,由編譯器判斷。若是不在聲明的時候初始化則必須提供變量的類型ide

一、可變變量的定義: var 關鍵字函數

var <變量名> : <變量類型> = <初始值>測試

var sum: Int = 3
sum = 8

//因爲編譯支持類型推導能夠省略Int類型
var sum = 3
sum = 8
複製代碼

二、不可變變量的定義: val 關鍵字，不能進行二次賦值，相似Java中的final類型優化

val <常量名> : <常量類型> = <初始值>

val sum: Int //沒有賦值初始化以前必須指定類型
sum = 5
複製代碼

fun sum(a: Int, b: Int, c: Int): Int {
    return a + b + c
}
複製代碼

4、註釋

Kotlin 支持單行和多行註釋，和java中相似。

5、字符串模板

一、模板中的簡單名稱

fun main(args: Array<String>) {
	var a = 1
	var s1 = "a is $a"
}
複製代碼

二、模板中的任意表達式

fun main(args: Array<String>) {
    var a = 1
    a = 2
    val s2 = "${s1.replace("is", "was")}, but now is $a"
}
複製代碼

6、使用條件表達式

使用if表達式替代了java中的三目運算符

fun maxOf(a: Int, b: Int): Int {
    if (a > b) {
        return a
    } else {
        return b
    }
}

fun main(args: Array<String>) {
    println(maxOf(1, 5))
}
複製代碼

在Kotlin中if表達式是帶有返回值的，因此能夠簡化成下面的形式。

fun maxOf(a: Int, b: Int) = if (a > b) a else b

fun main(args: Array<String>) {
    println(maxOf(1, 5))
}
複製代碼

7、NULL檢查機制

Kotlin的空安全設計對於聲明可爲空的參數，在使用時要進行空判斷處理，有兩種處理方式，字段後加!!像Java同樣拋出空異常，另外一種字段後加?可不作處理返回值爲 null或配合?:作空判斷處理

//類型後面加?表示可爲空
var age: String? = "23"
//字段後面加"!!"拋出空指針異常
val ages = age!!.toInt()
//字段後面加」？「不作處理返回 null
val ages1 = age?.toInt()
//使用」?:「 表示age爲空返回-1
val ages2 = age?.toInt() ?: -1
複製代碼

一、當一個引用可能爲 null 值時, 對應的類型聲明必須明確地在類型後面標記爲」？「表示可爲 null。當 str 中的字符串內容不是一個整數時, 返回 null:

fun main(args: Array<String>) {
    if (args.size < 2) {
        println("Two Integers Expected")
        return
    }
    val x = parseInt(args[0])
    val y = parseInt(args[1])
    
    //println(x + y) 因爲標識了可能爲null,直接使用x + y在編譯器看來是非法，須要去作非空判斷
    if (x != null && y != null) {
        println(x + y)
    }
}

fun parseInt(s: String): Int? {//表示當前函數返回值可能爲null,就必須在類型後面標識"?"
    return s.toInt()
}
複製代碼

8、類型檢測以及自動類型轉換

咱們可使用 is 運算符檢測一個表達式是否某類型的一個實例(相似於Java中的instanceof關鍵字)。

fun getStringLength(obj: Any): Int? {
    if (obj is String) {
        // 作過類型判斷之後，obj會被系統自動轉換爲String類型
        return obj.length
    }

    //在這裏還有一種方法，與Java中instanceof不一樣，使用!is
    // if (obj !is String){
    // // XXX
    // }

    // 這裏的obj仍然是Any類型的引用
    return null
}
複製代碼

或者

fun getStringLength(obj: Any): Int? {
  if (obj !is String)
    return null
  // 在這個分支中, `obj` 的類型會被自動轉換爲 `String`
  return obj.length
}
複製代碼

甚至能夠是這樣的

fun getStringLength(obj: Any): Int? {
  // 在 `&&` 運算符的右側, `obj` 的類型會被自動轉換爲 `String`
  if (obj is String && obj.length > 0)
    return obj.length
  return null
}
複製代碼

9、區間

使用in運算符來檢測某個數字是否在指定的區間內，區間表達式具備操做符形式".."的rangeTo函數輔助in和!in組合而成。區間能夠支持任何能夠比較的類型，對於原生的整型，內部有一個優化的實現。

一、檢測某個數字是否在指定區間內

val x = 10
val y = 9
if (x in 1..y + 1) {//表示x是否在1~y+1範圍內。
    println("fits in range")
}
複製代碼

二、檢測某個數字是否在指定區間外

val list = listOf("a", "b", "c")
if (-1 !in 0..list.lastIndex) {
    println("-1 is out of range")
}

if (list.size !in list.indices) {
    println("list size is out of valid list indices range too")
}
複製代碼

三、區間迭代

for(x in 1..10){//至關於 x >= 1 && x <= 10
    println(x)
}
複製代碼

或者

fun printList(num: Int) {
    for (i in 1..num) {//至關於 i >= 1 && i <= num
        print(i)
    }
}
複製代碼

使用 until 函數排除結束元素

for (i in 1 until 10) {// i in [1, 10) 排除了 10,至關於 i >= 1 && i < 10
    println(i)
} 
複製代碼

四、數列迭代

for(x in 1..100 step 2){//遞增數列迭代，每次間隔步長是2；1，3，5，7...
    println(x)
}

for(x in 9 downTo 0 step 3){//遞減數列迭代，每次間隔步長是3；9，6，3，0
    println(x)
}  
複製代碼

10、使用集合

一、對集合進行迭代

fun main(args: Array<String>) {
    val items = list.of("java", "kotlin", "python")
    for (item in items) {
        println(item)
    }
}
複製代碼

二、使用 in 運算符判斷集合內是否包含某個實例

when {
    "java" in items -> println("is good lang")
    "kotlin" in items -> println("is good good lang")
    else -> println("python is best lang")
}
複製代碼

三、使用lambda 表達式來過濾(filter)和映射(map)集合

fun main(args: Array<String>) {
    val langs = listOf("C", "C++", "Java", "Python", "JavaScript")

    langs.filter { it.startsWith("C") }
            .sortedBy { it }
            .map { it.toUpperCase() }
            .forEach { println(it) }
}
複製代碼

11、使用循環

在Kotlin中的循環有兩種方式分別是for，while，在for循環中使用"in"來遍歷，而且有兩個遍歷方式。

一、for循環

val items = listOf("java", "kotlin", "android")
for (item in items) {//for遍歷集合
    println("lang $item")
}

for (index in items.indices) {//相似於java中的數組的length-index的遍歷
    println("The $index index is ${items[index]}")
}
複製代碼

二、while循環

val items = listOf("java", "kotlin", "android")
var index = 0
while (index < items.size) {//while 循環的遍歷方式
    println("The $index lang is ${items[index++]}")
}
複製代碼

12、使用條件if,when

在kotlin中if的使用於java類似可是在kotin中if是表達式有值的，而在java中是語句，可使用kotlin中的if表達式替代java中的三目運算符在kotlin中的。when與switch功能相似

fun main(args: Array<String>) {
    println(descript("hello"))
}

fun descript(obj: Any): String = when (obj) {
    1 -> "one"
    "hello" -> "hello word"
    is Long -> "long type"
    !is String -> "is not String"
    else -> {
        "unknown type"
    }
}
複製代碼

十3、建立類與實例

fun main(args: Array<String>) {
    val rectangle = Rectangle(100.0, 200.0)
    val triangle = Triangle(100.0, 100.0, 100.0)
    println("rectangle is ${rectangle.isSquare}, and perimeter is ${rectangle.perimeter}, and area is ${rectangle.calculateArea()}")
    println("triangle perimeter is ${triangle.perimeter}, and area is ${triangle.calculateArea()}")
}

abstract class Shape(val sides: List<Double>) {
    val perimeter: Double get() = sides.sum()
    abstract fun calculateArea(): Double
}

interface RectangleProperity {
    val isSquare: Boolean
}

class Rectangle(var height: Double, var length: Double)
    : Shape(listOf(height, length, height, length)), RectangleProperity {
    override fun calculateArea(): Double = height * length
    override val isSquare: Boolean get() = height == length
}

class Triangle(var sideA: Double, var sideB: Double, var sideC: Double)
    : Shape(listOf(sideA, sideB, sideC)) {
    override fun calculateArea(): Double = sideA * sideB * sideC
}
複製代碼