Was heißt eigentlich Programmieren?

Wenn du aufschreibst, was ein Computer tun soll, nennt man das Programmieren‌. Das Tolle daran ist, dass du selbst bestimmen kannst, was getan werden soll. Lässt du dein Programm laufen, macht der Computer die Sachen, die du ausgeheckt hast. Natürlich wird er dann nicht dein Zimmer aufräumen und dir auch keine Tasse Kakao ans Bett bringen. Aber kannst du erst mal programmieren, kannst du den Computer sozusagen nach deiner Pfeife tanzen lassen.

Allerdings passiert es gerade beim Programmieren, dass der Computer nicht so will, wie du es gerne hättest. Meistens ist das ein Fehler im Programm. Das Problem kann aber auch irgendwo anders im Computer oder im Betriebssystem liegen. Das Dumme bei Fehlern ist, dass sie sich gern so gut verstecken, dass die Suche danach schon manchen Programmierer zur Verzweiflung gebracht hat.

Vielleicht hast du nun trotzdem Lust bekommen, das Programmieren zu erlernen. Und ausgerechnet noch für die »ganz Kleinen«. Dann brauchst du ja nur noch eine passende Entwicklungsumgebung‌, und schon kann’s losgehen.

Was ist eine Entwicklungsumgebung?

Um ein Programm zu erstellen, musst du erst etwas eintippen. Das ist wie bei einem Brief oder einer Geschichte, die man schreibt. Das Textprogramm dafür kann sehr einfach sein, weil es ja nicht auf eine besondere Schrift oder Darstellung ankommt wie bei einem Brief oder einem Referat. So etwas wird Editor‌ genannt.

Ist das Programm eingetippt, kann es der Computer nicht einfach lesen und ausführen. Jetzt muss es so übersetzt werden, dass der PC versteht, was du von ihm willst. Weil er aber eine ganz andere Sprache spricht als du, muss ein Dolmetscher her.

Du programmierst in einer Sprache, die du verstehst, und der Dolmetscher übersetzt es so, dass es dem Computer verständlich wird. So etwas heißt dann Compiler‌.

Im Prinzip kann man für Android mehrere Programmiersprachen benutzen, am meisten verbreitet ist Java. Hier gibt es als Dolmetscher die Java Virtual Machine‌ (kurz JVM‌). Diese Art »Zwischencomputer« lässt sich kostenlos installieren.

Eigentlich wird ein Java-Programm also an die JVM weitergereicht, die es dann für den jeweiligen Computer passend zubereitet: Das kann ein PC z.B. mit Windows sein. Oder ein Smartphone z.B. mit Android. Ein und dasselbe Java-Programm kann so im Prinzip auf jedem beliebigen Gerät funktionieren, das über eine JVM verfügt.

Schließlich müssen Programme getestet, überarbeitet, verbessert, wieder getestet und weiterentwickelt werden. Dazu gibt es noch einige zusätzliche Hilfen. Daraus wird dann ein ganzes System, die Entwicklungsumgebung.

Warum gerade Java?

Leider kannst du nicht einfach programmieren, wie dir der Mund gewachsen ist. Eine Programmiersprache‌ muss so aufgebaut sein, dass möglichst viele Menschen in möglichst vielen Ländern einheitlich damit umgehen können.

Weil in der ganzen Welt Leute zu finden sind, die wenigstens ein paar Brocken Englisch können, besteht auch fast jede Programmiersprache aus englischen Wörtern. Es gab auch immer mal Versuche, z.B. in Deutsch zu programmieren, aber meistens klingen die Wörter dort so künstlich, dass man lieber wieder aufs Englische zurückgreift.

Eigentlich wäre es egal, welche Programmiersprache du benutzt. Am besten eine, die möglichst leicht zu erlernen ist. Doch in der Android-Welt ist die Nummer 1 die Programmiersprache Java‌, mit der du es auch in diesem Buch zu tun hast. Diese gehört inzwischen zu den am meisten verbreiteten Sprachen im Computer-Bereich. Sie ist nicht einfach, aber auch für Anfänger geeignet, die mit Java ihre erste Programmiersprache lernen wollen. Und: Es ist eine Sprache, die Smartphones und Tablets mit Android gut verstehen.

Der Weg zum guten Programmierer kann ganz schön steinig sein. Nicht selten kommt es vor, dass man die Lust verliert, weil einfach gar nichts klappen will. Das Programm tut etwas ganz anderes, man kann den Fehler nicht finden und man fragt sich: Wozu soll ich eigentlich programmieren lernen, wo es doch schon genug Apps gibt? Und dann noch ausgerechnet für Android. Aber du verspürst da einen Reiz, eigene Apps zu schreiben? Es ist also nicht nur einen Versuch wert, es kann sich durchaus lohnen, das Programmieren zu erlernen.

Android Studio, die Entwicklungsumgebung zum Buch

Um den Kauf einer Entwicklungsumgebung für Java und für Android musst du dich nicht kümmern, beides bekommst du kostenlos aus dem Internet.

Google stellt dir Android Studio‌ zur Verfügung, eine komfortable und leistungsstarke Entwicklungsumgebung, mit der du unter allen Versionen von Windows programmieren kannst. Android Studio macht es auch möglich, Smartphones und Tablets zu simulieren und damit alle Apps erst mal auf dem PC unter Windows zu testen.

Wie man Android Studio und Java aus dem Internet holt und installiert, erfährst du in Anhang A.

Wie arbeite ich mit diesem Buch?

Grundsätzlich besteht dieses Buch aus einer Menge Text mit vielen Abbildungen dazwischen. Natürlich habe ich mich bemüht, alles so zuzubereiten, dass daraus lauter gut verdauliche Happen werden. Damit das Ganze noch genießbarer wird, gibt es zusätzlich noch einige Symbole, die ich dir hier gern erklären möchte:

Was brauchst du für dieses Buch?

Installiert wird Java in ein Verzeichnis deiner Wahl, z.B. C:\Programme\Java. Auch Android Studio muss installiert werden und auch hier kannst du das Verzeichnis selbst bestimmen, z.B. C:\Programme\Android. Zusätzlich empfiehlt es sich, auf einem anderen Laufwerk einen Arbeitsordner für die Projekte einzurichten, z.B. D:\Projekte.

Die Beispielprogramme in diesem Buch gibt es alle als Download von der Homepage des Verlages, falls du keine Lust zum Abtippen hast:

http://www.mitp.de/899

Und auch die Lösungen zu den Fragen und Aufgaben sind dort untergebracht.

Hinweise für Lehrer

Dieses Buch lässt sich natürlich auch für den Informatik-Unterricht verwenden. Dort setzt natürlich jeder Lehrer seine eigenen Schwerpunkte. Benutzen Sie an Ihrer Schule bereits ein Werk aus einem Schulbuchverlag, so können Sie dieses Buch in Ergänzung zu dem vorhandenen Schulbuch einsetzen. Weil wir hier sozusagen »bei null« beginnen, ist auch ein direkter Einstieg in Java möglich – ohne irgendwelche anderen Programmierkenntnisse.

Der wesentliche Schwerpunkt in diesem Buch ist die Programmierung für das vor allem bei Smartphones weitverbreitete Betriebssystem Android. Dabei kommt auch die objektorientierte Programmierung nicht zu kurz.

In den Projekten werden die wesentlichen Elemente des Java-Wortschatzes wie auch die wichtigsten Komponenten für eine Android-Applikation (App) eingesetzt. In den Lösungen zu den Aufgaben finden Sie weitere Vorschläge zur Programmierung.

Android Studio starten

‌Bevor wir mit dem Programmieren anfangen können, muss das Entwicklungssystem Android Studio installiert werden. Genaues erfährst du im Anhang A. Hier solltest du dir von jemandem helfen lassen, wenn du dir das Einrichten nicht allein zutraust.

Eine Möglichkeit, Android Studio zu starten, ist diese:

• Öffne den Ordner, in den du Android Studio untergebracht hast (z.B. C:\programme\Android).

Dort musst du nun weiter in einen Unterordner mit dem Namen BIN wechseln:

Hier suchst du unter den vielen Symbolen eines der grünen heraus, und zwar das mit dem Namen studio.exe.

• Nun kannst du das Programm mit einem Doppelklick auf das Symbol starten.

Beim ersten Start kann es sein, dass dich noch ein Überbleibsel von der Installation erwartet.

Ein Setup Wizard‌ informiert dich über einige installierte Elemente (die du zum Teil später noch kennenlernen wirst).

• Schließe dieses Fenster mit einem Klick auf Finish.

Je nach Computer kann es eine Weile dauern, bis Android Studio geladen ist. Einige Zeit später landest du in einem Willkommen-Fenster.

Du möchtest gern gleich mit einem neuen Projekt beginnen? Das könntest du mit einem Klick auf Start a new Android Studio project direkt in die Wege leiten.

Besser aber ist es, wir leisten noch ein bisschen Vorarbeit.

Der SDK Manager

• Um das System auf den neuesten Stand zu bringen und das nötige »Drumherum« zu installieren, klicke unten rechts auf das kleine Dreieck hinter Configure.

• Es öffnet sich ein kleines Menü, wo du auf SDK Manager klickst.

Es öffnet sich ein neues Zusatzfenster. (Möglicherweise wird noch einiges geladen, ehe es dir zur Verfügung steht.)

‌Unter der Option Android SDK kannst du dir nun die Android-Versionen aussuchen, für die du deine Apps programmieren willst. Bedenke, dass es bis zu einer Stunde (und länger) dauern kann, bis alles heruntergeladen und installiert ist. Ich habe mich entschieden, alle älteren Versionen mindestens ab 5.0 (Level 21) zu bedienen, musste dafür jedoch teilweise sehr lange warten.

• Nach deiner Auswahl klickst du auf OK.

Nun musst du noch die Lizenz-Bestimmungen absegnen.

• Markiere unten den Eintrag Accept und klicke dann auf Next. Damit startest du die Installationen.

In einem neuen Fenster kannst du die langwierigen Downloads und Installationen mitverfolgen, wenn du willst.

• Am Schluss beendest du das Ganze mit einem Klick auf Finish.

Und du landest wieder im Willkommen-Fenster von Android Studio.

Ein neues Projekt erzeugen

Und nun kannst du endlich in dein erstes Projekt einsteigen.

• Dazu klickst du auf die Schaltfläche Start a new Android Studio project.

Ein neues Dialogfeld mit dem Titel Create New Project erscheint und fordert dich heraus. Dann musst du etwas eingeben und gleich eine weitere Entscheidung treffen.

Zuerst braucht dein Projekt einen Namen. Du kannst natürlich My Application stehen lassen, doch ich empfehle dir, stets einen eigenen neuen Namen zu vergeben. Nennen wir das erste Projekt einfach Projekt1, auch weil wir noch nicht wissen, was genau die App, die nachher herauskommt, macht.

• Tippe hinter Application Name einen neuen Namen ein.

Weiter unten wird das Verzeichnis angezeigt, in dem dein Projekt untergebracht werden soll. Im Allgemeinen bietet Android Studio einen Platz im Benutzer-Ordner auf Laufwerk C: an. Ich schlage vor, die Projektdateien in einem anderen Laufwerk und Ordner unterzubringen.

Dazu könntest du einen weiteren Ordner in D:\Android mit dem Namen Projekte erstellen. Wenn dir das zu umständlich ist, lasse einfach den angebotenen Speicherort hinter Project location stehen.

• Wenn Name und Speicherort feststehen, kannst du auf Next klicken.

Im folgenden Fenster genügt es, wenn ein Haken vor Phone and Tablet steht. Wir wollen eine App (= Applikation) für Smartphones entwickeln, aber wenn das Ding auch auf einem Tablet läuft, umso besser (an anderen Geräten sind wir derzeit nicht interessiert).

• Sorge dafür, dass die Android-Version eingestellt ist, mit der du arbeiten willst. Dann klicke auf Next.

Und nun geht es um die Activity‌. So nennt man ein Benutzerinterface.‌ Das ist die Verbindungsstelle zwischen dem Benutzer (z.B. dir) und einem Smartphone. Vereinfacht kann man hier sagen: ein Fenster auf dem Display. Also quasi der Rahmen für die Aktivitäten einer App. Du solltest dich hier für eine »Empty Activity« entscheiden, also sozusagen ein »Fenster mit nix drin«.

