Kotlin笔记面向对象（五）

Kotlin笔记数据类型（一） Kotlin笔记字符串（二） Kotlin笔记运算符（三） Kotlin笔记函数（四）

---

文章目录

Kotlin笔记面向对象（五）前言一、面向对象思维导图二、属性1.延迟初始化属性2.委托属性3.惰性加载属性4.可观察属性 三、构造函数1.主构造函数声明2.次构造函数声明使用3.默认构造函数 四、扩展1.扩展属性2.扩展函数3.中缀函数4.成员优先 五、修饰符六、 数据类七、 枚举八、 嵌套类九、内部类十、object关键字1.对象表达式2.对象声明3.伴生对象 总结

---

前言

面向对象是比较重要的，要充分理解面向对象三大特征

封装：封装能够使外部访问者不能随意存取对象的内部数据，隐藏了对象的内部细节，只保留有限的对外接口。外部访问者不用关心对象的内部细节，使得操作对象变得简单

继承：继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为

多态：是指一个类实例（对象）的相同方法在不同情形有不同表现形式。多态机制使具有不同内部结构的对象可以共享相同的外部接口。这意味着，虽然针对不同对象的具体操作不同，但通过一个公共的类，它们（那些操作）可以通过相同的方式予以调用。

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、面向对象思维导图

示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。

二、属性

Kotlin中属性可以在类中声明，称为成员属性。属性也可以在类之外，类似于 顶层函数，称为顶层属性，事实上顶层属性就是全局变量。属性声明结构

var|val 属性名 [ : 数据类型] [= 属性初始化 ] [getter访问器] [setter访问器]

1.延迟初始化属性

使用 lateinit 关键字，在类声明的时候属性必须初始化，使用此关键字可以延迟属性初始化

fun main(args: Array<String>) { var student3=Student3() student3.name="zyb" println(student3.name) } class Student3{ var score:Float=10.0f lateinit var name:String }

2.委托属性

使用关键字by 将属性 的get/set 方法委托给对象

class Student3{ var name:String by Teacher() } class Teacher{ var name:String="张三" operator fun getValue(thisRef: Any, property: KProperty<*>):String{ return this.name } operator fun setValue(thisRef: Any,property: KProperty<*>,value:String){ this.name=value } }

3.惰性加载属性

使用关键字 by lazy 惰性加载属性必须是val的，而延迟初始化属性必须是var的

fun main(args: Array<String>) { var dog=Dog() println(dog.info) } class Dog{ var name:String="金毛" var age:Int=2 val info:String by lazy{ "name:$name age:$age" } }

4.可观察属性

监听属性的变化

fun main(args: Array<String>) { var cat=Cat() cat.age=1 } class Cat{ var age:Int by Delegates.observable(0){ property, oldValue, newValue -> println("old:$oldValue new:$newValue") } }

三、构造函数

构造函数事一个特殊的函数，在类初始化的时候调用

1.主构造函数声明

完整的主构造函数声明

class Pig constructor(name:String,age:Int){ var name:String var age:Int init { this.name=name this.age=age } }

简写的主构造函数声明

class Pig (var name:String,var age:Int)

constructor 在有修饰符修饰的时候不能省去

class Pig private constructor(var name:String,var age:Int)

主构造函数还可以设置默认值

class Pig (var name:String="品种",var age:Int=2)

2.次构造函数声明使用

fun main(args: Array<String>) { var cat=Pig("大猪") var pig=Pig("小猪",18,20.0f) var pig1=Pig() } class Pig (var name:String,var age:Int){ var price:Float=10.0f constructor(name:String,age:Int,price:Float) :this(name,age){ this.price=price } constructor(name: String):this(name,12,12.0f) constructor() }

3.默认构造函数

如果不显示声明构造函数的话，系统会自动生成一个无参数的构造方法

四、扩展

1.扩展属性

fun main(args: Array<String>) { var pig =Pig("小猪",2,20.0f) println(pig.info) } var Pig.info:String get() { return "${this.name} 年龄 :${this.age} 价格:${this.price}" } set(value) { } class Pig (var name:String,var age:Int){ var price:Float=10.0f constructor(name:String,age:Int,price:Float) :this(name,age){ this.price=price } constructor(name: String):this(name,12,12.0f) }

2.扩展函数

fun main(args: Array<String>) { var pig =Pig("小猪",2,20.0f) println(pig.getInfoPig()) } fun Pig.getInfoPig():String{ return "${this.name} 年龄 :${this.age} 价格:${this.price}" } class Pig (var name:String,var age:Int){ var price:Float=10.0f constructor(name:String,age:Int,price:Float) :this(name,age){ this.price=price } constructor(name: String):this(name,12,12.0f) }

3.中缀函数

定义中缀运算符，就是要声明一个infix关键字修饰的函数，该函数只能有一 个参数，该函数不能是顶层函数，只能成员函数或扩展函数

fun main(args: Array<String>) { var pig =Pig("小猪",2,20.0f) pig getNamePig "pig" } class Pig (var name:String,var age:Int){ var price:Float=10.0f constructor(name:String,age:Int,price:Float) :this(name,age){ this.price=price } constructor(name: String):this(name,12,12.0f) infix fun getNamePig(name:String){ println(name) } }

4.成员优先

相同函数的优先级 成员函数大于扩展函数

五、修饰符

可见性修饰符类成员声明顶层声明公有public 默认所有地方可见所有地方可见内部internal模块中可见模块中可见保护protected子类中可见顶层声明中不能使用私有private类中可见文件中可见

六、 数据类

fun main(args: Array<String>) { var person =Person1("zyb",1) println(person) } data class Person1(var name:String,var age: Int)

七、 枚举

枚举类的使用

fun main(args: Array<String>) { var flag=WeekDays.MONDAY when(flag){ WeekDays.MONDAY -> println("星期一") WeekDays.TUESDAY -> println("星期二") WeekDays.WEDNESDAY -> println("星期三") WeekDays.THURSDAY -> println("星期四") else -> println("星期五") } } //最简单形式的枚举类 enum class WeekDays { // 枚举常量列表 MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY }

枚举类构造函数

fun main(args: Array<String>) { println(WeekDays.MONDAY) } //最简单形式的枚举类 enum class WeekDays (private var names:String,private var index:Int){ // 枚举常量列表 MONDAY("星期一",2), TUESDAY("星期二",3), WEDNESDAY("星期三",4), THURSDAY("星期四",5), FRIDAY("星期五",5); override fun toString(): String { return "$names:$index" } }

八、 嵌套类

内部类无法访问外部类的 属性和方法，外部类可以初始化内部类，并访问属性和方法

class A{ var index:Int=0 fun sayA(){ println(index) } class B{ var indexB:Int=1 fun sayB(){ println("B") } } fun initB(){ var b=B() b.indexB b.sayB() } }

九、内部类

class Out{ var age:Int=10 fun getAges():Int=age inner class Inner{ var innerName:String="Inner" fun getOutInfo():String{ println(getAges()) return "$innerName $age" } } fun test(){ var inner=Inner() inner.getOutInfo() } }

十、object关键字

1.对象表达式

类似于java的匿名对象

fun main(args: Array<String>) { setOnclickLister( object : OnclickLister{ override fun onclick() { println("点击了") } }) } fun setOnclickLister(onclickLister: OnclickLister){ onclickLister.onclick() } interface OnclickLister{ fun onclick() }

2.对象声明

声明对象是个单例

object Sun{}

3.伴生对象

Kotlin中没有static 关键字。所以要使用静态方法和静态属性，静态代码块，只能通过 companion object 来声明

fun main(args: Array<String>) { var fish =Fish() println(fish.name) println(Fish.getVersin()) } class Fish{ var name:String="zhang" constructor(){ println("构造方法") } companion object{ var version:Int=10 fun getVersin():Int{ return version } init { println("静态代码块") } } }

---

总结

主要记录了类声明、属性、扩展、构造函数和可见性修饰符。最后介绍了数据 类、枚举类、嵌套类和使用object关键字。