Kotlin四：类和对象 归纳总结

你瞅啥？

Kotlin 类可以包含：构造函数和初始化代码块、函数、属性、内部类、对象声明。

• Kotlin 中使用关键字 class 声明类，后面紧跟类名：

// 类名为 Test 
class Test {
  // 类体构成
}
// 定义一个空类
class Empty
// 在类中定义成员函数
class FunClass{
  fun test(){
       print("Foo") 
  }
}

• 类的属性：
  1. 可以用关键字 var 声明为可变的，否则使用只读关键字 val 声明为不可变。
2. 创建类实例 【Kotlin 中没有 new 关键字】
3. 要使用一个属性，只要用名称引用它即可 【使用 . 号来引用】
4. Koltin 中的类可以有一个 主构造器，以及一个或多个次构造器，主构造器是类头部的一部分，位于类名称之后 【如果主构造器没有任何注解，也没有任何可见度修饰符，那么constructor关键字可以省略】

// 1、实现属性
class FunClass{
  var name : String = "zhang"
  var age : Int = 20
  var city : String = "bj"
}
// 2、创建类实例
val site = FunClass() // Kotlin 中没有 new 关键字
// 3、使用 . 号来引用 属性
site.name
 // 4、构造器
class Person constructor(firstName: String) {}
// 没有任何注解，也没有任何可见度修饰符，那么constructor关键字可以省略
class Person (firstName: String) {}

• getter 和 setter：

class PersonInfo{
    var lastName :String ="zhang"
    get() = field.toUpperCase() // 将变量赋值后转换为大写
    set

    var no : Int = 100
    get() = field // 后端变量
    set(value){
        if(value<10){
            field = value
        }else{
            field = -1
        }
    }
    var heiht : Float = 145.5F
    private set
}

/**
 * 输出结果
 * ==lastName:WANG
 * ==no:9
 * ==no:-1
 */
fun main(args: Array<String>) {
    var personinfo : PersonInfo = PersonInfo()
    personinfo.lastName ="Wang"
    println("==lastName:${personinfo.lastName}")

    personinfo.no = 9
    println("==no:${personinfo.no}")

    personinfo.no = 20
    println("==no:${personinfo.no}")

}

• 主构造器：
  1. 主构造器中不能包含任何代码，初始化代码可以放在初始化代码段中，初始化代码段使用 init 关键字作为前缀
2. 注意：主构造器的参数可以在初始化代码段中使用，也可以在类主体n定义的属性初始化代码中使用。 一种简洁语法，可以通过主构造器来定义属性并初始化属性值（可以是var或val）

class Person constructor(firstName: String) {
    init {
        println("FirstName is $firstName")
    }
}

class PersonInfo constructor(name :String){
    var lastName :String = name
    get() = field.toUpperCase() // 将变量赋值后转换为大写
    set

    var no : Int = 100
    get() = field // 后端变量
    set(value){
        if(value<10){
            field = value
        }else{
            field = -1
        }
    }
    var heiht : Float = 145.5F
    private set

    init {
        println("==constructor lastName:${lastName}")
    }
}

/**
 * 输出结果
 * ==constructor lastName:LIU
 * ==lastName:WANG
 * ==no:9
 * ==no:-1
 */
fun main(args: Array<String>) {
    var personinfo : PersonInfo = PersonInfo("Liu")
    personinfo.lastName ="Wang"
    println("==lastName:${personinfo.lastName}")

    personinfo.no = 9
    println("==no:${personinfo.no}")

    personinfo.no = 20
    println("==no:${personinfo.no}")

}

• 次构造函数：

1. 如果类有主构造函数，每个次构造函数都要，或直接或间接通过另一个次构造函数代理主构造函数。在同一个类中代理另一个构造函数使用 this 关键字
class Person(val name: String) {
constructor (name: String, age:Int) : this(name) {
// 初始化...
}
}
2. 如果一个非抽象类没有声明构造函数(主构造函数或次构造函数)，它会产生一个没有参数的构造函数。构造函数是 public 。如果你不想你的类有公共的构造函数，你就得声明一个空的主构造函数
class DontCreateMe private constructor () {}

class PersonInfo constructor(name :String){
    var lastName :String = name
    get() = field.toUpperCase() // 将变量赋值后转换为大写
    set

    var no : Int = 100
    get() = field // 后端变量
    set(value){
        if(value<10){
            field = value
        }else{
            field = -1
        }
    }
    var heiht : Float = 145.5F
    private set

    init {
        println("==constructor lastName:${lastName}")
    }
    // 次构造函数
    constructor (name: String, alexa: Int) : this(name) {
        no= alexa
        println("==次构造函数 $alexa")
    }
}

/**
 * 输出结果
 * ==constructor lastName:LIU
 * ==次构造函数 30
 * ==lastName:WANG
 * ==no:-1
 * ==no:9
 * ==no:-1
 */
fun main(args: Array<String>) {
    var personinfo : PersonInfo = PersonInfo("Liu",30)
    personinfo.lastName ="Wang"
    println("==lastName:${personinfo.lastName}")

    personinfo.no = 9
    println("==no:${personinfo.no}")

    personinfo.no = 20
    println("==no:${personinfo.no}")

}

• 抽象类：
  1. 抽象是面向对象编程的特征之一，类本身，或类中的部分成员，都可以声明为abstract的。抽象成员在类中不存在具体的实现。
2. 非抽象的open成员函数可以在抽象类中重载。

// 输出结果：Honda is running safely..
abstract class Car{
    abstract fun run()
}
class Honda: Car(){
    override fun run(){
        println("Honda is running safely..")
    }
}
fun main(args: Array<String>){
    val obj = Honda()
    obj.run();
}

执行上面示例代码，得到以下结果 -

Honda is running safely..

open class Car {
    open fun run() {
        println("Car is running..")
    }
}
abstract class Honda : Car() {
    override abstract fun run()
}
class City: Honda(){
    override fun run() {
        //  TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
        println("Honda City is running..")
    }
}
fun main(args: Array<String>){
    val car = Car()
    car.run()
    val city = City()
    city.run()
}

执行上面示例代码，得到以下结果 -

Car is running..
Honda City is running..