Dart: Was es ist, Merkmale der Flutter-Sprache und Programmierung

Was ist Dart?

Dart ist eine Programmiersprache mit C-ähnlicher Syntax, die von Google unter der Leitung von Lars Bak (Schöpfer von Eclipse) entwickelt wurde. Die erste Veröffentlichung erfolgte 2011, aber Dart gewann erst 2018 mit der Veröffentlichung von Flutter 1.0 an echter Popularität. Die Sprache wurde für die Erstellung von Benutzeroberflächen entwickelt: Sie bietet integrierte Unterstützung für Streams, Futures und reaktive Muster.

Darts Philosophie ist «Gleichgewicht zwischen Leistung und Produktivität». Die Sprache unterstützt zwei Kompilierungsstrategien: JIT (Just-In-Time) für die Entwicklung mit Hot Reload und AOT (Ahead-Of-Time) für Release-Builds mit nativer Leistung. Der JIT-Compiler injiziert modifizierten Code in Millisekunden in eine laufende Anwendung, ohne eine APK-Neukompilierung zu erfordern — dies ist Darts entscheidender Vorteil gegenüber anderen Sprachen in der mobilen Entwicklung.

Ein Hauptmerkmal von Dart ist Sound Null Safety, eingeführt in Dart 2.12 (2021). Das Typsystem stellt sicher, dass eine Variable ohne explizite Deklaration (int?) nicht null sein kann. Dadurch wird NullPointerException zur Kompilierungszeit ausgeschlossen. Laut Google hat die Einführung von Null Safety die Absturzrate in Flutter-Anwendungen in Produktionsumgebungen um 30% reduziert.

Dart-Ökosystem

Das Dart-Ökosystem umfasst drei Hauptbereiche: Flutter (mobile und Desktop-Anwendungen), AngularDart (Webanwendungen) und Dart Server (Serverlösungen). Flutter ist die dominierende Plattform: Laut Statista (2025) wird Flutter in 46% der plattformübergreifenden mobilen Projekte eingesetzt, vor React Native (38%) und Xamarin (8%).

Dart-Syntax: Typen, Funktionen und Klassen

Die Dart-Syntax ähnelt Java und JavaScript, hat aber eigene einzigartige Konstrukte. Alles in Dart ist ein Objekt — selbst int, double und bool erben von Object. Die Typisierung ist optional: Eine als var deklarierte Variable leitet den Typ automatisch ab, aber es wird empfohlen, Typen aus Gründen der Lesbarkeit und Leistung explizit anzugeben.

Basistypen und Deklarationen

Dart unterstützt int, double, String, bool, List, Set, Map, Record, Symbol und Runes. Nullable-Typ — jeder Typ mit dem Suffix ? (int?, String?). Der ??-Operator (null-aware) gibt den Wert auf der rechten Seite zurück, wenn links null steht. Die Kaskadennotation (..) ermöglicht das Aufrufen mehrerer Methoden auf demselben Objekt, ohne die Referenz zu wiederholen.

// Basistypen und Deklarationen in Dart
void main() {
  // Explizite Typisierung
  int age = 25;
  double price = 19.99;
  String name = 'Dart';
  bool isValid = true;

  // Null Safety — Variable kann null sein
  int? nullableAge = null;
  int result = nullableAge ?? 0; // Null-aware-Operator

  // Sammlungen mit Generics
  List<String> items = ['Dart', 'Flutter', 'Mobile'];
  Map<String, dynamic> config = {
    'version': '3.0',
    'mode': 'debug',
  };

  // Kaskadennotation
  final list = <String>[]
    ..add('one')
    ..add('two')
    ..sort();
}

// Record — anonymer unveränderlicher Typ
(String, int) user = ('Alice', 30);
print(user.$1); // 'Alice'

Der dynamic-Typ deaktiviert die Typprüfung — verwenden Sie ihn nur bei der Arbeit mit JSON oder dynamischen Daten. Record ist ein neuer Typ in Dart 3.0, der das Gruppieren von Werten ohne Erstellung einer separaten Klasse ermöglicht. Der Null-aware-Operator ?? ist die Standardmethode für die Arbeit mit Nullable-Werten und ersetzt lange if-else-Prüfungen.

Klassen und Mixins

Klassen in Dart — einfache Vererbung (extends), mehrfache über Mixins (mixin). Dart unterstützt Interfaces nicht als separates Konzept — jede Klasse kann implementiert werden (implements). Ein Mixin ist eine Klasse ohne Konstruktor, deren Methoden und Felder mit dem Schlüsselwort with zu jeder Klasse hinzugefügt werden können.

// Klassen, Vererbung und Mixins in Dart
abstract class Animal {
  void sound(); // abstrakte Methode
}

mixin Swimmer {
  void swim() => print('Swimming...');
}

mixin Flyer {
  void fly() => print('Flying...');
}

class Duck extends Animal with Swimmer, Flyer {
  @override
  void sound() => print('Quack!');
}

void main() {
  final duck = Duck();
  duck.sound(); // Quack!
  duck.swim();  // Swimming...
  duck.fly();   // Flying...
}

// Benannter Konstruktor
class Config {
  final String env;

  Config.development() : env = 'dev';
  Config.production()  : env = 'prod';
}

Die Klasse Duck erbt von Animal und verwendet zwei Mixins — Swimmer und Flyer. Dies demonstriert Mehrfachvererbung ohne Diamantproblem: Mixins werden linear aufgelöst (Super-Chain). Benannte Konstruktoren (Config.development) sind eine Alternative zu statischen Factory-Methoden zum Erstellen von Objekten mit voreingestellten Parametern.

Asynchronität in Dart: Future, Stream und async/await

Asynchronität in Dart wird durch Future (einzelner Wert), Stream (Wertesequenz) und async/await implementiert. Dart verwendet ein Single-Thread-Modell mit einer Ereignisschleife, ähnlich wie JavaScript, aber mit einem wichtigen Unterschied: Lange Berechnungen blockieren die UI nicht, da Dart-Code in einem Isolate ausgeführt wird — einem separaten Thread ohne gemeinsamen Speicher.

Future repräsentiert eine asynchrone Operation, die nach einiger Zeit abgeschlossen wird. Ein Future kann sich im Zustand „ausstehend“, „mit Wert abgeschlossen“ oder „mit Fehler abgeschlossen“ befinden. Die .then().catchError()-Kette ist eine Alternative zu async/await, aber zur besseren Lesbarkeit wird await empfohlen.

// Asynchrones Laden von Daten mit Future und Stream
import 'dart:convert';
import 'package:http/http.dart' as http;

class ApiService {
  final String baseUrl;

  ApiService(this.baseUrl);

  // Future für eine einzelne Anfrage
  Future<Map<String, dynamic>> fetchUser(int id) async {
    final response = await http.get(
      Uri.parse('$baseUrl/users/$id'),
    );

    if (response.statusCode == 200) {
      return jsonDecode(response.body);
    } else {
      throw Exception('Failed to load user: ${response.statusCode}');
    }
  }

  // Stream für eine Datensequenz
  Stream<int> countStream(int max) async* {
    for (var i = 1; i <= max; i++) {
      await Future.delayed(Duration(seconds: 1));
      yield i;
    }
  }
}

void main() async {
  final api = ApiService('https://api.example.com');

  // Verwendung von await
  final user = await api.fetchUser(1);
  print('User: ${user['name']}');

  // Stream-Verarbeitung mit await for
  await for (final count in api.countStream(5)) {
    print('Count: $count');
  }
}

Die Klasse ApiService demonstriert zwei Arten von Asynchronität: Future für eine HTTP-Anfrage (einzelne Antwort) und Stream für einen sequenziellen Zähler (Generator mit async* und yield). Stream ist effektiv für die Arbeit mit Sensoren, Geolokalisierung, Firebase Realtime Database — überall dort, wo Daten kontinuierlich eintreffen. Isolate verwendet separaten Speicher — Daten werden über SendPort/ReceivePort übertragen.

Dart und Flutter: Anwendungsarchitektur

Dart und Flutter bilden einen einheitlichen Stack: Flutter ist das UI-Framework, Dart ist die UI-Beschreibungssprache. In Flutter ist alles ein Widget — von einem Button bis zu einer gesamten Anwendung. Widgets können Stateful (mit veränderlichem Zustand) und Stateless (unveränderlich) sein. Dart beschreibt deklarative UI: build() gibt einen Widget-Baum zurück, den Flutter mit Skia (oder Impeller auf iOS) rendert.

Struktur einer Flutter-Anwendung

