Zelf mobiele apps bouwen (deel 5)

Door: Gertjan Groen | 25 oktober 2021 09:04

How To

Eenvoudige apps bouwen is nog niet echt programmeren. We nemen een stapje terug en introduceren de programmeertaal Kotlin, waarvoor we eerst een ontwikkelomgeving installeren.

Code downloaden

In dit deel van de cursus Apps bouwen worden wat voorbeelden van stukjes code gegeven. Omdat overtikken van code erg foutgevoelig is, kun je die code ook downloaden en daarna bekijken of kopiëren. Zie het bestand code-appsbouwen-deel5.txt beschikbaar via www.pcmweb.nl/download.

Kotlin is de officiële programmeertaal voor Android Studio. Wil je een volleerd Android-programmeur worden, dan zul je er waarschijnlijk niet genoeg aan hebben. Zo is het nuttig om bijvoorbeeld meer te leren over object-georiënteerd programmeren en ook wat kennis van Java op te doen, want daar werkt Android onder de motorkap mee. Ga je daadwerkelijk Android-apps bouwen, dan kun je zowel Kotlin als Java gebruiken. Ze werken naadloos samen en je kunt ze beide in je project gebruiken. Het voordeel van Kotlin is dat je efficiënter kunt werken, omdat er minder regels code nodig zijn om hetzelfde te doen.

We geven je een basis van Kotlin, maar verdere verdieping is zeker gewenst.

Ontwikkelen in Android Studio?

Je kunt Android Studio gebruiken om te leren programmeren met Kotlin, maar het is niet de beste optie. Alles is daarin namelijk ingericht op het bouwen van apps. Oefenen met alleen Kotlin is wat omslachtig. Daarom gebruiken we hier het programma IntelliJ IDEA, dat we gewoon náást Android Studio installeren. In delen 2 en 4 van deze cursusreeks schreven we al dat Android Studio op deze software is gebaseerd, waardoor het er heel sterk op lijkt. Je zult er daarom snel mee overweg kunnen. En vrijwel alles wat je in deze software leert is in Android Studio toepasbaar!

IntelliJ IDEA installeren

Om IntelliJ IDEA te downloaden, ga je naar www.jetbrains.com/idea. Klik op Download en volg de downloadlink naar de gratis Community-editie. Start daarna de installatie. Zet op het scherm Installation Options onder Create Desktop Shortcut een vinkje bij 64-bit launcher. Heb je een (tegenwoordig vrij zeldzame) 32bit-versie van Windows, zet dan vinkjes bij alleen alle 32bit-opties! Onder Create Associations vink je alle opties aan, zodat je ondersteunde bestanden automatisch in IntelliJ IDEA kunt openen. Via een configuratiewizard kun je vervolgens enkele aanpassingen doen en extra’s installeren. Je kunt overal de standaardinstellingen accepteren. Na de installatie kun je IntelliJ IDEA direct openen. Zie je de optie Plugin Updates Available, dan raden we aan deze updates te installeren, zodat ze up-to-date zijn.

Bij de installatie kiezen we enkele aangepaste opties.

Instellingen aanpassen voor prettiger coderen

We raden je aan om enkele instellingen aan te passen, zodat code wat beter leesbaar is. Dat kun je zowel in IntelliJ IDEA als in Android Studio doen! Dat kan in de openingsdialoog via Configure / Settings of (als je de software al hebt geopend) via het menu File / Settings. Blader dan naar Editor / General / Appearance. Zet hier de optie Show method seperators aan. Er wordt dan een horizontale scheidingslijn tussen functies gezet, zodat je ze makkelijker uit elkaar kunt halen. Ga vervolgens naar Editor / General / Code Folding en haal onder General de vinkjes weg bij File header en Imports. Doe hetzelfde onder Java bij One-line methodes, Closures en Generic constructor and method parameters. Als deze opties aanstaan, wordt veel code ingevouwen, terwijl je zulke code als je begint met programmeren liever altijd ziet. Andere instellingen die je eerder in Android Studio hebt doorgevoerd, zoals die onder Editor / General / Auto Import, zul je ook nog in IntelliJ IDEA moeten doen, als je ze wenst te gebruiken.

Enkele kleine aanpassingen helpen je bij het schrijven van code.

Aan de slag met IntelliJ IDEA

Oefenen zonder Android Studio

