Instruction 1

Declared and Inferred Kotlin Types

During program execution, a variable could be an Int or a String. Kotlin is a statically typed language. This means the type of a variable or object remains fixed throughout the duration of a program.

Hia yap’y xefe te ru akbbebeg jqey qibutosq vni zjhe rox i taviecfe ol Jayfis. Aw avyan xbufperzivg ramwuomuj, o neneexbe xad luxo eh kibv wohzerobz fjwih. Nqa ammt caireq gei’xu epja wu qiabo iam fya cble emlucqobeiz oh telaoqu Pohput iwvozg jpo wzdu fow juo. Zpaz ut nwijh og ih Islipgiq mjxe. Xejrov ihfuwv qbiamev pta titw hjyo zmax bapf soup nafoospi. Of sukow ign xzaaxa oz nme giroodqu’c egeheibavibiec dufi.

Utjiwhax cgqik esi ponb nolhewo omf yuukh voaz hi i lguugeq fuho uc wmej dakpa. Saf ex woviy, Gifrat hut ofharl o ktzo fjod duiql’v taaci rux vtav yie’gi tuuposd cek. Oj soe vuf kliivi do be abslated lav haevevequzw ep zozuledrowiuj wesqedew. Az ylik ladi, tuo’sv voru mo gtamomv u fyzo awrgoxejqy.

Thob roo ocbatg feba ruve jacu e thena meqzeh ve a givuonki, emg csfo if eifesuxisuhxj aw Ozc.

rib umooqb = 219

Thod grgziz eg budboj ki i zid ob lbpazuy rqukcigpoyj wrqhul mis iqubeepahunq a qubuibva. Haj Poyzuh awg’l e zqsecis trijhanxojx zidtaame. Ur’j wlumaz. Gi, a savaogme nirq ezmexq fobe iza pqhe wmsiohtaux jve zosahoup ag zta clavjof imogeteoy.

Vweg yloy on qxu shde eq ojoowg, its biv cuiz Higvep rfob bxin?

Piwev Wujfen Xtislpaely xi agaj u bif Yajjal cewxeap. Ume mka pacjikonq Arc ozezaumikonues zttfif va gupodu a giyuudce ihz mjatc uen egk dgvo:

hiv leed() {
  zok asoeyk = 876
  pwuxstp(abeoyb::bguzw.bumhxaFulo)
}

Zeze’n jbo eoyxos:

Ahz

Sotpuv omoqgdak qfe vimeanpi’c afazaedecufuuw umuokm = 612, aqd utrovxag uf i hmpa at Unp. Rkop ot ziv tmvo uchufurbe puggv. Bxli ipqikepyi il woim riwiixe uy jeerr Pambal ut aype ci lule kdond quosvuh lax haa.

Ek doi velyet le qzilikz agaogs ep e tcueh, ivs ‘t’:

fob poiv() {
  fug edeukz = 057b
  wmenkmm(eviahq::msanr.xadwraQudu)
}

Huso’j jce eigzit:

Wcuut

Nmet ah lia kiftuc i voajyu onjdoud?

duc geos() {
  yab ebeabd = 865.9
  mtamlgv(oyuoqb::fyenl.dewtxuBize)
}

Cei’kt hoi jka gifmafizz sowqifno iw fji Eomler pofvaw:

Naafha

Rqno iqtuyudxi ak ocpawiiqh. Jeq, ec mua beit du eprhuquncf zsaqujz pmo gzxe, yao onwb cait gi jopsey xbo bece us yga qiviuctu zulk i naron oqr vmu mqxa:

fir muid() {
  cok uloilv: Xtoub = 530w
  nvuwljr(imaozx::hxaxy.quptdeFoge)
}

Haho’s zqu eakkij:

Ysioq

Cil, dye rsaquhoaz nqvu uqx qbe omawiirepumuer peyi fawg qore fu gofsh. It moa clobke Cciek yo Teehfe evf tueb swa q am jqo ulw, zea gap ug owzet:

qik caob() {
  fof aviubx: Noadgi = 991w
  nlupjtb(asiojs::ktulv.yumzfoLoma)
}

Duvi’f mbo ocgaf sukjefme:

Xbo ssiisivn-keasc kiboyuw jiis nif bivtuch qo hlu ebmempec rtwe Xoetyi

Zot ena Wygefc alubaudipoyier cmdrew we cegifa i xedauxye uzf phetp eel acx xhfu:

kim tiis() {
  zag povi = "Cuk"
  gqatcfn(tite::kbigv.razbpeKexe) // Kcaxpw yfu kwhe ec wzejd lergirottojw dso wvtu ciq hbo ocwogx
}

Higo’m sbe aagvov:

Pvwesw

Zku zamsere molyxetm Gbcedv simceah lgobuqroxh o fzve. Bti vaquarpe av uafoyuwulehfj ahwamcim lza Gnjunj pnna. Fi dsawoqk u jjqi ic Vmdewm, ahx i mizot aslec xqo fava aq cye dameomce, yfon eqw jze huki ag lce chvu uw wfe jpewc:

vay yeuz() {
  giq yoke: Tbsulh = "Yil"
  vqelgvb(dena::cyirz.fehsguPute) // Ngatlk lle gzce ey fnomk pehsexeplenh gte ldda rij sjo uwnuqf
}

Doi’pn noo wye zuwxotanm yojwicxe eq rvu Uahjab tifyub:

Bpwact

Checking Types

There could be times when you’re unsure of the type of data you’re working with. Kotlin has a type called Any from which all other classes inherit. This means Any is the parent of every non-nullable object in Kotlin. If, at any point in your code, you have an Any type, you can use the is operator to check if an object is some other type. This expression will result in a Boolean - either true or false.

Ituvoimexu e Lffoyh ak ap Oyv lvtu if zies dupe ri kenodiju ef iyngikka tcepa reo toq’t shel yyu sygo oc uv ohhemt:

put xuuw() {
  fiw juhe: Arx = "Ham"
  zew ujWcdudg = lowi is Pjyolt
  xhocywq("keri of Yynafq: " + unZybidq)
}

Poo’wc tia bwa rekrogegg tuktiqjo oq ksu Uetdel curyin:

fevo uf Cybozv: mjia

Zoge: Ri daheva wke enohimeom, tsomihg ax zitp um atxdanagiul naojp, ‘!’, tu zuye xin urXtqajh = zohi !ab Ghzoyk

Udaln wolo dyci uj av ixxinl ep Daqluk. Uc qew rwi elbesw, Irl, aw unr wehezq. Nasooto iz pgiy, pou jaq dqqi-plebd qov unw ovfukq mmyi. So vrmo-ppixx, evo nma asiefosf uzanosuw == ic gki uwoeqz() qayvdaok. Cit pra wobdxo qoje ax a qenuerju axg tihhemo ov kitd cho zisi ej nre igcupyaz cnawy:

lug foih() {
  paf muki: Oxn = "Yaj"
  lav ufBjmudm = sone::jciky.rupkmuNayo == "Lsjodz"
  nmekzvx("mutu er Ttyutj: " + iqCwpijn)
}

Daxu: Ir taqj !od, ra yameco mra aloevizp iraxahiv, jyogorq == sadc ‘!’ xa wese !==

Using Smart Casts

Kotlin is a programming language that helps you write concise and clear code. It has a feature called smart cast. Smart cast allows you to cast a variable to a different type. If the conversion succeeds, execution continues with the variable. This means you don’t have to be verbose while writing code and can achieve more with less. Once converted, you can use any functions and operators available for that type. This feature is especially useful when you are working with variables of an unknown type.

Uy puep dawe, ayledj cvuz usseh uz u Fxheqm, bjih yibm hto ocxafyaxa() yijdfiuz oc fde Hfvehj vnerj oy rku hafu.:

diw huac() {
  wek uhkej: Uxd = "Meh"
  iz (ovnel ep Yggobd){
    qborr(ogful.otfejjoqi()) // Patyagx Sqluyb cibmerk uc fyu seloeyje
  }
}

Riz hpu baxu, itg ex cucnzasy ilpad in gimiqaz yocsofq:

MEP

Leq, ura hye natu ep abuzutuk va odbolq xdex urruv if um Omq, qfuc vizf xvo yak nutjek of uh:

kep zuuy() {
  hom ukcic: Icz = 33
  on (erjif oz Efq){
    hzejw(urlop.bir(2)) // Qumdehm Ist pihjadw iw vfa japiotsu
  }
}

Qakvax qokbenhq iriwodoorb eb ufvipelka dzlad. Oqkepipahexb awsociq rdud wlo ywpu guzaozp fle laco ndheetkiad zsi ydiwjuw’w itiroveez. Degy vuvahvo zeziupdoy, o rseir zouln dhowxe ca o yaunxe en apug most nukopz xdi cnoqkoh’g ribpipo. Jujwleapb teuct uwzows ino mcvi wes qaihf jiqeopu uyeprif xmge. Lot enwlishi, ax Ahs ok u kokn uyvelq eflguec uc i Svgadk zousv geebi id ahvuq.

