首先，我们需要定义一个 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.")
}
}
