În acest articol, veți afla despre moștenire. Mai precis, ce este moștenirea și cum să o implementăm în Kotlin (cu ajutorul exemplelor).
Moștenirea este una dintre caracteristicile cheie ale programării orientate pe obiecte. Permite utilizatorului să creeze o nouă clasă (clasă derivată) dintr-o clasă existentă (clasă de bază).
Clasa derivată moștenește toate caracteristicile din clasa de bază și poate avea caracteristici suplimentare proprii.
Înainte de a intra în detalii despre moștenirea Kotlin, vă recomandăm să verificați aceste două articole:
- Clasa și obiecte Kotlin
- Kotlin Constructor primar
De ce moștenire?
Să presupunem că, în aplicația dvs., doriți trei personaje - un profesor de matematică , un fotbalist și un om de afaceri .
Deoarece, toate personajele sunt persoane, pot merge și vorbi. Cu toate acestea, au și unele abilități speciale. Un profesor de matematică poate preda matematică , un fotbalist poate juca fotbal și un om de afaceri poate conduce o afacere .
Puteți crea individual trei clase care pot merge, vorbi și își pot îndeplini abilitățile speciale.
În fiecare dintre clase, ați copia același cod pentru mers și vorbi pentru fiecare personaj.
Dacă doriți să adăugați o caracteristică nouă - mâncați, trebuie să implementați același cod pentru fiecare caracter. Acest lucru poate deveni cu ușurință predispus la erori (la copiere) și coduri duplicat.
Ar fi mult mai ușor dacă am avea o Personclasă cu caracteristici de bază, cum ar fi să vorbim, să mergem, să mâncăm, să dormim și să adăugăm abilități speciale acelor caracteristici conform personajelor noastre. Acest lucru se face folosind moștenirea.
Folosind moștenire, acum nu implementați același cod pentru walk(), talk()și eat()pentru fiecare clasă. Trebuie doar să le moștenești .
Deci, pentru MathTeacher(clasa derivată), veți moșteni toate caracteristicile unei Person(clase de bază) și adăugați o nouă caracteristică teachMath(). La fel, pentru Footballerclasă, moștenești toate caracteristicile Personclasei și adaugi o caracteristică nouă playFootball()și așa mai departe.
Astfel, codul dvs. este mai curat, ușor de înțeles și extins.
Este important să ne amintim: Când lucrați cu moștenirea, fiecare clasă derivată ar trebui să îndeplinească condiția dacă este „ sau nu ” o clasă de bază. În exemplul de mai sus, MathTeacher este a Person , Footballer este a Person . Nu poți avea ceva de genul, Businessman este un Business .
Moștenirea Kotlin
Să încercăm să implementăm discuția de mai sus în cod:
clasă deschisă Persoană (vârstă: Int) (// cod pentru a mânca, vorbi, plimbare) clasă MathTeacher (vârstă: Int): persoană (vârstă) (// alte caracteristici ale profesorului de matematică) clasă Fotbalist (vârstă: Int): persoană ( varsta) (// alte caracteristici ale fotbalistului) clasa Om de afaceri (varsta: Int): Persoana (varsta) (// alte caracteristici ale omului de afaceri)
Aici, Personeste o clasă de bază, și clase MathTeacher, Footballerși Businessmansunt derivate din clasa Person.
Observați, cuvântul cheie opendinaintea clasei de bază Person,. Este important.
În mod implicit, clasele din Kotlin sunt finale. Dacă sunteți familiarizat cu Java, știți că o clasă finală nu poate fi subclasată. Prin utilizarea adnotării deschise pe o clasă, compilatorul vă permite să obțineți clase noi din aceasta.
Exemplu: Moștenirea Kotlin
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() )
Când rulați programul, ieșirea va fi:
Numele meu este Jack. Vârsta mea este de 25 de ani Predau în școala primară. Numele meu este Cristiano. Vârsta mea este de 29 de ani. Cânt la LA Galaxy.
Aici, două clase MathTeacherși Footballersunt derivate din Personclasă.
Constructorul principal al Personclasei a declarat două proprietăți: vârstă și nume și are un bloc de inițializare. Blocul inițializatorului (și funcțiile de membru) ale clasei de bază Personpot fi accesate de obiectele claselor derivate ( MathTeacherși Footballer).
Clase derivate MathTeacherși Footballerau propriile funcții de membru teachMaths()și playFootball()respectiv. Aceste funcții sunt accesibile numai din obiectele clasei lor respective.
Când MathTeacherse creează obiectul t1 al clasei,
val t1 = MathTeacher (25, "Jack")
Parametrii sunt trecuți către constructorul primar. În Kotlin, initblocul este apelat atunci când obiectul este creat. Deoarece, MathTeachereste derivat din Personclasă, caută blocul inițializatorului în clasa de bază (Persoană) și îl execută. Dacă MathTeacherar avea blocul inițial, compilatorul ar fi executat și blocul inițial din clasa derivată.
Apoi, teachMaths()funcția pentru obiect t1este numită folosind t1.teachMaths()instrucțiune.
Programul funcționează în mod similar , atunci când obiectul f1de Footballereste creat de clasă. Execută blocul init al clasei de bază. Apoi, playFootball()metoda Footballerclasei se numește folosind instrucțiune f1.playFootball().
Note importante: Moștenirea Kotlin
- Dacă clasa are un constructor primar, baza trebuie inițializată utilizând parametrii constructorului primar. În programul de mai sus, ambele clase derivate au doi parametri
ageșiname, și ambii parametri sunt inițializați în constructorul primar din clasa de bază.
Iată un alt exemplu:
Aici constructorul principal al clasei derivate are 3 parametri, iar clasa de bază are 2 parametri. Rețineți că ambii parametri ai clasei de bază sunt inițializați.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") ) - În cazul în care nu există un constructor primar, fiecare clasă de bază trebuie să inițializeze baza (folosind super cuvânt cheie) sau să delege altui constructor care face asta. De exemplu,
Pentru a afla mai multe despre cum funcționează acest program, vizitați Kotlin Secondary Constructor.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) ( ) )
Anularea funcțiilor și proprietăților membrilor
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
Puteți apela funcții (și proprietăți de acces) ale clasei de bază dintr-o clasă derivată folosind supercuvânt cheie. Iată cum:
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) )
Când rulați programul, ieșirea va fi:
Vârsta mea este de 31. Vârsta mea falsă este de 26 de ani.
