Kotlin-类和对象

06-01 1668阅读

文章目录

  • 类
    • 主构造函数
    • 次要构造函数
    • 总结
    • 对象
      • 初始化
      • 类的继承
      • 成员函数
      • 属性覆盖(重写)
        • 智能转换
        • 类的扩展

          类

          class Student {
}

          这是一个类,表示学生,怎么才能给这个类添加一些属性(姓名,年龄…)呢?

          主构造函数

          我们需要指定类的构造函数。构造函数也是函数的一种,但是它专门用于对象的创建

          Kotlin的类可以添加一个主构造函数和一个或多个次要构造函数。主构造函数是类定义的一部分,像下面这样编写:

          class Student constructor(name: String, age: Int) {
    
}

          如果主构造函数没有任何注释或可见性修饰符,则可以省略constructor关键字,如果类中没有其他内容要写,也可以直接省略{}, 像下面这样:

          class Student (name: String, age: Int)

          但是,这里仅仅是定义了构造函数的参数,还不是类的属性

          仅在对象初始化时使用构造函数参数，并且不想让这些参数以属性的形式被外部访问时，可采用这种写法,那我们要怎么才能定义类的属性呢?

          可以为这些参数添加var(可变)或val(不可变)关键字来表示属性:

          class Student (var name: String,val age: Int)

          这样才算是定义了类的属性,我们也可以给这些属性设置初始值:

          class Student (var name: String = "zhangsan",val age: Int = 20)

          因为是构造函数, 实例化的时候会传入值, 所以可以给也可以不给初始值

          如果将这些属性直接作为类的成员变量写到类里面,必须配初始值，否则无法通过编译,这样我们不用编写主构造函数也能定义属性,这里仍会隐式生成一个无参的构造函数:

          class Student  {
    var name: String = "zhangsan"
    val age: Int = 20
}

          也可以写成这样:

          class Student(name : String, age: Int) {
    var name: String = name
    val age: Int = age
}

          这样不是多此一举嘛,直接在括号里(主构造函数)定义属性不就好了,这样的好处就是可以自定义属性的get和set方法

          class Shape(var width:Int, var height:Int) {
    val area: Int
//      get() {
//          return width * height
//      }
        get() = width * height
}
fun main() {
    var a = Shape(2, 3)
    println("Width: ${a.width}, Height: ${a.height}")
    println("Area: ${a.area}")
}

          Kotlin-类和对象

          class Shape(width:Int, height:Int) {
    val area: Int
        init {
            area = width * height
        }
    val perimeter: Int
        init {
            perimeter = (width + height) * 2
        }
}

          当然,如果不希望一开始就有初始值,而是之后某一个时刻(用它之前)去设定初始值, 我们也可以为其添加懒加载(用它之前给属性初始值):

          lateinit 修饰符:

          1. 只能用于可变属性（即 var 声明的属性），而不能用于只读属性（使用 val 声明的属性）
          2. 不能用于基本数据类型的属性。
          class Student {
    lateinit var name: String
    val age: Int = 0
}

          次要构造函数

          除了直接使用主构造函数创建对象外,我们也可以添加一些次要构造函数,次要构造函数中的参数仅仅表示传入的参数,不能像主构造函数那样定义属性:

          • 如果该类有一个主构造函数,则每个次要构造函数都需要直接或间接委托给主构造函数。委托到同一个类的另一个构造函数是 this 关键字完成的 
            class Student(var name: String, var age: Int) {
    //这里的 this 表示当前这个类, this() 就是调用当前类的无参构造函数
    //这里其实是调用主构造函数,并且参数只有name,年龄直接给默认值18
    constructor(name: String) : this(name, 18) {
        println("次要构造函数")
    }
}
fun main() {
    var stu = Student("小明")
}

            Kotlin-类和对象

            • 如果一个类没有主构造函数,那么我们也可以直接在类中编写次要构造函数,: 
              class Student {
    var name: String
    var age: Int
    //在次要构造函数的参数前使用 var 或者 val 是不被允许的
    //次要构造函数可以编写自定义的函数体
    constructor(name: String, age: Int) { //这里的参数不是类属性,仅仅是形参
        this.name = name
        this.age = age
    }
}

              总结

              • 主构造函数:可以直接定义类属性,使用更方便,但主构造函数只能存在一个,并且无法编写函数体,不过可以用init编写,下面对象初始化有介绍
              • 次要(辅助)构造函数:可以存在多个,并且可以自定义函数体,但是无法像主构造函数那样定义类属性,并且当类具有主构造函数时,所有的次要构造函数必须直接或间接地调用主构造函数

                对象

                构造函数也是函数,我们可以用类名()的形式创建对象

                class Student(var name: String, var age: Int)
