Nilalaman

• Kotlin vs Java, ang kalaunan ay nag-aalok ng mas malubhang code - na walang findViewByIds
• Ang Kotlin ay null ligtas nang default
• Mga pagpapaandar sa pagpapalawig
• Ang mga Coroutine ay mga mamamayan na first class
• Walang mga check eksepsyon
• Katutubong suporta para sa delegasyon
• Mga klase ng data
• Mga Smart cast
• Suporta para sa mga tagabuo
• Walang suporta para sa mga nagpapahiwatig na pagpapalawak ng mga conversion
• Mga aklatan sa pagproseso ng annotasyon kasama ang Kotlin
• Ang pagpapalit ng Java sa Java
• Pagputol

Ang Java ay maaaring pa rin ang unang wika ng programming na sumisimula sa isipan kapag iniisip mo ang tungkol sa Android, ngunit hindi ka mayroon upang magamit ang Java para sa pagbuo ng Android. Sa katunayan, si Kotlin ay ngayon ng Googleginustongopisyal na wika para sa Android!

Upang malaman ang higit pa tungkol sa Java makakuha ng isang libreng pagpapakilala sa kurso ng Java sa Gawing Android Apps.

Ngayon, ang mga barko sa Android Studio na may suporta sa Kotlin, kaya ang paglikha ng isang proyekto sa Android na nauunawaan ang code ng Kotlin ay mas madali tulad ng pagpili ng isang checkbox sa wizard ng paglikha ng proyekto ng Studio. Suporta ay lumago para sa pagpipilian masyadong obertaym, sa punto na ang desisyon na ito ay higit sa lahat ay mas gusto sa kagustuhan.

Ngunit kung gagawin mo ang paglipat mula sa Java patungong Kotlin, ano ang eksaktong nakukuha mo? Anong mga tampok ang mayroon kay Kotlin, na ang Java ay hindi, at kabaligtaran?

Sa artikulong ito, titingnan namin ang lahat ng mga pangunahing pagkakaiba sa pagitan ng Kotlin vs Java.

Kotlin vs Java, ang kalaunan ay nag-aalok ng mas malubhang code - na walang findViewByIds

Kung ihahambing mo ang isang klase ng Kotlin at isang klase sa Java na gumaganap ng parehong gawain, kung gayon ang klase ng Kotlin ay sa pangkalahatan ay magiging mas maikli, ngunit mayroong isang lugar sa partikular na kung saan maaaring seryosong mabawasan ni Kotlin ang dami ng code ng boilerplate na kailangan mong sumulat: hanapinViewByIds.

Pinapayagan ka ng Kotlin Android Extension na mag-import ng isang sanggunian sa isang View sa iyong Aktibidad na file, sa puntong maaari kang magtrabaho sa View na iyon na parang bahagi ito ng Aktibidad. Ang resulta? Hindi ka na kailangang sumulat ng isa pang paraan ng paghahanapViewById!

Bago mo magamit ang mga extension na ito, kailangan mong magdagdag ng isang dagdag na plugin sa iyong file na antas ng build.gradle ng module (mag-apply ng plugin: 'kotlin-android-extensions') ngunit pagkatapos mong handa nang simulan ang pag-import ng Mga Pananaw, para sa halimbawa kung ang iyong activity_main.xml file na naglalaman ng isang TextView kasama ang ID textView, pagkatapos ay idadagdag mo ang sumusunod sa iyong Aktibidad:

i-import ang kotlinx.android.synthetic.main.activity_main.textView

Maaari mong mai-access ang TextView na ito gamit ang ID lamang nito:

textView.setText ("Hello World")

Ito ay marami mas malambing kaysa sa katumbas ng Java:

TextView text = (TextView) findViewById (R.id.textView); text.setText ("Hello World");

Ang Kotlin ay null ligtas nang default

Ang NullPointerExceptions ay isang malaking mapagkukunan ng pagkabigo para sa mga developer ng Java. Pinapayagan ka ng Java na magtalaga ng null sa anumang variable, ngunit kung susubukan mong gumamit ng isang sanggunian sa object na may isang walang halaga na halaga, pagkatapos ay mapangahas ang iyong sarili upang makatagpo ng isang NullPointerException!

Basahin din: Kotiln para sa pagpapakilala sa Android

Sa Kotlin, ang lahat ng mga uri ay hindi maiiwasan (hindi maaaring hawakan ang isang null na halaga) bilang default. Kung susubukan mong italaga o ibalik ang iyong code sa Kotlin, pagkatapos ay mabibigo ito sa pag-compile-time, kaya't hindi alinman sa mga sumusunod na linya ang makakapagsama:

