Kotlin開發之旅《二》—Kotlin的基本語法

如果對Kotlin不太瞭解的童鞋們，請參考

Kotlin開發之旅《一》— 初學者Kotlin基礎必備

Kotlin成為Android開發首選語言——你絕對不能錯過的

今天關於來學習Kotlin的基本語法。Java to Kotlin 主要語法，以便於你快速認識 Kotlin 這門語言

1、變數的宣告

• 定義區域性變數

  次賦值（只讀）的區域性變數

    val a: Int = 1 // ⽴即賦值
    val b = 2 // ⾃動推斷出 `Int` 型別
    val c: Int // 如果沒有初始值型別不能省略
    c = 3 // 明確賦值
  
    // a = b + c; 寫法錯誤複製程式碼

  可變變數

    var x = 5 // ⾃動推斷出 `Int` 型別
    x += 1複製程式碼

2、 使⽤條件表示式

  fun maxOf(a: Int, b: Int): Int {
    if (a > b) {
        return a
    } else {
        return b
    }
  }
//使⽤ if 作為表示式:

    fun compare(a: Int, b: Int) = if (a > b) a else b複製程式碼

3、使⽤可空值及 null 檢測

 fun parseInt(str: String): Int? {
    var length : Int? = 0;
    if(str != null){
        length = str.length;
    }
    return length;
}

fun parseString(content : String) :String ?{

    return content;
}

eg:

fun printProduct(arg1: String, arg2: String) {
    val x = parseInt(arg1)
    val y = parseInt(arg2)
    // 直接使⽤ `x * y` 可能會報錯，因為他們可能為 null
    if (x != null && y != null) {
    // 在空檢測後，x 和 y 會⾃動轉換為⾮空值（non-nullable）
        println(x * y)
    }
    else {
        println("either '$arg1' or '$arg2' is not a number")
    }
}

fun printProduct2(arg1: String, arg2: String) {
    val x = parseInt(arg1)
    val y = parseInt(arg2)
    if (x == null) {
        println("Wrong number format in arg1: '${arg1}'")
        return
    }
    if (y == null) {
        println("Wrong number format in arg2: '${arg2}'")
        return
    }
// 在空檢測後，x 和 y 會⾃動轉換為⾮空值
    println(x * y)
}複製程式碼

4、for迴圈的使用

• 基本遍歷

   fun useForListMap(){
               //例項化list計劃
               var list = listOf("終端","研發部","歡迎","你");
               //遍歷list
               for (content in list){
                   println(content);
               }
               //遍歷 方法2
               for (content in list.indices){
                   println("------"+list[content]);
                   println(content);
               }
   }    複製程式碼

• Java

    if (value >= 0 && value <= 100) {}
  
    for (int i = 1; i <= 100 ; i++) {}
  
    for (int i = 1; i < 100 ; i++) {}
  
    for (int i = 100; i >= 0 ; i--) {}
  
    for (int i = 1; i <= 100 ; i+=2) {}
  
    for (int i = 100; i >= 0 ; i-=2) {}複製程式碼

• Kotlin

    if (value is 0..100) {
    }
  
    for (i in 1..100 ) {}
  
    for (i in 1 until 100) {} // 半開區間：不包含 100
  
    for (i in 100 downTo 0) {}
  
    for (i in 1..100 step 2) {}
  
    for (i in 100 donwTo 1 step 2) {}複製程式碼

• Java

    List<String> list = Arrays.asList("java", "c++", "Android", "Kotlin", "iOS");
  
    for(int i = 0; i < list.size(); i++ ) {
  
        list.set(i, "Hello " + list.get(i));
  
        if (!list.get(i).contains("c")) {
  
            System.out.println(list.get(i));
        }
    }
  
    //輸出：
    //    Hello java
    //    Hello Android
    //    Hello Kotlin
    //    Hello iOS複製程式碼

