Kotlin-类和对象

最新推荐文章于 2023-07-06 17:46:50 发布

原创最新推荐文章于 2023-07-06 17:46:50 发布 · 218 阅读

1 ·

CC 4.0 BY-SA版权

Kotlin 专栏收录该内容

6 篇文章

订阅专栏

本文介绍了Kotlin中的类定义、对象创建、构造函数、成员变量与方法、伴生对象等概念，并详细讲解了类的继承、抽象类、接口及其实现方式等内容。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一.类的定义

class Panda : Animal() {
    init {

    }
}

1.Kotlin省略了public，因为它对外是开放的

2.用:代替了extends

3.Kolin进行继承，父类使用了()

4.用init函数当作构造函数

二.对象的创立

        val panda = Panda();

不需要添加new关键字

三.构造函数

class Panda constructor(name:String,age:Int) : Animal() {
    init {
        println("the panda's name is $name")
    }

    constructor(name: String, age: Int, weight: Int) : this(name, age){
        println("the panda's name is $name age is $age weigh is $weight")
    }
    
}

类后面的构造函数叫主构造函数，下面的函数叫二级构造函数，要添加二级构造函数，必须实现主构造函数。

为了让函数没有从属关系，可以都写成二级构造函数

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

    constructor(name: String, age: Int, weight: Int) : this(name, age) {
        println("the panda's name is $name age is $age weigh is $weight")
    }

}

构造函数区别于Java构造函数，有一点很明显是构造函数可以加默认参数,要让Java语言调用，需要在关键字constructor加入@JvmOverloads

class Panda {
    @JvmOverloads constructor(name: String, age: Int, weight:Int = 100) {
        println("the panda's name is $name age is $age weigh is $weight")
    }
}

四.类的成员

1.成员变量

class Panda constructor(var name: String, val age: Int) {
    var period: String = ""

    init {
        period = if (age > 3) "old panda" else "young panda "
    }
}

构造方法中参数前面加上var/val，就可以直接建立对象的时候，直接访问其变量

val panda = Panda("panda", 12)
        val period = panda.period;
        val age = panda.age
        val name = panda.name

2.方法


    fun eatFood(botanyType: String, weight: Int): Boolean {
        ...
        return true;
    }

3.伴生对象

伴生对象实现类中static方法，companion object修饰为一个伴生对象，类方法和类变量都写在伴生对象里面

class Panda constructor(var name: String, val age: Int) {
    var period: String = ""

    init {
        period = if (age > 3) "old panda" else "young panda "
    }

    fun eatFood(botanyType: String, weight: Int): Boolean {
        return true;
    }
     companion object Animal{
        val SUCKLER = "哺乳动物"
        val  OVIPARA = "孪生动物"
        val  HUMAN = "人类"
        fun action(action: Int): String {
            when (action) {
                0-> SUCKLER
                1 -> OVIPARA
                else -> HUMAN
            }
            return HUMAN
        }
    }
}

通过Panda可直接访问伴生对象,一般直接省略伴生对象名

Panda.action(1);
Panda.Animal.action(0);
val suckler = Panda.SUCKLER;

五.类的继承

需要继承父类，父类需要open修饰，父类默认是不可继承的，包括方法需要被继承，也需要open来修饰

open class SucklerAnimal {
    constructor(name: String, age: Int) {}
     open fun show(){
         print("属于哺乳动物")
     }
}

class Panda constructor(var name: String, val age: Int): SucklerAnimal(name,age) {
    var period: String = ""

    init {
        period = if (age > 3) "old panda" else "young panda "
    }

    fun eatFood(botanyType: String, weight: Int): Boolean {
        return true;
    }
    companion object Animal{
        val SUCKLER = "哺乳动物"
        val  OVIPARA = "孪生动物"
        val  HUMAN = "人类"
        fun action(action: Int): String {
            when (action) {
                0-> SUCKLER
                1 -> OVIPARA
                else -> HUMAN
            }
            return HUMAN
        }
    }

    override fun show() {
        super.show();
    }

}

Kotin中权限修辞符有：

public 对所有人开发

internal 只对本模块内部提供

protected 对本身和子类提供

private 只对自己开放

六.抽象类

用abstract修辞类和方法


 abstract class SucklerAnimal {
    constructor(name: String, age: Int) {}
    abstract fun show()
}

七.接口

interface Behaveior {
    var behave: String //需要重写
    
    fun fly(): String //需要重写
    fun swim(): String
    fun run(): String

    fun action() {//可定义普遍方法
        print("${fly()}  ${swim()}  ${run()}")
    }
}

八.接口代理

首先实现接口

class PandaBehaveior : Behaveior {
    override var behave: String = ""

    override fun fly(): String {
       return  "Panda can't fly "
    }

    override fun swim(): String {
        return  "Panda can swim"
    }

    override fun run(): String {
        return  "Panda can run"
    }
}

通过关键字by来声明类使用代理类实现其接口

class Panda constructor(var name: String, val age: Int,behaveior: Behaveior): SucklerAnimal(name,age),Behaveior by  behaveior{

    override fun show() {
    }

}

调用

  val panda = Panda("panda", 12, PandaBehaveior())
        panda.fly()
        panda.swim()
        panda.run()

九.特殊类

1.嵌套类

class Car(var color: String){

    class Wheel(var weight: Int){
        fun show() {
            print("weight = $weight")
        }
    }
    
}

调用

        Car.Wheel(100).show()

无法引用外部类变量，嵌套类相当于静态内部类

2.内部类

嵌套类前加入inner关键字就是内部类了，可以访问外部变量

class Car(var color: String){

    inner class Wheel(var weight: Int){
        fun show() {
            print("weight = $weight  color = $color" )
        }
    }

}

调用

        Car("red").Wheel(100).show()

3.枚举类

enum class Season(val seasonName:String) {
    SPRING("春天"), SUMMER("夏天"), AUTUMN("秋天"), WINTER("冬天")
}

4.密封类

sealed class SeasonType {
    //嵌套类需要继承SeasonType形成密封类
    class Spring(var name:String):SeasonType()
    class Summer(var name:String):SeasonType()
    class Autumn(var name:String):SeasonType()
    class Winter(var name:String):SeasonType()
}

  val count:Int = 2;
 when (count) {
//覆盖了所有类型，所以不需要else
            0 -> SeasonType.Spring("春天")
            1 -> SeasonType.Summer("夏天")
            2 -> SeasonType.Autumn("秋天")
            3 -> SeasonType.Winter("冬天")
        }

5.数据类

用data修饰class类

data class User(val name:String,var age:Int,var weight:Int) {
}

调用

  val liMing = User("liming", 15, 100)
        print(liMing.toString())
        val liuChen = liMing.copy(name = "liuchen")
        print(liMing.equals(liuChen))

6.模版类

data class User<T>(val name: String, var age: Int, var weight: Int,var type:T) {
}