Android_Tutorial_Lektion13_fotolia_RA_Studio_46292813

Programmier Tutorial: Apps für Android entwickeln – Teil 13: Mit Refactoring die Struktur unseres Quellcodes verbessern

In dieser Lektion werden wir den Quellcode unserer Android App umstrukturieren, mit dem Ziel diesen dadurch übersichtlicher zu gestalten.

Für solche Aufgaben stellt uns Android Studio einige sehr hilfreiche Umstrukturierungsfunktionen zur Verfügung. Diese Funktionen werden unter dem Oberbegriff Refactoring zusammengefasst.


Im theoretischen Teil der Lektion werden wir zunächst klären, was unter dem Begriff Refactoring bei der Softwareentwicklung zu verstehen ist und welche Refactoring-Werkzeuge in Android Studio integriert sind. Anschließend werden wir mit Hilfe verschiedener Refactoring-Funktionen den Quellcode unserer App umstrukturieren und dabei auch eine Verbesserung am bisherigen Code vornehmen.

Danach werden wir den Quellcode von nicht benötigten Elementen bereinigen, ihn neu ausrichten und die Import-Anweisungen optimieren lassen. Dabei werden wir einige Coding-Werkzeuge von Android Studio näher kennenlernen. Abschließend führen wir unsere Android App zum Testen auf dem Android Virtual Device im Android Emulator aus.

1. Was ist Refactoring in Android Studio

Der Begriff Refactoring bezeichnet in der Informatik die manuelle oder automatische Strukturverbesserung des Quelltextes, wobei das Programmverhalten erhalten bleibt.

In der Softwareentwicklung spielt Refactoring (Restrukturierung des Quellcodes) eine wichtige Rolle. Je komplexer eine Anwendung ist, desto unübersichtlicher und unverständlicher kann der Quellcode werden. Um genau dies zu verhindern bzw. zu beheben, wird Refactoring während der Entwicklung angewandt.

Durch Refactoring sollen folgende Eigenschaften des Quellcodes verbessert werden:

  • Lesbarkeit
  • Erweiterbarkeit
  • Übersichtlichkeit
  • Verständlichkeit
  • Erleichterung des Testens
  • Eliminierung von Redundanz

Wir selbst werden Refactoring einsetzen, um unseren bisherigen Quellcode übersichtlicher und modularer zu gestalten. Dabei werden die vorgenommenen Änderungen aber stets ohne Einfluss auf das Verhalten unserer Anwendung bleiben.

1.1 Die Refactoring-Funktionen von Android Studio

menu_refactor

Die Refactoring-Funktionen von Android Studio

Android Studio stellt eine Vielzahl an hilfreichen Refactoring-Maßnahmen zur Verfügung. Neben einfachen Funktionen, wie dem sicheren Löschen von Variablen, können auch sehr spezielle Refactoring-Maßnahmen, wie das Konvertieren einer anonymen zu einer inneren Klasse, von Android Studio durchgeführt werden.

Je nach Kontext stellt Android Studio automatisch passende Refactoring-Funktionen zur Auswahl. Der Kontext ergibt sich aus dem gerade ausgewähltem Quelltext bzw. der Postion des Cursors. Die verfügbaren Refactoring-Funktionen können über die obere Menüleiste mit dem Eintrag Refactor angesehen werden. Die Funktionen können in die unten aufgeführten Gruppen unterteilt werden.

Android Studio besitzt Refactoring-Maßnahmen für:

  • gezieltes Verschieben, Kopieren und sicheres Löschen von Quellcode-Elementen.
  • Extrahieren bestimmter Code-Elemente in eine Variable, Konstante, Methode, Interface oder Klasse (Extract).
  • Auslagern bestimmter Instanzvariablen in die Super- bzw. Sub-Klasse (Pull & Push Members).
  • Umbenennen eines Symbols, einer Signatur oder einer Datei.
  • Umschließen von Instanzvariablen, so dass diese eigene Zugriffsmethoden erhalten (Encapsulate Fields).
  • spezielle Refactoring-Aufgaben, wie Konvertieren einer anonymen zu einer inneren Klasse oder Konvertieren einer statischen Methode zu einer Instanzmethode.

Wir werden in dieser Lektion nicht alle in Android Studio enthaltenen Refactoring-Funktionen behandeln können. Das würde den Rahmen sprengen und zu Unübersichtlichkeiten führen. Wir möchten mit dieser Lektion vielmehr einen Einblick in dieses bedeutsame Thema geben und dem Leser auf praktische Weise mit einigen wichtigen Refactoring-Funktionen vertraut machen. Mehr dazu im praktischen Teil der Lektion.

1.2 Die Coding-Funktionen von Android Studio

menu_code

Die Coding-Funktionen von Android Studio

Neben dem Refactoring stellt Android Studio noch weitere Funktionen zur Quellcode-Verbesserung und -Automatisierung bereit. Auf diese kann über den Eintrag Code in der oberen Menüleiste zugegriffen werden.

Die Hauptaufgabe dieser Coding-Funktionen besteht darin, die Effektivität des Programmierers zu erhöhen.

So können Methoden der Basisklasse auf Wunsch überschrieben werden (Override Methods). Android Studio erzeugt dann automatisch den Methodenkopf und fügt auch, wenn erforderlich, notwendige Anweisungen in den Methodenrumpf ein.

Diese Coding-Funktion ist gerade bei der Entwicklung von Android Apps eine große Erleichterung, da sehr oft die Callback-Methoden der Basisklasse, wie onCreate(), onPause() und onResume(), überschrieben werden müssen.

Mit der Surround With-Funktion können im Editor markierte Code-Zeilen mit If-Else-, Try-Catch– oder Schleifen-Blöcken umschlossen werden. Da solche Code-Elemente beim Programmieren oft benötigt werden, erspart diese Coding-Funktion dem Entwickler eine Menge Schreibarbeit und minimiert gleichzeitig die Fehleranfälligkeit.

Neben der automatischen Code-Generierung beherrscht Android Studio aber noch weitere Coding-Funktionen. So kann durch die Funktion Reformat Code der gerade im Editor bearbeitete Quellcode neu ausgerichtet werden.

Mit der Funktion Rearrange Code werden die Code-Elemente wie Variablen, Methoden und Konstruktoren der Reihenfolge nach neu angeordnet. Die anzuwendende Reihenfolge kann an die eigenen Bedürfnisse angepasst werden. Diese Funktion ist sehr hilfreich, wenn man fremden Quellcode in das eigene Projekt integrieren möchte.

Schließlich möchten wir noch die Funktion Optimize Imports kurz vorstellen. Dank ihrer Hilfe können die Import-Anweisungen im Quellcode immer aktuell gehalten werden. Sie ordnet die Import-Anweisungen alphabetisch an und entfernt nicht mehr verwendete Anweisungen aus dem Quellcode. Wir werden sie später im praktischen Teil dieser Lektion zum Optimieren unserer eigenen Import-Anweisungen nutzen.

2. Mit Refactoring den Quellcode unserer App umstrukturieren

Wir möchten nun den bisherigen Quellcode unserer Android App durch Umstrukturierung verbessern. Dazu werden wir schrittweise Refactoring-Maßnahmen am Code durchführen.

Um diese Umstrukturierungsmaßnahmen durchzuführen, öffnen wir die Klassendatei MainActivity.java im Editor von Android Studio. Dazu klicken wir doppelt auf ihren Dateinamen im Project Tool Window. Die Klassendatei befindet sich im Package-Ordner de.codeyourapp.zitate unseres Projekts.

Der bisherigen Quellcode der Klassendatei MainActivity.java ist unten aufgeführt:

MainActivity.java

package de.codeyourapp.zitate;
 
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
//import android.widget.TextView;
 
import android.util.Log;
 
public class MainActivity extends AppCompatActivity {
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
 
        String logTag = MainActivity.class.getSimpleName();
 
        Log.v(logTag, "Verbose     - Meldung.");
        Log.d(logTag, "Debug       - Meldung.");
        Log.i(logTag, "Information - Meldung.");
        Log.w(logTag, "Warning     - Meldung.");
        Log.e(logTag, "Error       - Meldung.");
 
        //TextView welcomeMessageTV = new TextView(this);
        //welcomeMessageTV.setText("Hello CodeYourApp World!");
        //setContentView(welcomeMessageTV);
 
        setContentView(R.layout.activity_main);
    }
}

Den oben aufgeführten Quellcode werden wir nun schrittweise durch Refactoring verbessern. Jede Refactoring-Maßnahme wird dabei einzeln erfolgen, so dass die automatischen Code-Änderungen stets nachvollziehbar bleiben.

Folgende Refactoring-Maßnahmen werden wir nun zur Code-Verbesserung durchführen:

  1. Umwandeln der Logging-Variable logTag in eine Konstante.
  2. Umbenennen der neu erstellten Konstante.
  3. Extrahieren der Logging-Methodenaufrufe in eine eigene Methode.
  4. Bereinigen und Formatieren des Quellcodes sowie Optimieren der Import-Anweisungen.

2.1 Umwandeln der Logging-Variable logTag in eine Konstante

Unser bisheriger Quellcode enthält eine Logging-Variable mit dem Namen logTag, welche über die Herkunft der Logging-Meldung informiert. Da sich der Wert dieser Variable niemals ändert, ist es besser ihn in einer Konstante zu hinterlegen. Und dies wollen wir nun als unserer erste Refactoring-Maßnahme umsetzen.

Mit folgenden Arbeitsschritten wandeln wir die Variable logTag in eine Konstante um:

  1. Mit der rechten Maustaste auf die Variable logTag im Editorfenster klicken (Markierung A).
  2. Anschließend den Eintrag Refactor des Kontext-Menüs anklicken.
  3. Dann auf den Eintrag Extract klicken.
  4. Und schließlich auf den Eintrag Constant… klicken.
refactor_constant

Umwandeln der Logging-Variable logTag in eine Konstante

Als Nächstes wird uns eine Live-Vorschau der Refactoring-Maßnahme im Editorfenster von Android Studio eingeblendet. Wir müssen an dieser Stelle den Namen der anzulegenden Konstante vorgeben. Um diesen Prozess zu beschleunigen, werden uns bereits einige sinnvolle Namen vorgeschlagen.

Den für die Konstante vorgeschlagenen Namen LOG_TAG lassen wir im blauen Textfeld (Markierung B) stehen und bestätigen die Refactoring-Maßnahme durch Drücken der Enter Taste.

refactor_constant_name

Android Studio schlägt einige sinnvolle Namen für die anzulegende Konstante vor

Jetzt legt Android Studio automatisch eine neue Konstante mit dem Namen LOG_TAG an und entfernt die bisherige Logging-Variable logTag. Außerdem werden alle nun nicht mehr gültigen Referenzen auf die Variable mit Referenzen auf die neu angelegte Konstante ersetzt.

Der umstrukturierte Quellcode sieht in Android Studio nun wie folgt aus:

refactor_constant_end

Die Variable wurde in eine Konstante umgewandelt und alle Referenzen entsprechend angepasst

Wie der oberen Abbildung zu entnehmen ist, wurde die neue Konstante LOG_TAG (Markierung C) direkt unterhalb der Klassendeklaration von Android Studio angelegt. Die Variable logTag wurde dabei automatisch gelöscht.

In den fünf Methodenaufrufen (Markierung D) wird nun auf die neu angelegte Konstante LOG_TAG referenziert. Auch dieses Austauschen der Referenzen wurde von Android Studio automatisch durchgeführt. Somit ist unsere erste Refactoring-Maßnahme nun abgeschlossen.

2.2 Umbenennen der neu erstellten Konstante

Als Nächstes werden wir zu Übungszwecken den Namen der eben angelegten Konstante ändern. Auch hierfür stellt Android Studio eine Refactoring-Funktion bereit, die neben den Namen auch alle alten Referenzen im Code mit umbenennt.

Mit folgenden Arbeitsschritten ändern wir den Namen der Konstante:

  1. Mit der rechten Maustaste auf die Konstant LOG_TAG im Editorfenster klicken (Markierung A).
  2. Anschließend den Eintrag Refactor des Kontext-Menüs anklicken.
  3. Dann auf den Eintrag Rename… klicken.
refactor_rename

Umbenennen der Konstante LOG_TAG mit Refactoring

Auch diesmal präsentiert uns Android Studio wieder eine Live-Vorschau der Refactoring-Maßnahme im Editorfenster.

Wir tragen LOG als neuen Namen für die Konstante in das blaue Textfeld (Markierung B) ein und bestätigen die Refactoring-Maßnahme durch Drücken der Enter Taste.

refactor_rename_preview

In der Live-Vorschau von Android Studio geben wir als neuen Namen LOG ein

Jetzt ändert Android Studio automatisch den Namen der neuen Konstante von LOG_TAG in LOG um. Außerdem werden alle nun nicht mehr gültigen Referenzen auf die Konstante angepasst.

Der umstrukturierte Quellcode sieht in Android Studio nun wie folgt aus:

refactor_rename_end

Die Konstante wurde von Android Studio umbenannt und alle Referenzen entsprechend angepasst

Wie der oberen Abbildung zu entnehmen ist, trägt die neue Konstante nun den Name LOG (Markierung C).

Auch der Code der fünf Methodenaufrufen (Markierung D) wurde von Android Studio automatisch an den neuen Namen der Konstante angepasst. Auf diese Weise kann man auch später noch Namensänderungen sehr schnell im Quellcode sicher per Refactoring durchführen lassen.

2.3 Extrahieren der Logging-Methodenaufrufe in eine eigene Methode

Nun werden wir eine etwas komplexere Refactoring-Maßnahme durchführen. Und zwar werden wir die fünf Logging-Methodenaufrufe in eine eigene Methode auslagern lassen. Dazu werden wir die Extract Method Funktion von Android Studio verwenden.

Das Auslagern der Methodenaufrufe in eine eigene Methode erfolgt durch folgende Arbeitsschritte:

  1. Auswählen der Zeilen 17 bis 21 (Markierung A), in denen die fünf Methodenaufrufe erfolgen.
  2. Danach mit der rechten Maustaste auf die ausgewählten Zeilen klicken.
  3. Anschließend den Eintrag Refactor des Kontext-Menüs anklicken.
  4. Dann auf den Eintrag Extract klicken.
  5. Und schließlich auf den Eintrag Method… klicken.
refactor_method

Auslagern der Logging-Methodenaufrufe in eine eigene Methode

Diesmal wird uns von Android Studio keine Live-Vorschau angezeigt. Stattdessen öffnet sich der Extract Method-Dialog, mit welchem wir sehr komfortabel die zu erstellende Methode definieren können.

In dem Extract Method-Dialog nehmen wir nur eine Änderung vor. Und zwar tragen wir in das Textfeld Name als Methodennamen sendLogMessages ein. Die übrigen Einstellungen lassen wir unverändert. Um die neue Methode anlegen zu lassen, bestätigen wir abschließend den Dialog mit Klick auf den Refactor Button.

refactor_method_dialog

Mit dem Extract Method Dialog definieren wir die zu erstellende Methode

Jetzt erstellt Android Studio die sendLogMessages() Methode. Dabei werden die fünf bisherigen Logging-Methodenaufrufe automatisch in den Rumpf der neuen Methode eingefügt. Zusätzlich fügt Android Studio an die Position im Quellcode, an der sich vorher die Methodenaufrufe befanden, den Methodenaufruf der neu erstellten sendLogMessages() Methode ein.

Der umstrukturierte Quellcode sieht in Android Studio nun wie folgt aus:

refactor_method_end

Die bisherigen Logging-Methodenaufrufe wurde von Android Studio in eine eigene Methode ausgelagert

In der oberen Abbildung ist die Refactoring-Maßnahme bereits abgeschlossen. Es ist zu erkennen, dass in der onCreate() Methode der Aufruf der neu erstellten sendLogMessages() Methode (Markierung B) erfolgt.

Die fünf Logging-Methodenaufrufe befinden sich nun nicht mehr an dieser Stelle, sondern wurden per Refactoring von Android Studio in die automatisch erstellte sendLogMessages() Methode (Markierung C) ausgelagert, welche sich direkt unterhalb der onCreate() Methode befindet.

Die Refactoring-Maßnahmen haben wir nun durchgeführt. Wir können unseren Quellcode jedoch noch weiter von Android Studio verbessern lassen, indem wir auf die Coding-Funktionen der Entwicklungsumgebung zurückgreifen. Mehr dazu im nächsten Abschnitt.

2.4 Bereinigen des Quellcodes und Optimieren der Import-Anweisungen

Wir möchten nun unseren umstrukturierten Quellcode von nicht mehr benötigten Zeilen befreien und anschließend die Import-Anweisungen von Android Studio optimieren lassen.

Der umstrukturierte Quellcode sieht in Android Studio momentan wie folgt aus:

code_comments

In dem umstrukturierten Quellcode befinden sich noch auskommentierte Zeile, die wir nun manuell entfernen

In der oberen Abbildung sind die nicht mehr benötigten Zeilen markiert. Wir werden nun die auskommentierte Import-Anweisung (Markierung A) und den auskommentierten Code-Block (Markierung B) manuell entfernen.

Anschließend sollte der bereinigte Quellcode in Android Studio wie folgt aussehen:

code_reformat

Beheben des Formatierungsfehlers durch Neu-Ausrichten des Quellcodes

Nachdem die auskommentierten Zeilen nun manuell entfernt wurden, möchten wir uns der Formatierung unseres Quelltextes widmen. Dafür stellt Android Studio die Coding-Funktion Reformat Code zur Verfügung, durch die der Quellcode automatisch neu ausgerichtet wird.

Unser Code ist fast optimal formatiert, jedoch haben wir noch einen kleinen Formatierungsfehler eingebaut. Und zwar fehlt in der Zeile, in welcher die Konstante angelegt wird (Markierung C), ein Leerzeichen direkt nach dem Gleichheitszeichen, siehe obere Abbildung.

Diesen Formatierungsfehler beheben wir nun folgendermaßen:

An dieser Stelle endet der freie Inhalt dieser Lektion. Wir hoffen, sie hat dir bis hierher gefallen! Du kannst sie im geschützten Bereich von ProgrammierenLernenHQ fortsetzen, in welchem sich alle Lektionen unserer Android Online-Kurse befinden.

Unsere Android Kurse bestehen aus insgesamt 43 großen Lektionen und sind unterteilt in 13 frei zugängliche und 30 Premium-Lektionen. Die Premium-Lektionen befinden sich in dem geschützten Bereich und sind nur für Käufer unserer Android Online-Kurse zugänglich.

plhq_teaser_hbox_gelb_fotolia_RA Studio_46292813 An dieser Stelle endet der freie Inhalt dieser Lektion. Wir hoffen, sie hat dir bis hierher gefallen! Du kannst sie durch Kauf unseres Android Online-Kurs Gesamtpakets freischalten.

In unserem Android Online-Kurs Gesamtpaket befinden sich 43 große Lektionen, in denen wir dir schrittweise zeigen, wie voll funktionstüchtige Android Apps programmiert werden.

Diese Lektion ist Teil unserer Android Kurse. Insgesamt sind unsere Online-Kurse unterteilt in 13 frei zugängliche und 30 Premium-Lektionen.

Die Premium-Lektionen befinden sich in dem geschützten Bereich und sind nur für Käufer des Android Online-Kurs Gesamtpakets zugänglich.



Welche Inhalte befinden sich im Android Online-Kurs Gesamtpaket?

  • Das Gesamtpaket enthält alle Android Online-Kurse von ProgrammierenLernenHQ.
  • Im Paket enthalten ist unser großer Android Apps Programmieren Online-Kurs. Dieser besteht aus 35 großen Lektionen und ist als Einstiegskurs konzipiert worden. Die Grundlagen der Android App Entwicklung praxisnah und verständlich zu lehren, ist das Hauptziel des Android Apps Programmieren Kurses.
  • Im Paket enthalten ist auch unser SQLite Datenbank App Programmieren Online-Kurs. Dieser besteht aus 8 großen Lektionen und ist als weiterführender Kurs konzipiert worden. Der Kurs schließt an unseren Android Apps Programmieren Hauptkurs an und widmet sich dem speziellen Thema der SQLite Datenbanken.
  • Durch den Kauf erhältst du unbegrenzten Zugang zu all unseren Android Online-Kursen. Wir werden in Zukunft weitere Android Kurse hinzufügen. Auch auf alle zukünftigen Kurse erhältst du vollen Zugriff.

Wir hoffen, Dich bald als neuen Kursteilnehmer unserer Android Online-Kurse begrüßen zu dürfen!

Einmal kaufen und dadurch zeitlich unbegrenzten Zugriff auf alle Inhalte unserer Android Online-Kurse erhalten.






Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht.