Kotlin inheritance
Kotlin all classes in inherit the Any class, which is the superclass of all classes and the default superclass for classes that do nothave a supertype declaration
class Example // Implicit inheritance from Any
Three functions are provided by default of Any :
equals()
hashCode()
toString()
Note: Any is not java.lang.Object .
If a class is to be inherited, you can use the open keyword is modified.
open class Base(p: Int) // Defining a Base Class
class Derived(p: Int) : Base(p)
Constructor function
Subclass has main constructor
If the subclass has a primary constructor, the base class must be initialized immediately in the main constructor.
open class Person(var name : String, var age : Int){// Base class
}
class Student(name : String, age : Int, var no : String, var score : Int) : Person(name, age) {
}
// test
fun main(args: Array<String>) {
val s = Student("Runoob", 18, "S12346", 89)
println("Student name： ${s.name}")
println("Age： ${s.age}")
println("Student ID： ${s.no}")
println("Achievement： ${s.score}")
}
Output result:
Student name： Runoob
Age： 18
Student ID： S12346
Achievement： 89
Subclass does not have a main constructor
If the subclass does not have a primary constructor, it must be used in eachsecondary constructor super keyword initializes the base class, or proxies another constructor. When you initialize a base class, you can call different constructors of the base class.
class Student : Person {
constructor(ctx: Context) : super(ctx) {
}
constructor(ctx: Context, attrs: AttributeSet) : super(ctx,attrs) {
}
}
Example
/**User base class**/
open class Person(name:String){
/**Secondary constructor**/
constructor(name:String,age:Int):this(name){
//initialization
println("-------Base class secondary constructor---------")
}
}
/**Subclass inherits the Person class**/
class Student:Person{
/**Secondary constructor**/
constructor(name:String,age:Int,no:String,score:Int):super(name,age){
println("-------Inheritance class secondary constructor---------")
println("Student name： ${name}")
println("Age： ${age}")
println("Student ID： ${no}")
println("Achievement： ${score}")
}
}
fun main(args: Array<String>) {
var s = Student("Runoob", 18, "S12345", 89)
}
Output result:
-------Base class secondary constructor---------
-------Inheritance class secondary constructor---------
Student Name: Runoob
Age: 18
Student ID: S12345
Score: 89
Rewrite
In the base class, use the fun when a function is declared, this function defaults to final modified and cannot be overridden by subclasses. If subclasses are allowed to override the function, add it manually open modify it, using the subclass rewriting method override key words:
/**User base class**/
open class Person{
open fun study(){ // Allow subclass override
println("I have graduated")
}
}
/**Subclass inherits the Person class**/
class Student : Person() {
override fun study(){ // override method
println("I am studying in college")
}
}
fun main(args: Array<String>) {
val s = Student()
s.study();
}
The output is as follows:
I am studying in college
If there are multiple identical methods (inherited or implemented from otherclasses, such as classes A, B), you must override the method, using the super paradigm to selectively invoke the implementation of the parent class.
open class A {
open fun f () { print("A") }
fun a() { print("a") }
}
interface B {
fun f() { print("B") } //The default member variable of
the interface is open
fun b() { print("b") }
}
class C() : A() , B{
override fun f() {
super<A>.f()//call A.f()
super<B>.f()//call B.f()
}
}
fun main(args: Array<String>) {
val c = C()
c.f();
}
C inherits from a() or b() C can not only inherit functions from A or B, but also C can inherit A() 、 B() functions we have incommon. At this point, there is only one implementation of the function in,and in order to disambiguate, the function must call the A() and B() and provide your own implementation.
The output is as follows:
AB
Attribute rewriting
Property override use override keyword, the property must have a compatible type, and each declared property can be initialized through the initialization program or getter method is overridden:
open class Foo {
open val x: Int get { …… }
}
class Bar1 : Foo() {
override val x: Int = ……
}
You can use one. var property to override a val property, but not the other way around. Because val property itself defines the getter method, rewritten as var property declares an additional onein the derived class setter method
You can use it in the main constructor override keyword as part of the property declaration:
interface Foo {
val count: Int
}
class Bar1(override val count: Int) : Foo
class Bar2 : Foo {
override var count: Int = 0
}