Flutter Mobile Development · Leçon

Widgets sans état ou avec état

Comprenez les différences fondamentales entre StatelessWidget et StatefulWidget, et apprenez quand et comment utiliser chacun pour créer des interfaces utilisateur dynamiques.

Widgets sans état ou avec état est une leçon Flutter Mobile Development gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Flutter Mobile Development, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Flutter Mobile Development comprend 4 leçons au total.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

Widgets: The Building Blocks

Les interfaces utilisateur Flutter sont entièrement construites à partir de widgets. Considérez-les comme des briques LEGO ! Tout ce que vous voyez à l'écran – texte, boutons, et même les conteneurs de mise en page – est un widget.

Les widgets décrivent l'apparence de l'interface utilisateur de votre application en fonction de sa configuration et de son état actuels. Il existe deux types principaux de widgets que vous rencontrerez :

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!

Questions Fréquemment Posées

La leçon « Widgets sans état ou avec état » est-elle gratuite ?

Oui — le texte complet de « Widgets sans état ou avec état » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Flutter Mobile Development, passe à CoddyKit PRO. Le cours Flutter Mobile Development comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Widgets sans état ou avec état » ?

Comprenez les différences fondamentales entre StatelessWidget et StatefulWidget, et apprenez quand et comment utiliser chacun pour créer des interfaces utilisateur dynamiques. Tu pratiques Flutter Mobile Development avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Flutter Mobile Development ?

Aucune expérience préalable n'est requise. Flutter Mobile Development sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Widgets sans état ou avec état » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Flutter Mobile Development ?

Oui. Chaque leçon Flutter Mobile Development inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Widgets sans état ou avec état
Widgets de mise en page essentiels
Éléments d’interface interactifs
Créer des listes défilantes avec ListView

← Retour à Flutter Mobile Development