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
}
-
1. Geographical Information Systems in the World Wide Web Era
4
-
2. Basic technology of WebGIS
4
-
3. Geographic Web Services
5
-
4. aggregation of geographical information
4
-
5. mobile GIS
5
-
6. Geographic information portal
3
-
7. New generation national spatial data infrastructure and GIS
4
-
8. Application of WebGIS in E-Commerce
3
-
9. Application of WebGIS in E-government
3
-
10. Hotspots and frontiers of WebGIS
2
-
1. Angularjs2
8
-
1. SVG tutorial
19
-
1. Memcached
20
-
1. C# tutorial
61
-
1. Sqlite
47
-
2. Go
43
-
2. Docker
59
-
2. Vue3
19
-
2. Servlet
21
-
3. React
23
-
3. SOAP tutorial
10
-
3. Android
18
-
3. Mongodb
44
-
3. Kotlin
18
-
4. Lua
31
-
4. MySQL tutorial
34
-
4. Appml
12
-
5. Perl
45
-
5. Postgresql
41
-
web
15
-
5. Web Services tutorial
6
-
6. Ruby
41
-
6. Design-pattern
35
-
7. Django
18
-
7. Rust
22
-
6. WSDL tutorial
8
-
8. Foundation
39
-
9. Ios
43
-
8. Css3
26
-
9. Swift
43
-
11. HTML tutorial-(HTML5 Standard)
54
-
12. Http
6
-
13. Regex
6
-
14. Regexp
7
Principles, Technologies, and Methods of Geographic Information Systems
102
In recent years, Geographic Information Systems (GIS) have undergone rapid development in both theoretical and practical dimensions. GIS has been widely applied for modeling and decision-making support across various fields such as urban management, regional planning, and environmental remediation, establishing geographic information as a vital component of the information era. The introduction of the “Digital Earth” concept has further accelerated the advancement of GIS, which serves as its technical foundation. Concurrently, scholars have been dedicated to theoretical research in areas like spatial cognition, spatial data uncertainty, and the formalization of spatial relationships. This reflects the dual nature of GIS as both an applied technology and an academic discipline, with the two aspects forming a mutually reinforcing cycle of progress.
-
1. Introduction to Geographic Information Systems
6
-
2. From the Real World to the Bit World
3
-
3. Spatial Data Model
7
-
4. Spatial Reference Systems and Map Projections
5
-
5. Data in GIS
4
-
6. Spatial data acquisition
2
-
7. Spatial Data Management
6
-
8. Spatial analysis
8
-
9. Digital Terrain Model (DTM) and Terrain Analysis
5
-
10. Spatial modeling and spatial decision support
6
-
11. Spatial data representation and map making
6
-
12. 3S Integration Technology
5
-
13. Network Geographic Information System
4
-
14. Examples of Geographic Information System Application
8
-
15. Organization and Management of Geographic Information System Application Projects
10
-
16. Geographic Information system Software Engineering Technology
7
-
17. Geographic Information System Standards
3
-
18. Geographic Information System and Society
3
-
19. Earth Information Science and Digital Earth
4