• Sorge dafür, dass Empty Activity markiert ist, und klicke dann auf Next.

Auch im folgenden Fenster kannst du alles für dein aktuelles Projekt so stehen lassen.

• Diesmal klickst du auf Finish und schließt damit auch das Fenster.

Nun beginnt Android Studio, deine Einstellungen zu verarbeiten. Das kann eine Weile dauern.

Was dich dann erwartet, könnte etwa so oder ähnlich aussehen:

‌Für den ersten Augenblick mag das ein bisschen sehr verwirrend sein. Doch fangen wir ganz oben an. Dort sitzt die Menüleiste. Darunter befinden sich mehrere Symbole, die man mit der Maus anklicken kann.

‌Von den vielen Menüs wirst du wahrscheinlich diese am meisten benutzen:

• Über das File-Menü kannst du Dateien speichern, laden (öffnen), ausdrucken, neu erstellen oder Android Studio beenden.

• Das Menü Edit hilft dir bei der Bearbeitung deines Programmtextes, aber auch bei anderen Programmelementen. Außerdem kannst du dort bestimmte Arbeitsschritte rückgängig machen oder wiederherstellen.

• Über das Run-Menü sorgst du dafür, dass dein Projekt ausgeführt wird.

• Und das Help-Menü bietet dir vielfältige Hilfsinformationen (auf Englisch) an.

Unter dem Menübereich erwarten dich ein paar Fensterabschnitte:

• Links siehst du eine Spalte, die dem Explorer in einem Fenster unter Windows entspricht, hier werden die Bestandteile deines Projekts aufgelistet. (Möglicherweise sieht es bei dir anders aus, z.B. wenn oben nicht Android eingestellt ist und die Listen eingeklappt sind.)

• Rechts steht der sogenannte Quelltext, mit dem du jetzt sicher noch nichts anfangen kannst.

• Ganz unten sind weitere Informationen. Dort werden unter anderem auch Fehler gemeldet.

Der AVD Manager

Haben wir etwa schon ein Programm bzw. eine App?

• Probiere einfach aus, was passiert, wenn du im Run-Menü auf den ersten Eintrag Run 'app' klickst (oder auf den grünen Pfeil in der Symbolleiste).

Nach einer Weile bekommst du dieses Dialogfeld zu sehen:

Mit »No USB devices« ist gemeint, dass offenbar kein Smartphone oder Tablet per USB am Computer angeschlossen ist. Und das »none« unter Connected Devices weist darauf hin, dass auch kein Smartphone emuliert wird. Ansonsten ist darunter gähnende Leere.

Wir müssen also nur ein solches Gerät, genannt Android Virtual Device (kurz: AVD)‌ finden und das aktivieren.

• Klicke auf Create New Virtual Device.

Und schon erscheint ein neues Dialogfeld mit dem Titel Select Hardware. Hier findest du unter Phone eine ganze Reihe von Smartphones, die offenbar unter Android Studio emuliert werden können.

• Markiere das Gerät, das du haben willst, und klicke dann auf Next.

Und schon landest du im nächsten Dialogfeld mit dem Titel System Image.

Hier wählst du eines der Android-Systeme aus der Liste. Was darin steht, hängt auch davon ab, wie viel du mit dem SDK Manager installiert hast.

• Gegebenenfalls musst du noch Dateien für die betreffenden Versionen nachladen. Klicke also hinter dem Namen der Version auf Download.

Anschließend sollte das System deiner Wahl markiert sein.

• Klicke nun auf Next.

Und damit bist du fast fertig.

• Im letzten Dialogfeld kannst du für den Emulator (AVD) noch einen eigenen Namen eingeben, wenn du willst. Klicke abschließend auf Finish.

Und damit landest du wieder am Anfang. Nun hast du eine Liste mit einem neuen Emulator. (Diese Liste kannst du natürlich später beliebig erweitern.)

• Um das Ganze abzuschließen, klicke auf OK.

Die Emulation starten

Und nun wollen wir schauen, ob wir unser erstes Programm zum Laufen kriegen.

• Dazu klickst du wieder im Run-Menü auf Run 'app' (oder auf den grünen Pfeil in der Symbolleiste).

