A fogalmak megismerése, elmélyülés az operátorokban és az ágakban, a platform elsajátítása 2020. november 24. 11 perc 4720 https://d2xzmw6cctk25h.cloudfront.net/post/2453/og_image/3e08cac12579476376b4a26475905b90.png
Ebben a cikkben bemutatjuk az első játékalkalmazás megírásának lépéseit. A fejlesztési folyamat során megismerkedik a Kotlin nyelv alapjaival: változókkal, operátorokkal, ágakkal, valamint az Android platform programozásának alapjaival: elrendezések létrehozása, eseményfigyelők, alkalmazás elindítása.
Először beszéljünk általában Kotlinról.
Nyelvigény
Kotlin még az 1.0 kiadás előtt, 2016 februárjában elnyerte az elfogadását. A szakértők értékelik rövidségéért, kifejezőképességéért és biztonságáért. Miután a Google bejelentette, hogy teljes mértékben támogatja ezt a nyelvet az Android-alkalmazások fejlesztésében, a Kotlin népszerűsége ugrásszerűen megnőtt. Most az operációs rendszer szinte minden új alkalmazásának létrehozásához használják. A Java-val való teljes felcserélhetősége miatt a meglévő projektekhez is kapcsolódik, ha hosszú távú támogatásukat tervezik. Tehát a Kotlin az iparági szabvány az Android fejlesztésében. Igény van rá, és ez a fő előnye.
A lakonikus fontos előny
A Kotlin lehetővé teszi, hogy ugyanazokat a dolgokat írjon, mint a Java-ban, de lényegesen kevesebb kóddal. Például:
public class Személy {private String keresztnév; privát karakterlánc vezetéknév; privát int kor; public Person (String keresztnév, String vezetéknév, int kor) {this.firstName = keresztnév; this.lastName = vezetékNév; ez.kor = életkor; } public String getFirstName () {return firstName; } public String getLastName () {return lastName; } public int getAge () {visszatérési kor; }}
Ez egy egyszerű osztály egy személy (keresztnév, vezetéknév, életkor) leírására, amelyet a Java-ban egy egyszerű objektum képviseletére használnak. Most ugyanez, csak Kotlinban:
adatosztály Személy (val firstName: String, val lastName: String, val age: Int)
Lenyűgöző, nem?
Nyelvbiztonság
A Java, a Kotlin is, statikusan tipizált nyelv. Tehát az objektumok helytelen használatával kapcsolatos szintaktikai hibákat és hibákat a projekt összeállításakor elkapják. Ennek köszönhetően az üzemképtelen kódot gyorsan azonosítják, a hibákat azonosítják és kijavítják.
Teljes Java kompatibilitás
A Kotlin úgy lett megtervezve, hogy bárhol használható legyen a Java: teljesen kompatibilisek. Az alkalmazáskód egy része Java-ban, másik része pedig Kotlinban lehet, és minden rendben fog működni. Korlátozások nélkül férhet hozzá a Kotlinban írt osztályokhoz Java kódból és fordítva.
Egyébként az Android-alkalmazások fejlesztésekor a Java-t legfeljebb a 7-es verziónál használják, ahol a stream-api, az alapértelmezett interfész-módszerek és egyéb szolgáltatások nem állnak rendelkezésre. Az Android Studio 3.0 csak a Java 8 egyes funkcióit engedélyezi. A Kotlin rendelkezik mindezekkel az eszközökkel – és még sok mással.
Kotlin létrejöttének története
A Kotlin fejlesztését 2010-ben kezdték meg a JetBrains szakemberei. Már nem elégedtek meg a Java lehetőségeivel, és úgy döntöttek, hogy létrehozzák saját programozási nyelvüket, kombinálva a meglévő PL legjobb tulajdonságait. A Kotlin név a Finn-öbölben található sziget tiszteletére szolgál, amelyen Kronstadt városa található. 2011-ben az új nyelvet bemutatták a nyilvánosságnak, 2012-ben pedig megnyitották a forráskódját. Ez idő alatt intenzív fejlesztést és tesztelést végeztek. Az 1.0-s verzió 2016-ban jelent meg. Akkor is sok Android-fejlesztő a Kotlint használta projektjeiben. Miután bejelentette a Google I / O 2017-ben, hogy teljes mértékben támogatja a mobilalkalmazások készítésének nyelvét, Kotlin rendkívül népszerűvé vált a szakmai közösségben.
Gyakorlat
Javasoljuk, hogy írjon össze egy programot egy véletlenszám kitalálására. Az alkalmazás véletlenszerű számot fog kitalálni 0 és 9 között, és a felhasználónak három kísérletet kell kitalálnia. Minden alkalmazás után az alkalmazás megkérdezi, hogy a rejtett szám kisebb vagy nagyobb.
Fejlesztési környezetre van szükségünk. Telepítéséhez és alkalmazássablon létrehozásához (amelyet alapul veszünk) – olvassa el ezt a cikket, és térjen vissza ide.
Most, hogy elindította a fejlesztői környezetet és létrehozta a projektet, automatikusan két fül van nyitva: az alkalmazás képernyő elrendezésének létrehozásához (activity_main.xml) és a programozáshoz (MainActivity.kt). Kezdjük az elrendezéssel. Ilyen képernyőt kell rajzolnunk:
Ehhez nyissa meg az activity_main.xml fület. Minden itt XML jelölőnyelven van megírva. Az összes vizuális elem, amelyet a felhasználó bármely alkalmazás képernyőjén lát, XML használatával kerül leírásra. Valójában ez egy címkekészlet (
xml version = "1.0" encoding = "utf-8"?>Most találjuk ki, mit jelent ez az egész. A ConstraintLayout tárolót használjuk minden elemünkhöz (gombok, beviteli mezők stb.). Benne elhelyezheti az elemeket egymáshoz viszonyítva, és a képernyő típusától és méretétől függetlenül megtartják ezt a helyzetet. Ez nagyon fontos, figyelembe véve, hogy hány különböző telefonon fut az Android operációs rendszer.
A konténerünkben az első elem a Start gomb lesz (AppCompatButton). A következő tulajdonságokkal rendelkezik:
- android: id - egyedi azonosító, amely alapján megtaláljuk ezt az elemet a MainActivity.kt;
- android: layout_width - a gomb szélessége, amely megegyezik a szöveg hosszával;
- android: layout_height - alapértelmezett magasság;
- android: layout_marginTop - eltolás a képernyő felső szélétől;
- android: szöveg : - gombcímke;
- app: layout_constraintLeft_toLeftOf - a gomb bal széle a tároló bal széléhez húzódik; app: layout_constraintRight_toRightOf - A gomb jobb széle a tároló jobb széléhez húzódik. Ennek eredményeként a gomb a képernyő közepén helyezkedik el a vízszintes síkban;
- app: layout_constraintTop_toTopOf - A gomb felső éle a tároló felső széléhez húzódik. Vagyis esetünkben a gomb mindig 100 pixel lesz a képernyő felső szélétől.
Ezután következik a szövegmező, ahol megjelenítjük az eredményt (a játék kezdete, függetlenül attól, hogy a felhasználó kitalálta-e a számot vagy sem). Ehhez a TextView-t használjuk:
- android: id - azonosító;
- android: layout_width - a szélesség megegyezik a megjelenített szöveg szélességével (ott még nincs szöveg);
- android: layout_height - alapértelmezett magasság;
- android: textColor - szöveg színe. A vörös értéket hexadecimális kóddal (# FF0000) használtuk;
- android: textSize - szövegméret;
- app: layout_constraintLeft_toLeftOf és app: layout_constraintRight_toRightOf - jelzik, hogy a szöveg mindig középre kerül;
- app: layout_constraintTop_toBottomOf - a szöveg felső széle mindig a Start gomb alsó széle alatt lesz.
Most foglalkozzunk a felhasználó által kitalálni kívánt szám megadásának mezőjével. Ez az AppcompatEditText:
- android: id - azonosító;
- android: layout_width - width;
- android: layout_height - height (van egy alapértelmezett értékünk);
- android: gravitáció - a beviteli mezőben lévő számot a középpontba kell beírni, nem pedig balról;
- android: tipp - tipp;
- android: inputType - a numerikus billentyűzet azonnal kihúzásra kerül;
- android: maxLength - csak egy számjegyből álló számot adhat meg;
- app: layout_constraintLeft_toLeftOf és app: layout_constraintRight_toRightOf - jelzik, hogy a mező mindig középre kerül;
- app: layout_constraintTop_toBottomOf : - a beviteli mező felső széle mindig az eredményszöveg alsó széle alatt lesz.
Az utolsó elem pedig egy másik gomb, amelyre kattintva a felhasználó megtudja, kitalálta-e a számot vagy sem:
- android: id - azonosító;
- android: layout_width - a szélesség megegyezik a megjelenített szöveg szélességével (ott még nincs szöveg);
- android: layout_height - alapértelmezett magasság;
- android: szöveg - gomb címke;
- app: layout_constraintLeft_toLeftOf és app: layout_constraintRight_toRightOf - jelzik, hogy a gomb mindig középre kerül;
- app: layout_constraintTop_toBottomOf - a gomb felső széle mindig a beviteli mező alsó széle alatt lesz.
Indítsa el az emulátort, és ellenőrizze, hogy minden a megfelelő módon jelenik-e meg. Most térjünk közvetlenül a kódra. A tevékenység az alkalmazás képernyője. Az imént rajzolt elrendezés oda kerül, minden gomb kattintás feldolgozásra kerül, és eldől, hogy mely feliratokat jelenítse meg a szövegmezőkben. Nyissa meg a MainActivity.kt fület, és cserélje ki az összes kódot erre (csak ne érintse meg a felső sort, például a example.app.myapp csomagot):
import android.os.Bundle import androidx.appcompat.app.AppCompatActivity import kotlinx.android.synthetic.main.activity_main. * import kotlin.random.Random class MainActivity: AppCompatActivity () {override fun onCreate (savedInstanceState: Bundle?) {super .onCreate (savedInstanceState) setContentView (R.layout.activity_main) var count = 0 var userGuess = -1 var randomNumber = -1 buttonStartGame.setOnClickListener {randomNumber = Random.nextInt (0, 10) textViewResult.text = "Találj ki egy számot 0-tól akár 9 "// Programozók vagyunk! } buttonGuess.setOnClickListener {if (randomNumber <0) {randomNumber = Random.nextInt (0, 10)} val userInput = editTextUserNumber.text.toString () userGuess = userInput.toInt () if (count <2) {if (userGuess == randomNumber) {textViewResult.text = "Találd ki! Még egyszer?" count = 0 userGuess = -1 randomNumber = -1} else {textViewResult.text = if (userGuess> randomNumber) "kevesebb!" különben "több!" count ++}} else {textViewResult.text = if (userGuess == randomNumber) "Találd meg! Még egyszer?" else "Nem találta ki: (Még egyszer?" count = 0 userGuess = -1 randomNumber = -1}}}}Még egy kódtömb, amelyet elemezni kell 🙂 Kezdjük sorrendben: fentről lefelé és balról jobbra.
Az első dolog, amit a projektben használt könyvtári importál, lát. Most nem figyelünk rájuk, mivel automatikusan importálják őket.
Következik a MainActivity osztály: AppcompatActivity () és egy nyitó göndör zárójel. Az osztály kulcsszó a nyelv osztályaira utal. Ezek olyan konstrukciók, amelyekben az összes fő művelet végbemegy: változókat deklarálunk, más osztályokat, függvényeket írunk. Minden program osztályokból áll, néha több ezren lehetnek.
Az osztály nevét (MainActivity) a kulcsszó után írják. Szokás az osztályneveket CamelCase-be írni (WordsIntegratedEach With Big Letters). Az osztályoknak, hasonlóan más entitásokhoz (függvények, változók), ajánlott mnemonikus, azaz "beszélő" neveket adni. A vastagbél után van egy másik osztály. Ez azt jelenti, hogy örökölünk ettől az osztálytól, és minden képességét megkapjuk. Az osztálytestet a név után göndör zárójelben írják. Tartalmazhat mezőket, függvényeket és más osztályokat. A változók adatokat tárolnak - erről egy alkalmazás fejlesztésekor gondoskodunk. A függvények parancsokat vagy kódokat tartalmaznak. A függvények (változók) nevét általában camelCase stílusban írják (mint például a Classes ButColorFirstLetter).
Osztályunknak csak egy funkciója van - az onCreate (). Minden tevékenységben (képernyőn) szerepel. Ettől kezdődik a képernyő elindítása és megjelenítése (e funkció nélkül a képernyő egyszerűen nem jelenik meg).
A függvény argumentumokon (Bundle ...), amelyeket nem fogunk használni, és a szülő metódushoz (super ...) hív meg, amelyet, amint észrevetted, alapértelmezés szerint be is illesztenek, létezik a setContentView módszer. A képernyőn megjelenő elrendezést érvként továbbadjuk neki. Enélkül a képernyő elindul, de üres lesz.
Ezután három változó deklarációját látjuk egyszerre:
- var count = 0
- var userGuess = -1
- var randomNumber = -1
Találjuk ki. A változók valamilyen adatot tárolnak (számok, karakterláncok, egyéb osztályok, logikai értékek, függvények). Ezek a cellák a telefon memóriájában, ahol az értékeket tárolják. Az értékeket egy cellába lehet írni és el lehet olvasni. Kotlinban egy változó használata előtt deklarálnia kell és meg kell adnia a típust, mivel erősen tipizált nyelvvel van dolgunk. De ha a típus nyilvánvaló, akkor elhagyhatja: a Kotlin fordító kitalálja, hogy a változó milyen típusú.
A változók lehetnek primitívek (számok, szimbólumok, logikai értékek) vagy referenciák (tömbök, karakterláncok, bármely más objektum). A Kotlin-nak nyolc primitív típusa van (bájt, int, rövid, hosszú, úszó, kettős, logikai, char) és végtelen számú referenciatípus. A változó neve betűket és számokat, aláhúzást tartalmazhat. Nem kell számmal kezdeni. A szakmai fejlődés során csak a betűket használják a változó nevekben. A névnek világosan meg kell jelölnie a változó célját, hogy azonnal egyértelmű legyen, mire szolgál. Három változónk van:
- var count = 0. Ez a próbálkozások száma, amelyet a játékos használt. Minden kísérlet után a szám 1-gyel nő. Amikor pedig eléri a 2-t (0, 1, 2 - három kísérlet), a játéknak vége. A programozásnál a számlálást mindig 0-tól tartják, nem pedig 1-től, ahogyan azt a mindennapi életben megszoktuk;
- var userGuess = -1. A felhasználó által beírt szám. Kezdetben -1: tehát biztosak vagyunk abban, hogy a felhasználó még nem írt be semmit;
- var randomNumber = -1. Az alkalmazás által generált szám. Kezdetben -1: tehát biztosak vagyunk benne, hogy a játék még nem kezdődött el.
Természetesen észrevette, hogy minden változó előtt a var kulcsszó áll. A változó deklarációk Kotlinban kissé eltérnek a Java-tól. A deklaráció elején a var vagy val kulcsszó van feltüntetve, majd a változó neve, majd típusa vagy azonnal az értéke. Ha a változó azonnal inicializálódik (mint esetünkben) a deklaráció helyén, a típus elhagyható. A fordító a hozzárendelt érték típusából következtet. Kétféle változó létezik Kotlinban:
- a var változtatható, vagyis tetszőleges számú érték rendelhető hozzá;
- a val megváltoztathatatlan (Java értelemben végleges), csak egyszer rendelhet hozzá értéket, de így is sokszor elolvashatja.
A Kotlin alkotói javasolják a val használatát, amikor csak lehetséges. Ez a megközelítés lehetővé teszi a hibák elkerülését és a megbízhatóbb kód megírását. Mivel minden változónknak minden egyes új játéknál (vagy akár a játék során) frissítenie kell az értékeit, akkor minden változónk változó.
Ezután jön a következő kód:
buttonStartGame.setOnClickListener {randomNumber = Random.nextInt (0, 10) textViewResult.text = "Találj ki egy számot 0-tól 9-ig"}Itt megtaláljuk a gombot az XML elrendezésben (buttonStartGame), és felakasztunk rá egy "kattintási figyelőt" (setOnClickListener). Ez azt jelenti, hogy amikor a felhasználó rákattint erre a gombra, a göndör zárójeles kód végrehajtásra kerül.
Ezekben hozzáférünk az egyik változónkhoz, és véletlenszerű értéket rendelünk hozzá a Random osztály és a nextInt függvény segítségével. Ez lehetővé teszi, hogy egy változónak átadja azokat a határokat, amelyeken belül véletlenszerű számot szeretnénk kapni.
Ezt követően azonnal megtaláljuk a szövegmezőnket, és ott megjelenítjük a "Találd meg a számot 0-tól 9-ig" szöveget. Az összes kódot törölheti és futtathatja az alkalmazást:
import android.os.Bundle import androidx.appcompat.app.AppCompatActivity import kotlinx.android.synthetic.main.activity_main. * import kotlin.random.Random class MainActivity: AppCompatActivity () {override fun onCreate (savedInstanceState: Bundle?) {super .onCreate (savedInstanceState) setContentView (R.layout.activity_main) var count = 0 var userGuess = -1 var randomNumber = -1 buttonStartGame.setOnClickListener {randomNumber = Random.nextInt (0, 10) textViewResult.text = "Találj ki egy számot 0-tól akár 9 "// Programozók vagyunk! }}}Az alkalmazás már működik, és reagál a kattintásokra! Visszatérünk a fő kódtömbhöz, majd a következőket látjuk:
buttonGuess.setOnClickListener {if (randomNumber <0) {randomNumber = Random.nextInt (0, 10)} ...Mint már megértette, felakasztottuk a hallgatót a "Találd" gombra való kattintásokra. És akkor van egy érdekes konstrukció, amely az if ("ha") kulcsszóval kezdődik. Ez az úgynevezett feltételellenőrzés vagy elágazás: amikor összehasonlítunk néhány logikai kifejezést (azokat, amelyekre csak "igen" vagy "nem" lehet válaszolni), és a válaszra összpontosítva ezt vagy azt a műveletet hajtjuk végre.
Bármely magas szintű programozási nyelv lehetővé teszi a program végrehajtásának sorrendjének megváltoztatását egy adott körülménytől függően. Kotlin ehhez használja az if konstrukciót. E kulcsszó után egy logikai kifejezés kerül zárójelbe, majd a parancsok csoportja göndör zárójelben. Ha egy logikai kifejezés eredménye igaz, akkor a parancsok ezen csoportja végrehajtásra kerül, ha hamis - nem. Van még egy másik kulcsszó is, amely utána mehet a feltételnek, és azt jelentheti, hogy "különben csináld."
A kódban ellenőrizzük a feltételt ( randomNumber <0). Ha a randomNumber értéke kisebb, mint nulla, akkor véletlen számot generálunk. Ha nagyobb vagy egyenlő nullával, akkor ez azt jelenti, hogy a véletlenszám már létrejött (a játék javában zajlik!) És semmit sem kell tenni: folytathatja a program végrehajtását.
Ezután megkapjuk azt az értéket, amelyet a felhasználó bevitt a beviteli mezőbe. Rátérünk az editTextUserNumber oldalra, kivesszük belőle az értéket, és lefordítjuk egy karakterláncba. Ennek az értéknek a tárolásához deklaráltuk a userInput változót (a val kulcsszóval, mert nem kell módosítanunk ezt az értéket). Ezután azonnal hozzárendeljük az értéket a userGuess változóhoz. De mivel a userGuess Int típusú, a userInput pedig String, ezért a toInt () függvény segítségével számokká kell alakítanunk a karakterláncot.
Ezután ellenőrizzük a következő feltételt: ha a próbálkozások száma kevesebb, mint kettő (vagyis a felhasználó még nem használt fel mindent), akkor folytatjuk a játékot. Ellenkező esetben (a másik kulcsszó) befejezzük a játékot, megjelenítjük az eredményt és felajánljuk, hogy újra játszunk. Ha a felhasználónak még mindig vannak próbálkozásai, ellenőrizzük a következő feltételt: megegyezik-e a beírt szám véletlenszerű számmal? Figyelje meg, hogyan történik az összehasonlítás a == operátor használatával. A programozásban ez az egyezés összehasonlítása, és a = érték-hozzárendelési operátor. Ne keverje össze őket.
Ha a felhasználó száma megegyezik (==) a véletlenszerű számmal, akkor tippel. Megjelenítjük a megfelelő szöveget, és visszaállítjuk a játék paramétereit (próbálkozások száma, felhasználói válasz és véletlenszerű szám).
if (userGuess == randomNumber) {textViewResult.text = "Kitaláltad! Ismét?" count = 0 userGuess = -1 randomNumber = -1} else {textViewResult.text = if (userGuess> randomNumber) "kevesebb!" különben "több!" szám ++}Ha a felhasználó rosszul tippel (más ...), akkor az eredményt a szövegmezőben jelenítjük meg, és eggyel növeljük a használt kísérletek számát. Figyelje meg, hogyan történik ez az egész. A lényeg az, hogy Kotlinban (a Java-val ellentétben) összehasonlító kifejezések használhatók ennek eredményeként. Ezért tudjuk olyan tömören megjeleníteni a szöveget a szövegmezőben: text = if (userGuess> randomNumber) "kevesebb!" különben "több!" Ha a felhasználó száma több, mint véletlenszerű, akkor a "kevesebb" szót írjuk be a szövegmezőbe, különben (különben) "több" -et.
A második érdekes pont a ++ kifejezésszám. Csak növeli az aktuális értéket (számot) eggyel. Ugyanaz, mint az írás count = count + 1.
Ebben a kódblokkban ellenőriztük a felhasználó számának egyenlőségét (userGuess == randomNumber) "többé-kevésbé" (ha (userGuess> randomNumber) "kevesebbet!" Egyéb "többet!"), És elvégeztük a megfelelő műveleteket. Itt található a klasszikus elágazás és a programvezérlés az összehasonlítás eredményétől függően.
Továbblépés az alkalmazás utolsó kódtömbjéhez. Ha a felhasználónak nincs több kísérlete (különben ...), akkor befejezzük a játékot.
textViewResult.text = if (userGuess == randomNumber) "Megtalálta! Ismét?" else "Nem sejtetted :( Még egyszer?" count = 0 userGuess = -1 randomNumber = -1Az eredményt egy szövegmezőben jelenítjük meg az előzőhöz hasonlóan, és visszaállítjuk a count és userGuess értékeket. Ez minden! Első jelentkezése elkészült.
Bónusz: a hibák megelőzése
Próbálja meg üresen hagyni a mezőt, majd kattintson a "Találd" gombra. Az alkalmazás összeomlik. Ez azért van, mert egy üres karakterláncot próbálunk számokká konvertálni:
val userInput = editTextUserNumber.text.toString () userGuess = userInput.toInt ()Ennek elkerülése érdekében adjunk hozzá még egy ellenőrzést:
if (userInput.isBlank ()) {textViewResult.text = "Kérjük, írjon be egy számot!" } más {...Itt ellenőrizzük, hogy a beviteli mező üres-e. Az isBlank függvény igaz, ha nincs semmi a mezőben, és hamis, ha a számot megadjuk. Ha a mező üres, akkor az "Írjon be egy számot" szöveget mutatunk, különben folytatjuk a programot.
A teljes kód így fog kinézni:
import android.os.Bundle import androidx.appcompat.app.AppCompatActivity import kotlinx.android.synthetic.main.activity_main. * import kotlin.random.Random class MainActivity: AppCompatActivity () {override fun onCreate (savedInstanceState: Bundle?) {super .onCreate (savedInstanceState) setContentView (R.layout.activity_main) var count = 0 var userGuess = -1 var randomNumber = -1 buttonStartGame.setOnClickListener {randomNumber = Random.nextInt (0, 10) textViewResult.text = "Találj ki egy számot 0-tól akár 9 "// Programozók vagyunk! } buttonGuess.setOnClickListener {if (randomNumber <0) {randomNumber = Random.nextInt (0, 10)} val userInput = editTextUserNumber.text.toString () if (userInput.isBlank ()) {textViewResult.text = "Írjon be egy számot! " } else {userGuess = userInput.toInt () if (count <2) {if (userGuess == randomNumber) {textViewResult.text = "Találd megint?" count = 0 userGuess = -1 randomNumber = -1} else {textViewResult.text = if (userGuess> randomNumber) "kevesebb!" különben "több!" count ++}} else {textViewResult.text = if (userGuess == randomNumber) "Találd meg! Még egyszer?" else "Nem találta ki :( Még egyszer?" count = 0 userGuess = -1 randomNumber = -1}}}}}Természetesen az alkalmazás kódja javítható és optimalizálható. Gondolkodjon önálló munkaként, hogyan csinálná? Örömmel hallanám a válaszokat a kommentekben 🙂