{"id":2873,"date":"2023-10-13T16:47:23","date_gmt":"2023-10-13T14:47:23","guid":{"rendered":"https:\/\/www.art-events.de\/weblog\/?p=2873"},"modified":"2023-10-16T16:29:43","modified_gmt":"2023-10-16T14:29:43","slug":"ae-android-kochbuch-texte-anzeigen-u-eingeben-buttons","status":"publish","type":"post","link":"https:\/\/www.art-events.de\/weblog\/ae-android-kochbuch-texte-anzeigen-u-eingeben-buttons\/","title":{"rendered":"AE Android Kochbuch: Texte anzeigen u. eingeben, Buttons"},"content":{"rendered":"

Teil2 AE Android Kochbuch: Layout Design, Text anzeigen und Text eingeben<\/p>\n

Unser AE Android Kochbuch f\u00fcr Praktiker. Hier zeige ich euch wie ihr schnell und einfach Android programmieren lernt. Tipps aus der Praxis. Vorweg noch mal der Hinweis: Dieses ist zwar ein Grundkurs, aber ihr solltet schon etwas Grundlagenwissen haben. Zum Beispiel wissen, was eine Variable ist, und dass man Zahlen in Integer und Texte in String Variablen speichert. Wenn euch solche Basics noch fremd sind \u2013 ich empfehle die ersten Kapitel vom Buch Java ist auch nur eine Insel oder andere Literatur, die euch in solche grundlegenden Dinge einf\u00fchrt.<\/p>\n

Den ersten Teil der Einf\u00fchrung findet ihr hier. Android Programmieren Getting Started und Device Manger<\/a><\/p>\n

<\/a>Hier im Teil2:<\/h1>\n

Inhaltsverzeichnis<\/strong><\/p>\n

Hier im Teil2: 1<\/a><\/p>\n

Sch\u00f6n soll es aussehen. Die Sache mit dem Layout 2<\/a><\/p>\n

Lineares Layout 2<\/a><\/p>\n

TextView – einen Text anzeigen 5<\/a><\/p>\n

EditText – eine Eingabe anfordern 7<\/a><\/p>\n

Einen Button anzeigen 8<\/a><\/p>\n

Anwendung im Emulator ausf\u00fchren 9<\/a><\/p>\n

Java Code: Texte \u00e4ndern 11<\/a><\/p>\n

Kommentieren bis der Arzt kommt 12<\/a><\/p>\n

Variablen sind wichtig 12<\/a><\/p>\n

Variablen global oder lokal 12<\/a><\/p>\n

Variablen Initialisierung 13<\/a><\/p>\n

Der Programmcode 14<\/a><\/p>\n

Java Code: eine Android Eingabe auswerten 16<\/a><\/p>\n

Der KeyListener reagiert auf Benutzerereignisse 16<\/a><\/p>\n

Button Click mitbekommen und auswerten 18<\/a><\/p>\n

<\/a>Sch\u00f6n soll es aussehen. Die Sache mit dem Layout<\/h1>\n

Wer schon einmal Desktop Windows Anwendungen programmiert hat, kennt es komfortabel: Einfach das gew\u00fcnschte Element (Button, Textbox etc) mit der Maus anklicken und an die Stelle des Bildschirms zotteln, wo man es hin haben m\u00f6chte. Dann noch 2x drauf klicken und sofort Programmcode programmieren, der beim Dr\u00fccken, Maus klicken oder sonstiger Aktion auszuf\u00fchren ist. Fertig.<\/p>\n

Ganz so praktisch ist es in der Android Welt im Moment noch nicht. Allerdings l\u00e4sst euch Android nicht alleine und bietet einige verschiedene Modell der Layoutgestaltung an. Was allerdings toll ist: ihr k\u00f6nnt die Modelle auch kombinieren und so jederzeit zwischen den Layouts wechseln, die f\u00fcr eure Anwendung optimal erscheinen.<\/p>\n

Im ersten Teil dieses Kurses haben wir mit dem Android Studio eine neue Anwendung mit einer leeren (empty) Activity erstellt. Standardm\u00e4\u00dfig hat das Android Studio hierf\u00fcr Layout gew\u00e4hlt, das sich Constraint Layout nennt. In Business Anwendungen wird jedoch oftmals das Linear Layout verwendet, das ich nachfolgend weiter vorstellen m\u00f6chte.<\/p>\n

<\/a>Lineares Layout<\/h2>\n

Wie schon im Namen erkennbar, wird hierbei der Bildschirm linear in Zeilen eingeteilt. Von oben nach unten \/ vertikal. Oder alternativ: horizontal auf einer Zeile. Wir k\u00f6nnen also z.b. einen Text in Zeile1 anzeigen, in Zeile2 eine Eingabe holen und in Zeile3 mit einem Button speichern.<\/p>\n

Das Ganze funktioniert dann wie eine Tabelle mit mehreren Zeilen und eine oder mehreren Spalte(n). Wenn ihr innerhalb einer Zeile mehr Elemente unterbringen m\u00f6chtet, f\u00fcgt ihr einfach eine Zeile mit mehreren Spalten hinzu. Hierbei wird dann das horizontale Layout in das vertikale Layout eingebettet. Einfach mal als Beispiel in Tabellendarstellung:<\/p>\n\n\n\n\n
Zeile1, Spalte1<\/td>\n<\/tr>\n
Zeile2, Spalte1<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n\n\n\n
Zeile3, Spalte1<\/td>\nSpalte2<\/td>\nSpalte3<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n\n\n\n
Zeile4, Spalte1<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n\n\n\n
Zeile5, Spalte1<\/td>\nSpalte2<\/td>\nSpalte3<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Um in unserer noch leeren Anwendung das Lineare Layout zu erhalten, schalten wir unser bisheriges Layout in das Lineare Layout um. Wie das geht? –\u00a0Wechselt in den Design Editor:<\/p>\n

<\/p>\n

Markiert den Text Constraint.Layout mit der rechten Maustaste, w\u00e4hlt Convert View und dann LinearLayout.<\/p>\n

<\/p>\n

Anschlie\u00dfend \u00e4ndert sich der Inhalt eurer Layout Datei und wird automatisch auf Linear umgestellt.<\/p>\n

Standardm\u00e4\u00dfig w\u00e4hlt das Studio das Linear Layout in Horizontal. Das wollen wir nicht. Also noch einmal mit der rechten Maustaste jetzt auf LinearLayout und w\u00e4hlt als Orientierung vertical aus, denn wir wollen unsere Anwendung in Zeilen untereinander pr\u00e4sentieren.<\/p>\n

<\/p>\n

Wechselt von der Darstellung DESIGN auf Darstellung SPLIT, um die \u00c4nderung zu sehen.\u00a0Wenn ihr das erledigt habt und euren Editor jetzt auf SPLIT umstellt, seht ihr das Element und seine Attribute.<\/p>\n

<\/p>\n

Wir werden zuk\u00fcnftig recht h\u00e4ufig zwischen den Editor Ansichten hin- und herschalten. Macht euch am besten mit den Unterschieden von DESIGN, SPLIT und CODE vertraut. Ich pers\u00f6nlich nutze am h\u00e4ufigsten DESIGN, um Elemente einzuf\u00fcgen und SPLIT, um die Elemente dann wunschgem\u00e4\u00df zu ver\u00e4ndern.<\/p>\n

<\/a>TextView – einen Text anzeigen<\/h1>\n

Unter Windows hei\u00dft das Element zum Anzeigen von Texten Label. Unter Android: TextView.<\/p>\n

Wechselt in den DESIGN Editor und zieht von der Palette unter Common eine TextView in die Darstellung eures Android Ger\u00e4tes. Da wir das Lineare Layout verwenden, wird die TextView jetzt erst einmal ganz oben in der Zeile dargestellt.<\/p>\n

<\/p>\n

Wenn ihr jetzt wieder zum Reiter SPLIT wechselt, k\u00f6nnt ihr die Attribute der neuen TextView sehen und bearbeiten.<\/p>\n

<\/p>\n

Ich will euch nicht mit einer Auflistung von Attributen langweilen. Die meisten sind selbst erkl\u00e4rend. Jedoch: Attribute gibt es viele. Im DESIGN Editor seht ihr diverse Attribute, die einem Element automatisch zugef\u00fcgt werden, wenn ihr sie ausf\u00fcllt. Alternativ k\u00f6nnt ihr im CODE oder SPLIT Editor auch direkt im XML Code \u00e4ndern und seht dann auch die Auswirkungen der \u00c4nderungen.<\/p>\n

Wenn ihr im DESIGN Editor ein Element in die Darstellungsfl\u00e4che zieht, werden sofort die wichtigsten Attribute automatisch angelegt. Was uns jetzt am meisten interessiert sind:<\/p>\n

id=
\n<\/strong>Dann folgt die Kennung unter der wir diese TextView sp\u00e4ter im Programmcode nutzen k\u00f6nnten, z.B. wenn wir Texte ver\u00e4ndern m\u00f6chten<\/p>\n

layout_width= und layout_height=
\n<\/strong>Hier werden Breite und H\u00f6he des Elementes bestimmt und sind momentan auf \u201eabh\u00e4ngig vom Inhalt\u201c gesetzt. Ihr k\u00f6nnt auch mit absoluten Pixeln oder relativen Dots arbeiten, wenn ihr dort etwas umstellen wollt. Am Anfang lassen wir die Grundeinstellungen unver\u00e4ndert.
\n<\/strong><\/p>\n

text=
\n<\/strong>Spannend ist die Attribut Zeile text= – hier wird der Text eingetragen, der sofort angezeigt werden soll. Den k\u00f6nnen wir sp\u00e4ter zur Laufzeit ver\u00e4ndern, wenn wir \u00fcber die id auf das Element zugreifen. Doch jetzt wollen wir hier einen eigenen Text eintragen. Au\u00dferdem geben wir dem Element gleich einen sinnvollen Namen und nennen es textViewName.<\/p>\n

<\/p>\n

Ihr seht, wie sich rechts im Anzeigefenster sofort der Text \u00e4ndert und k\u00f6nnt \u00fcberpr\u00fcfen, ob euch die Darstellung gef\u00e4llt. Nat\u00fcrlich k\u00f6nnt ihr auch die Farbe oder Gr\u00f6\u00dfe \u00e4ndern. Spielt einfach mit den Attributen herum, um ein Gef\u00fchl daf\u00fcr zu bekommen!<\/p>\n

<\/a>EditText – eine Eingabe anfordern<\/h1>\n

Unter Windows Forms nennen wir es Textbox. Unter Android EditText. EditText gibt uns eine Box in der der Benutzer etwas eintragen kann.<\/p>\n

Im DESIGN Editor ziehen wir jetzt eine EditText in unsere Anwendung. Bl\u00f6derweise gibt es im DESIGN Editor dieses Element nicht unter diesen Namen, ihr m\u00fcsst hier Plain Text w\u00e4hlen! Auch hier wieder: mit der Maus markieren, gedr\u00fcckt halten und in die Darstellungsfl\u00e4che ziehen. Das Studio legt dann sofort eine Eingabezeile mit der Beschriftung Name an.<\/p>\n

<\/p>\n

Im Code \/ Split Editor schaut es so aus. Und dort \u00e4ndern wir auch gleich die Id, damit es zueinander passt.<\/p>\n

<\/p>\n

<\/a>Einen Button anzeigen<\/h1>\n

Das mit dem Button d\u00fcrfte Euch jetzt leicht fallen. Erweitert die Anwendung im Design Editor um einen Button, \u00e4ndert die ID und schaut euch das Ergebnis an.<\/p>\n

<\/p>\n

Eure Anwendung hat jetzt schon mal drei Elemente und macht richtig was her.<\/p>\n

<\/p>\n

<\/a>Anwendung im Emulator ausf\u00fchren<\/h1>\n

Wir erinnern uns an den ersten Teil<\/a>. Dort habe ich \u00fcber den Device Manager geschrieben und wie ihr eure Anwendung auf dem PC unter Android simulieren k\u00f6nnt. Wenn ihr im Device Manager schon Android Ger\u00e4te angelegt habt, w\u00e4hlt ein Ger\u00e4t aus und startet die Emulation mit dem gr\u00fcnen Button.<\/p>\n

<\/p>\n

Das Android Studio \u00fcbersetzt das Programm, startet den Emulator und pr\u00e4sentiert euch das Mini Programm im Android Fenster. Ihr k\u00f6nnen jetzt auf das Namensfeld klicken, einen Namen eingeben und den Button bet\u00e4tigen. Allerdings passiert noch nichts \u2013 weil wir den Programmcode hierf\u00fcr noch nicht erarbeitet haben!<\/p>\n

<\/p>\n

<\/a>Java Code: Texte \u00e4ndern<\/h1>\n

Bisher waren wir nur in der XML Layout Datei unterwegs. Um jetzt mit diesen Elementen etwas zu veranstalten kommt Java Programmierung ins Spiel. Wechselt in Fenster zur Anzeige der Java Datei. Ihr seht den vom Studio automatisch erzeugten Programmcode.<\/p>\n

<\/p>\n

Wenn man in der Programmierung, z.B. unter C etwas erreichen will, baut man eine Klasse und f\u00fcllt sie mit Funktionen, die spezielle Sachen machen. In Java hei\u00dfen die Funktionen Methoden und eine Methode muss immer innerhalb einer Klasse stehen. Java und C haben gemeinsam, dass Methoden (bzw. Funktion) in geschweiften Klammern {} stehen und eine Befehlsleile mit dem Semikolon ; beendet wird. Ausnahme: IF Abfragen, Schleifen u.a. Wer mehr zu den Details, zur Syntax und Co wissen will, ich empfehle das Buch<\/p>\n

JAVA IST AUCH NUR EINE INSEL aus dem Rheinwerk Verlag!<\/strong><\/p>\n

https:\/\/www.rheinwerk-verlag.de\/java-ist-auch-eine-insel\/<\/p>\n

In unserem Fall finden wir die Klasse MainActivity und dort eine Methode onCreate, die wohl offensichtlich beim Start dieser Activity aufgerufen wird. Zwei Zeilen stehen schon drin. In der zweiten Zeile wird die XML Layout Datei aktiviert, damit ihr die Darstellung erhaltet, die wir zuvor definiert haben.<\/p>\n

<\/a>Kommentieren bis der Arzt kommt<\/h2>\n

Ich bin ein Freund von Kommentaren im Programmcode! Egal ob englisch oder deutsch, ich f\u00fclle meine Sourcecodes immer mit Kommentaren, um zu beschreiben, was die Codezeilen machen. Dabei trenne ich Methoden voneinander durch Markierungszeichen mit Strichen ab. Das Ganze hat den Vorteil, dass Sourcecodes auch nach Jahren noch lesbar bleiben und ihr selbst oder ein Anderer schnell versteht, was ihr mit den nachfolgenden Befehlszeilen bezweckt! W<\/p>\n

Wie ihr eure Kommentare schreibt ist dabei egal. Wichtig ist der Gedanke: jetzt im Moment wisst ihr genau, was ihr tut. Wenn ihr aber nach Jahren noch (oder jemand anders) in den Sourcecode schaut, muss er \/ sie \/ es schnellstens verstehen, was ihr genau dort macht. Daf\u00fcr sind Kommentare da. Sie sind die Versicherung f\u00fcr die Zukunft \u2013 und jede fehlende Erkl\u00e4rung kann genau dann Schwierigkeiten machen, euren Code nachzuvollziehen.<\/p>\n

<\/a>Variablen sind wichtig<\/h2>\n

Wir werden f\u00fcr jedes Element aus der Layout Datei eine Variable deklarieren. Variablen sind die Dinger, die man im Programmcode setzen, \u00e4ndern, abfragen, zuweisen kann. Sie sind sozusagen das Baumaterial f\u00fcr ein Programm. Grunds\u00e4tzlich gilt: Variablen sind dann wichtig, wenn ihr ihr mit dem Element im Java Code etwas veranstalten wollt!<\/p>\n

<\/a>Variablen global oder lokal<\/h2>\n

Wenn ihr Variablen nur innerhalb einer Methode einsetzen m\u00f6chtet, reicht eine lokale Deklaration. Wollt ihr die gleiche Variable innerhalb der ganzen Klasse verwenden, solltet ihr sie global deklarieren.<\/p>\n

Variablen m\u00fcssen vor einer Verwendung deklariert werden! <\/strong>Eine Deklaration enth\u00e4lt immer den Typ der Variable und ihre Bezeichnung. Bei Variablen au\u00dferhalb einer Methode wird noch ihre Lebensdauer eingef\u00fcgt, z.B. private, um zu zeigen, dass sie nur in einer Klasse g\u00fcltig sind!<\/p>\n

Globale Deklaration hat den Nachteil: ihr solltet Variablen mit dem gleichen Namen nicht noch einmal lokal deklarieren. Sonst kann euer Programm ungewollte Sachen veranstalten \u2013 Stichwort: mangelnde \u00dcbersichtlichkeit! Lokal hat den Nachteil, ihr m\u00fcsst u.U. eine Variable h\u00e4ufiger deklarieren, wenn ihr sie an verschiedenen Stellen nutzen wollt.<\/p>\n

Global: Private static Variablentyp Name_derVariable\r\n<\/strong>private static String Name1;\r\nprivate static TextView TextView1;<\/pre>\n
Lokal: Variablentyp Name_derVariable\r\n<\/strong>String Name2;\r\nTextView TextView2;<\/pre>\n
Ob ihr eure Variablen lokal oder global deklariert, bleibt eigentlich euch \u00fcberlassen. Generell gilt das eingangs gesagte: Wollt ihr sie nur innerhalb einer Methode verwenden, reicht lokal. Sollen sie in der ganzen Klassen allen Methoden zur Verf\u00fcgung stehen m\u00fcsst ihr global w\u00e4hlen. Aber aufpassen: Zu viele globale Variablen machen auch den Code un\u00fcbersichtlich und k\u00f6nnen so Fehler produzieren!<\/p>\n
Fans der reinen Programmierung m\u00f6gen jetzt aufst\u00f6hnen – aber ich pers\u00f6nlich mag es gerne, wenn ich die Elemente der Layout Datei global in allen Methoden meiner Klasse verwenden kann, ohne sie jedes Mal neu zuweisen zu m\u00fcssen. Deshalb setze ich sie auf global private static au\u00dferhalb der Methode, wenn ich absehen kann, dass ich sie in der Klasse noch einmal ben\u00f6tige. Kann ich das nicht erkennen, deklariere ich sie nur lokal in einer Methode. Allerdings sind sie dann auch nur dort bekannt und ihr m\u00fcsst sie wieder neu deklarieren, wenn ihr sie in einer anderen Methode verwenden wollt. Bei einigen Layoutelementen aus der XML Datei kann es immer wieder vorkommen, dass ich sie \u00fcberall in der Klasse \u00e4ndern oder abfragen will. Da spare ich mir gerne Schreibarbeiten und verwende gleich die globale private static Deklaration. Das bedeutet dann: Das Objekt ist in allen Methoden dieser Klasse bekannt und kann sofort genutzt werden.<\/p>\n
<\/a>Variablen Initialisierung<\/h2>\n
Nach oder zusammen mit der Deklaration muss eine Variable initialisiert werden, damit dort auch ein sinnvoller Wert enthalten ist, z.B.<\/p>\n
String MickyMaus = \"Ich bin die Maus\";\r\n\r\nInteger i = 5;<\/pre>\n
Die Initialsierung von Layoutelmenten folgt \u00fcber eine eigene Methode findViewById:<\/p>\n
EditText etName <\/em>= findViewById(R.id.editTextName<\/em>);<\/pre>\n
Doch schauen wir uns den Programmcode an:<\/p>\n
<\/a>Der Programmcode<\/h2>\n
<\/p>\n
Zeile 17-19 globale Deklaration der Variablen, alternativ Zeile 29-31 lokal in der Methode. Letztere Methode ist per Kommentar \u201everschlossen\u201c und daher nicht aktiv. Diese doppelte Deklaration macht nat\u00fcrlich keinen Sinn \u2013 ich habe es nur wg besserer \u00dcbersicht eingebaut, damit ihr seht, wie es aussehen m\u00fcsste, wenn die Variablen lokal deklariert werden.<\/p>\n
Zeile 34-36 Zuweisung der Variablen auf die Steuerelemente in der Layoutdatei.<\/p>\n
Zeile 38-39. Die Zuweisung nutzen wir gleich und und weisen zwei Elementen neuen Anzeigetext hinzu, d.h. wir \u00e4ndern zur Laufzeit der App Texte in den Elementen. Das TextView bekommt einen neuen Inhalt und der Button eine neue Beschriftung.<\/p>\n
Wenn ihr das Ganze jetzt im Emulator ausf\u00fchrt, \u00e4ndert sich euer Programm schon:<\/p>\n
<\/p>\n
<\/a>Java Code: eine Android Eingabe auswerten<\/h1>\n
<\/a>Der KeyListener reagiert auf Benutzerereignisse<\/h2>\n
Kommen wir zum KeyListener. Ein Listener unter Android stellt euch unter Android vordefinierte Methoden bereit, um auf Ereignisse zu reagieren. Ob der Benutzer einen Button dr\u00fcckt, in eine Liste klickt oder was auch immer \u2013 der Listener soll das mitbekommen und dann von euch bestimmten Programmcode ausf\u00fchren.<\/p>\n
F\u00fcr jedes Element, das auf ein Benutzerereignis reagieren soll, m\u00fcsst ihr einen eigenen Listener basteln und diesen in der onCreate Methode zuweisen! Wenig \u00fcberraschend: wenn der Benutzer einen Button dr\u00fcckt, muss in onCreate ein Key Listener definiert werden.<\/p>\n
Ihr k\u00f6nnt die Aktionen f\u00fcr den Listener direkt in der Methode eintragen \u2013 oder z.b. f\u00fcr den Listener eigene Methoden erstellen und alle Buttons in einer eigenen Methode unterbringen.<\/p>\n
Ich bin ein Fan davon, Key Listener in einer separaten Methode zu versammeln. Gerade wenn mehrere Buttons in einer Activity sind, wird meiner Meinung nach so die Lesbarkeit des Codes erleichtert. Man kann sofort nachschauen, was passiert, wenn ein bestimmter Button gedr\u00fcckt wird und muss nicht wild im Code in endlos langen Methoden herum scrollen.<\/p>\n
Doch genug der Vorrede. Wir erweitern unseren Programmcode um den Key Listener f\u00fcr den Button in unserer Activity:<\/p>\n
<\/p>\n
Um den Key Listener schlussendlich zu erzeugen, benutzen wir einfach die Intelligenz vom Android Studio!<\/p>\n
Die rote Wellenlinie unter dem this zeigt uns, dass etwas nicht stimmt und der Nacharbeit bedarf. Cursor auf die rote Wellenlinie setzen und mit der rechten Maustaste \u00f6ffnet sich ein Context Men\u00fc. Das Studio kann uns Vorschl\u00e4ge anzeigen, um das Problem zu beheben: Show Context Actions.<\/p>\n
<\/p>\n
Im Context Men\u00fc schl\u00e4gt uns das Studio gleich zwei M\u00f6glichkeiten vor, die rote Wellenlinie weg zu bekommen. Der zweite Vorschlag ist das, was wir wollen: Android soll einen Key Listener f\u00fcr die Methode onClick einbauen!<\/p>\n
<\/p>\n
Hiermit wird unsere Activity um den onClick Listener erweitert und der Code am Anfang der Klasse sieht jetzt auf einmal so aus:<\/p>\n
<\/p>\n
Anschlie\u00dfend will das Studio noch wissen, ob es eine separate Methode f\u00fcr den KeyListener bei onClick anlegen soll. Das ist dann unsere Alternative: onClick!<\/p>\n
<\/p>\n
Und schon erzeugt uns Android eine neue Methode mit dem noch leeren Key Listener! In letzter Konsequenz hei\u00dft das \u00fcbrigens, das m\u00fcsst nur nur erstmalig beim ersten Button in der Klasse veranstalten. Beim zweiten Button ist dieser Key Listener schon da und ihr k\u00f6nnt ihn gleich mit Leben f\u00fcllen. Daher auch ein Grund, warum ich mit einer separaten Methode arbeite und den KeyListener nicht direkt in onCreate unterbringe: der Tippaufwand wird geringer, wenn man mehr als einen Button hat!<\/p>\n
<\/p>\n
<\/a>Button Click mitbekommen und auswerten<\/h2>\n
Meine Methode mit dem KeyListener baue ich in der Regel mit Switch Anweisungen auf. Hier wird jeder Button eingetragen und der Programmcode hinterlegt, was zu tun ist. Oder es werden weitere Methoden aufgerufen, die irgendwelche Aktionen erledigen, wenn der Button gedr\u00fcckt wird. H\u00e4tten wir weitere Buttons w\u00fcrde wir einfach neue case Anweisungen hinzuf\u00fcgen.<\/p>\n
<\/p>\n
Ihr seht ab Zeile 53, was passieren soll, wenn der Button buttonName gedr\u00fcckt wird. In Zeile 55 wird der Wert Inhalt der Textview an eine globale String Variable gbName \u00fcbergeben und kann dann in weiteren Methoden ausgewertet werden. Was hierzu letztlich noch fehlt \u2013 die globale Deklaration der String Variable in der Klasse aber au\u00dferhalb der Methoden, die wir in unserem Programmcode in Zeile 21 untergebracht hatten:<\/p>\n
private static String gbName<\/em>;<\/p>\n
Das war es mit dem zweiten Teil. Ihr k\u00f6nnt jetzt eigene Elemente in eure Activity einbauen, Texte anzeigen, Eingaben vom Benutzer holen, diese in Variablen speichern, damit ihr damit etwas anstellt.<\/p>\n
Unsere erste Minianwendung beenden wir an dieser Stelle und wollen uns jetzt einem ersten kleinen echten Programm zuwenden. In Teil3 programmieren wir einen kleinen Editor, in dem ihr Texte eingeben k\u00f6nnt, Scanner testen und noch so einiges mehr.<\/p>\n
Video<\/h3>\n