Kotlin的解析(上)

前言

1. Kotlin的概述：

1.1 kotlin是什麼
（1）Kotlin是由JetBrains建立的基於JVM的編程語言
（2）在技術層面上，JAVA和Kotlin是同一級別的，都是以Java Byte Code形式運行在虛擬機上
1.2kotlin相對於Java有什麼優點
（1）更容易學習：Kotlin是一門包含不少函數式編程思想的面向對象的編程語言
（2）輕量級：相比於其餘的語言，Kotlin函數庫更小，因爲Android存在65K方法數限制，使得這一點比較重要
（3）高度互操做性：Kotlin能夠和其餘Java庫友好且簡單的進行互相操做
（4）很是友好的集成Android Studio 以Gradle，Kotlin又一個專門用於Android Studio的插件，以及另外一個專門用於Gradle的插件。推出的AS3.0+已經集成了Kotlin
（5）Kotlin還有不少語法層面的特性，如數據模型、空指針安全、擴展函數等
1.3 kotlin能作什麼
（1）服務端開發
（2）以JavaScrip方式運行
（3）開發Android App

2.Kotlin基礎知識

2.1基礎語法

2.1.1 定義變量：

絕大數編程語言都有常量和變量，Kotlin和同源的Java相似，儘管沒有常量語法，但可使用final關鍵字定一個不能夠修改的變量
複製代碼

Java代碼

int n=30;
int ok;
final int m =20;
ok =123;
m=10;
複製代碼

Kotlin代碼

var n :Int =30
var ok:Int 
val m :Int =20 
m=10 //編譯出錯，由於m是常量
複製代碼

不一樣點

（1）位置不一樣

（2）變量和常量須要關鍵字：在Kotlin中，定義變量須要var，定義常量須要val開頭

（3）數據類型首字母：在kotlin中，數據類型都以大寫字母開頭

（4）若是在定義變量時未進行初始化，就必需要制定數據類型，若是在定義變量時進行了初始化，能夠不指定數據的類型，Kotlin編譯器會自動根據等號右側的值推倒數據的類型

2.1.2 定義函數

函數定義以下幾個部分：

（1）函數頭，包括函數名和識別函數的關鍵字，如fun、function等

（2）參數，包括參數名和參數類型

（3）返回值

Kotlin 代碼

fun add (m: Int ,n:Int):int
{
return m+n
}

fun process(m: Int):Unit //也能夠省略
{
println(m*m)
}
複製代碼

2.1 .3 註解

（1）但行註解 // （2塊註解// （3）嵌套註解/*//*/ 新增的Java中是不支持的

2.2 基礎數據類型

2.2.1 數值類型

數據類型	佔用字節數
Double	8
Float	4
Long	8
Int	4
Short	2
Byte	1

Kotlin代碼

var m =29
val n :Byte=10
m=n  //編譯錯誤，沒法將Byte隱式轉換爲Int

var x:Long =20 //能夠將Int類型的值隱式轉爲Long
val value:Short=20
m=value //編譯錯誤，沒法將short隱失轉換爲Int
複製代碼

若是我非要轉換呢？莫急Kotlin提供了一系列的方法使用來進行類型之間的轉換：

toByte()   toShort() ... toChar()
複製代碼

Kotlin與Java同樣提供了一些特殊的表示方法，表示Long、Float以及十六進制和二進制（八進制目前還不支持） （1）表示Long/Float類型的值，在數字後面加上L/F或者l/f （2）表示十六進制，在數以前加0x （3）表示二進制，數值前面加0b （4）若是數值很大，還能夠123_3454_567這樣表示

2.2.2 字符類型

在Kotlin語言中，字符類型用Char描述，不過和JAVA不一樣的是，在Kotlin中，字符不能直接看做數字

Java代碼