Eine Flutter-Anwendung in Dart besteht aus main() → runApp(MyApp()) → MaterialApp. MaterialApp umfasst Routing (routes), Theme (theme) und Lokalisierung. Jeder Bildschirm ist ein Scaffold mit AppBar, Body (normalerweise Column/ListView) und BottomNavigationBar. Navigation über Navigator.push/pop oder benannte Routen.

// Einfache Flutter-Anwendung in Dart
import 'package:flutter/material.dart';

void main() => runApp(MyApp());

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Dart Demo',
      theme: ThemeData(primarySwatch: Colors.blue),
      home: HomeScreen(),
    );
  }
}

class HomeScreen extends StatefulWidget {
  @override
  _HomeScreenState createState() => _HomeScreenState();
}

class _HomeScreenState extends State<HomeScreen> {
  int _counter = 0;

  void _increment() {
    setState(() {
      _counter++;
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: Text('Dart + Flutter')),
      body: Center(
        child: Text('Counter: $_counter'),
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: _increment,
        child: Icon(Icons.add),
      ),
    );
  }
}

Das Widget HomeScreen ist ein StatefulWidget mit internem Zustand _counter. Der Aufruf von setState() benachrichtigt Flutter, die UI neu aufzubauen — der Dart-Code führt build() erneut aus und erstellt einen neuen Widget-Baum. Flutter vergleicht (diff) effizient den alten und neuen Baum und aktualisiert nur die geänderten Teile des Bildschirms. Hot Reload ersetzt build(), ohne den _counter-Zustand zurückzusetzen.

Dart-Kompilierung: JIT vs AOT

Die Dart-Kompilierung ist hybrid: JIT für die Entwicklung und AOT für die Produktion. Im Debug-Modus führt die Dart VM einen JIT-Compiler aus, der Bytecode mit der Möglichkeit zum heißen Austausch von Code interpretiert. Im Release-Modus erstellt dart compile exe oder flutter build ein natives AOT-Binary für eine bestimmte Architektur (arm64, x86_64, armv7).

Die JIT-Kompilierung von Dart im Debug-Modus ermöglicht Hot Reload in etwa 1 Sekunde — Entwickler sehen UI-Änderungen, ohne den Anwendungszustand zu verlieren. Die AOT-Kompilierung bietet eine Leistung, die nativen Swift/Kotlin-Anwendungen nahekommt. Laut Google erreicht Flutter auf Dart AOT selbst auf Mittelklassegeräten 60 FPS-Animationen.

Dart-Entwicklerwerkzeuge

Dart-Entwicklerwerkzeuge umfassen das Dart SDK (dart-Compiler, dartanalyzer, dartfmt, pub), das Flutter SDK und IDE-Plugins. Das Dart SDK wird zusammen mit dem Flutter SDK im Ordner flutter/bin/cache/dart-sdk installiert. Pub ist der Paketmanager, der pubspec.yaml liest und Abhängigkeiten von pub.dev herunterlädt.

Wichtige Werkzeuge

dart analyze — statischer Analysator, der Typen, ungenutzte Importe und potenzielle Fehler prüft. dart format — Formatierer, der Code automatisch in einen einheitlichen Stil bringt. dart doc — Dokumentationsgenerator aus ///-Kommentaren. Flutter DevTools — Profiler mit Widget-Baum-Inspektor, Logs, Speicher und Netzwerk. Dart VM Service — Debugging einer laufenden Anwendung über WebSocket.

# pubspec.yaml — Dart-Projektkonfiguration
name: my_flutter_app
description: A new Flutter project.
version: 1.0.0

environment:
  sdk: '>=3.0.0 <4.0.0'

dependencies:
  flutter:
    sdk: flutter
  http: ^1.2.0
  provider: ^6.1.0
  shared_preferences: ^2.2.0
  json_annotation: ^4.8.0

dev_dependencies:
  flutter_test:
    sdk: flutter
  build_runner: ^2.4.0
  json_serializable: ^6.7.0
  flutter_lints: ^3.0.0

Die Datei pubspec.yaml beschreibt die Abhängigkeiten eines Dart-Projekts. Das Feld environment:sdk gibt die Dart-Version an — aktuell stabil ist 3.x. Dependencies sind die Hauptbibliotheken, dev_dependencies für Tests und Codegenerierung. json_annotation + json_serializable generieren JSON-Serialisierungscode über build_runner. flutter_lints ist ein Regelsatz für den Analysator.