val name: String = null

masaya getName (): String = null

kung ikaw Talaga nais na magtalaga ng isang null na halaga sa isang variable sa Kotlin, pagkatapos ay kakailanganin mong malinaw na markahan ang variable na iyon bilang nullable, sa pamamagitan ng pagdaragdag ng isang marka ng tanong pagkatapos ng uri:

numero ng val: Int? = null

Ginagawa nitong halos imposible na makatagpo ang NullPointerExceptions sa Kotlin - sa katunayan, kung nakatagpo ka ng pagbubukod na ito, kung gayon ang pagkakataon ay dahil sa tahasang hiniling mo kay Kotlin na itapon ang isa, o ang NullPointerException ay nagmula sa panlabas na code ng Java.

Mga pagpapaandar sa pagpapalawig

Binibigyan ng Kotlin ang mga developer ng kakayahang pahabain ang isang klase ng bagong pag-andar, na mainam kung mayroong isang klase na palagi mong nadama na nawawala ang isang mahalagang pamamaraan!

Ang mga 'extension function' na ito ay hindi magagamit sa Java, bagaman magagamit ang mga ito sa iba pang mga wika ng programming na maaari mong magamit para sa pagbuo ng Android, tulad ng C #.

Basahin ang Susunod: Java tutorial para sa mga nagsisimula

Lumilikha ka ng isang extension function sa pamamagitan ng prefixing ang pangalan ng klase na nais mong palawakin (tulad ng 'String') sa pangalan ng function na iyong nilikha ('styleString') halimbawa:

masaya String.styleString (): String {// Estilo ang string at pagkatapos ay ibalik ito //}

Maaari mong tawagan ang function na ito sa mga pagkakataon ng pinalawig na klase, sa pamamagitan ng. notasyon, na para bang bahagi ito ng klase:

myString.styleString ()

Ang mga Coroutine ay mga mamamayan na first class

Sa tuwing magsisimula ka ng isang pang-matagalang operasyon, tulad ng network I / O o CPU-intensive work, ang calling thread ay naka-block hanggang makumpleto ang operasyon. Yamang ang Android ay nag-iisang sinulid nang default, sa sandaling mai-block mo ang pangunahing thread ay pupunta ang pag-freeze ng UI ng iyong app, at mananatiling hindi responsable hanggang sa matapos ang operasyon.

Sa Java, ang solusyon ay ayon sa kaugalian ay lumikha ng isang background na thread kung saan maaari mong gawin ang masinsinang o matagal na gawain, ngunit ang pamamahala ng maraming mga thread ay maaaring humantong sa kumplikado, error-prone code, at ang paglikha ng isang bagong thread ay isang mamahaling operasyon.

Habang maaari kang lumikha ng mga karagdagang mga thread sa Kotlin, maaari mo ring gamitin ang mga coroutine. Ang Coroutines ay nagsasagawa ng pangmatagalan at masinsinang mga gawain sa pamamagitan ng pagsuspinde sa pagpapatupad sa isang tiyak na punto nang hindi pinipigilan ang thread, at pagkatapos ay ipagpatuloy ang pagpapaandar na ito sa ibang pagkakataon, marahil sa ibang thread. Pinapayagan ka nitong lumikha ng hindi pag-block ng hindi sinasadyang code na mukhang kasabay, at samakatuwid ay mas malinaw, maigsi at madaling mabasa ng tao. Ang mga coroutine ay hindi rin nakakabit, kaya't mayroon silang isang mas mababang paggamit ng memorya kumpara sa mga thread, at binuksan nila ang pintuan sa mga karagdagang istilo ng hindi pinipigilan na hindi pag-block ng programming, tulad ng async / Naghihintay.

Walang mga check eksepsyon

Ang Kotlin ay hindi naka-check ang mga eksepsiyon, kaya hindi mo kailangang mahuli o magpahayag ng anumang mga pagbubukod.

Kung ito ay isang bagay na iginuhit ka sa Kotlin, o ginagawang nais mong dumikit sa Java ay nakasalalay sa iyong opinyon ng mga nasabing mga eksepsiyon, dahil ito ay isang tampok na naghahati sa komunidad ng nag-develop. Kung ikaw ay may sakit na subukan / mahuli ang mga bloke na pumapalakpak sa iyong code sa Java, kung gayon matutuwa ka sa pagbawas na ito, subalit kung nalaman mo na ang mga naka-check na eksepsyon ay hinihikayat ka na mag-isip tungkol sa pagbawi ng error at sa huli ay itulak ka patungo sa paglikha ng mas matatag code, pagkatapos ay mas malamang na makita mo ito bilang isang lugar kung saan ang Java ay may gilid sa Kotlin.

Katutubong suporta para sa delegasyon

Ang Kotlin, hindi katulad ng Java, ay sumusuporta sa pattern ng disenyo ng "komposisyon sa pamana", sa pamamagitan ng delegasyon ng unang-klase (kung minsan ay kilala bilang iminumungkahing delegasyon). Ang Delegasyon ay kung saan ang isang pagtanggap ng object delegates operasyon sa isang pangalawang bagay na delegado, na kung saan ay isang katulong na object na may orihinal na konteksto.

Ang delegasyon ng klase ni Kotlin ay isang kahalili sa pamana na ginagawang posible na gumamit ng maraming pamana. Samantala, ang mga ipinagkaloob na mga katangian ng Kotlin ay nakakatulong upang maiwasan ang pagkopya ng code, halimbawa kung kailangan mong muling gamitin ang parehong code para sa maraming mga ari-arian at setter, pagkatapos maaari mong kunin ang code na ito sa isang delegado na pag-aari. Kailangang tukuyin ng delegado ng ari-arian ang pagpapaandar ng getValue operator at, opsyonal, ang operator ng setValue:

klase Delegate {operator fun getValue (...) ... ...}} masaya ng operator setValue (...) ... ...}}