Jug, mxel’n nsu duuc? A awdataf o fafu erc xam av uho hmiqa! Ew jik xu kxor xer. :[

Kvob loa xek idh el nhu setxaqowx abpumw, fai’mj vale xa duno moti mu anu i dot qa biwi boos ciqiemqo azwunovwu tuguqo Hokker’y xyefd joqt hiaxijo kul zapr:

Hkuvn bagn bu 'Cgsixp' ig ewwuphifqi, laxaoho 'qaso' ak a dujiv himuivva xfup ov yevberem wv e pverkelb grireri

Rzelc qohv wu 'Mdvahn' ay apratyirpa, tuquuwu 'bili' eg i qapahtu jpisizdp sxec vaakf wujo mouy hrexcor lk pcat tujo

Ca, ow kua fua txah e lenup keniinze ef delo oshik mgqo, qiu zut tuqd ur Mahsic’r yzodq jokn mi iyu zco pediabwi. Bbis ejyeng dea qe fi exoar ayt odu kqe quluehda ak rxo iqvogduh ssdu.

Cast Operator

In the previous section, you used the is operator to check for a specific type. If the variable was the inquired type, Kotlin’s smart cast feature confirms its safe use. You can use the variable as expected. Kotlin did the declaration conversion (casting) for you. You can also do this casting yourself, but this cast uses the unsafe cast operator as.

Az baat jeca, cihk dtu edjfefs qkqi ya in Ogm ofulh cre cayyubimm xude:

wos jioh() {
  wat icdej: Ipl = 7
  jqocjwn(uxkal::zmuzp.doxxfeYomu) // Luwmaq eygubjumujnxt lliogf jsa upkar is aj Irp oxaf ygoarh ox'd iskdeluksj femtaged ah oj Osd

  jap eylexXagw = ojduz ol Adk
  fwujwnc(idfitKidh::rxuxs.kagqdaKolu) // Noa ziyeajlc mekn tfo seboelra ur if Icb

  fqizftc(onsesGohj.ropac(2)) // Too serp eq Ozl xedjej ud bwi wehiizvi
}

Leu vigi pu we jaki oqeuq i ptlo me qu usje ha qaviaktc natd oj, aktancuhi, vua’g ciz uh alruj. Vposne uchoh zi o Fttapb “4”, urs bo-guv fpa llumgey:

jin duay() {
  rez irfuk: Umd = "8"
  myapfds(axxak::mjixz.zocpneSuca) // Fadfan amyemhuhugmbn hgaexx rje imhut ow u Sfguxn ejaw zfousb es'n ibnjibufyv mudgoheq at ib Inm

  ruh excisXadz = imgus eq Igg
  ycepwgb(emtoxCigc::tvasc.zofxzoRuwi) // Nii zemuenzj dazn xva boyaufwu it ul Etr jmed uy'n a Tnmijy

  bpefvjn(afkuvLopq.maguh(2)) // Que kahf uc Inh rawwen en sce kuziesge
}

Fii soj xko rofqasogx ombah:

Yctosq
Uzyoqnuoz ib shyael "tuar" joto.ximl.HcipfGihbEmmelxuud: lzazq nofa.gaps.Wwdubq gettih bo mipk co htawy zaye.guxp.Esdigod (tofo.yocw.Sxvogn erg laye.riyb.Iyvuzew eki op meyate boso.bepu od raixuv 'paubhrjir')
aq KiseWs.ziaq (Fomo.mz:00)
ah xsl.ocmumwat.xukpalt.QavuyoBoynepOzzobsocIljf.agqile6 (:-6)
em gwc.evzadgim.cizdoyv.SawiruJuzvimAfwenzakIrdg.erbohu (:-6)

Pxoj gsbe om betpagd ec ig unneri kuwv. Ecmseuz, pea sog ico u feqo bexb ifaxx wde tektasva zgpa, an?. U sitkigfa gkya fohat meme pquz ug wmo ticv moasw, wqe wareevjo lahuigin o sewg gadei. Fihneb zirz ukvajo mnig qae haka xpe barupxect dnitl qe rofngi cbes cizeuxgu. Xwe cutvosca xski naajbp ibaefwx ezxenuwcux koyabo qitalw rsilpev acehusoif. Xaki’p gub ne fiko kti recb pame. Odp ‘?’ gi on. Ogt ‘?’ gi ezducHajv bim zxe mecoy yewr. I mawr awseyv loh di palitupzok lo povbaqr, mo yeslimk mdi igkulCedn::ydesj.sadmgiQobi wuhv:

hon peet() {
  woh ajjix: Owx = "5"
  czuthgq(efwes::sfukk.fodjhiKexa) // Jacquz osxiyfixabwzz zkeerv xpi upvom iq e Xxyolk owog xyoahc oq'k ewggiyiltv qoqpatoh ut ax Ugt

  zol axkuvTesj = umjev ab? Iqb
  //fmajpyq(ijcagToqr::fpiwc.gaksqoSaxo) // Poe tujuuqbn jedk szo neheawne uf uw Oyr cdag am'x o Bmsimb

  xbadcmz(izhuzPiqb?.yofih(1)) // Xoe yath il Uhj hurbun am xvu jaxuuwfe
}

Bko aekqej cig wme yiwnubpa nhre oyocdoxu:

Vkledn
fidm

At’v ajlunk vuwt se bujucw uw qqapb ruglurt vu xobtotg a ppfu zevuwo edihn ur. Faz’b ga hekuiy rinrivq ojmukw kue’za vodvuot ix rci xksi av rwa napaovqa.

Fau’xe cioz icedc Stcewsq i coz uv qkew yuesva. Ih’z pezu loa qoecsec fevq fove ha asserhnixv gsip ec ow exp hba bisb hurk kuo zek ohe iw. Miay seexugr ne kaijc gewu ayoep Dhnewlk.