Skip to content

4. Kapitel 3 - Einführung in Flutter

4.1. Quellen

Offizielle Dokumentation: https://docs.flutter.dev – insbesondere die Seiten „What is Flutter?“, „Introduction to widgets“ und „State management“. [Dart]-Sprache: https://dart.dev/language

4.2. Was Flutter nicht ist

Dies ist der wichtigste Ausgangspunkt dieses Kapitels, da er sich erheblich von den drei vorherigen Versionen dieses Kurses unterscheidet. [Angular], [React] und [Vue.js] erzeugen alle [JavaScript]/[TypeScript] KOMPILIERT, der von der [JavaScript]-Engine ausgeführt wird, die bereits in einem Browser vorhanden ist – diese Engine übernimmt die gesamte Darstellungsarbeit über [DOM] und [CSS]. Ein Werkzeug wie [Cordova]/[Capacitor] (in diesem Kurs nicht verwendet) erlaubt es zwar, einen solchen Web-Client in eine mobile Hülle zu verpacken, doch läuft der Client dann weiterhin in einem eingebetteten Browser (einer [WebView]) – niemals nativ.

[Flutter] hat mit alledem nichts zu tun. Der [Dart]-Code in diesem Dokument wird sowohl für Mobilgeräte als auch für Desktop zu NATIVEM Maschinencode kompiliert ([AOT]-Kompilierung, [Ahead-Of-Time] – dieselbe Kompilierungsfamilie wie bei einem C++- oder Rust-Programm), der vom Zielbetriebssystem direkt ausgeführt werden kann; es ist KEIN [JavaScript]-Interpreter und keine [WebView] irgendeiner Art erforderlich. [Flutter] enthält eine eigene Grafik-Rendering-Engine ([Impeller], die auf Mobilgeräten [Skia] als Standard-Engine abgelöst hat): Die Anwendung zeichnet jedes ihrer Pixel selbst, Bild für Bild, anstatt die Darstellung an die nativen Widgets des Betriebssystems zu delegieren (anders als [React Native], das in diesem Kurs nicht verwendet wird und stattdessen die tatsächlichen Oberflächenkomponenten von [Android]/[iOS] ansteuert). Diese architektonische Entscheidung ermöglicht es [Flutter] , in den drei Umgebungen, auf die dieses Dokument abzielt, eine identische Oberfläche darzustellen – es gibt keine nativen Betriebssystemkomponenten, deren Aussehen von Plattform zu Plattform variieren könnte.

Beim Ziel [web] gibt es hingegen offensichtlich keine Kompilierung zu nativem Maschinencode: [flutter build web] kompiliert den [Dart]-Code zu [JavaScript] (oder zu [WebAssembly], einem neueren Ziel), der vom Browser ausgeführt wird – doch dieses erzeugte [JavaScript] manipuliert NICHT das [DOM] oder [HTML] so, wie es [Vue.js] tut: Es rendert ebenfalls direkt auf ein einziges [<canvas>]-Element (oder über automatisch erzeugte [HTML]-Elemente, je nach gewähltem Rendering-Modus) und reproduziert so dasselbe [Flutter]-Erscheinungsbild wie auf Mobilgeräten und Desktop, anstatt sich auf mit [HTML]-Elemente zu stützen, die mit [CSS] gestaltet sind.

4.3. Das Entwicklungsmodell von Flutter: Alles ist ein Widget

[Angular], [React] und [Vue.js] – alle drei trennen die LOGIK einer Komponente ([TypeScript]) von ihrer DARSTELLUNG (einem [HTML]-Template, das je nach Framework getrennt oder integriert sein kann – siehe Kapitel 4 des Dokuments zu [Vue.js] in diesem Kurs, „Komponenten: [.vue]-Dateien und [Composition API]“). [Flutter] hebt diese Unterscheidung vollständig auf: ALLES ist innerhalb einer [Flutter]-Oberfläche ein [Widget] – eine Schaltfläche, ein Text, ein Rand, eine Ausrichtung und eine Hintergrundfarbe sind jeweils ein Widget, und eine vollständige Oberfläche ist nichts weiter als ein BAUM ineinander verschachtelter Widgets, der durch gewöhnlichen [Dart]-Code beschrieben wird (die Methode [build(BuildContext context)]) und nicht durch eine eigene Template-Sprache – in dieser Hinsicht führt [Flutter] die von [React] ([JSX], von [JavaScript], das die Oberfläche beschreibt) bereits getroffene Wahl noch weiter: Während [JSX] eine Auszeichnungssprache bleibt – GEMISCHT mit [JavaScript] –, [build(...)] gibt einfach einen [Dart]-AUSDRUCK zurück – verschachtelte Konstruktoraufrufe ([Scaffold(appBar: ..., body: Column(children: [...]))]) – ohne zusätzliche Syntax, die man lernen müsste.

4.4. StatelessWidget und StatefulWidget: während Vue.js keine Unterscheidung erfordert

[Vue.js] (wie zuvor in diesem Kurs [React] und [Angular] ) macht keinen strukturellen Unterschied zwischen einer Komponente mit veränderlichem Zustand und einer ohne: [ref(...)] kann in jedem [<script setup>] aufgerufen werden oder nicht, ohne dass sich an der Deklaration der Komponente selbst etwas ändert. [Flutter] ERZWINGT diese Unterscheidung bereits bei der Klassendeklaration: Ein [StatelessWidget] (nach seiner Konstruktion ändert sich nie etwas – siehe [ScheduleView] und [LoginPage] in Kapitel 4) führt seine Methode [build(...)] NUR dann erneut aus, wenn sich seine Parameter ändern; ein [StatefulWidget] wird mit einer separaten Klasse [State<T>] gekoppelt (siehe [_LoginFormState], [_AppRootState] …, Kapitel 4), die den veränderlichen Zustand und die Methode [setState(() { ... })] enthält – den EXPLIZITEN Aufruf, der ein neues Rendering auslöst, während [reactive(...)] auf der Seite von [Vue.js] jeden Schreibzugriff auf eine Eigenschaft automatisch erkennt. Diese Aufteilung in zwei Klassen (Widget/State) ergibt sich unmittelbar aus einer bewussten Entwurfsentscheidung in [Flutter]: Ein [Widget]-Objekt ist UNVERÄNDERLICH (bei jedem Rendering neu erstellt, wie ein einfaches Konfigurationsobjekt), während der zugehörige [State] von einem Rendering zum nächsten ÜBERLEBT.

4.5. Zustand zwischen Widgets teilen: provider, das Pendant zu provide/inject

[Vue.js] teilt Zustand zwischen weit voneinander entfernten Komponenten über das Paar [provide]/[inject]; [React] verwendet einen [Context]; [Angular] verwendet einen injizierbaren Singleton-Service. [Flutter] verfügt über keinen dieser Mechanismen im Framework selbst: Diesem Zweck dient das Drittanbieter-Paket [provider] (siehe [pubspec.yaml], Kapitel 4), das im [Flutter]-Ökosystem praktisch unverzichtbar ist. Sein Prinzip: Eine Klasse [ChangeNotifier] (eine gewöhnliche [Dart]-Klasse, die ihre Listener über [notifyListeners()] über eine Änderung benachrichtigen kann) wird durch einen an ihrer Wurzel platzierten [ChangeNotifierProvider] einem ganzen Teilbaum von Widgets zur Verfügung gestellt (siehe [MultiProvider] in [lib/main.dart], was den Aufrufen von [app.provide(key, value)] auf der Seite von [Vue.js] entspricht); jedes untergeordnete Widget liest sie dann mit [context.watch<MyService>()] (abonniert künftige Änderungen – das Pendant zu [useXxx()] auf der Seite von [Vue.js]) oder [context.read<MyService>()] (einmaliges Lesen ohne erneutes Abonnement – eine Unterscheidung, die [Vue.js] nicht treffen muss).

Wesentlicher Unterschied zu [reactive(...)]: Ein [ChangeNotifier] erkennt NICHTS automatisch. [reactive(...)] hüllt ein Objekt in einen [JavaScript]-Proxy, der jedes LESEN und jedes SCHREIBEN einer Eigenschaft abfängt; ein [ChangeNotifier] [Dart] ist eine gewöhnliche Klasse, und der Entwickler muss nach jeder Änderung, die ein neues Rendering auslösen soll, ausdrücklich [notifyListeners()] aufrufen – das erfordert mehr manuelle Disziplin, dafür ist der Mechanismus ohne „magische“ Proxys verständlich.

4.6. Keine eigene Template-Sprache: bedingtes Rendering und Listen

[v-if]/[v-else] und [v-for] ([Vue.js]) – ebenso wie [@if]/[@for] auf der Seite von [Angular] oder die ternären Operatoren && und [.map(...)] auf der Seite von [React] – werden in [Flutter] wieder zu GEWÖHNLICHEN [Dart]-Ausdrücken, direkt innerhalb von [build(...)]: ein klassisches [Dart]-[if]/[else] für eine Bedingung und [.map((element) => Widget(...)).toList()] für eine Liste – dasselbe Konzept wie [.map(...)] auf der Seite von [React], denn [Flutter] kennt, wie [React], keine eigene „Template-Sprache“, die sich von der Programmiersprache selbst unterscheidet. Die Syntax [if (condition) ...[ WidgetA, WidgetB ]] („if collection“, zum Beispiel in [lib/app.dart] verwendet, Kapitel 4) treibt diese Logik noch einen Schritt weiter als [React]: eine BEDINGUNG, die direkt in ein Listenliteral von Widgets eingefügt wird, ohne ternären Operator oder Hilfsfunktion.

4.7. Dart: ein enger Verwandter von TypeScript, nicht von JavaScript

[Dart] war nie als Alternative zu [TypeScript] für das Web gedacht (anders als dieses, das gezielt als Obermenge von [JavaScript] entworfen wurde): Es ist eine eigenständige Sprache, von Anfang an STATISCH typisiert (kein impliziter „[any]“-Modus) und kompiliert – niemals unverändert interpretiert. Für einen Entwickler, der von [TypeScript] kommt (wie bei den drei vorherigen Varianten dieses Kurses), lässt sich das Wesentliche nahezu direkt übertragen: Klassen, Interfaces ([Dart] verwendet [abstract class] oder einfache implementierte Klassen statt eines eigenen Schlüsselworts [interface]), Generics ([ServerResponse<T>], siehe Kapitel 4), [async]/[await] mit [Future<T>] (dem EXAKTEN Pendant zu [Promise<T>] in [TypeScript]) und eine in das Typsystem eingebaute Nullability-Prüfung ([String?] statt eines stets vorhandenen Strings – das Pendant zum Modus [strict] von [TypeScript], jedoch von der Sprache selbst erzwungen und nicht durch eine Compiler-Option).

Ein bemerkenswerter Unterschied, dem Sie in jeder Datei des folgenden Kapitels begegnen, die JSON dekodiert ([core/models/appointment_models.dart]): [TypeScript] entfernt seine Typen zur Kompilierzeit – ein [interface] wird nur zur Kompilierzeit geprüft, ein dekodiertes JSON-Objekt wird zur Laufzeit dann unverändert verwendet ([JSON.parse(...) as ServerResponse<T>], ein bloßes Versprechen an den Compiler). [Dart] hingegen bestimmt seine Typen zur Laufzeit: [jsonDecode(...)] liefert immer dynamische Typen ([Map<String, dynamic>]), die mit einem von Hand geschriebenen Konstruktor [fromJson(...)] ausdrücklich in Klasseninstanzen umgewandelt werden müssen – anfangs umständlicher, aber ein fehlender Schlüssel oder einer mit unerwartetem Typ löst dann sofort eine klare Ausnahme aus, statt sich unbemerkt fortzupflanzen.

4.8. Ein erstes minimales Beispiel

Hier ist die kleinste [Flutter]-Anwendung, die etwas auf dem Bildschirm anzeigt – vergleichen Sie sie mit [lib/main.dart]/[lib/app.dart] aus Kapitel 4, die deutlich funktionsreicher sind, aber aus EXAKT denselben Bausteinen aufgebaut sind ([runApp(...)], [MaterialApp] und ein Wurzel-Widget).

import 'package:flutter/material.dart';

void main() {
  runApp(
    const MaterialApp(
      home: Scaffold(
        body: Center(child: Text('Hello, RdvMedecins!')),
      ),
    ),
  );
}

Gehen wir diesen Code durch:

  • Zeile 1: [import 'package:flutter/material.dart';] – entspricht [import { ... } from 'vue']: [material.dart] enthält alle „Material-Design“-Widgets ([Google]), die in diesem Dokument verwendet werden – Schaltflächen, Textfelder, App-Leisten usw. [Flutter] bietet außerdem eine Reihe von [Cupertino]-Widgets (im [iOS]-Stil), die in diesem Kurs nicht verwendet werden, für alle, die diesen Stil auf Mobilgeräten ([Apple]) bevorzugen.
  • Zeile 3: [void main() {] – der Einstiegspunkt eines [Dart]-Programms, GENAU wie bei einem Programm in [C]/[Java] – [Flutter] kennt kein Pendant zum [HTML] einer Webseite, in das dann ein Skript [main.ts] eingebettet würde: Die Anwendung startet direkt HIER.
  • Zeile 4: [runApp(...)] – startet die Rendering-Engine von [Flutter] und übergibt ihr das anzuzeigende Wurzel-Widget – das Pendant zu [createApp(App).mount('#app')] auf der Seite von [Vue.js] ([src/main.ts]), in einem einzigen statt in zwei Aufrufen.
  • Zeilen 5–9: [MaterialApp(home: Scaffold(body: Center(...)))] – ein BAUM verschachtelter Widgets mit jeweils einer eigenen Aufgabe: [MaterialApp] konfiguriert Theme und Navigation; [Scaffold] liefert die Standardstruktur eines Bildschirms (Bereich für eine Anwendungsleiste, Inhaltsbereich usw.); [Center] zentriert sein Kind; [Text] zeigt eine Zeichenkette an. Keines dieser vier Widgets ist ein Sonderfall der Sprache: Es sind einfach [Dart]-KLASSEN, wie jene, die dieser Kurs im nächsten Kapitel selbst schreiben wird.

4.9. Zusammenfassung: Angular -> React -> Vue.js -> Flutter

Die vollständige Fassung finden Sie außerdem in der Datei [README.md] , die dem Code dieses Kapitels beiliegt.

  • [Angular]-Komponenten / [.vue]-Dateien / [.tsx]-Dateien → [Widgets] [Dart] ([StatelessWidget]/[StatefulWidget])
  • [signal()]/[ref()]/[useState()] → veränderliche Felder + [setState(...)] (lokaler Zustand), [ChangeNotifier] (geteilter Zustand)
  • [input()]/[output()], [defineProps]/[defineEmits], Funktionseigenschaften → Konstruktorparameter (Eingaben), als Parameter übergebene Funktionen (Ausgaben)
  • injizierbare/Composable-Services + [provide]/[inject]/[Context] → Service-Klassen + Paket [provider]
  • separates Template [Angular], [<template>], [Vue.js], [JSX], [React] → Methode [build(BuildContext)] (reines Dart)
  • [HttpClient]/[fetch] → Paket [http]
  • [localStorage] → [shared_preferences]
  • Kein Router (Einzelbildschirm-Anwendung, in allen 5 Varianten dieses Kurses)