Einleitung
Bevor wir dir den App-Erstellungs-Prozess unter Android näherbringen, ist es wichtig, ein grundlegendes Verständnis für die Programmiersprachen und deren Funktionsweise zu entwickeln. Jede Programmiersprache hat ihre eigene Struktur und Komplexität, die es zu meistern gilt, bevor du mit dem App-Erstellungs-Prozess beginnen kannst.
Heutzutage beherrscht fast jeder Programmierer mindestens eine Programmiersprache. Eine der bekanntesten und am häufigsten verwendeten Sprachen für die Android-Entwicklung ist Java. Java ist eine sogenannte „Hochsprache„. Dies bedeutet, dass der Quellcode in einer für Menschen verständlichen Form geschrieben wird. Hochsprachen sind darauf ausgelegt, relativ einfach zu lernen und zu verstehen, da sie sich von der Maschinen- oder Assembler-Sprache, die direkt vom Computer verstanden wird, deutlich unterscheiden. Dies ermöglicht es Entwicklern, sich auf die Logik und die Struktur ihrer Programme zu konzentrieren, anstatt sich mit den niedrigeren Details der Maschinenkommunikation zu beschäftigen.
Ein entscheidender Vorteil von Hochsprachen wie Java ist ihre Lesbarkeit. Code in einer Hochsprache ist oft in einer weitgehend natürlichen Sprache geschrieben, wodurch er für Menschen, die mit der Sprache vertraut sind, leichter verständlich wird. So kann beispielsweise ein einfacher Befehl wie „System.out.println(„Hallo, Welt!“);“ in Java dafür sorgen, dass der Text „Hallo, Welt!“ auf dem Bildschirm ausgegeben wird. Zum Vergleich dazu würde dieser Befehl in Assembler oder Maschinensprache wesentlich komplexer und schwerer verständlich sein.
Im Gegensatz dazu stehen Assembler- und Maschinensprachen, die direkt mit der Hardware des Computers kommunizieren. Diese Sprachen sind viel schwieriger zu verstehen, da sie aus sehr speziellen und niedrigen Anweisungen bestehen, die der Computer ausführen kann, aber für den Menschen nur schwer nachvollziehbar sind. Maschinensprache besteht aus binären Zahlen, also 0 und 1, während Assembler-Sprache eine noch höhere Abstraktionsebene bietet, aber ebenfalls eng an die Hardware gebunden ist.
Im nächsten Schritt werden wir dir zeigen, wie du mit diesen Sprachen und insbesondere mit Java eine einfache Android-App erstellst. Dabei werden wir uns auf die Android Studio-Entwicklungsumgebung konzentrieren und Schritt für Schritt erklären, wie du von der Installation der notwendigen Tools bis hin zum Schreiben deines ersten Programms vorgehst. Aber zuerst ist es wichtig, zu verstehen, wie du grundlegende Konzepte in Java und anderen Programmiersprachen anwendest, um den Einstieg in die App-Entwicklung zu erleichtern.
Das Beherrschen der Grundlagen von Java ist daher unerlässlich, um die Prinzipien hinter der App-Entwicklung auf Android zu verstehen. Auch wenn du in einer anderen Programmiersprache wie Python oder C++ versiert bist, werden dir die Prinzipien der objektorientierten Programmierung und der Struktur von Programmen helfen, auch in Java schnell zurechtzukommen. Sobald du diese Grundlagen beherrschst, wirst du in der Lage sein, deine eigene Android-App zu entwickeln und die Funktionsweise der mobilen Welt zu beeinflussen.
Nachfolgend siehst du dreimal das Programm „HalloWelt“ in den drei unterschiedlichen Sprachfamilien Hoch-, Assembler- und Maschinensprache:
Hochsprache: Java
public class HalloWelt { public static void main(String[] args) { System.out.println("Hallo Welt!"); } } -> Hochsprache -> Leicht verständlich für Menschen (menschennah) -> 1. Sprachebene
Assemblersprache:
DATA SEGMENT Meldung db "Hallo Welt" db "$" DATA ENDS CODE SEGMENT ASSUME CS:CODE,DS:DATA Anfang: mov ax, DATA mov ds, ax mov dx, offset Meldung mov ah, 09h int 21h mov ax, 4C00h int 21h CODE ENDS END Anfang -> Hardwarenahe Sprache -> Für Menschen weniger gut lesbar (mnemonische Symbole) -> 2. Sprachebene
Maschinensprache:
BA 0B 01 B4 09 CD 21 B4 4C CD 21 48 61 6C 6C 6F 20 57 65 6C 74 21 0D 0A 24 -> Hexadezimale Maschinensprache für den x86-Prozessor (Kann auch binär sein: z.B. 01011010) -> Für die Maschine (Prozessor, Mikrocontroller) leicht zu verarbeiten -> Für Menschen nicht zu verstehen -> 3. Sprachebene
1. Schritt: Jack-Compiler (Java-Quellcode ->Android-Bytecode)
Unter der Kompilierung versteht man den Prozess eines Tools (Compilers), den vom Programmierer eingegebenen Quellcode (*.java-Dateien) in Maschinencode (Prozessor) oder Zwischencode (Bytecode, *.class-Dateien) zu übersetzen. In Java wird Quellcode durch den Java-Compiler „javac.exe“ zunächst in einen plattformunabhängigen Bytecode (*.class-Dateien) übersetzt und dieser wiederum von einem Interpreter zur Laufzeit in Maschinencode. In Android sehen die Schritte so aus, dass zunächst ein sogenannter Jack-Compiler „Java Android Compiler Kit“ den Quellcode in Android-Bytecode überführt.
Schritt 1: Java-Quellcode (*.java-Dateien) -> JACK-Compiler (jack.jar) -> Android-Bytecode (*.dex-Dateien)
Extra-Schritt: Jill-Compiler (Java-Bytecode->Jack-Dateien)
Sofern es im Android-Projekt externe Third-Party-Libraries mit Java-Bytecode (*.class-Dateien) gibt, übersetzt diese der Jill-Compiler „Jack Intermediate Library Linker“ in Jack-Dateien (*.jack). Der zuvor erwähnte Jack-Compiler verarbeitet diese Dateien dann später weiter.
Achtung: Dieser Schritt wird wirklich nur dann ausgeführt, wenn externe Libraries vorhanden sind!
Extra-Schritt: Java-Bytecode (*class-Dateien) -> JILL-Compiler (jill.jar) -> Jack-Dateien (*.jack)
2. Schritt: Android-Runtime (Android-Bytecode->Maschinencode)
Nachdem der Jack-Compiler den Android-Bytecode (*.dex-Dateien) erzeugt hat, wird dieser zusammen mit anderen App-Bestandteilen zu einer APK-Datei zusammengefügt, auf das Zielgerät transportiert und dort installiert. Während der Installation wird nun nach dem „Ahead-Of-Time (AOT)“-Prinzip durch die Android-Runtime (ART) der Android-Bytecode in Maschinencode übersetzt.
Schritt 2: Android-Bytecode (*.dex-Dateien) -> Android-Runtime (ART) -> Maschinencode