• Kotlin

    var list = arrayOf("java", "c++", "Android", "Kotlin", "iOS")
  
    list.map {
  
        "Hello $it"
  
    }.filter {
  
        !it.contains("c")
  
    }.forEach {
  
        println(it)
  
    }
  
    //輸出：
    //    Hello java
    //    Hello Android
    //    Hello Kotlin
    //    Hello iOS    複製程式碼

只讀 list

    val list = listOf("a", "b", "c")複製程式碼

訪問 map

    val map = mapOf("a" to 1, "b" to 2, "c" to 3)
    println(map["key"])
    map["key"] = value複製程式碼

延遲屬性

    val p: String by lazy {
    // 計算該字串
    }複製程式碼

擴充套件函式

    fun String.spaceToCamelCase() { …… }
    "Convert this to camelcase".spaceToCamelCase()複製程式碼

建立單利

    object Resource {
    val name = "Name"
    }複製程式碼

• 返回when 表示式

   fun transform(color: String): Int {
   return when (color) {
   "Red" -> 0
   "Green" -> 1
   "Blue" -> 2
   else -> throw IllegalArgumentException("Invalid color param value")
   }
   }複製程式碼

  “try/catch”

   fun test() {
   val result = try {
   count()
   } catch (e: ArithmeticException) {
   throw IllegalStateException(e)
   }
   // 使⽤ result
   }複製程式碼

  “if” 表示式

   fun foo(param: Int) {
   val result = if (param == 1) {
   "one"
   } else if (param == 2) {
   "two"
   } else {
   "three"
   }
   }複製程式碼

  函式

  • Java

       public final void func() {}
    
       public final int func(int value) {
    
           return 1 * value;
       }複製程式碼

  • Kotlin

       fun func() {}
    
       fun func(value: Int): Int {
    
           return 1 * value
       }複製程式碼

    // 或者

       fun func(value: Int): Int = 1 * value        複製程式碼

類

• Java

       public final class Person {
  
           private String name = null;
  
           private int age = 25;
  
           private Person() {
           }
  
           public Person(String name, int age) {
  
               this.name = name;
               this.age = age;
           }
       }複製程式碼

  • Kotlin

       class Person private constructor() {
    
           private var name: String? = null
    
           private var age: Int = 25
    
           constructor (name: String, age: Int): this() {
    
               this.name = name
               this.age = age
           }
       }            複製程式碼

    靜態方法（ 伴生物件 ）

• Java

        public final class Manager {
  
                    private Manager() {}
  
                    public static Manager getInstance () {
  
                        return new Manager();
                    }
                }複製程式碼

  • Kotlin

    class Manager private constructor() {
    
        companion object {
    
            fun getInstance(): Manager = Manager()
        }
    }            複製程式碼

    實體類

• java

            public class Person {
  
            public String name;
  
            public age;
  
            public Person(String name, int age) {
  
                this.name = name;
                this.age = age;
            }
  
            public String getName() {
                return name;
            }
  
            public void setName(String name) {
                this.name = name;
            }
  
            public int getAge() {
                return age;
            }
  
            public void setAge(int age) {
                this.age = age;
            }
  
            @Override
            public boolean equals(Object o) {
                if (this == o) return true;
                if (o == null || getClass() != o.getClass()) return false;
  
                Person person = (Person) o;
  
                if (age != person.age) return false;
                return name != null ? name.equals(person.name) : person.name == null;
  
            }
  
            @Override
            public int hashCode() {
                int result = name != null ? name.hashCode() : 0;
                result = 31 * result + age;
                return result;
            }
  
            @Override
            public String toString() {
                return "Person{" +
                        "name='" + name + '\'' +
                        ", age=" + age +
                        '}';
            }
        }複製程式碼

• Kotlin

        data class Person(var name: String, var age: Int)複製程式碼

  解構

• Java

    Person p = new Person("haohao", 25);
  
    String name = p.getName();
  
    String age = p.getAge();複製程式碼

• Kotlin

    var p = Person("name", 25)
  
    var (name, age) = p複製程式碼

介面

• Java

    interface Readable {
  
        String getContent();
    }
    public final class Book implements Readable {
  
        @override
        public String getContent() {
  
            return "Hello";
        }
    } 複製程式碼

• Kotlin

    // Kotlin 介面中可以設定抽象和非抽象方法,可以有屬性但必須宣告為抽象或提供訪問器實現。
    interface Readable {
  
       fun getContent(): String
  
       fun getVersion(): Int = 0 
  
    }
    class Book(): Readable {
  
       override fun getContent(): String = "Hello"
  
       override fun getVersion(): Int {
  
           return super.getVersion()
       }
    }        複製程式碼

  繼承

• Java

    public class Person {
  
        private String name = null;
  
        public Person(String name) {
            this.name = name;
  
        }
  
        public void sayHello() {
            System.out.println("Hello");
        }
  
        public final void sayGood() {
            System.out.println("Good");
        }
  
    }
    public final class Student extends Person {
  
        private String school = null;
  
        public Student(String name, String school) {
            this.school = school;
            super(name);
        }
  
        @override
        public void sayHello() {
            super.sayHello();
            System.out.println("Hello Student");
        }複製程式碼

    }        複製程式碼

• Kotlin

        open class Person(private var name: String? = null) {
  
            open fun sayHello() = println("Hello")
  
            fun sayGood() = println("Good")
  
        }
        class Student(private var school: String? = null, name: String): Person(name) {
  
           override fun sayHello() {
               super.sayHello()
               println("Hello Student")
           }
  
        } 複製程式碼

  靜態與非靜態內部類

• Java

    public final class Outer {
  
        private int bar = 100;
  
        public static class Nester {
  
            public final String foo() {
                return "Hello Kotlin!";
            }
        }
  
        public final class Inner {
  
            public final int foo() {
                return bar; // 可以訪問外部類成員
            }
  
        }
  
    }複製程式碼

    System.out.println(new Outer.Nester().foo()); 

    // System.out.println(new Outer().Inner().foo()); 不能在其他類中例項化非靜態內部類複製程式碼

• Kotlin

    class Outer {
        private var bar: Int = 100
  
        // 巢狀類
        class Nester {
            // 不能訪問外部類成員
            fun foo() = "Hello Kotlin!"
        }
  
        // 內部類
        inner class Inner {
            // 可以訪問外部類成員
            fun foo() = bar
        }
    }複製程式碼

    println(Outer.Nested().foo())

    println(Outer().Inner().foo())           複製程式碼

匿名內部類

• Java

    view.setOnClickListener(new OnClickListener() {
  
        @override
        onClick(View view){
            // to do something.
        }
  
    });複製程式碼

• Kotlin

    interface OnClickListener {
        fun onClick()
    }
  
    class View(){
        var listener: OnClickListener? = null
  
        fun setOnClickListener(listener: OnClickListener) {
            this.listener = listener
        }
    }
  
    view.setOnClickListener(object : OnClickListener{
        override fun onClick() {
            TODO("not implemented")
        }
    })複製程式碼

  泛型

• Java

    public final class Wrapper<T> {
        private T item;
        public Wrapper(T item) {
            this.item = item;
        }
  
        public T getItem() {
            return item;
        }
    }
  
    Wrapper<String> wrapper = new Wrapper<>("Hello Kotlin");
    System.out.println(wrapper.getItem());複製程式碼

• Kotlin

    class Wrapper<T>(val item: T)
  
    var wrapper = Wrapper("Hello Kotlin")
    println(wrapper.item)複製程式碼

  匿名函式 ( Lambda 表示式 )

• Java (Java 8)

    new Thread(() -> {
  
        System.out.println("Hello Kotlin");
  
    }).start();
  
    // 同下
  
    new Thread(new Runnable() {
  
        @Override
        public void run() {
  
            System.out.println("Hello Kotlin");
  
        }
  
    }).start();複製程式碼

• Kotlin

    Thread(Runnable {
  
        println("Hello Kotlin")
  
    }).start()
  
    // Kotlin Lambda 表示式語法
  
    val sum = {x: Int, y: Int -> x + y }
  
    val sum1: (Int, Int) -> Int = {x, y -> x + y }
  
    val sum2 = fun(x: Int, y: Int): Int {
        return x + y
    }
  
    println(sum(2,8))
  
    println(sum1(2,8))
  
    println(sum2(2,8))
  
    //輸出：
    //    10
    //    10
    //    10
    //    Hello Kotlin        複製程式碼

  簡單非同步

• Java (Java 8)

    new Thread(() -> {
  
        data = DataSource.obtain(); //耗時操作
  
        runOnUiThread(() -> {
  
        view.load(data); //更新 UI   
  
        });
  
    }).start();複製程式碼

• Kotlin (Kotlin Anko)

    async {
  
        data = DataSource.obtain(); //耗時操作
  
        uiThread {
            view.load(data); //更新 UI
        }
    }複製程式碼

  泛型函式

• Java

    // Java 不能單獨實現泛型函式複製程式碼

• Kotlin

    fun <T> singletonList(item: T): List<T> {
        return arrayListOf(item)
    }
  
    val list = singletonList<String>("kotlin")   複製程式碼

  巢狀函式

• Java

    // Java 不支援巢狀函式複製程式碼

• Kotlin

    fun main(args: Array<String>) {
  
        fun sayHello() {
            println("Hello Kotlin")
        }
  
        sayHello();
    }
    // 輸出：
    //    Hello Kotlin        複製程式碼

  Kotlin lazy 懶載入

• Kotlin

    val lazyValue: String by lazy {
        println("init")  //第一次使用時才被初始化 
        "Hello Kotlin"
    }
  
    fun main(args: Array<String>) {
        println(lazyValue)
        println(lazyValue)
    }
  
    //輸出：
    //    init
    //    Hello Kotlin
    //    Hello Kotlin複製程式碼

  Kotlin 閉包

• 閉包的理解

  簡單理解：閉包能夠將一個方法作為一個變數去儲存，這個方法有能力去訪問所在類的自由變數。

• Kotlin

    val plus = {x: Int, y: Int -> println("$x plus $y is ${x+y}")}
  
    val hello = {println("Hello Kotlin")}
  
    fun main(args: Array<String>) { 
  
        {x: Int, y: Int ->
            println("$x plus $y is ${x+y}")
        }(2, 8)         // 自執行的閉包
  
        plus(2, 8)
        hello()
    }
  
    //輸出：
    //    2 plus 8 is 10
    //    2 plus 8 is 10
    //    Hello Kotlin複製程式碼

  Kotlin observable 觀察者

• Kotlin

    class Person{
        public var name: String by Delegates.observable("init .. "){
            property,oldValue,newValue -> println("property : $property, oldValue : $oldValue, newValue : $newValue")
        }
    }
  
    fun main(args: Array<String>) {
        val person = Person()
  
        println(person.name)
  
        person.name = "haohao"
        person.name = "nannan"
    }
  
    //輸出：
    //    init .. 
    //    property : var Person.name: kotlin.String, oldValue : init .. , newValue : haohao
    //    property : var Person.name: kotlin.String, oldValue : haohao, newValue : nannan複製程式碼

  學習文件

• 官網文件：

  kotlinlang.org/docs/refere…

• 官網：

  kotlinlang.org/

• 國內中文文件：

  huanglizhuo.gitbooks.io/kotlin-in-c…)

• 國內中文文件2：

  www.liying-cn.net/kotlin/docs…

• Kotlin-github地址

  github.com/JetBrains/k…

相關部落格地址：

github.com/androidstar…

相信自己，沒有做不到的，只有想不到的

如果你覺得此文對您有所幫助，歡迎入群 QQ交流群 ：232203809
微信公眾號：終端研發部

                                                      歡迎關注學習和交流）       複製程式碼