Kotlin笔记面向对象(五)

·  阅读 36
Kotlin笔记面向对象(五)

本文已参与「新人创作礼」活动,一起开启掘金创作之路

Kotlin笔记面向对象(五)

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


前言

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

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

继承:继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法,或子类从父类继承方法,使得子类具有父类相同的行为

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


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

一、面向对象思维导图

在这里插入图片描述

示例: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关键字。
分类:
Android
标签:
收藏成功!
已添加到「」, 点击更改