Das letzte Dialogfeld öffnet sich erneut.

• Klicke hier einfach (noch mal) auf OK. Und warte.

Kurz darauf tut sich ein weiteres, diesmal eindrucksvoll großes bzw. hohes Fenster auf, das wie ein Smartphone aussieht.

Warten wir jetzt erst einmal gelassen, bis das Emulations-Fenster so oder ähnlich aussieht:

Obwohl wir in Sachen Programmierung noch keinen Finger gerührt haben, erscheint hier schon ein Gruß an alle Welt (auf Englisch).

Android Studio beenden

‌Das erste Projekt ist erstellt und gelaufen. Was will man bei diesem Aufwand mehr? Natürlich willst du mehr, doch jetzt solltest du für eine Pause erst mal Android Studio verlassen.

Das geht in zwei Schritten. Neben dem Smartphone siehst du eine Steuer-Leiste. Mit Klick auf das Symbol für Power schaltest du das emulierte Smartphone aus.

• Klicke auf das kleine X ganz oben, um den Emulator zu schließen.

• Wenn dir dieses Meldefenster begegnet, solltest du auf Yes klicken.

Damit musst du beim nächsten Mal nicht mehr so lange warten, bis der Emulator gestartet ist.

• Zurück im Hauptbereich von Android Studio klickst du auf File und dann auf Exit. (Oder du klickst auch hier ganz oben rechts auf das kleine X.)

In einem weiteren Meldefenster wird noch einmal nachgefragt:

• Klicke auf Exit. (Wenn du dieses Fenster nicht mehr sehen willst, musst du vorher Do not ask me again markieren.)

Zusammenfassung

Eine eigene App. Dieses Ziel haben wir hier nicht erreicht. Noch nicht. Aber du hast schon mal einen ersten Eindruck über die Arbeit mit Android Studio gewonnen. Aller Anfang ist schwer? Hier passt es, doch der erste Hürdenlauf ist geschafft.

Du weißt jetzt etwas über

• den SDK Manager, der für die Android-Entwicklungspakete zuständig ist.

• den AVD Manager, der sich um die Smartphone-Emulatoren kümmert.

Du weißt, dass du eine Activity, ein Benutzerinterface als Aktionsrahmen für dein Projekt brauchst. Und du kennst schon ein paar Operationen im Umgang mit Android Studio:

Zwei Fragen …

1. Was bedeuten SDK und AVD?

2. Was ist eine Activity?

… aber noch keine Aufgaben

Design und Layout

‌‌Nun solltest du deinem ersten Projekt auch einen eigenen Stempel aufdrücken. Dazu musst du wieder hinein in die Arbeitsumgebung von Android Studio.

• Starte also Android Studio erst einmal neu.

Und einige Zeit darauf landest du ohne große Umschweife direkt in deinem Projekt.

Du siehst im Hauptfenster von Android Studio eine für dich vielleicht fremde Ansammlung von Text, auch Quelltext‌ genannt. Der wird dir wohl nur etwas sagen, wenn du schon mal programmiert hast.

Oben siehst du zwei Reiter mit den Namen activity_main.xml und ActivityMain.java. Damit sind auch die Programmiersprachen gekennzeichnet, die wir hier benutzen: XML und Java. Mit beiden werden wir uns im Laufe dieses Buches intensiver befassen. Offenbar gibt es also zwei Fenster mit zwei Quelltexten, die beide für unser Programm zuständig sind.

• Klicke auf den Reiter activity_main.xml.

Da steht dann schon eine ganze Menge mehr Text. Und wenn du etwas genauer hinschaust, dann wirst du irgendwo auch eine Zeile entdecken, in der dieses steht:

android:text="Hello World"

Ob das die Stelle ist, an der wir »Hello World« durch einen anderen Satz ersetzen können? Zum Beispiel mit »Hallo, wie geht es«?

Ehe du nun versuchst, einfach den Textteil Hello World direkt an Ort und Stelle durch einen anderen zu ersetzen, lassen wir hier lieber erst mal alles, wie es ist. Denn am Quelltext selbst sollte nur der »operieren«, der sich wirklich schon mit dem Programmieren auskennt. Und das tust du derzeit noch nicht.