void check(char c){
if(c == 97){//能夠編譯經過
}
複製代碼

Kotlin代碼

fun check(c: Char){
if(c == 97){//會產生編譯錯誤
}
}
複製代碼

2.2.3 布爾值

Kotlin語言中的布爾類型用Boolean描述，該類型有兩個值：true 和false

2.2.4 數組

//使用arrayOf 函數定義能夠存儲人意的數組
val arr1 = arrayOf(1,2,3,'a')
print(arr1[1])
arr1[2]='b'

//使用arrayOfNulls 函數定義數組
var arr2 = arrayOfNulls<Int>(10)

val arr3 = Array(10,{i ->(i*i).toString()}
println(arr3[3])
複製代碼

2.2.5 字符竄

//第一類字符串（與Java相似）
var s1 = "hello \nword"
println(s1)

//第2類字符竄，保留原始格式
var s3=""" hello word hehhe! """
複製代碼

字符串模版

val i=10
val s1 = "I = $I"
println(s1) 

val s2 = "abd"
val str = "$s2 的長度是 ${s2.length}"
println(str)
複製代碼

2.3 控制流

2.3.1 條件語句

Kotlin 代碼（傳統的if用法）

var a = 20
var b =30
var max :Int
var min: Int
if(a>b){
max = b
}

if(a>b){
min=a
}
else{
min=b
}

複製代碼

Kotlin 代碼（將if語句做爲表達式使用）

var a=20
var b=30
val max =if(a>b)a else b
println(max)

//if.   else 後面是一個代碼塊，最後一個表達式將做爲返回值
val min  = if(a>b){
println(a)
a
}
else{
println(b)
b
}
複製代碼

2.3.2 when 語句（代替了java的switch語句，功能簡直是逆天）

（1）標準的when的用法

var x=1
when(x){
1 -> {
println("x == 1")
}
2->{
println("x==2")
}
else ->{
println("輸出：x")
}
}
複製代碼

(2)when做爲表達式使用

var x =1
var m = when(x){
1 ,3,4-> { //若是多個分支執行的結果同樣，能夠在一個分支用(,)分隔多個條件
println("x ==1")
10}
2 -> {
println("x==2")
20
} else ->{
println("x")
40
}
}

println(m)
複製代碼

（3）使用in關鍵字

var n = 25
when(n){
in 1..10 -> println("輸初")
!in 30 .. 60 -> print("非30-60範圍")
else -> println("條件未知")
複製代碼

（4）分支條件還能夠式函數

fun getValue(x:Int):Int{
return x
}

var n =4
when(n){
getValue(2)->println("2")
getValue(4)->println(4)
else -> println("沒有知足條件！")
複製代碼

2.3.3 for 循環

枚舉數組中全部的元素

var arr = intArrayof(2,4,5,7,8)
for(item : Int in arr){
println(item)
}

for (i in arr.indices){
println("arr[$i] = " +arr[i])
}
複製代碼

2.3.4 while 循環

和Java裏面式同樣的，就很少說了，本身能夠看一下，沒啥變化的

3. 類和接口

與Java同樣，在Kotlin中，類的聲明也使用class，若是隻是聲明一個空的類的話，Kotlin和Java沒有任何的區別，不過要是定義其餘的成員，差異仍是很大 3.1 構造器

3.1.1 主構造器

  在Kotlin中，類容許定義一個主的構造器（primary constructor）和若干個第二構造器（secondary constructor），主構造器是類頭的一部分，緊跟在類名的後面，構造器參數是可選的 kotlin 代碼

class Persion constructor(firstName:String){
}
//若是主構造器沒有任何的註解或者修飾器，constructor關鍵字能夠省略

class Persion(firstName:String){
}
複製代碼

  目前你們可能有疑惑，代碼重只看的見定義主構造器，那麼應該在哪裏實現主構造器呢？其實，若是是主構造器的話，須要在init塊中進行初始化

class Persion (firstName:String){
var name = firstName
init{
println(firstName);
}
}
//要注意的，主構造器的參數不只能夠用於在init塊中，還能夠用於對類屬性的初始化
複製代碼

3.1.2 第二構造器

  （1）Kotlin類除了能夠聲明一個主構造器，還能夠聲明若干個第二構造器，第二構造器須要在類中聲明，前面必須加上constructor關鍵字 Kotlin 代碼

class Persion {
constructor(parent:Persion){
println(parent)
}
}
複製代碼

  （2）如若類中聲明瞭主構造器，那麼全部的第二構造器都須要在聲明後面調用主構造器，或者經過另一個第二構造器間接的調用第二構造器 Kotlin 代碼

class Demo(var url : String){
//主構造器實現部分
init{
println("主構造器，嘻嘻！無知的人類")
}
//第二構造器（經過this直接調用了主構造器）
constructor(value:Int):this("https://linghit666.doubi.com")
{
println(value)
}
//經過this直接調用了主函數
constructor(des:String,url:String):this("{"+url+"}")
{
println(des+";;;;"+url)
}
//經過第二構造器間接的調用主構造器
constructor():this(20)
{
println("https://www.doubi.com")
}
}
複製代碼

注意：在主構造器參數重可使用var和val，但第二構造器中不能使用var和val，意思就是第二構造器的參數都是直讀的，不能在構造器的內部改變參數值

3.1.3 Kotlin 中的Singleton模式

Kotlin 代碼(Singleton 模式)

class Singleton private constructor() {
   private object mHolder {
       var INSTANCE = Singleton()
   }

   companion object {
       fun getInstance(): Singleton {
           return mHolder.INSTANCE
       }
   }
}
//是否是感受大吃一驚，相對於Java的單例模式，是否是很懵逼，之因此Kotlin方式不一樣，主要由於Kotlin類不支持靜態方法和成員,因爲kotlin支持全局函數和變量，所以能夠直接使用全局函數和變量來代替靜態方法和靜態成員變量
複製代碼

3.1.4 Kotlin 函數中默認參數

  如今的不少語言都支持默認參數，例如js、dart、go等，可是遺憾的是Java並不支持，是否是很氣，可是值得慶幸的是Kotlin倒是支持默認參數

class Persion(val name:String="Bill",var value :Float = 20.4f,sex :Int) {
  //其實這個是Kotlin的一個語法糖，想知道原理的能夠反編一下，查看一下字節碼，應該就會懂了
}
複製代碼

3.2 類成員

  Kotlin 中屬性的語法

var/val [:][=<property_initalizer>] [] []

3.2.1 屬性的getter和setter 形式

  因爲Kotlin從語法上支持屬性，所以並不須要爲每個屬性單獨定義getter和setter方法 Kotlin 代碼

class Persion {

   private var name: String = "sdfsfd"
   fun getName(): String {
       return name
   }

   var value: Int = 0
       get() = field
       set(value) {
           field = value
           Log.i("tag","數值： " +"；；；；" +value)
       }

}
複製代碼

3.3 類的繼承

3.3.1 修飾符

private :僅僅在類的內部能夠訪問
protected：相似上面的，可是能夠在子類中也能夠訪問
internal：任何在模塊內部的類均可以訪問
public：任何的類均可以訪問
複製代碼

示例：

open class Outer {
    private val a = 1
    protected open val b = 2
    internal val c = 3
    val d = 4 //默認的是public

    protected class Nested {
        public val e: Int = 5
    }
}

class SubClass : Outer() {
    //a不能訪問，b、c、d、Nested().e均可以訪問
    override val b: Int = 10 //重寫父類的常量b
    init {
        b
        c
        d
       Nested().e
    }

}
複製代碼

3.3.2 類的繼承

  與Java不一樣，Kotlin類的繼承須要使用(:)冒號，而JAVA你懂得，注意，冒號後面須要調用父類的構造器，與JAVA同樣，都是單繼承，Kotlin默認時class是final的，也就是說，默認的時候不容許繼承，須要顯示的使用open

open class Parent {//使用open聲明，才能容許其餘類繼承
open val name :String ="know"
    protected var sex =1;
    open protected fun  getYcSex():Int{
        return sex
    }

}

class Child :Parent(){
override var name:String ="wukong"
    override fun getYcSex(): Int {
        return super.getYcSex()
    }
}
//若是在子類中重寫方法，就須要在父類相應的方法前面加open,並且要在子類的方法前面加override
//若是想阻止子類的方法被重寫，就要在override前面加final
//屬性重寫與方法相似，被重寫的屬性前面需使用open聲明,子類的屬性前加override,注意的是，val屬性能夠被重寫成var的，反之不行
複製代碼

3.4 接口

  Kotlin中的接口與Java相似，使用interface關鍵字聲明，一個類能夠實現多個接口，並且接口中的屬性以及方法都是open的

3.4.1接口的示例

interface Extend{
    fun  process()
    fun getYcName():String{
    //容許接口包含默認的方法體，有方法體的，不要求必定重寫
        return "nihao"
    }
}


class Child :Parent(),Extend{
    override fun process() {

    }

    override fun getYcName(): String {
      // 能夠不重寫
        return super.getYcName()
    }

    override fun getYcSex(): Int {
        return super.getYcSex()
    }
}
複製代碼

3.4.2抽象類

抽象方法不須要使用open聲明，由於抽象方法類自己均可以繼承

abstract class ChouXiang :Extend{
    abstract fun hellow()
}

class Persion :ChouXiang() {
    override fun hellow() {
        TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
    }

    override fun process() {
        TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
    }
}
複製代碼

總結

截止目前的話Kotlin中大概的基礎知識，差很少都示例講解了一下，基本的一些東西均可以看懂知道了，但願對你想了解kotlin有些幫助