Kotlin introductory notes (V) classes and objects, inheritance, constructors

Preface : This tutorial is best done with JAVA Study on the basis of

One 、 Classes and objects

         use class Keyword to declare a class , And java identical .

eg.

(1) Define a Person class ：

class Person {
    var name = ""
    var age = 0

    fun eat() {
        println(name + " is eating. He is " + age + " years old.")
    }
}

(2) Instantiation Person This class ：

val p = Person()

        kotlin Give up java Of new keyword . The reason for doing this , Because you call the constructor of a class , Your intention can only be to initialize this class .

(3)main Function ：

fun main() {
    val p = Person()
    p.name = "Jack"
    p.age = 19
    p.eat()
}

Run a screenshot ：

Two 、 Inherit

I have to mention that kotlin Several characteristics of ：

Kotlin Characteristics of ：

        Kotlin By default, all non abstract classes cannot be inherited

eg:

Now I define a Student class , Want it to inherit just Person class

class Student {
    var sno = ""
    var grade = 0
}

  Just now Person Class cannot be inherited , You need to add open keyword , As shown in the figure below ：

open class Person {
    var name = ""
    var age = 0

    fun eat() {
        println(name + " is eating. He is " + age + " years old.")
    }
}

Combined with the open The keyword is followed by the compiler ,Person This class is designed specifically for inheritance . such Person Class is allowed to be inherited .

And then let Student Class can inherit Person class , as follows ：

class Student : Person() {
    var sno = ""
    var grade = 0
}

Kotlin Of Inherited keywords are also heavy extends Change into :  , This is for those who have learned C# My friends are more familiar . But why is there a pair of parentheses after the inherited class ？ Because it involves Java Provisions for inherited characteristics , The constructor of the subclass must call the constructor of the parent class , This rule is in Kotlin We should also abide by . It will be explained later   Primary constructor   and   The secondary constructor   了 .

3、 ... and 、 Constructors

(1) Primary constructor

         Each class will have a main constructor without parameters by default （ Same as java Constructor for ）. Of course, you can also display the declaration parameters . But notice , The primary constructor has no body ！

class Student(val sno : String , val grade : Int) : Person() {
}

Instantiation ：

val student = Student("a123",5)

But , The primary constructor has no body , How to implement some logic ？

Kotlin It provides us with a init Structure , All the logic in the main constructor can be written in it ：

class Student (val sno : String , val grade : Int) : Person() {
    init {
        println("sno is " + sno)
        println("grade is " + grade)
    }
}

(2) The secondary constructor

Kotlin Regulations ,

1. Any class has only one primary constructor , But there can be many times constructors .
2. The secondary constructor can instantiate a class , But it has a function body .
3. When a class already has   Primary constructor   And then there is   The secondary constructor , All secondary constructors must call the primary constructor （ Including indirect calls ）.

eg.

Learn from the above ,Person The class of can also be written like this ：

open class Person(val name : String , val age : Int) {
    fun eat() {
        println(name + " is eating. He is " + age + " years old.")
    }
}

So we let Student class To inherit Person class

class Student (val sno : String , val grade : Int , name : String , age : Int) : Person(name , age) {
    constructor(name : String ,age : Int) : this("",0,name,age) {
        
    }
    constructor() : this("" , 0) {
        
    }
}

The secondary constructor is by constructor  Keywords to define , Here we define two secondary constructors ： The first secondary constructor receives name and age Parameters of ; The second constructor does not accept any parameters , It passes through this  Called our first constructor , And will name and age Initial value of Fu . Because of the second one The secondary constructor Indirectly call the first The secondary constructor  , So it is still legal .

So now we have three ways to be right Student initialization :

val student1 = Student()
val student2 = Student("Tom",15)
val student3 = Student("a123",5,"Jack",18)

A special case ：

There are only secondary constructors in a class , There is no primary constructor . This is a rare case , But in Kotlin Is allowed . When a class does not explicitly define a primary constructor and defines a secondary constructor , It just doesn't have a primary constructor .

class Student : Person {
    constructor(name : String , age : Int) : super(name,age){
    }
}

First ,Student There is no definition shown after the class Primary constructor , At the same time, because of the definition The secondary constructor , So now Student There is no primary constructor . So since there is no primary constructor , Inherit Person Class, there is no need to add brackets . Because there is no primary constructor , The secondary constructor can only call the constructor of the parent class , Call the parent constructor and Java identical , Use super keyword . No more talk here .

If you like this series , You might as well pay attention ！ Thank you for watching ！

Reference resources :

        《 First line of code Android ( The third edition )》   --- Guo Lin