Um am Projekt etwas zu ändern, wechseln wir besser in einen anderen Arbeitsbereich.

• Klicke ganz unten im Editorfenster auf den linken Reiter Design.

Und du landest in einem Bereich, in dem du direkt die Oberfläche deiner App beeinflussen kannst.

Es ist ratsam (aber nicht unbedingt nötig), hier gleich ein paar Änderungen vorzunehmen:

In der Leiste oberhalb des »Smartphone-Displays« siehst du den Eintrag Nexus (vielleicht steht da auch etwas anderes).

• Wenn du das ändern willst, öffne das zugehörige Menü und wähle am besten dein eigenes AVD-Gerät (oder ein anderes aus einer langen Liste).

Daneben gibt es die Möglichkeit, die Android-Version (als Nummer) einzustellen, in der das ganze Layout erscheinen soll.

• Wenn du willst, lasse alles, wie es ist. Oder suche dir eine (andere) Version aus. Du kannst das aber auch automatisch regeln lassen.

Bei dir war beim Start das linke Display leer? Eigentlich müsste man in der Darstellung den Text "Hello World" in der Mitte sehen. Wenn nicht, musst du das Erscheinungsbild ändern.

• Klicke dazu auf die Schaltfläche AppTheme.

Im folgenden Dialogfenster werden dir zahlreiche Layouts angeboten, von denen in der Abbildung nur einige wenige aufgeführt sind.

• Suche dir eines dieser »Themes« (außer AppTheme) aus und klicke dann auf OK.

Bei mir hat das Ganze jetzt dieses Aussehen:

• Wenn du willst, kannst du das noch reduzieren. Klicke dazu oben links auf das Symbol für Design Surface. Dann wähle im Menü Design.

Anschließend siehst du nur noch ein Display, die blaue Fläche daneben ist verschwunden.

Von Hello zu Hallo

‌Was uns jetzt interessiert, ist der Eintrag TextView „Hello World!“ im kleinen Component-Tree-Fenster unten links.

• Klicke darauf, sodass die Zeile markiert ist.

‌Im Fenster ganz rechts findest du ein Schema für die Position der Textanzeige und darunter einige Einträge. Das ist die Attributes-Liste. Wir kümmern uns jetzt um die Zeile, in der links text und rechts daneben Hello World steht.

• Klicke ganz rechts auf den kleinen Button (mit den drei Pünktchen).

Es erscheint ein Dialogfeld mit dem Titel Resources. Es ist eigentlich deutlich größer als die Abbildung und auf der linken Seite stehen zahlreiche Einträge untereinander, die dich aber aktuell nicht interessieren müssen.

• Klicke auf Add new Resource und direkt darunter auf New String Value.

Nun erscheint ein Fenster mit dem Titel New String Value Resource. Hier kannst du einen Namen und einen Wert für den neuen Text eingeben.

• Tippe hinter Resource Name ein: Hallo_Frage. Dann tippe hinter Resource Value ein: Hallo, wie geht es?

• Damit hast du eine neue Zeichenkette festgelegt. Klicke abschließend auf OK.

Dein neuer String taucht nun in der Anzeige auf.

Probieren wir jetzt aus, ob unser Projekt mit dem neuen String zurechtkommt.

• Klicke auf Run und Run 'app'.

Sorge dafür, dass dein Emulator markiert ist, und klicke auf OK.

Nun heißt es wieder eine Weile warten, bis endlich die Anzeige erscheint, die von dir stammt: der Satz »Hallo, wie geht es?« (→ Projekt1).

Damit du den Emulator nicht immer neu starten musst, kannst du ihn auch einfach laufen lassen. Wechsle direkt in das Hauptfenster von Android Studio. Dort geht es jetzt weiter.

Gut oder Schlecht

Der Anzeigetext »Hallo, wie geht es?« verlangt nach einer Antwort. Das heißt, derjenige, der diese App benutzt, sollte auch die Möglichkeit haben, darauf zu antworten. Am besten ganz einfach per Fingertipp.