fun main() {
    var stu: Student = Student("小明", 18)
    println(stu.name)
    println(stu.age)
    stu.name = "小红"
    println(stu.name)
}

                Kotlin-类和对象

                初始化

                在创建对象时,我们可能需要做一些初始化工作,可以使用初始化代码块(使用init关键字)来完成。假如我们希望对象在创建时, 年龄不足18岁就设定为18岁:

                注意：我们在创建对象的时候,就会自动执行init里面的代码

                class Student (var name: String, var age: Int){
    init {
        println("我是初始化操作")
        if (age  

                Kotlin-类和对象
                初始化操作可以有很多个:
                 

                class Student (var name: String, var age: Int){
    //多个初始化操作时,按从上往下的顺序执行
    init {
        if (age  

                Kotlin-类和对象
                如果初始化代码要用成员属性, 那就要在用之前先赋值
                 

                class Student {
    init {
        println("name is $name")
        println("age is $age")
    }
    var name: String = "Student"
    var age: Int = 20
}
fun main() {
    var stu = Student()
}

                 

                Kotlin-类和对象
                这里需要注意一下,次要构造函数实际上需要先执行主构造函数,所以会优先执行init
                 

                class Student (var name: String, var age: Int){
    init {
       println("我是初始化代码块")
    }
    constructor(name: String) : this(name, 18){
        println("我是次要构造函数的语句")
    }
}
fun main() {
    var stu = Student("张三")
}

                 

                Kotlin-类和对象
                 

                类的继承
                 

                在Kotlin中, 默认情况下, 类是"终态"的(不能被任何类继承)。要使类可继承,要用open关键字标记需要被继承的类
                 

                在Kotlin中只能单继承。需要注意的是,在对象创建并初始化的时候, 会优先对父类进行初始化,再对子类进行初始化
                 

                open class Student {
    init {
        println("父类初始化")
    }
    fun hello() = println("打招呼")
}
class ArtStudent: Student() {
    init {
        println("子类初始化")
    }
    fun draw() = println("我会画画")
}
fun main() {
    val student = ArtStudent()
    student.draw()
    student.hello()
}

                 

                Kotlin-类和对象
                 

                成员函数
                 

                现在我们的类有了属性，而对象也可以做出一些行为，我们可以通过定义函数来实现
                 

                class Student(var name: String, var age: Int) {
    fun hello() {
        println("大家好, 我是$name")
    }
}
fun main() {
    val student = Student("路飞", 20)
    student.hello()
}

                 

                Kotlin-类和对象
                如果函数中的变量存在歧义,那么优先使用作用域最近的一个
                 

                class Student(var name: String, var age: Int) {
    fun hello(name: String)  {
        println("大家好, 我是$name")
    }
}
fun main() {
    Student("路飞", 20).hello("比企谷八幡")
}

                 

                Kotlin-类和对象
                如果我们需要获取的是类中的成员属性,需要使用this关键字来表示
                 

                class Student(var name: String, var age: Int) {
    fun hello(name: String)  {
        println("大家好, 我是${this.name}")
    }
}
fun main() {
    Student("路飞", 20).hello("比企谷八幡")
}

                 

                Kotlin-类和对象
                 

                属性覆盖(重写)
                 

                有些时候,我们希望子类继承父类的某些属性,但是又希望去修改这些属性的默认实现
                 

                我们可以使用 override 关键字表示对一个属性的覆盖(重写)
                 

                open class Student {
    // 函数必须添加open关键字才能被子类覆盖
    open fun hello() = println("打招呼")
}
class ArtStudent: Student() {
    // 在子类中重写方法要添加 override 关键字
    override fun hello() {
        println("呀哈喽")
        super.hello()
    }
}
fun main() {
    val artStudent = ArtStudent()
    artStudent.hello()
}

                 

                Kotlin-类和对象
                同样的, 类的某个变量也是可以进行覆盖的
                 

                open class Student {
    open val name: String = "小明"
}
class ArtStudent: Student() {
    override val name: String = "小红"
}
fun main() {
    val artStudent = ArtStudent()
    println(artStudent.name)
}

                 

                Kotlin-类和对象
                对于可变的变量,也可以这样不加open
                 

                open class Student {
    var name: String = "小明"
}
class ArtStudent: Student() {
    init {
        name = "小红"
    }
}
fun main() {
    val artStudent = ArtStudent()
    println(artStudent.name)
}

                 

                Kotlin-类和对象
                也可以在子类的主构造函数中直接覆盖
                 

                open class Student {
    open var name: String = "小明"
}
class ArtStudent(override var name: String): Student()
fun main() {
    val artStudent = ArtStudent("小王")
    println(artStudent.name)
}

                 

                Kotlin-类和对象
                 

                open class Student {
    open var name: String = "小明"
}
class ArtStudent(override var name: String): Student() {
    init {
        name = "小红"
    }
}
fun main() {
    val artStudent = ArtStudent("小王")
    println(artStudent.name)
}

                 

                Kotlin-类和对象
                这种初始化顺序要特别注意
                 

                open class Student {
    open var name: String = "小明"
    init {
        println(name.length) // 这里拿到的name其实是还未初始化的子类的name
    }
}
class ArtStudent(override var name: String): Student()
fun main() {
    val artStudent = ArtStudent("小王")
    println(artStudent.name)
}

                 

                由于父类初始化在子类之前,此时子类还没有初始化,其覆盖的属性此时没有值,在JVM平台下,没有初始化的对象引用默认为null,那么这里就会出现空指针异常
                 

                Kotlin-类和对象
                name明明是一个不可空的String类型,还会出现空指针异常。因此,对于使用了open关键字的属性只要是在初始化函数、构造函数中使用,要额外小心
                 

                智能转换
                 

                编译器可以根据当前的语境自动进行类型转换
                Kotlin-类和对象
                不仅仅是if判断的场景,还包括when、while 以及 && || 等
                 

                open class Student
class ArtStudent: Student() {
    fun draw(): Boolean = true
}
fun main() {
    val student: Student = ArtStudent()
    while (student is ArtStudent) student.draw()
    // 很明显如果前面为真,那么肯定是 ArtStudent 类型, 后面可以智能转换
    if (student is ArtStudent && student.draw()) ;
}

                 

                可空类型同样支持这样的智能转换
                 

                class Student {
    fun hello() = println("Hello World")
}
fun main() {
    val student: Student? = Student()
    student?.hello()
    if (student != null) {
        student.hello() //根据语境将student从Student?智能转换为Student
    }
}

                 

                在处理可空类型时,为了防止出现异常,我们可以使用更加安全的as?运算符
                 

                open class Student
class ArtStudent: Student()
fun main() {
    val student: Student? = null
    student as? ArtStudent //当student为null时,不会抛出异常,而是返回null
}

                 

                类的扩展
                 

                Kotlin提供了扩展类或接口的操作来为其添加额外的函数或属性,无需通过类继承或者使用装饰器等设计模式
                 

                比如我们想为String类型添加一个自定义操作
                 

                fun String.test() = "hello world"
fun main() {
    val str = ""
    println(str.test())
}

                 

                Kotlin-类和对象
                注意,类的扩展是静态的,实际上并不会修改原本的类,也不会将新成员插入到类中,仅仅是将我们定义的功能变得可调用,像真的有一样。同时,在编译时也会明确具体调用的扩展函数:
                 

                open class Shape
class Rectangle : Shape()
fun Shape.getName() = "Shape"
fun Rectangle.getName() = "Rectangle"
fun printShape(shape: Shape) {
    println(shape.getName())
}
fun printRectangle(rectangle: Rectangle) {
    println(rectangle.getName())
}
fun main() {
    printShape(Rectangle())
    printRectangle(Rectangle())
}

                 

                Kotlin-类和对象
                 

                如果类本身就具有同名同参的函数,那么扩展函数将失效:
                 

                class Test {
    fun hello() = println("你干嘛")
}
fun Test.hello() = println("哎呦")
fun main() {
    Test().hello()
}

                 

                Kotlin-类和对象
                不过,重载是没问题的
                 

                class Test {
    fun hello() = println("你干嘛")
}
fun Test.hello(str: String) = println(str)
fun main() {
    Test().hello("哎呦")
}

                 

                Kotlin-类和对象
                同样的,类的属性也是可以通过这种形式来扩展的,但是有一些小小的要求
                Kotlin-类和对象
                可以看到直接扩展属性是不允许的,扩展并不是真的往类中添加属性。因此, 扩展属性本质上也不会真的插入一个成员字段到类的定义中,这就导致并没有变量去存储我们的数据, 我们只能明确定义get和set来创建扩展属性
                 

                class Test 
val Test.name
    get() = "666"
fun main() {
    println(Test().name)
}

                 

                Kotlin-类和对象
                 

                由于扩展属性并没有存储真正的变量,而是使用get和set函数,所以,像field这样的后备字段就无法使用了
                 

                还有需要注意的是,我们定义的扩展属性,同样受到访问权限控制
                 

                Kotlin-类和对象
                除了直接在顶层定义类的扩展外,我们也可以在类中定义其他类的扩展,并且在定义时可以直接使用其他类提供的属性
                 

                class A {
    val name = "张三"
}
class B {
    //像这种扩展,由于是在类中定义,因此也仅限于类内部使用
    fun A.test() = println(this.name)
    fun test() = A().test()
}
fun main() = B().test()

                 

                Kotlin-类和对象
                在函数名发生冲突的时候,需要特别处理
                 

                class A {
    fun hello() = println("Hello A")
}
class B {
    //像这种扩展,由于是在类中定义,因此也仅限于类内部使用
    fun A.test() {
        hello() //优先匹配被扩展类里的函数
        this.hello()
        this@B.hello()
    }
    fun hello() = println("Hello B")
    fun test() = A().test()
}
fun main() = B().test()

                 

                Kotlin-类和对象
                定义在类中的扩展也可以跟随类的继承结构,进行重写
                 

                open class A {
    open fun A.test() = "AAA"
    fun hello() = println(test())
}
class B:A() {
    override fun A.test() = "BBB" //对父类定义的扩展函数进行重写
}
fun main() {
    A().hello()
    B().hello()
}

                 

                Kotlin-类和对象
                 

                我们可以在某个函数里面编写扩展,但作用域仅限于当前函数
                 

                fun main() {
    fun String.print() = println("此剑斩穹,不破不休")
    "".print()
}

                 

                还可以将一个扩展函数作为参数给到一个函数类型变量
                 

                fun main() {
	// func就是扩展函数名
    val func: String.(Int) -> String = { it.toString() + this }
    println("出击!".func(123))
    //如果是直接调用,那就必须传入对应类型的对象作为首个参数,此时this就指向我们传入的参数
    println(func("撤退!", 321)) 
}

                 

                Kotlin-类和对象
免责声明：我们致力于保护作者版权，注重分享，被刊用文章因无法核实真实出处，未能及时与作者取得联系，或有版权异议的，请联系管理员，我们会立即处理! 部分文章是来自自研大数据AI进行生成,内容摘自(百度百科,百度知道,头条百科,中国民法典,刑法,牛津词典,新华词典,汉语词典,国家院校,科普平台)等数据,内容仅供学习参考,不准确地方联系删除处理! 图片声明：本站部分配图来自人工智能系统AI生成,觅知网授权图片,PxHere摄影无版权图库和百度，360，搜狗等多加搜索引擎自动关键词搜索配图，如有侵权的图片，请第一时间联系我们。

相关阅读

目录[+]

取消
微信二维码
微信二维码
支付宝二维码