3.11. Kotlin inheritance

发布时间 ： 2025-10-25 13:34:28 UTC      

Page Views: 10 views

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)

3.11.1. 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) { 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 
 
 
 
  
 
  3.11.2.  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 
 
 
 
 
 
  3.11.3.  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 } 
 
 
 
  
                
                

                    

                        

                            
                                文章链接
                            
                            ：
                            3.11. Kotlin inheritance 
                        

                    

                

            
        
        

            

    
        
        

            

                

                    
                        
                            
                                Web框架 
                            
                            
                        
                             946
                        
                    
                    
                    
                        

                            
 
 
 

                        

                    
                

                
                

            

        
    
    
        
        

            

                

                    
                        
                            
                                《地理信息系统原理、技术与方法》 
                            
                            
                        
                             97
                        
                    
                    
                    
                        

                            
 
 
 最近几年来，地理信息系统无论是在理论上还是应用上都处在一个飞速发展的阶段。 GIS被应用于多个领域的建模和决策支持，如城市管理、区划、环境整治等等，地理信息成为信息时代重要的组成部分之一； “数字地球”概念的提出，更进一步推动了作为其技术支撑的GIS的发展。 与此同时，一些学者致力于相关的理论研究，如空间感知、空间数据误差、空间关系的形式化等等。 这恰好说明了地理信息系统作为应用技术和学科的两个方面，并且这两个方面构成了相互促进的发展过程。 
 
 

                        

                    
                

                
                

            

        
    
    
        
        

            

                

                    
                        
                            
                                WEB基础 
                            
                            
                        
                             289