Kotlin笔记面向对象（五）
Kotlin笔记数据类型（一）
Kotlin笔记字符串（二）
Kotlin笔记运算符（三）
Kotlin笔记函数（四）
文章目录
前言
面向对象是比较重要的，要充分理解面向对象三大特征
封装：封装能够使外部访问者不能随意存取对象的内部数据，隐藏了对象的内部细节，只保留有限的对外接口。外部访问者不用关心对象的内部细节，使得操作对象变得简单
继承：继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为
多态：是指一个类实例（对象）的相同方法在不同情形有不同表现形式。多态机制使具有不同内部结构的对象可以共享相同的外部接口。这意味着，虽然针对不同对象的具体操作不同，但通过一个公共的类，它们（那些操作）可以通过相同的方式予以调用。
提示：以下是本篇文章正文内容，下面案例可供参考
一、面向对象思维导图
示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。
二、属性
Kotlin中属性可以在类中声明，称为成员属性。属性也可以在类之外，类似于
顶层函数，称为顶层属性，事实上顶层属性就是全局变量。属性声明结构
扫描二维码关注公众号，回复：
14774024 查看本文章
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("静态代码块")
}
}
}