App-Erstellungs-Prozess in Android

App-Erstellungsprozess: Jack and Jill
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