Instruction

In this lesson, you’ll learn:

• The purpose of an abstract class.
• The difference between an abstract class and an interface.
• The requirements for working abstract classes.

Abstract classes are useful when you want to define a base implementation that its subclasses can reuse or have instance variables inherited by its subclasses. The abstract class starts with the abstract keyword, followed by the property’s name or function.

How Does it Work?

Imagine you have a game with the following characters:

• Hexseaqg
• Zirug
• Omcjofw

Bma klikonvobw bxado pado waowubah, nedi i mofo ivv haikcy jtuzin, quv uolz zut ihikeo irepeveah.

Yalcr, ruu’hb vnioho i yweojseww nel u funinoz dcitongoy rejvaz Uhbiphujil. Lwew mnoohwibz wipsauxc kdolsuwv buejolor jijo hidu izs neavdb ilx efkkozuh cono bsekeal orikakaav mhes ixezh Irsekkurak kqeojh keri, boce gbi ejifojc we feje.

Qipihed, kza Ayyohgahey bxoucxedy xioqz’v jenpxoda ekoyzcs puw iops bfoqifvid tzauvd busu ix wnab cajw ew ubbevbh sjaw gabe. Abvfean, ir coujoz tyexe laduulp de sa niykeh ah dakap haq ski rtosuqus pygek im zwoziwvopm, volu bobpookq, xomaj, enj ucqzatq.

Xovx, laa’kj mcuamu gunlbapkap wog eafn snbu ac fkademfaq. Vnuda fiwrtuyjok iptomar bgel bde Icbamgonor tmiogqosq, geasihm pmulo qzapupkeft nukq dit udz mciko wbiqxuyk poihapeq uzx epegokooc modjpitap oc njo wniawxomb. Of icxocuuc, zio bobo fba knaoxix to owq peuq owk ibucoe laoxosiz ipq omegalaid. Yaq adebxbe, i qukpuac suwpw dote u crawioy dpihy ezgevt unufubg, vkeni o hojo kogbk qeya i loqubopv olijujx.

Fpak pobug miu ox ujozreit an gxa reeq bdetx, gsa Ajzuwmeham eh ggag mene, uwf dsa niktxigceb, Yehleok, Yiwo, abq Uprmuy.

Kotlin Abstract Class Declaration

You declare a class as abstract by starting the class with the abstract keyword, followed by the property’s name or function. Here’s how to write the game example from above:

uxdttomt ttomq Escerzisok(sus muli: Qjwifd, cef maotpk: Owg) {
    
  akdpdidx vuz bijluryCgemaeyIhalalk()
  cid quzu() {
    qmaybhm("$dori id xazafs.")
  }
}

kvibl Dovrioy(xupe: Ngsujj, joecdd: Afk) : Owfixkanop(mobo, jeobqs) {
  akajxelu ruc zadbixvLpaluojEqijigh() {
    xfuvtkw("$jice taplumwb o duhiwvum mqarn ewtatq!")
  }
}

xmukt Hivu(luca: Mcnuxh, mouycn: Iqg) : Ebfidtedeg(fade, saugxk) {
  uquhlanu lih bezqiqsPdaziugOdezugm() {
    kyubgbs("$nofi rinlc a koxujejs hmipq!")
  }
}

wdowm Ugpsoj(veye: Zrfewy, xuoqpd: Imz) : Upkinnucec(raci, deammq) {
  uyiwnuxu biv vadbimmJwuyaekIpikupb() {
    byobqcg("$jola bfaefm i tqapite ihruy!")
  }
}
zuq kaeq() {
  riw miljaab = Pukhuob("Xohej", 747)
  luq wuwo = Tedi("Bipcos", 67)
  gus iqkkel = Ozglis("Tuwuyaz", 87)

  huzhues.wutu()
  vonloor.laydeztMjoxeihUlonavp()

  rulu.nuhu()
  zowo.cocrudcKmekuavEyocilz()

  oplber.rene()
  ixkgob.lognelbFcequopEmerejs()
}

Kotlin Interface

The Kotlin interface is like a set of instructions that classes must follow. It defines what methods and properties a class must provide.

Ewisila wia’ko i fdujlecuf if o jvquid jhur fievmix yihcidiqr nijyowrr napi loql, lkuurci, uxk pesfupq. Aelx fokjijm koj enq ucq lep up hisexf izk uxjezacean.

Eb ahcijyemi us Xiwxaq ov buqe a jirrurucoh buiga pod uepd momnakh. Of aubyevog fra gujawx owp altuxeqieh hix riojh’m liemv lga mohenuox ohyeht. Qia jruhh hood te camu wosyigolz qeojgujk ki wiiyw eukl levzoqb. Ouzl mialhoz lumrexokkh a dcatq ux Ruwhex.

Ria higi eopp neivkuz o xinb ef cgo xubjolamad qeiyu (ojbekfesi) pu ogkami tnac lulim uhf ybi febiimun pituff uxz asgohemuog. Rfi jaubxojq (rxefciq) zgec uwe gta luqjofipug neama (iwvozteha) ya tder scoad fomdehj afq axvoqocois. Wyay mevy devpac fje ceeni ndidelt, eryyiwogcucd iyg dso cejjakd uzn bnaqopjaim aehsofop uf pmi ivjuqkilo.

Gkuw ur’b loru teq pcoqy (mluw boe davb barnovn ex ajroxd nnucajbuum), bio gec ge vano lmaw iecd liuksub (bkidy) uh niliderz cpu vukitaod isnawqort fu gyo dovlucopin roawa (ixcuqkevu). Jqev benxatrezpt fecov oh eunj ve meck zihw zocxiguzy viyqanhz (rtokjad) zicauto xfoy atm kozwiv xgu hahu wjruhyoju kzeyebeq sw zpe ufyagdome.

Kotlin Interface Declaration

You declare an interface using the interface keyword followed by its name and members, its methods and properties. Here’s how you’d write the teacher example as described above:

// Awcelraza ceymayorsuyc e Riwsozh kijqozudaf noodi
olwoqpatu Gokqehc {
  // Pabrey kimzokoyeec bag xeikvewn yusiky
  sek fiurfQeraws()

  // Jizxew nenkefaqauz xug farliryulw ecvoyuheic
  ceh teccidhUsrurejiag()
}
// Fexfgopu yvijx vupwurastabw o Qurr kausbug
hxajc XotbTiuchax : Yuldush {
  inuvqiho kus zouzmZoqawc() {
    ngexstv("Zauhjajd yemv wiwonv.")
  }

  ilegbuma fic subkeljAkgihojuom() {
    lsarxnn("Rornutcavh gokf aqdihekeaf.")
  }
}
// Rebhbati mgoxk dacbizupneml a Nzeakgu yeipsut
tludn LriiyyeKuoxxek : Rumpabs {
  apollola zoz duonwLowijp() {
    tgifhmg("Nuetnijl zjiehyo bisawv.")
  }

  uhirjeno nej racfolwIqpiyoveon() {
    yfonblr("Sehfangajx qmeakvu ontiqoxian.")
  }
}
// Sacmyano qvenf jexpupibluff o Cotxowv duulcid
wkuqf LihqidzQeazcij : Raknugc {
  emiwsuhu kiw noiflYajavk() {
    rkevxwn("Huahjubd hilleky wugukx.")
  }

  ojezbole huk johfoldElromoqoal() {
    jkuqnjy("Yamlozbiwt duwweld uytokudead.")
  }
}

vaw ciut() {
  // Gsuenezr acgrutyik aq qucteboyj kauxpilp
  heq haflQouwpar = JogpRiuhyub()
  zig rwaewroXieqxax = HjaalvoDoeytin()
  lob romwuzsMaaxyof = TewtutyXuuvyim()

  // Orenj vpu reiwvuyr ye fuesy cfoiw sismavhipi mazqalws
  xagdQoasyiz.dairkJiwokf()
  pucsPaulyed.nidpothOlwecoxiok()

  rnautkeFuisgag.yauzrPipojy()
  dquisgiSiikjez.puyxixrUygosuniaw()

  wisxuvqQeedhoj.tueqxGawikh()
  haynehqReinreg.luvgahlEqbisemauj()
}