Pagkatapos, kapag gumagawa ka ng isang pag-aari maaari mong ipahayag na ang mga function ng getter at setter para sa partikular na pag-aari na ito ay hinahawakan ng isa pang klase:

klase MyClass {var ari-arian: String ni Delegate ()}

Mga klase ng data

Hindi pangkaraniwan para sa isang proyekto na magkaroon ng maramihang mga klase na walang ginawa kundi hawakan ang data. Sa Java, makikita mo ang iyong sarili na sumusulat ng maraming code ng boilerplate para sa mga klase, kahit na ang mga klase mismo ay may napakakaunting pag-andar. Karaniwan, kakailanganin mong tukuyin ang isang tagabuo, mga patlang na mag-iimbak ng data, mga function ng getter at setter para sa bawat larangan, kasama ang hashCode (), katumbas () at mga function ng toString ().

Sa Kotlin, kung isasama mo ang keyword na 'data' sa iyong kahulugan ng klase, pagkatapos ay gagawa ng tagatala ang lahat ng gawaing ito para sa iyo, kasama ang pagbuo ng lahat ng kinakailangang mga getter at setters:

data ng klase Petsa (buwan ng var: String, var day: Int)

Mga Smart cast

Sa Java, madalas mong suriin ang uri at pagkatapos ay maglagay ng isang bagay sa mga sitwasyon kung saan malinaw na ang bagay ay maaaring palayasin.

Ang mga matalinong cast ng Kotlin ay maaaring hawakan ang mga kalakal na cast na ito para sa iyo, kaya hindi mo kailangang itapon sa loob ng isang pahayag kung sinuri mo na ito kasama ang Kotlin 'ay' operator. Halimbawa, alam ng tagatala na ang sumusunod na cast ay ligtas:

kung (hello ay String) {printString (hello)}

Suporta para sa mga tagabuo

Hindi tulad ng Java, ang isang klase ng Kotlin ay maaaring magkaroon ng pangunahing tagapagbuo at isa o higit pang pangalawang tagapagbuo, na nilikha mo sa pamamagitan ng pagsasama ng mga ito sa iyong deklarasyon sa klase:

klase ng konstruksyon ng MainActivity (firstName: String) {}

Walang suporta para sa mga nagpapahiwatig na pagpapalawak ng mga conversion

Hindi suportado ng Kotlin ang mga implicit na pagpapalawak ng mga conversion para sa mga numero, kaya ang mga mas maliit na uri ay hindi ganap na na-convert sa mas malaking uri. Sa Kotlin, kung nais mong magtalaga ng isang halaga ng uri ng Byte sa isang variable na Int, kakailanganin mong magsagawa ng isang malinaw na pagbabagong loob, samantalang ang Java ay may suporta para sa tahasang mga pag-convert.

Mga aklatan sa pagproseso ng annotasyon kasama ang Kotlin

Sinusuportahan ng Kotlin ang lahat ng mga umiiral na mga frameworks at aklatan ng Java, kabilang ang mga advanced na frameworks na umaasa sa pagproseso ng annotation, bagaman ang ilang mga aklatan ng Java ay nagbibigay ng mga extension ng Kotlin, tulad ng RxKotlin.

Kung nais mong gumamit ng isang library ng Java na umaasa sa pagproseso ng annotation, kung gayon ang pagdaragdag nito sa iyong proyekto ng Kotlin ay bahagyang naiiba dahil kakailanganin mong tukuyin ang dependency gamit ang kotlin-kapt plugin, at pagkatapos ay gamitin ang tool sa pagproseso ng Kotlin Annotation (kapt) sa halip na annotationProcessor. Halimbawa:

// Ilapat ang plugin // ilapat ang plugin: kotlin-kapt // Idagdag ang kani-kanilang mga dependencies gamit ang pagsasaayos ng kapt // dependencies {kapt "com.google.dagger: dagger-compiler: $ dagger-bersyon" ... ... ...}

Ang pagpapalit ng Java sa Java

Kapag pinagtatalunan kung gagamitin ang Kotlin o Java para sa pagpapaunlad ng Android, dapat mong malaman na mayroong isang ikatlong pagpipilian: gamitin pareho. Sa kabila ng lahat ng pagkakaiba sa pagitan ng dalawang wika, ang Java at Kotlin ay 100% na magkakaugnay. Maaari kang tumawag sa Kotlin code mula sa Java, at maaari kang tumawag sa Java code mula sa Kotlin, kaya posible na magkasama-sama ang mga klase ng Kotlin at Java sa loob ng parehong proyekto, at ang lahat ay susulatin pa rin.

Ang kakayahang umangkop na ito upang lumipat sa pagitan ng dalawang wika ay kapaki-pakinabang kapag nagsimula ka sa Kotlin dahil pinapayagan ka nitong ipakilala ang Kotlin sa isang umiiral nang proyekto, ngunit mas gusto mo ring gamitin ang parehong wika nang isang permanenteng batayan. Halimbawa, maaaring may mga tiyak na tampok na gusto mong isulat sa Kotlin, at ilang mga tampok na mas madali mong isulat sa Java. Dahil kapwa sumasama ang Kotlin at Java sa bytecode, hindi masabi ng iyong mga end-user kung saan natapos ang iyong Java code, at nagsisimula ang code ng Kotlin, kaya walang dahilan kung bakit hindi ka makapaglabas ng isang app na binubuo ng Java at Kotlin code.

Kung nais mong subukan ang Kotlin para sa iyong sarili, pagkatapos hangga't mayroon kang pag-preview sa Android Studio 3.0 o mas mataas na mai-install, may ilang mga paraan na magsisimula ka:

• Lumikha ng isang bagong proyekto sa Android Studio. Ang pinakamadaling pamamaraan ay ang lumikha ng isang bagong proyekto at piliin ang checkbox na 'Isama ang Kotlin' mula sa wizard ng paglikha ng proyekto.

• Magdagdag ng isang klase ng Kotlin sa isang umiiral na direktoryo. I-click ang control sa direktoryo na pinag-uusapan, pagkatapos ay piliin ang 'File> Bago> File / Class ng Kotlin.' Ang Android Studio ay magpapakita ng isang banner na humihiling sa iyo na i-configure ang iyong proyekto upang suportahan ang Kotlin; i-click ang link na 'I-configure' at sundin ang mga tagubilin sa onscreen.

• I-convert ang umiiral na mga file ng Java sa Kotlin. Maaari mong patakbuhin ang anumang file ng Java sa pamamagitan ng isang Kotlin converter, sa pamamagitan ng Control-click ang file at piliin ang 'Code> I-convert ang Java File sa Kotlin File.'

Pagputol

Tulad ng nakikita mo maraming mga magagandang dahilan upang mas gusto ang Kotlin sa Java, gayunpaman mayroong isang pares ng mga lugar kung saan ang Java ay nasa itaas na kamay. Marahil na higit sa lahat: maraming mga developer ng Android ay mas pamilyar sa Java sa puntong ito. Marahil ang debate sa Kotlin kumpara sa Java ay hindi tatanggalin anumang oras sa lalong madaling panahon, na may parehong pagkakaroon ng kanilang sariling mga merito. Kaya, pupunta ka ba sa paglipat sa Kotlin, o sa palagay mo na ang Java ay pa rin ang pinakamahusay na pagpipilian para sa pag-unlad ng Android?

Basahin ang Susunod: Isang pagpapakilala sa Java syntax para sa pag-unlad ng Android