Kotlin-arv (med eksempler)

I denne artikel lærer du om arv. Mere specifikt, hvad er arv, og hvordan man implementerer det i Kotlin (ved hjælp af eksempler).

Arv er et af nøglefunktionerne i objektorienteret programmering. Det giver brugeren mulighed for at oprette en ny klasse (afledt klasse) fra en eksisterende klasse (basisklasse).

Den afledte klasse arver alle funktionerne fra basisklassen og kan have sine egne yderligere funktioner.

Inden du går i detaljer om Kotlin-arv, anbefaler vi dig at kontrollere disse to artikler:

  • Kotlin klasse og objekter
  • Kotlin Primary Constructor

Hvorfor arv?

Antag, at du i din ansøgning vil have tre karakterer - en matematiklærer , en fodboldspiller og en forretningsmand .

Da alle tegn er personer, kan de gå og tale. De har dog også nogle specielle færdigheder. En matematiklærer kan undervise i matematik , en fodboldspiller kan spille fodbold og en forretningsmand kan drive en virksomhed .

Du kan individuelt oprette tre klasser, der kan gå, tale og udføre deres specielle færdigheder.

I hver af klasser kopierede du den samme kode til gang og snak for hvert tegn.

Hvis du vil tilføje en ny funktion - spis, skal du implementere den samme kode for hvert tegn. Dette kan let blive udsat for fejl (ved kopiering) og duplikatkoder.

Det ville være meget lettere, hvis vi havde en Personklasse med grundlæggende funktioner som snak, gå, spise, sove og tilføje specielle færdigheder til disse funktioner i henhold til vores tegn. Dette gøres ved hjælp af arv.

Ved hjælp af arv, nu behøver du ikke implementere den samme kode til walk(), talk()og eat()for hver klasse. Du skal bare arve dem.

Så for MathTeacher(afledt klasse) arver du alle funktionerne i en Person(basisklasse) og tilføjer en ny funktion teachMath(). Ligeledes for Footballerklassen arver du alle funktionerne i Personklassen og tilføjer en ny funktion playFootball()og så videre.

Dette gør din kode renere, forståelig og udvidelig.

Det er vigtigt at huske: Når man arbejder med arv, skal hver afledte klasse opfylde betingelsen om det "er en" basisklasse eller ej. I eksemplet ovenfor MathTeacher er a Person , Footballer er a Person . Du kan ikke have noget som, Businessman er en Business .

Kotlin arv

Lad os prøve at implementere ovenstående diskussion i kode:

 åben klasse Person (alder: Int) (// kode til at spise, tale, gå) klasse MathTeacher (alder: Int): Person (alder) (// andre funktioner i matematiklærer) klasse Fodboldspiller (alder: Int): Person ( alder) (// andre funktioner i fodboldspiller) klasse Forretningsmand (alder: Int): Person (alder) (// andre funktioner i forretningsmand)

Her, Personer en base klasse, og klasserne MathTeacher, Footballerog Businessmaner afledt af Person klassen.

Bemærk, nøgleordet openfør basen klassen, Person. Det er vigtigt.

Som standard er klasser i Kotlin endelige. Hvis du er fortrolig med Java, ved du, at en endelig klasse ikke kan underklasseres. Ved at bruge den åbne kommentar på en klasse giver kompilator dig mulighed for at udlede nye klasser fra den.

Eksempel: Kotlin-arv

 open class Person(age: Int, name: String) ( init ( println("My name is $name.") println("My age is $age") ) ) class MathTeacher(age: Int, name: String): Person(age, name) ( fun teachMaths() ( println("I teach in primary school.") ) ) class Footballer(age: Int, name: String): Person(age, name) ( fun playFootball() ( println("I play for LA Galaxy.") ) ) fun main(args: Array) ( val t1 = MathTeacher(25, "Jack") t1.teachMaths() println() val f1 = Footballer(29, "Christiano") f1.playFootball() )

Når du kører programmet, vil output være:

Jeg hedder Jack. Min alder er 25 år, jeg underviser i folkeskolen. Mit navn er Cristiano. Min alder er 29 Jeg spiller for LA Galaxy.

Her er to klasser MathTeacherog Footballerafledt af Personklassen.

Den primære konstruktør i Personklassen erklærede to egenskaber: alder og navn, og den har en initialiseringsblok. Initiliseringsblokken (og medlemsfunktionerne) i baseklassen Personkan tilgås af objekterne fra afledte klasser ( MathTeacherog Footballer).

Afledt klasser MathTeacherog Footballerhar deres egne medlem funktioner teachMaths()og playFootball()hhv. Disse funktioner er kun tilgængelige fra objekterne i deres respektive klasse.

Når objektet t1 af MathTeacherklasse oprettes,

 val t1 = MathTeacher (25, "Jack")

The parameters are passed to the primary constructor. In Kotlin, init block is called when the object is created. Since, MathTeacher is derived from Person class, it looks for initializer block in the base class (Person) and executes it. If the MathTeacher had init block, the compiler would have also executed the init block of the derived class.

Next, the teachMaths() function for object t1 is called using t1.teachMaths() statement.

The program works similarly when object f1 of Footballer class is created. It executes the init block of the base class. Then, the playFootball() method of Footballer class is called using statement f1.playFootball().

Important Notes: Kotlin Inheritance

  • If the class has a primary constructor, the base must be initialized using the parameters of the primary constructor. In the above program, both derived classes have two parameters age and name, and both these parameters are initialized in primary constructor in the base class.
    Here's another example: 
     open class Person(age: Int, name: String) ( // some code ) class Footballer(age: Int, name: String, club: String): Person(age, name) ( init ( println("Football player $name of age $age and plays for $club.") ) fun playFootball() ( println("I am playing football.") ) ) fun main(args: Array) ( val f1 = Footballer(29, "Cristiano", "LA Galaxy") )
    Here the primary constructor of the derived class has 3 parameters, and the base class has 2 parameters. Note that, both parameters of the base class are initialized.
  • In case of no primary constructor, each base class has to initialize the base (using super keyword), or delegate to another constructor which does that. For example, 
     fun main(args: Array) ( val p1 = AuthLog("Bad Password") ) open class Log ( var data: String = "" var numberOfData = 0 constructor(_data: String) ( ) constructor(_data: String, _numberOfData: Int) ( data = _data numberOfData = _numberOfData println("$data: $numberOfData times") ) ) class AuthLog: Log ( constructor(_data: String): this("From AuthLog -> + $_data", 10) ( ) constructor(_data: String, _numberOfData: Int): super(_data, _numberOfData) ( ) )
    To learn more on how this program works, visit Kotlin Secondary Constructor.

Overriding Member Functions and Properties

If the base class and the derived class contains a member function (or property) with the same name, you can need to override the member function of the derived class using override keyword, and use open keyword for the member function of the base class.

Example: Overriding Member Function

 // Empty primary constructor open class Person() ( open fun displayAge(age: Int) ( println("My age is $age.") ) ) class Girl: Person() ( override fun displayAge(age: Int) ( println("My fake age is $(age - 5).") ) ) fun main(args: Array) ( val girl = Girl() girl.displayAge(31) )

When you run the program, the output will be:

 My fake age is 26.

Here, girl.displayAge(31) calls the displayAge() method of the derived class Girl.

You can override property of the base class in similar way.

Visit how Kotlin getters and setters work in Kotlin before you check the example below.

 // Empty primary constructor open class Person() ( open var age: Int = 0 get() = field set(value) ( field = value ) ) class Girl: Person() ( override var age: Int = 0 get() = field set(value) ( field = value - 5 ) ) fun main(args: Array) ( val girl = Girl() girl.age = 31 println("My fake age is $(girl.age).") )

When you run the program, the output will be:

 My fake age is 26.

As you can see, we have used override and open keywords for age property in derived class and base class respectively.

Calling Members of Base Class from Derived Class

Du kan kalde baseklassens funktioner (og få adgang til egenskaber) fra en afledt klasse ved hjælp af supernøgleord. Sådan gør du:

 open class Person() ( open fun displayAge(age: Int) ( println("My actual age is $age.") ) ) class Girl: Person() ( override fun displayAge(age: Int) ( // calling function of base class super.displayAge(age) println("My fake age is $(age - 5).") ) ) fun main(args: Array) ( val girl = Girl() girl.displayAge(31) )

Når du kører programmet, vil output være:

 Min alder er 31. Min falske alder er 26.

Interessante artikler...