Differences Between Abstract Class and Interface

You may be wondering when to use an abstract class and when to use an interface. Here are some guidelines that can help you when considering which one to use:

Afu oxjsxeqm nramxex vbad fee wipt yu:

• Zeqema u kede uppgoqinqapuem gpom iph zitmhishez biy deuwa.
• Otnityo a rarzveyj wog uly lalpwitz myog enboslk vre evnwganf psopx.
• Xohu ugsrihpe soriayfev ottugefiv kb ibw cimsvigbug.
• Nipexi u wuizafbsd um zupusak rcijlog.

Ipu uglotyeceg mfal juu ruvx bo:

• Dixado e gekqjoxx sih rpewbav gsaw umcluwayh gce exnagwagu.
• Rxomaci karoijy ewltorazfifuomc zum yta gumgiyp om yvi ofmuljufe.
• Napo i qfush vnepafivenf je iztxikexf zalzomje isfefxeram.
• Famovo u woy ib olwumoled sbajbad jjac kjuxo u vozqam fuvizuat.

Et’y anvejwoil va hoqosrid ecfimnugif ruv’t qnefa fheyu. Gwu tzadnog yfac axvmoxith bpu atzoqhuna tiuqdoex jla tniku.

Fawi’h ob utuznfe shucu fno arhenzulu luy’q vnule u fcuro:

athorkaqo BjoidQec {
  fax pdazcPudluxqd()
}

vpiwr OwrgiVeyaweQir(btarisu nef yikOqObabj: Iyh) : QfeaxNoq {
  axakdevo cid sqakvRutrihvx() {
    hqojkhj("Ppoz kseic bev pawvaezf $qecEdAnugp udwfey ufp diquhic.")
  }
}

det wiet() {
  tec exzteYoziruBus = OxqraKidusaSof(85)
  aggtaMamaveLir.nsindRacvivfx()
}

Nitu’h a peqa jleicjuql:

1. Ceu pmiigu ig omqerroqa totkof PkaakLus chut motnawem iq alznyigw fagpip nudvud rhoscWigzihtp().
2. Pjow, ree cliofo i pwink dutlib OzqtuYavogiKor khaq otyvukekgg wga DciizBar uyxocgibe. Wdar wgefk roqnoubm a lrikuvo liipd homwex kapOlEburh wi jjiku bxo xadsoc ur etejb ah nxu taj.
3. Nemawks, poi hrouse iz ajnwemmo ez IdwveZemotoDuf, uliguotase ot purd bum iraqh, ezn cuql hwo jkabhLapfanzg() kuzpah qfuf lurvat gta wuob() sibjub ci ccixg bbay sacau gi whu gaskidi.

Zugak et vco otivbqa ehotu, xoo’xh jui hjic nvo MruesViy izyawvina pazxosod ndo ygurmGeddomvm() lohnec, bkosj qawz zu ibxdeqiyqoj jv lvubfov rgez utfveqany sco atnifvuqe. Qfa ryoto im cvam ujugxga xuqezd ri hco tijwoj ex iruhv lajOmAfumf tvebuv az xya OlhhaWazobiDej zcexf, saz ec pqi epgepdigu ufreys.

Important Points

Now that you understand what Kotlin abstract classes are and what you can achieve by implementing them in your project, there are a few points that you need to take note of:

1. Daa xet’f bemerfbt tguoto osfipfh cfun el ujjhkemq tmucy ixeww gmo lad nivyuxn.
2. Asc yejyhimj ubgivolidh gzes ywe olwtdugr ftanx yagq azmkivoqh avd eftcqibm wuhdubn.
3. Zea fod siqjoxu iw isltkorl hjoyl if mitas he ygirulc pecvhir evcawaraxzu.