Kotlin学习笔记-3 --- 类与对象

文章参考

class KotlinClass {

}

/**
 * 空类
*/
class EmptyClass

类的修饰符

1）classModifier: 类属性修饰符，标示类本身特性

• abstract // 抽象类
• final // 类不可继承，默认属性
• enum // 枚举类
• open // 类可继承，类默认是final的
• annotation // 注解类

2）accessModifier: 访问权限修饰符

• private // 仅在同一个文件中可见
• protected // 同一个文件中或子类可见
• public // 所有调用的地方都可见
• internal // 同一个模块中可见

1、构造函数

1）主构造函数

定义

class PersonEntity constructor(name: String, sex: String, age: Int) {
    private val TAG: String = "PersonEntity"

    private var mName: String = name
    private var mSex: String = sex
    private var mAge: Int = age

    init {
        Log.i(TAG, "初始化 : $mName   $mSex   $mAge")
    }

    fun display() {
        Log.i(TAG, "个人信息 : $mName   $mSex   $mAge")
    }
}

使用

val person1 = PersonEntity("Alex", "man", 24)
person1.display()

输出日志

2）次构造函数

定义

class PersonEntity constructor(name: String) {
    private val TAG: String = "PersonEntity"

    private var mName: String = name
    private var mSex: String = "xxx"
    private var mAge: Int = -1

    init {
        Log.i(TAG, "主构造函数初始化 : $mName   $mSex   $mAge")
    }


    constructor(name: String, sex: String) : this(name) {
        mSex = sex
        Log.i(TAG, "次构造函数(2个参数)初始化 : $mName   $mSex   $mAge")
    }


    constructor(name: String, sex: String, age: Int) : this(name, sex) {
        mAge = age
        Log.i(TAG, "次构造函数(3个参数)初始化 : $mName   $mSex   $mAge")
    }


    fun display() {
        Log.i(TAG, "个人信息 : $mName   $mSex   $mAge")
    }
}

使用

val person1 = PersonEntity("Alex", "man", 24)
person1.display()

日志输出

2、getter 和 setter

• getter 和 setter 都是可选
• val不允许设置setter函数，因为它是只读的

注：Kotlin 中类不能有字段。提供了 Backing Fields(后端变量) 机制,备用字段使用field关键字声明,field 关键词只能用于属性的访问器。

定义

class StudentEntity {
    val TAG: String = "StudentEntity"
    
    var name: String? = ""
        get() = field?.toUpperCase()
        set(value) {
            field = if (TextUtils.isEmpty(value.toString())) {
                "xxx"
            } else {
                value
            }
        }

    var age: Int? = 0
        get() {
            return if (field?.toInt() == 0) {
                -1
            } else {
                field?.toInt()
            }
        }

    fun display() {
        Log.i(TAG, "$name    $age")
    }
}

使用

val student1 = StudentEntity()
student1.name = ""
student1.age = 0
student1.display()
student1.name = "Alex"
student1.age = 24
student1.display()

日志输出

3、常用类

1）抽象类

• 类和属性若想被继承，需要用关键字open标注
• 抽象类或抽象成员则无需open标注

---

父类 abstract

/**
 * 抽象类
 */
abstract class Parent {

    //可继承方法
    open fun p() {}

    //抽象方法
    abstract fun p2()
}

子类

class Child : Parent() {

    override fun p() {
        super.p()
    }

    override fun p2() {
        TODO("Not yet implemented")
    }

}

---

父类 open

open class Parent {
    //可继承方法
    open fun p() {}
}

子类

class Child : Parent() {

    override fun p() {
        super.p()
    }
}

---

2）嵌套类

注：嵌套类无法直接使用外部类的属性

定义

/**
 * 外部类
 */
class ExternalClass {

    private var externalArg: String? = "external Arg"
    fun externalFun() = externalArg

    /**
     * 嵌套类
     */
     class NestClass {
        private var nestArg: String? = "nest arg"
        fun nestFun() = nestArg
        //fun getExternalArg() = externalArg  //会报错
    }
}

使用

val externalClass = ExternalClass()
var externalArg = externalClass.externalFun()
Log.i(TAG, "externalArg : $externalArg")

val nestClass = ExternalClass.NestClass()
var nestArg = nestClass?.nestFun()
Log.i(TAG, "nestArg : $nestArg")

日志输出

3）内部类

• 内部类使用 inner 关键字标注
• 内部类可直接使用外部类的属性

定义

/**
 * 外部类
 */
class ExternalClass {

    private var externalArg: String? = "externalArg"

    /**
     * 内部类
     */
    inner class InternalClass {
        private var internalArg: String? = "internalArg"
        fun getInternalArg() = internalArg
        fun getExternalArg1() = externalArg
        fun getExternalArg2(): String? {
            var e = this@ExternalClass
            return e.externalArg
        }
    }
}

使用

val internalClass = ExternalClass().InternalClass()
val internalArg = internalClass.getInternalArg()
val externalArg1 = internalClass.getExternalArg1()
val externalArg2 = internalClass.getExternalArg2()
Log.i(TAG, "internal Arg : $internalArg")
Log.i(TAG, "external Arg 1 : $externalArg1")
Log.i(TAG, "external Arg 2 : $externalArg2")

日志输出

4）内部匿名类

接口

/**
 * 接口
 */
interface CalculateInterface {

    fun calculate(result : Int)
}

内部匿名类

class CalculateClass constructor(x: Int, y: Int) {

    private var a: Int = x
    private var b: Int = y

    fun add(calculateCallback: CalculateInterface) {
        var result: Int = a + b
        calculateCallback.calculate(result)
    }
}

使用

var calculateClass = CalculateClass(2, 3)
calculateClass.add(object : CalculateInterface {
    override fun calculate(result: Int) {
        Log.i(TAG, "result : $result")
    }
})

日志输出