Met de installatie van IntelliJ IDEA heb je een ontwikkelomgeving waarin je los van Android Studio kunt oefenen met Kotlin. In deze les introduceren we de belangrijke aspecten van deze programmeertaal. We gaan beginnen met een eenvoudig basisprogramma. Start daarvoor IntelliJ IDEA en kies in de openingsdialoog New Project. Selecteer links Kotlin en kies rechts onder JVM de optie Console Application. Voer bij Name een naam in (bijvoorbeeld Demo) en bij Location een map waarin je projectbestanden wilt bewaren. Accepteer verder de standaardinstellingen, klik op Next en dan Finish. Links zie je je projectvenster (net als bij Android Studio). Open daarin onder src/main/kotlin het bestand main.kt. Hierin zie je de volgende regels:

fun main(args: Array<String>) {

println("Hello World!")

}

Wat je ziet is een verplichte functie main voor het hoofdprogramma, die meerdere strings als parameters (ofwel ‘argumenten’) accepteert. Die worden als zogenaamde array (een lijst met gegevens) ingelezen. De printopdracht toont daarna een tekst met println() op een hele regel. Er wordt overigens niets met eventuele argumenten gedaan, al kan dat natuurlijk wel (zie het kader ‘Programma starten met argumenten’). Probeer het te starten. Klik daarvoor met rechts op een lege plek in de editor en kies Run MainKt’. Of gebruik het menu Run of druk op Shift+F10. Onderaan in de interface, in het venster Run, zie je de uitgevoerde tekst. We gaan aanpassingen doen in deze functie en houden steeds deze uitvoer in de gaten.

Binnen de functie main schrijf je de gewenste code in Kotlin.

Programma starten met argumenten

Je kunt eenvoudig enkele parameters opgeven bij de programmastart. Ga hiervoor naar Run / Edit Configurations en voer achter Program arguments het argument in, bijvoorbeeld het woord welkom. Verander de printopdracht in de code dan naar println(args[0]), waarmee in feite het eerste element van de array wordt geprint, in dit geval de string welkom.

Commentaar toevoegen

Voordat we beginnen, staan we even stil bij het gebruik van commentaar waarmee je code kunt verduidelijken, bijvoorbeeld bepaalde functies of opdrachten. Dat is handig voor jezelf, maar ook voor iemand anders die jouw code onder ogen krijgt. Een regel met commentaar begin je eenvoudigweg met //. Je mag commentaar behalve op een eigen regel ook achter een opdracht zetten. Veel teksteditors, waaronder IntelliJ IDEA en Android Studio, bieden een snelle manier om meerdere regels als commentaar te beschouwen. Selecteer daarvoor de regels en klik op Ctrl+/. Met dezelfde toetscombinatie zet je het commentaar ook weer terug naar code.

Verder kun je een heel blok als commentaar laten beschouwen door het blok te omsluiten met /* gevolgd door */. In de voorbeelden in dit cursusdeel gebruiken we commentaar om het resultaat van een printopdracht te laten zien, bijvoorbeeld:

println("Hello World!") // Hello World!

Takenlijstje voor wijzigingen  

Vaak zul je tijdens het programmeren al ideeën voor uitbreidingen hebben of heb je simpelweg geen tijd om een bepaalde functie af te ronden. In zo’n geval is het handig om de tekst todo in je commentaar op te nemen. Zulk commentaar wordt handig in soort takenlijstje opgenomen. Die vind je door links onderaan in de gebruikersinterface op TODO te klikken. Alle regels commentaar met de tekst todo worden hier opgesomd. Als je op een regel klikt, ga je direct naar de bewuste regel in je code. Dit werkt overigens ook in Android Studio.

Voor openstaande wijzigingen in je code kun je handig een automatisch takenlijstje bijhouden.

Variabelen en gegevenstypen

Bij het programmeren zul je regelmatig gegevens moeten opslaan. Hiervoor gebruik je variabelen. Een variabele kun je zien als een naam voor een geheugenlocatie waar bepaalde gegevens zijn opgeslagen. Het gegevenstype bepaalt wat voor soort gegevens dat zijn, bijvoorbeeld een tekst of getal. Hier maken we als voorbeeld een variabele tekstWelkom met een korte welkomsttekst:

var tekstWelkom = "Welkom!"

Kotlin ziet aan de waarde die je aan de variabele toekent dat String als gegevenstype moet worden gebruikt. Je kunt het gegevenstype ook expliciet opgeven:

var tekstWelkom: String = "Welkom!"

Zeker als er onduidelijkheid over kan bestaan, moet je het gegevenstype noemen. Dat is onder andere het geval als je een variabele eerst declareert, waarna je pas later een waarde toekent. Kotlin kan niet raden om welk gegevenstype het gaat, dus moet je het benoemen, bijvoorbeeld:

var tekstWelkom: String

tekstWelkom = "Welkom!"

Getallen

Voor gehele getallen kent Kotlin de gegevenstypes Byte (8 bit), Short (16 bit), Int (32 bit) en voor heel grote getallen een Long (64 bit). Een leeftijd kun je bijvoorbeeld noteren als:

var leeftijd = 30

Kotlin kiest zelf het gegevenstype en dat is voor gehele getallen (behalve bij heel grote getallen) een Int. In deze 32bit-ruimte kun je waarden van -2.147.483.648 tot en met 2.147.483.647 bewaren. Strikt genomen is een Short (-32.768 t/m 32.767) of zelfs een Byte (-128 t/m 127) genoeg om iemands leeftijd te bewaren. Die mag je dus ook gebruiken, al win je er op moderne computers in de praktijk weinig mee. Wil je zo’n kleiner gegevenstype gebruiken, dan zul je dat ook expliciet op moeten geven:

var leeftijd: Byte = 30

Voor zwevende-kommagetallen zijn er twee gegevenstypen, namelijk de Float (32 bit) en (voor extra precisie) de Double (64 bit). De komma schrijf je bij het programmeren overigens altijd met een punt. Als je een getal met een punt toekent aan een variabele, zal Kotlin dat standaard als een Double beschouwen, bijvoorbeeld:

var pi = 3.14

Wens je de hogere precisie van een Float, dan moet je dat opgeven met een f achter de waarde:

var pi = 3.14f

De f is overigens ook nog steeds nodig als je al expliciet het gegevenstype hebt benoemd:

var pi: Float = 3.14f

Een handigheidje is dat je een underscore (_) in de waarde mag gebruiken om lange getallen leesbaarder te maken:

var langgetal = 1_000_000

Kotlin kent ook de zogeheten Boolean met true of false als mogelijke waarden. Een logisch voorbeeld waarin je het gebruikt, is een lamp die aan of uit kan staan:

var lichtStaatAan: Boolean = true

Werken met variabelen voor bijvoorbeeld teksten in Kotlin.

Gebruik van var versus val

Je ziet dat we hier steeds het sleutelwoord var hebben gebruikt om een variabele te declareren. Dat is het meest gangbaar. Je gebruikt het als de waarde nog kan veranderen nadat je die hebt toegekend. Als een waarde niet meer verandert, kun je beter het sleutelwoord val gebruiken. Dat is bijvoorbeeld van toepassing voor de waarde van pi:

val pi = 3.14

Nadat je zoals hier de waarde voor pi met val hebt opgegeven, kun je deze verderop in je code niet meer veranderen. Als je het wel doet, geeft dat een foutmelding.

Berekeningen

Op getallen kun je berekeningen loslaten via zogeheten operators. De meeste spreken voor zich, zoals optellen (+), aftrekken (-), vermenigvuldigen (*) en delen (/):

var leeftijd = 12

leeftijd = leeftijd + 1

Je kunt in dit voorbeeld ook de verkorte notatie leeftijd += 1 gebruiken of zelfs leeftijd++. In dit voorbeeld spreekt het overigens voor zich dat je met integers werkt en dat het resultaat een integer blijft, maar in andere gevallen moet je rekening houden met het gegevenstype. Heb je bijvoorbeeld de variabele salaris van het type Int en verhoging van het type Double, dan kun je ze niet zomaar bij elkaar optellen:

var salaris = 12

var verhoging = 0.5

salaris = salaris + verhoging //foutmelding!

Je kunt dit op verschillende manieren oplossen. Het meest logisch is in dit geval om salaris als Double te declareren. Dat kan eenvoudigweg door var salaris = 12.0 te schrijven, of, als je expliciet wilt zijn, met var salaris: Double = 12.0, maar de punt is in beide gevallen cruciaal. Meestal zal Kotlin voor het resultaat van een berekening het meest logische gegevenstype gebruiken. Vermenigvuldig je bijvoorbeeld twee variabelen van het type Int, dan levert dat een integer op. Vermenigvuldig je een Double met een Int, dan geeft dat een Double, zoals in onderstaand voorbeeld waarin we de omtrek van een cirkel berekenen:

val pi = 3.14

var straal = 12

var omtrek = pi * 2 * straal

println(omtrek) //75.36

Er zijn allerlei methodes om gegevenstypen te converteren. Wil je bijvoorbeeld graag een Int als resultaat, dan kun je dat oplossen door van pi een Int te maken met de methode 

toInt():

val pi=3.14

println(pi.toInt()*2*12) //72

