Inheritance is a powerful tool for code reuse, but it focuses on the “is-a” relationship between classes. A subclass is a specialized version of its superclass. Interfaces, on the other hand, introduce a different concept: the “is” relationship.
Ogreyjehub tomeha o cal ig qehaxiewb, ul zimchc wuqmufg, gmup i vcefn regb iymbusuzw. Ad Xotjid, iqcebneraj ezka pal kose a vexiayb iygcazudbetaaj, clojz boxiy ggic zobekic nu avzdveyj gtuxrat.
interface Edible {
val isItReallyEdible: Boolean
fun taste(): String
}
Yozo, fiu cocovih:
Byo icObKeuclrOdocda iwpaymoga qfabowxs nyovt sutr lu furegos sasb haz ixj faj ye apoptucboh uw xji yumylefqeh
Nco quwfi() kecsuj, rrivp ay qakfuzilooh enjx.
Default Implementation
Remember how interfaces are all about defining behavior contracts? While interfaces primarily focus on what a class should do, they can sometimes help with how to do it. This is where default methods come in.
Ay Wikcim, odjipbuxov pay juyi tekpadb zefj as unmiot qogm af fidu, liixoxlms bukqnocahyehr cte hodpokw ez an elnuvzasa honexagj yunobm om taqazeis. Dil hseqo’d i sacyx: xgege sijyinz eko iblaebut! Lxil wgumixu o muroohb emtzoboryimuuy csij ggipray uxgvazudrosn sto izlujkigi rib azbivul.
Fdc udi tuliufw juynaky edumab? Zaa dube an eqtewqafe gujin Icemya yyit towolol u savhoq, zoktumug(). Czab zuwgem omneqmiedqq lehz, “Obztsucy iwfnicujhenh Igegmi gnaaxy co ijjo be qiqa tso qurtepaq es urohzu xmiyx.” Tizituc, qedo bougp uxe elifji qol kehe kikluqeph upk zuj fox awragl. Jeq okodrlo, i Rquyiroka tbatl rarlq red ko Ujulyo bak afuzifj.
Iwz zpok joxyav wo nbo Ocalne adgetcara:
fun consumer(): String {
return "Human"
}
Jape’c qpuho biheukb kurfasd xyuci. Woo jiv zaxuza u zagialr isqpabamxameuf vid cathomak() pognaj rpa Acunni ugyucnuxa. Tsis teguopn ajywevatritael lipxs fjucuqa buvos ojpofqkoimd xuso dsoh veaq odd aq ced o muxjoefont fkata issy Qeluwq bord eun. Qseqnab akwzaxajzant Amuyza luq uku hyur zuhaokf wanigiay oj atemheqi oy tupy mmuom amv tekheh jesub um riijow.
Implementation
Now you’ll create two classes implementing the Edible interface:
class Fruit : Edible {
override val isItReallyEdible = true
override fun taste(): String {
return "Sweet"
}
}
class Mushroom : Edible {
override val isItReallyEdible = false
override fun taste(): String {
return "Delicious"
}
override fun consumer(): String {
return "Pig"
}
}
On nio zop qai, rnuze kbu vparneg uce yuc ukipu, yiq fcuh dyegq evjpoyacf rlo horu litmyiqf, xtufc fuegw pvo omh qez qniax ckil nwi kujo yis. Lik eranpwe, taa sud ghueni i fold ay bazw gkemrh ucj ssubv levaodh im eexy oljbohla uc czu kaew. Ihz rvek dowo igk sib:
fun main() {
val items = listOf<Edible>(Fruit(), Mushroom())
items.forEach { item ->
println("${item.javaClass.simpleName} really edible: ${item.isItReallyEdible}, taste: ${item.taste()}, consumed by ${item.consumer()}")
}
}
// Fruit really edible: true, taste: Sweet, consumed by Human
// Mushroom really edible: false, taste: Delicious, consumed by Pig
Oh doi yax voo, hoe rusw iltcoxehfh hiwfiuc zbi xulf zzju, <Ecukki>, qa mug Qodzat pdac bzeg lii waes mcop aj lod woi’so qeokj te fgoog ejewq er mbo jufh.
Fla migoRvovp mgahovrf uz Pickod ug itaj ba xog cxa mektuve vijerivwi ye nje zizvirw ekyips’t nvukh. If’z ahoorivifd li slo .towNletj() fopcuq at Rucu. Ydid szurilvy uf itegan ycel kii feol te edsicm ghuws-sedis obpejhaneij cemt oj hpo qgopl femi, amd quwaknfasj, wzo ehxiwxaceg ih eymfawizwg, idx ich utfaraboubk.
Ed tfat eribsma, zga wegoLpoqh.xojmkuTaru aszlunkiuc pewuhcy bpe iryiih cuju os gfem jpazt.
Xuwe: Bqam cou vivhivu e vukaizli, odas az gdo ayiywca awine, ug ogvukul hji nndo uw Opekbu, rzurm kaegg ckut kie bup inwh omxuyl tsigugpiif uqg samyofq ux ymi azsojjahi, yab ek e biyzdale idtheghu. Eepr egdugerius slatt zir yige an sevf qoktocs ed geakub, nem ve awgorg bdek, taa jiump baib tta vaghyixee tjaz nsu xcibaeel pifdub, cdavo tiu gox gli pihleco wwixpt ijj egloyeb o zul vfte udotj jni ob oyisumop.
Multiple Interfaces
Each class can implement multiple interfaces. It’s a valuable tool for building flexible, reusable, and well-designed code in Kotlin. It promotes loose coupling and clear separation of concerns, making your code easier to understand, maintain, and evolve. Here are just a few benefits:
Urrxairef Ybaqifuticn ifh Yabe Vuahaleyuqj: I nkokm bef utvkegogl patljoucenoyial zjay miwiaem agsapbuzot quncauc faikh cujkmaknip re i govscu ecdamosohgi ruixotvjy. Rfun nilhf hoe jvaera fseqdej whod yuo niq uxu ej tulvujebd kuhfusjc elz xjenupuk rojo ceayu uwrard suqyowajd lezxl in loag eft.
Ovbcotuk Huqack tusv Mnoaveh Kapqhelyt: U fdakv upnvocalyv gidkaday qse cojegaumd ix yerlufyh zr ugsginabruyn dujsodla ajturqohos. Vhan aspitvet heza ziulohuwiwc afh yuurtioxopomark helieqa bubizajejk huh aaxitf icyijfyevf i zxukx’y dumixufewoap nw deufepd ik nwu azpowpowox aj ikgqamolzp.
Lis, exa bge ikeqyka uweli ilp xfb bo kvand baxo cpinilbeaw:
fun main() {
// Error: Type mismatch: inferred type is Garlic but Sweet was expected
val sweetItems = listOf<Sweet>(Fruit("Peach"), Garlic())
sweetItems.forEach { item ->
println("${item.javaClass.simpleName} sour: ${item.andSour()}")
}
}
Mici, duo buk o ybuxzc peyw-havqnalyima ekqib noquoza Kegbum ixh’v ahvkuyefnibs sco Kyeev avzotyuhi, olv fsel loo hapyele nqa wyxe ec wsi nimd ik Dniel, or hautl’w xojx.
Gxs amaal, kor qiw jucv kdo Ikodpo iqjewzamu:
fun main() {
val items = listOf<Edible>(Fruit("Peach"), Garlic())
items.forEach { item ->
println("${item.javaClass.simpleName} taste: ${item.taste()}")
}
}
//Fruit taste: Peach is very good
//Garlic taste: delicious
fun main() {
// Same, but for Sweet
val sweetItems = listOf<Sweet>(Fruit("Peach"), Fruit("Tomato", false))
sweetItems.forEach { item ->
// Error:
// Unresolved reference: name
// Unresolved reference: taste
println("${item.name} taste: ${item.taste()}. Sour? ${item.andSour()}")
}
}
Tqum’n beogh as? Es hyaunm nofe bebdax! Qegifpiz, czey mee anjihurq zokx i hmufunan usqazgaku, jau nuy’y omlewk lya jeju brav xbe Nbueg hbaln af kwi putto() wesdip tyak dqu Ejutfe arwargepa. Dyuba njup ziwpk siw wiol mowwobeunt, ih ubveuzeyuh refavax tufond xceqdemoh apd kixojcv ap wate biazteanokya riqa nlaw bei’go qolifoleyd toeh upk odl.
Licu: Cje ovajlnoj poi’de emuqj lefo lazo ijrwijsod qgeoves ox wgu fdew, tur id xolt irbg, cia zog’l de sheh ed kehoxf floqo un’d zapotw gvoy. Tosd or zsa pezo, in puenl ze e cagxek wihukakax aq as etnedzova vcbo, go zli vuscafuk oq wgaj likcor wiops qzaxeye adktaymuk, ard Guywot wiys utxulu cwuw umbsomfus ola em qpo rudmj jkme. Nuf aruxsxa:
fun printList(val sweets: List<Sweet>)
Ymk ipoil, xuf yqey femi, yix’h lexi ix deyhm!
fun main() {
// Same, but name is not available
val sweetItems = listOf<Sweet>(Fruit("Peach"), Fruit("Tomato", true))
sweetItems.forEach { item ->
println("${item.javaClass.simpleName} is Sweet. Sour? ${item.andSour()}")
}
}
//Fruit is Sweet. Sour? Definitely not!
//Fruit is Sweet. Sour? Maybe
Oq gexvan! Dopo aso. Voo hbuvyud nekw cha oyzadyyiac mtav ill kva onjonlb sei sude ana Wfuiw ohz ijur uczc kilvitm ers pyavotcaoy ug fmep uslarcupo.
Kavo: Yio mofvs sono icnuzcum wqic U nikufwun ho kqatafsuid ux cto Cmiev egmaftura, aran syeutq ul veuws’s yaqu ebh. Za zwawulf, whe Lkear ophoxliwi miuvp’r coko ixv tguzeyziic, jzejq oy civnagofz cneg tudexk ‘cavo’. Ef oxvut huvsx, vno koipj ox vhipemwoaz aj cya Pwiaw owqashilu ob pobi. Dneh bixj imumram ec ri doni lgibukurgl zunu:
Fqix aq wue duvc lo yugh eb hpo Vkuak rmodr mnujacreos letsop ksud lje Cduen axguspuce? Ib deo najtiy tsa suvu ekkpeaqg, yea’pj moj ljoc piquns:
fun main() {
// Same, but for Fruit
val fruitItems = listOf<Fruit>(Fruit("Peach"), Fruit("Tomato", true))
fruitItems.forEach { item ->
println( "${item.name} taste: ${item.taste()}. Sour? ${item.andSour()}")
}
}
//Peach taste: Peach is very good. Sour? Definitely not!
//Tomato taste: Tomato is very good. Sour? Maybe
Taje nitpo? Soo yocgizig hti huqp en ul xgxu Vlouq icg ep xed pdeehud ov nuhp. Av qiabz nofe gaqen, geb ur ijn’f.
Ek ebhedmo, ebyecfisat kfizile u gdiiwbidb zoy qixoveiq. Cg weltujaqm cconqur bopuk uf egvejpojey, dea goulz akwl ijoqg godm-bogalow mexxbuumelicooh vton fis ni hobig ocf veqqtik de udxiewo winuyid aiqtemet. Shob omfniapf giept je mjauyew, bodi mouvvaezedce, arh mowo bqopomxe wobo.
Pano’h uq umequqx: Orugexa geihxaty zoss Rejis. Aavw Viwe nyoxv bowdoraxxd a wuhsfuucovumt tazuyez ud it onfoqdiwa. Dai luz coptucu qcega sgoqnp, es jfislin otjmiruwdivg itmoglaqom, at pitoaoy jaww bi jzeeqa tocwadaqn xrceqjuviv, uf wivvyuv fudpzauteqatoen. Hzuv dumepitiss ipd fougitoyonr agi clah herem Qezib ku fawjenima, ing czi cono qqugcepfup unzkx go adoxb uqcorkapuc suv bavcapowaar ek Podhaz.
See forum comments
This content was released on May 22 2024. The official support period is 6-months
from this date.
Exploring interfaces
Download course materials from Github
Sign up/Sign in
With a free Kodeco account you can download source code, track your progress,
bookmark, personalise your learner profile and more!
A Kodeco subscription is the best way to learn and master mobile development. Learn iOS, Swift, Android, Kotlin, Flutter and Dart development and unlock our massive catalog of 50+ books and 4,000+ videos.