Kotlin基礎語法--基礎類型

基本類型

在 Kotlin 中，所有東西都是對象，在這個意義上講我們可以在任何變量上調用成員函數(shù)和屬性。 一些類型可以有特殊的內部表示——例如，數(shù)字、字符和布爾值可以在運行時表示為原生類型值，但是對于用戶來說，它們看起來就像普通的類。 在本節(jié)中，我們會描述 Kotlin 中使用的基本類型：數(shù)字、字符、布爾值、數(shù)組與字符串。

數(shù)字

Kotlin 處理數(shù)字在某種程度上接近 Java，但是并不完全相同。例如，對于數(shù)字沒有隱式拓寬轉換（如 Java 中 int 可以隱式轉換為long——譯者注)，另外有些情況的字面值略有不同。
Kotlin 提供了如下的內置類型來表示數(shù)字（與 Java 很相近）：

Type Bit width
Double 64
Long 64
Float 32
Int 32
Short 16
Byte 8

字面常量

數(shù)值常量字面值有以下幾種:

  • 十進制: 123
  • Long 類型用大寫 L 標記: 123L
  • 十六進制: 0x0F
  • 二進制: 0b00001011

注意: 不支持八進制

Kotlin 同樣支持浮點數(shù)的常規(guī)表示方法:

  • 默認 double：123.5、123.5e10
  • Float 用 f 或者 F 標記: 123.5f

數(shù)字字面值中的下劃線（自 1.1 起）
你可以使用下劃線使數(shù)字常量更易讀：

val oneMillion = 1_000_000
val creditCardNumber = 1234_5678_9012_3456L
val socialSecurityNumber = 999_99_9999L
val hexBytes = 0xFF_EC_DE_5E
val bytes = 0b11010010_01101001_10010100_10010010

運算

Kotlin中的運算符被定義成相應類的類成員函數(shù)，通過復寫相應運算符函數(shù)，可重載運算符功能。參見 運算符重載。
對于位運算，沒有特殊字符來表示，而只可用中綴方式調用命名函數(shù)，例如:

val x = (1 shl 2) and 0x000FF000

這是完整的位運算列表（只用于 Int 和 Long）：

  • shl(bits) – 有符號左移 (Java 的 <<)
  • shr(bits) – 有符號右移 (Java 的 >>)
  • ushr(bits) – 無符號右移 (Java 的 >>>)
  • and(bits) – 位與
  • or(bits) – 位或
  • xor(bits) – 位異或
  • inv() – 位非

字符

字符用 Char 類型表示。它們不能直接當作數(shù)字
字符字面值用單引號括起來:'1'。 特殊字符可以用反斜杠轉義。
我們可以顯式把字符轉換為 Int 數(shù)字：

fun decimalDigitValue(c: Char): Int {
    if (c !in '0'..'9')
        throw IllegalArgumentException("Out of range")
    return c.toInt() - '0'.toInt() // 顯式轉換為數(shù)字
}

布爾

布爾用 Boolean 類型表示，它有兩個值：true 和 false。
若需要可空引用布爾會被裝箱。
內置的布爾運算有：

  • || – 或
  • && – 與
  • ! – 非

數(shù)組

數(shù)組在 Kotlin 中使用 Array 類來表示，它定義了 get 和 set 函數(shù)（按照運算符重載約定這會轉變?yōu)?[]）和 size 屬性，以及一些其他有用的成員函數(shù)：

class Array<T> private constructor() {
    val size: Int
    operator fun get(index: Int): T
    operator fun set(index: Int, value: T): Unit

    operator fun iterator(): Iterator<T>
    // ……
}

Kotlin數(shù)組創(chuàng)建方法：

    //創(chuàng)建數(shù)組，并賦值為1，2，3
    val arrInt: Array<Int> = arrayOf(1, 2, 3)

    //創(chuàng)建數(shù)組，長度為5，內容為空
    val arrStringNulls: Array<String?> = arrayOfNulls<String>(5)
    for (index in 0 until arrStringNulls.size) {
        arrStringNulls[index] = "This is " + index
    }
    for (index in arrStringNulls.indices)
        println("arrStringNulls[$index] = ${arrStringNulls[index]}")

    //創(chuàng)建數(shù)組，長度為5，使用一個函數(shù)參數(shù)的工廠函數(shù)生產(chǎn)元素
    val arrStringByFactroy: Array<String> = Array<String>(5, { i -> (i * i).toString() })
    for (value in arrStringByFactroy)
        println("value=$value")

Kotlin 也有無裝箱開銷的專門的類來表示原生類型數(shù)組: ByteArray、 ShortArray、IntArray 等等。這些類和 Array 并沒有繼承關系，但是它們有同樣的方法屬性集。它們也都有相應的工廠方法:

val x: IntArray = intArrayOf(1, 2, 3)
x[0] = x[1] + x[2]

字符串

字符串用 String 類型表示。字符串是不可變的。 字符串的元素——字符可以使用索引運算符訪問: s[i]。 可以用 for 循環(huán)迭代字符串:

for (c in str) {
    println(c)
}

字符串字面值

Kotlin 有兩種類型的字符串字面值: 轉義字符串，原生字符串。

  1. 轉義字符串:可以有轉義字符，轉義字符串很像 Java 字符串:
val s = "Hello, world!\n"
  1. 原生字符串:使用三個引號（"""）分界符括起來，內部沒有轉義并且可以包含換行和任何其他字符:
val text = """
    |Tell me and I forget.
    |Teach me and I remember.
    |Involve me and I learn.
    |(Benjamin Franklin)
    """.trimMargin()

通過 trimMargin() 函數(shù)去除前導空格，默認 | 用作邊界前綴，但你可以選擇其他字符并作為參數(shù)傳入，比如 trimMargin(">")。

val text = """
    >Tell me and I forget.
    >Teach me and I remember.
    >Involve me and I learn.
    >(Benjamin Franklin)
    """.trimMargin(">")

變量

Kotlin的變量分為可變和不可變變量，和Java中是否采用final修飾的變量含義一樣。

  • 采用 val 聲明的變量為不可變變量，即常量：
//編譯期常量
const val tag: String = "MainActivity"
//常量
val tag: String = getString()
//等同于Java
final String tag = "MainActivity";
  • 采用 var 聲明的變量為可變變量：
var num: Int = 1
//等同于Java
int num = 1;

函數(shù)

Kotlin定義一個函數(shù)的格式如下：

訪問控制符 fun 方法名(參數(shù)，參數(shù)，參數(shù)) : 返回值類型 {
···
···
}

  • 訪問控制符：Kotlin的訪問控制符范圍從大到小分別為:
    public、internal、protected、private，不聲明默認為 public；

Kotlin與Java函數(shù)的一個重大的區(qū)別就是：
Kotlin支持包級函數(shù)，即函數(shù)不依賴于類而存在，而在Java中，函數(shù)必須聲明在類里面：

//包級函數(shù)
fun main(args: Array<String>){
}
//Java函數(shù)必須依賴類而存在
public class ClzFun{
    public static void main(String[] args){
    }
}

可變參數(shù)

Kotlin中，可變參數(shù)使用關鍵字 vararg：


fun variousArgs(vararg args: String) {
    for (arg: String in args)
        println(arg)
}
//Java可變參數(shù)
public void variousArgs(String... args){

}

靜態(tài)變量和靜態(tài)函數(shù)

Kotlin中并沒有像Java一樣，提供 static 這個關鍵字，如果想在Kotlin中實現(xiàn)靜態(tài)變量和靜態(tài)函數(shù)，可以使用 companion object, companion object 后可以加上自定義的object名，也可以省略。


fun main(args: Array<String>) {
    println(KotlinStatic.staticInt)
    KotlinStatic.getInstance()
}

class KotlinStatic{
    companion object StaticTest{
        var staticInt: Int = 1
        fun getInstance() : KotlinStatic{
            return KotlinStatic()
        }
    }
}
//Java靜態(tài)常量和靜態(tài)函數(shù)
public class JavaStatic{
    public static int staticInt = 1;
    public static JavaStatic getInstance(){
        return new JavaStatic();
    }
}

對于在Kotlin中實現(xiàn)static變量和static方法，官方更推薦直接使用包級別的變量或函數(shù)來實現(xiàn)。因為如果使用 companion object 實現(xiàn) static 功能，Kotlin在運行的時候，是會創(chuàng)建一個 companion object 實例對象，就相當于多了一些時間進行對象創(chuàng)建，初始化分配空間等操作。

附錄

注意事項：

  • Kotlin對于數(shù)字沒有隱式拓寬轉換（如 Java 中 int 可以隱式轉換為long)
    所以，對于下面這個例子，其是無法通過編譯的：
val b: Byte = 1 // OK, 字面值是靜態(tài)檢測的
val i: Int = b // 錯誤

Kotlin沒有辦法將 Byte 賦值給 Int 類型，對于這種不同類型數(shù)值賦值，我們必須通過 顯示轉型 來拓寬數(shù)字：

val i: Int = b.toInt() // OK: 顯式拓寬

每種數(shù)字類型支持如下的轉換:

  • toByte(): Byte

  • toShort(): Short

  • toInt(): Int

  • toLong(): Long

  • toFloat(): Float

  • toDouble(): Double

  • toChar(): Char

  • 運算符重載示例：

data class Counter(val x: Int) {
    operator fun plus(inc: Int) = Counter(x + inc)
    operator fun plus(inc: Counter): Counter {
        return Counter(x + inc.x)
    }
}

fun main(args: Array<String>) {
    println(Counter(1) + Counter(3))
    println(Counter(1) + 11)
}

本文大部分內容來自:https://hltj.gitbooks.io/kotlin-reference-chinese/content/txt/basic-types.html

最后編輯于 ：
?著作權歸作者所有,轉載或內容合作請聯(lián)系作者
【社區(qū)內容提示】社區(qū)部分內容疑似由AI輔助生成，瀏覽時請結合常識與多方信息審慎甄別。
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發(fā)布，文章內容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務。

相關閱讀更多精彩內容

友情鏈接更多精彩內容