Dazu brauchen wir eine neue Komponente, die Button‌ genannt wird. Man sagt auch Schaltfläche‌. Und viele sprechen einfach von einem Knopf. Wichtig ist, dass man diesen Bereich mit dem Finger antippen bzw. im Emulator mit der Maus anklicken kann.

Eine Komponente kennst du ja schon: das Anzeigefeld oder Textfeld‌, auch TextView‌ genannt. Das ist die Fläche, in der der Text »Hallo, wie geht es?« angezeigt wird.

Bevor du eine neue Komponente einsetzt, solltest du erst einmal die bereits vorhandene verschieben. Und zwar nach oben.

• ‌Dazu klickst du auf das Textfeld im Display des angezeigten Smartphones und schiebst es dann bei gedrückter Maustaste nach oben.

• ‌‌‌Nun suchst du unter Widgets nach dem Eintrag Button und klickst darauf.

• Dann ziehe die Maus mit gedrückter linker Taste ins Display-Feld des angezeigten Smartphones.

Du siehst bereits angedeutet, wo der Button platziert wird, er lässt sich durch die Mausbewegung nach oben oder unten verschieben.

• Wenn du eine Position gefunden hast, die dir passt, lasse die linke Maustaste los.

Und es gibt eine neue Komponente mit der Aufschrift »Button«. Weil uns eine Antwort nicht reicht, wiederholen wir das Ganze jetzt gleich noch mal.

• Markiere links erneut den Eintrag Button, ziehe die Maus auf eine Stelle im Display neben dem bereits vorhandenen Button und lasse die Maustaste los.

Nun müsste es bei dir etwa so aussehen:

Klar, dass wir die Aufschriften »Button« nicht so stehen lassen können. Also sollten wir sie schleunigst ersetzen. Ich schlage vor, wir bieten die klassischen Antworten »Gut« und »Schlecht« an.

• Markiere den linken Button. Dann suche in der Liste rechts unten den Eintrag text, rechts daneben steht Button.

• Klicke ganz rechts auf den kleinen Button (mit den drei Pünktchen).

‌Es erscheint das dir schon bekannte Dialogfeld mit dem Titel Resources, dort steht ja unter anderem auch dein Begrüßungs-String Hallo_Frage in der Liste.

• Klicke wieder auf Add new Resource und direkt darunter auf New String Value.

Im nächsten Fenster mit dem Titel New String Value Resource wird nun wieder ein Name und ein Wert für den neuen Text verlangt.

• Tippe hinter Resource Name ein: Antwort_Gut. Tippe hinter Resource Value ein: Gut. Klicke dann zur Bestätigung auf OK.

Sobald du zurück im Hauptfenster von Android Studio bist, zeigt der linke Button auch schon seine neue Aufschrift.

• Und nun darfst du dem zweiten Button die Aufschrift »Schlecht« geben. Für den Namen kannst du Antwort_Schlecht benutzen.

Wenn dir das gelungen ist, dürfte es auch in deinem Projekt so aussehen:

Nun spricht nichts dagegen, das Projekt in seinem jetzigen Zustand einmal über den Emulator zu schicken (→ Projekt1).

• Klicke auf Run und Run 'app'.

Diesmal geht es etwas flotter, weil der Emulator bereits im Hintergrund lauert.

• Sollte erst das bekannte Fenster auftauchen, musst du nur auf OK klicken.

Etwas später bekommst du ein solches Bild:

Überzeugend sieht es bei mir nicht aus, eher so, als hätten sich die beiden Buttons ineinander verhakt. Es kann auch sein, dass beide Buttons ganz oben links in der Ecke »hängen«. Mal schauen, was sich da machen lässt.

• Zurück in Android Studio klickst du links auf einen Button-Eintrag und schaust rechts nach einem Schema, das etwa so aussieht:

Hier lässt sich einstellen, wie weit eine Komponente vom Display-Rand entfernt sein darf bzw. muss. Ich habe für meine Buttons diese Werte gewählt:

• Klicke auf eins der kleinen blauen Symbole, dann kannst du einen Wert eintippen. Du musst nicht alles ändern, möglicherweise genügen die Werte für den linken und rechten Rand. Gegebenenfalls musst du später noch mal etwas ändern.

Nun sollte das Ganze nach einem erneuten Start etwa so aussehen: