淺談Kotlin（三）：類

淺談Kotlin（一）：簡介及Android Studio中配置 淺談Kotlin（二）：基本類型、基本文法、代碼風格 淺談Kotlin（三）：類 淺談Kotlin（四）：控制流

前言：

　　已經學習了前兩篇文章，對Kotlin有了一個基本的認識，往後的文章開始深入介紹Kotlin的實戰使用。

　　本篇介紹Kotlin中類的使用。

一、表現形式

　　首先看一段Java中定義類的形式，定義三個屬性，每一個屬性對應一個get、set方法，有一個toString()方法

/*
* @author xqx
* @emil [email protected]
* create at 2017/5/18
* description: 自己寫的類，人，包含姓名，年齡，性别
*/

public class XPatient {
    private String name;  //姓名
    private int age;      //年齡
    private int sex;     //性别  1、男    2、女

    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;
    }

    public int getSex() {
        return sex;
    }

    public void setSex(int sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "XPatient{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex=" + sex +
                '}';
    }
}      

　　

　　接下來我們看這個類對應的Kotlin的表現形式：

　　跟着下面的操作做一個處理，讓我們這個類對應的 .java 檔案轉化為對應的 .kt 檔案

　　之後轉換完成我們看下轉換後的代碼：

　　看一下變化：

　　　　　　1、代碼量少了很多

　　　　　　2、get/set方法都沒有了

　　　　　　3、隻有一個重寫的toString()方法。

　　　　　　4、類的屬性都有一個預設的初始值

/*
* @author xqx
* @emil [email protected]
* create at 2017/5/18
* description: 自己寫的類，人，包含姓名，年齡，性别
*/

class XPatient {
    var name: String? = null  //姓名
    var age: Int = 0      //年齡
    var sex: Int = 0     //性别  1、男    2、女

    override fun toString(): String {
        return "XPatient{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex=" + sex +
                '}'
    }
}      

二、定義類的構造方法

　　首先看Java類的構造

　　Java中定義構造方法特點：

　　　　　　1、方法名需要和類名一緻

　　　　　　2、參數可以任意屬性值的組合，也可以不寫

　　　　　　3、可以有多個構造方法

//無參數的構造方法
    public JPatient() {
    }

    //類的三個屬性值都需要的構造方法
    public JPatient(String name, int age, int sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }      

　　在看Kotlin的類，這裡有個知識點 ：Kotlin類中可以有一個主構造方法 和 一個至多個二級構造方法。

　　①、主構造方法的的寫法：

　　　　直接寫在類的頭部，類似于定義方法的形式 加一個參數。

　　　　需要添加 init{} 代碼塊來處理對主構造方法傳來的參數的初始化操作。

class XPatient(name: String? ,age: Int ,sex: Int) {  //主構造方法的形式 ，類名後面加(屬性名 : 屬性類型 .....)
    var name: String? = null  //姓名
    var age: Int = 0      //年齡
    var sex: Int = 0     //性别  1、男    2、女


    /*進行主構造函數的初始化,自己定制*/
    init {
        this.name = name;
        this.age = age+1;
        this.sex = sex-1;
    }
    ....
}      

　　　　

　　②、二級構造方法：

　　　　為了實作類似于Java中一個類具有多種構造方法

　　　　二級構造函數最終委托到主構造方法，中間可以有0個或多個中間二級構造方法。

　　　　個人了解，如果涉及到一個類有多個構造方法的時候，主構造方法盡量設為無參的。

　　　　如下：當建立一個對象XPatient("Alice",18); 的時候 會調用二級構造方法 constructor(name: String?,age : Int):this(name){}

　　　　　　　該二級構造方法再委托(調用)對應的一個參數name(String) 對應的二級構造方法  constructor(name:String?):this( ){}

　　　　　　　一個參數的該二級構造方法最終委托(調用)主構造方法

　　　　下面舉例測試：

class XPatient() {
    var name: String? = null  //姓名
    var age: Int = 0      //年齡
    var sex: Int = 0     //性别  1、男    2、女


    /*進行主構造函數的初始化*/
    init {
        Log.i("xqxinfo","調用了無參數的主構造方法");
    }

    /*傳入(name)*/
    constructor(name:String?):this( ){
        this.name = "Alice";
        Log.i("xqxinfo","調用了一個參數的二級構造方法");

    }
    /*傳入(name,age)*/
    constructor(name: String?,age : Int):this(name){
        this.age = age+1;
        Log.i("xqxinfo","調用了兩個參數的二級構造方法");
    }

    override fun toString(): String {
        return "XPatient{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex=" + sex +
                '}'
    }
}      

　　　　進行測試：

val patient = XPatient("Alice", 18)
Log.i("xqxinfo", "該對象的屬性值" + patient.toString())      

　　　　列印結果：

05-19 18:08:05.621 25081-25081/? I/xqxinfo: 調用了無參數的主構造方法

05-19 18:08:05.621 25081-25081/? I/xqxinfo: 調用了一個參數的二級構造方法

05-19 18:08:05.621 25081-25081/? I/xqxinfo: 調用了兩個參數的二級構造方法

05-19 18:08:05.621 25081-25081/? I/xqxinfo: 該對象的屬性值XPatient{name='Alice', age=19, sex=0}

 　　　這裡看一下，不要以為先執行了主構造方法，然後再執行一個參數的，再執行兩個參數的二級構造方法。

　　　 實際還是先執行了建立對象的那個參數 對應的兩個參數的二級構造方法，兩個參數的構造方法調用一個參數的構造方法，一個參數的又調用了主構造方法。

　　　 是以當主構造方法執行完之後，會傳回來執行一個參數的構造方法内的處理，一個參數的構造方法執行完了，再執行兩個參數的構造方法内的處理。類似于遞歸。

　　    是以列印結果如上代碼所示。

二、類的繼承

　　關于Kotlin的類有幾個知識點需要先知道：

　　　　1、預設情況下，任何類都是根繼承自Any(類似于Java中的Object)

　　　　2、預設情況下，任何類都是不可繼承的(final)

　　　　3、隻有被申明open或者abstract的類可以被繼承

　　繼承形式：

open class Animal(name: String)  // 被繼承的類  需要open修飾
class Person(name: String, surname: String) : Animal(name)     //繼承Animal類的類      

注：方法即函數