Je kunt je afvragen waar methodes zoals toInt() vandaan komen. De achtergrond is dat Kotlin geen zogenaamde primitieve gegevenstypen kent. Als je een gegevenstype als Int of Float gebruikt, dan wordt hier intern een object voor gemaakt. En op zo’n object kun je allerlei ingebouwde methodes loslaten. Een methode die je heel vaak tegenkomt is toString(). Daarmee vraag je in feite om een bepaalde waarde als String te krijgen.

Variabelen eenvoudig hernoemen

Er is een eenvoudige manier om de naam van een variabele te veranderen. Daarvoor klik je rechts in je code op de variabele en kies je Refactor / Rename. Voer nu de nieuwe naam in; deze nieuwe naam wordt daarna overal in je code doorgevoerd. In Android Studio kom je dat ook tegen als je bijvoorbeeld de ID van een component in je lay-out verandert.

De naam voor een variabele kun je eenvoudig overal laten aanpassen.

Lijsten

Vaak wil je meerdere gegevens bewaren die bij elkaar horen in een lijst. Dat kan in Kotlin met listOf(), bijvoorbeeld voor soorten fruit:

var fruit = listOf("appel","peer","banaan")

Je hoeft het gegevenstype niet op te geven, al mag dat wel:

var fruit: List<String> = listOf("appel","peer","banaan")

Nu je een lijst hebt gemaakt, kun je via de index een item uit deze lijst aanwijzen. Het eerste item begint bij 0. De waarde kun je laten zien met:

println(fruit[0]) //appel

Merk op dat je de inhoud van items in zo’n lijst niet kunt veranderen. Daar gebruik je een zogeheten array voor. Je kunt zo’n array declareren met de volgende opdracht:

var fruit = arrayOf("appel","peer","banaan")

Ook hier kun je optioneel het gegevenstype opgeven:

var fruit: Array<String> = arrayOf("appel","peer","banaan")

Bij een array kun je wel de waarde van items veranderen, zoals het tweede item:

fruit[1] = "mandarijn"

println(fruit[1]) //mandarijn

Wil je ook nog items toe kunnen voegen aan een lijst of verwijderen? Dan kun je weer een ander soort lijst gebruiken, de zogenoemde MutableList:

var fruit: MutableList<String> = mutableListOf("appel","peer","banaan")

Hierna kun je een item toevoegen aan deze lijst door eenvoudigweg de methode add te gebruiken:

fruit.add("mandarijn")

Bij bovenstaande opdracht komt het item achteraan. Je kunt optioneel een index opgeven als het item op een bepaalde plek moet komen, bijvoorbeeld 0 voor in het begin:

fruit.add(0, "mandarijn")

Er zijn veel meer methodes, bijvoorbeeld om een item te verwijderen of te vervangen. Je hoeft niet altijd de index te gebruiken, maar kunt ook een bepaald element op naam verwijderen:

fruit.remove("peer")

Lijsten zul je vaak tegenkomen bij het bouwen van apps, dus het is goed hier wat ervaring mee op te doen. Je kunt ze niet alleen voor teksten gebruiken, maar ook bijvoorbeeld integers en objecten.

Met lijsten kun je gegevensverzamelingen maken, bijvoorbeeld voor soorten fruit.

Beslissingen, lussen en functies

Beslissingsopdrachten

Als je al wat ervaring met programmeren hebt, zul je veel dezelfde opdrachten tegenkomen, maar soms in iets andere vorm. Vrij herkenbaar zijn de beslissingsopdrachten. Als voorbeeld nemen we de eerdere Boolean en maken we een keuze afhankelijk van zijn waarde:

var lichtStaatAan: Boolean = true

if (lichtStaatAan) {

println("Het licht staat aan!")

} else {

println("Het licht staat uit!")

}

Je kunt ook een vergelijking tussen haakjes zetten die – zoals we dat noemen – evalueert naar een Boolean:

var leeftijd = 19

if (leeftijd >= 18) {

println("Volwassen!")

}

Er zijn verschillende operatoren bruikbaar in vergelijkingen:

< kleiner dan

> groter dan

== gelijk aan

!= niet gelijk aan

<= kleiner dan of gelijk aan

>= groter dan of gelijk aan

Een handig ezelsbruggetje om te onthouden, is dat je van < (kleiner dan) de letter k kunt maken. Je kunt operatoren ook gebruiken in vergelijkingen, waarbij je het resultaat vervolgens direct toewijst aan een variabele van het gegevenstype Boolean. Je kunt het als verkorte beslissingsopdracht zien:

var leeftijd = 19

var volwassen: Boolean = leeftijd >= 18

Documentatie voor Kotlin

We gaan in sneltreinvaart door de belangrijkste eigenschappen van Kotlin. Op de website van Kotlin vind je hier een uitgebreidere beschrijving. Zo lees je bijvoorbeeld onder Basics / Control Flow hoe je beslissingen kunt nemen of lussen kunt inbouwen. Het is altijd handig dit als referentie erbij te gebruiken.

Kotlin biedt online een uitgebreide referentie voor de programmeertaal.

Lussen

Lussen gebruik je om opdrachten te herhalen. In dit voorbeeld gebruiken we een lus om de getallen 1 tot en met 10 te doorlopen:

for (x in 1..10) {

println(x)

}

Een lus kun je handig gebruiken voor het doorlopen van een lijst:

var fruit: MutableList<String> = mutableListOf("appel","peer","banaan")

for (fruitsoort in fruit) {

println(fruitsoort)

}

Functies

We werken steeds in main, in feite het hoofdprogramma, maar je kunt hierin ook zelf functies schrijven. Aan zo’n functie kun je eventueel argumenten meegeven, zoals ook bij de functie main zelf gebeurt. Functies voeg je steeds toe binnen de functie main en pas nadat je de functie hebt geschreven kun je deze daadwerkelijk aanroepen. Als voorbeeld schrijven we een eenvoudige functie berekenSom() die twee gehele getallen accepteert en toekent aan de variabelen a en b van het type Int. Die variabelen kun je dan in je programma gebruiken om bijvoorbeeld de som van de getallen te printen:

fun main(args: Array<String>) {

fun berekenSom(a: Int, b: Int) {

println(a + b)

}

berekenSom(12, 5)

}

Je kunt natuurlijk ook een lijst gebruiken om bijvoorbeeld voor een reeks getallen de som te laten berekenen. Dat kan er dan als volgt uitzien:

fun telGetallenOp(getallen: Array<Int>) {

var som: Int = 0

for (getal in getallen) {

som = som + getal

}

println(som) // 20

}

telGetallenOp(arrayOf(12, 5, 3))

In het bovenstaande voorbeeld printen we de som binnen onze functie, maar je kunt de som ook retourneren, zodat je er in je hoofdprogramma iets aan hebt. Daarvoor geef je in de functiedeclaratie op welk gegevenstype wordt geretourneerd, in dit voorbeeld een Int. De waarde ken je toe aan een variabele (in dit voorbeeld resultaat) als je de functie aanroept:

fun main(args: Array<String>) {

fun telGetallenOp(getallen: Array<Int>) : Int {

var som: Int = 0

for (getal in getallen) {

som = som + getal

}

return som

}

var resultaat = telGetallenOp(arrayOf(12, 5, 3))

println(resultaat) // 20

}

Voorbeeld-apps gebruiken

Je kunt GitHub gebruiken om je eigen code te verspreiden, zoals we later in deze cursus laten zien. Maar er zijn op GitHub ook veel apps waarvan je de broncode direct kunt downloaden en gebruiken. Dat is handig voor studiedoeleinden of zelfs als basis voor je eigen project. Als je net begint, kan zo’n kant-en-klaar project wel wat overweldigend zijn. Gebruik het als zo’n aanpak voor jou werkt.

Als het gaat om het leren programmeren, is het vaak beter om je kennis stap voor stap op te bouwen. Op www.github.com/android vind je veel voorbeeld-apps van Google voor Android, die over het algemeen erg functioneel zijn. Enkele zijn opgebouwd in Java. Als je het prettig vindt, kun je filteren op de programmeertaal Kotlin.

Om een project te gebruiken, bijvoorbeeld de app Sunflower, klik je op Code en dan Download zip. Pak het zip-bestand uit. In de openingsdialoog van Android Studio kies je vervolgens Open an Existing Project en blader je naar de bewuste map waar je de broncode opent. Soms moet je enkele aanvullende plug-ins installeren. Probeer voordat je aanpassingen gaat doen eerst eens of je de app gewoon kunt starten. Mogelijk moet je nog wat bijstellen voordat dit lukt.

Google stelt verschillende voorbeelden voor Android-apps beschikbaar.

0 Reactie(s) op: Zelf mobiele apps bouwen (deel 5)

  • Om te reageren moet je ingelogd zijn. Nog geen account? Registreer je dan en praat mee!
  • Er zijn nog geen reacties op dit artikel.

Wanneer je een reactie plaatst ga je akoord
met onze voorwaarden voor reacties.