Flutter Mobile Development · Lektion

Stateless- und Stateful-Widgets

Verstehen Sie die grundlegenden Unterschiede zwischen StatelessWidget und StatefulWidget und lernen Sie, wann und wie Sie die beiden beim Erstellen dynamischer Benutzeroberflächen einsetzen.

Stateless- und Stateful-Widgets ist eine kostenlose Flutter Mobile Development-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Flutter Mobile Development-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Flutter Mobile Development-Kurs umfasst insgesamt 4 Lektionen.

Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.

Widgets: The Building Blocks

Flutter UIs are built entirely from widgets. Think of them as LEGO bricks! Everything you see on screen – text, buttons, even layout containers — is a widget.

Widgets describe how your app's UI should look given its current configuration and state. There are two main types of widgets you'll encounter:

StatelessWidget
StatefulWidget

StatelessWidget: Static UI

A StatelessWidget is a widget that does not change its appearance or behavior over time. Once it's built, it stays the same.

It doesn't have any internal "state" to manage.
Its properties are immutable (cannot be changed after creation).
It's perfect for displaying static content like text, icons, or images that don't need to react to user input or data changes.

Simple StatelessWidget

Here's a basic StatelessWidget that displays a welcome message. Notice how its content is fixed.

Run this code to see a static "Hello, CoddyKit!" message.

import 'package:flutter/material.dart';

void main() {
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(
          title: const Text('Stateless Demo'),
        ),
        body: const Center(
          child: Text(
            'Hello, CoddyKit!',
            style: TextStyle(fontSize: 24),
          ),
        ),
      ),
    );
  }
}

When to Go Stateless

Use a StatelessWidget when:

The widget's appearance depends only on its own configuration parameters (passed in its constructor).
It doesn't need to respond to user interactions (like taps) or internal data changes.
Examples: Text, Icon, Image, AppBar, Padding, Row, Column.

These widgets are efficient because Flutter doesn't need to rebuild them if their parent changes, unless their properties explicitly change.

StatefulWidget: Dynamic UI

A StatefulWidget is a widget that can change its appearance and behavior over time, reacting to user input or data changes.

It has internal "state" that can be modified.
When its state changes, the widget rebuilds to reflect the new state.
It's perfect for interactive elements like checkboxes, sliders, or dynamic lists.

Updating UI with setState()

To make a StatefulWidget dynamic, you modify its internal state. When the state changes, you must call the setState() method.

Calling setState() tells Flutter that the internal state of this widget has changed, and it needs to rebuild the UI to reflect the new state.

Without setState(), your state might change, but the UI won't update!

Interactive StatefulWidget

Let's build a simple counter app using a StatefulWidget. Tap the button to increment the number.

Observe how setState() is used to update the _counter variable and rebuild the UI.

import 'package:flutter/material.dart';

void main() {
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(
          title: const Text('Stateful Demo'),
        ),
        body: const Center(
          child: CounterWidget(),
        ),
      ),
    );
  }
}

class CounterWidget extends StatefulWidget {
  const CounterWidget({super.key});

  @override
  State<CounterWidget> createState() => _CounterWidgetState();
}

class _CounterWidgetState extends State<CounterWidget> {
  int _counter = 0; // This is the mutable state

  void _incrementCounter() {
    setState(() {
      _counter++; // Update state
    });
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      mainAxisAlignment: MainAxisAlignment.center,
      children: <Widget>[
        Text(
          'Count: $_counter',
          style: const TextStyle(fontSize: 32),
        ),
        const SizedBox(height: 20),
        ElevatedButton(
          onPressed: _incrementCounter,
          child: const Text('Increment'),
        ),
      ],
    );
  }
}

StatefulWidget's Journey

StatefulWidgets go through a lifecycle. Key moments include:

createState(): Creates the mutable state object.
initState(): Called once when the widget is inserted into the widget tree. Good for one-time setup.
build(): Called every time the widget needs to display its UI, typically after setState().
dispose(): Called when the widget is removed from the tree. Good for cleaning up resources.

Understanding these helps manage complex interactions.

Choosing the Right Widget

Here's a quick comparison to help you decide:

StatelessWidget:
- Immutable properties.
- Doesn't change after creation.
- No internal state.
- Efficient for static content.
StatefulWidget:
- Mutable state (managed by a `State` object).
- Can change dynamically.
- Responds to user interaction/data.
- Uses setState() to trigger rebuilds.

Most widgets start as stateless; only make them stateful if they truly need to change dynamically.

Widget Type Challenge

You are building a Flutter app. Which type of widget would you primarily use for a simple icon that, when tapped, changes its color?

Recap: Dynamic vs. Static

Great job! You've learned the fundamental difference between StatelessWidget and StatefulWidget.

StatelessWidgets are for static UI elements that don't change after they're built.
StatefulWidgets are for dynamic UI elements that need to react to interactions or data changes, using setState() to update their appearance.

Choosing the right widget type is crucial for building efficient and maintainable Flutter applications. In the next lesson, we'll dive into basic layout widgets!

Häufig gestellte Fragen

Ist die Lektion „Stateless- und Stateful-Widgets“ kostenlos?

Ja — der vollständige Text von „Stateless- und Stateful-Widgets“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Flutter Mobile Development-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Flutter Mobile Development-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Stateless- und Stateful-Widgets“?

Verstehen Sie die grundlegenden Unterschiede zwischen StatelessWidget und StatefulWidget und lernen Sie, wann und wie Sie die beiden beim Erstellen dynamischer Benutzeroberflächen einsetzen. Du übst Flutter Mobile Development mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Flutter Mobile Development zu starten?

Keine Vorkenntnisse erforderlich. Flutter Mobile Development auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Stateless- und Stateful-Widgets“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Flutter Mobile Development-Lektion Code schreiben und ausführen?

Ja. Jede Flutter Mobile Development-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

Stateless- und Stateful-Widgets
Grundlegende Layout-Widgets
Interaktive Elemente der Benutzeroberfläche
Scrollbare Listen mit ListView erstellen

← Zurück zu Flutter Mobile Development