Android学习(五)-Kotlin编程语言-面向对象中的 继承-构造函数-接口三模块学习
首先,我们需要定义一个 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.")
}
}