首先，我们需要定义一个 Person 类：

open class Person {
    var name = ""
    var age = 0

    fun eat() {
        println("$name is eating.")
    }
}

注意，Person 类前面加上了 open 关键字，表示这个类可以被继承。在 Kotlin 中，默认情况下类是不可继承的，必须显式地声明为 open。

定义 Student 类

接下来，我们定义 Student 类并让它继承 Person 类：

class Student : Person() {
    var sno = ""
    var grade = 0
}

这里使用冒号 : 来表示继承关系，并且在 Person() 后面加上括号。这表示 Student 类的主构造函数在初始化时会调用 Person 类的无参数构造函数。

构造函数

Kotlin 的构造函数分为两种：主构造函数和次构造函数。这里只讲解主构造函数

主构造函数

主构造函数是最常用的构造函数，直接定义在类名后面。例如：

class Student(val sno: String, val grade: Int) : Person() {
}

在这个例子中，sno 和 grade 是通过主构造函数传入的参数，并且被声明为 val，这样它们就成为了 Student 类的属性。

初始化逻辑

如果需要在主构造函数中编写一些初始化逻辑，可以使用 init 块：

class Student(val sno: String, val grade: Int) : Person() {
    init {
        println("sno is $sno")
        println("grade is $grade")
    }
}

调用父类构造函数

当父类有带参数的构造函数时，子类的主构造函数必须通过括号传递这些参数。例如，修改 Person 类使其带有 name 和 age 参数：

open class Person(val name: String, val age: Int) {
    var name = name
    var age = age

    fun eat() {
        println("$name is eating.")
    }
}

相应的，Student 类需要修改如下：

class Student(val sno: String, val grade: Int, name: String, age: Int) : Person(name, age) {
}

这里我们在 Student 类的主构造函数中添加了 name 和 age 参数，并将它们传递给 Person 类的构造函数。

---

接口

接口

在面向对象编程中，接口是实现多态编程的重要组成部分。Java 是单继承语言，但可以实现多个接口。Kotlin 中的接口与 Java 非常相似，但也有一些细微差别。接下来，我们将通过具体代码学习如何在 Kotlin 中使用接口。

定义接口

首先，我们创建一个名为 fly 的接口，选择类型为“Interface”。

interface fly() { 
   println("cat can fly")
}

在接口中定义的函数不需要有具体的实现，只是声明了需要实现的行为。

实现接口

open class animal{
    val name:String="小花";
    var age:Int=0;
}
class cat: animal(),catfly{
    override fun fly(){
     println("猫会飞")
    }
}
interface catfly {
    fun fly(){
        println("cat can fly")
    }
}

在 Kotlin 中，继承父类和实现接口都使用冒号 :，多个接口之间用逗号 , 分隔。

默认实现

Kotlin 允许对接口中的函数提供默认实现。这与 Java 8 引入的默认方法类似。

interface abc { 
    fun num() { 
        println("abc") 
    } 
}

现在，如果某个类实现了 abc 接口但没有重写 num 函数，将自动使用默认实现。

---

函数的可见性修饰符

在面向对象编程中，控制函数和属性的可见性非常重要。Java 和 Kotlin 都提供了多种可见性修饰符，但它们之间有一些差异。接下来，我们将详细对比这两种语言中的可见性修饰符。

常见的可见性修饰符

修饰符	Java	Kotlin
public	所有类可见（默认）	所有类可见（默认）
private	当前类可见	当前类可见
protected	当前类、子类、同一包路径下的类可见	当前类、子类可见
default	同一包路径下的类可见（默认）	无
internal	无	同一模块中的类可见

详细说明

• public: 表示该函数或属性对所有类都可见。在 Kotlin 中，默认情况下所有函数和属性都是 public。
• private: 表示该函数或属性只对当前类内部可见。与其他语言一致。
• protected: 在 Java 中，表示该函数或属性对当前类、子类和同一包路径下的类可见。而在 Kotlin 中，protected 仅对当前类和子类可见。
• default (Java): 表示该函数或属性在同一包路径下的类可见。这是 Java 中的一种默认可见性，但在 Kotlin 中不存在。
• internal (Kotlin): 表示该函数或属性在同一模块中的类可见。这对于模块化开发非常有用，可以隐藏一些内部实现细节。

示例

下面是一些具体的代码示例，展示如何在 Kotlin 中使用不同的可见性修饰符。

Public

public class MyClass {
    public fun myPublicFunction() {
        println("public.")
    }
}

Private

class MyClass {
    private fun myPrivateFunction() {
        println("private.")
    }
}

Protected

open class ParentClass {
    protected fun myProtectedFunction() {
        println("This function is protected.")
    }
}

class ChildClass : ParentClass() {
    fun accessProtectedFunction() {
        myProtectedFunction()
    }
}

Internal

internal class MyInternalClass {
    internal fun myInternalFunction() {
        println("internal.")
    }
}

---