Data types (int, double, String, bool) in Flutter - Deep Dive

Overview - Data types (int, double, String, bool)

What is it?

Data types are categories that tell the computer what kind of information is stored in a variable. In Flutter, common data types include int for whole numbers, double for decimal numbers, String for text, and bool for true or false values. These types help the app understand how to use and display the data correctly.

Why it matters

Without data types, the app wouldn't know how to handle different kinds of information, leading to errors or confusing behavior. For example, adding two numbers is different from joining two pieces of text. Data types keep the app organized and make sure it works as expected.

Where it fits

Before learning data types, you should understand what variables are and how to store information. After mastering data types, you can learn about more complex structures like lists, maps, and custom classes to organize data better.

Mental Model

Core Idea

Data types are labels that tell the app what kind of information a variable holds so it can handle it correctly.

Think of it like...

Think of data types like different containers in a kitchen: a jar for spices (int), a bottle for oil (double), a box for cookies (String), and a switch that is either on or off (bool). Each container holds a specific kind of item and you use them differently.

┌─────────────┐
│   Variable  │
├─────────────┤
│ Data Type   │──> int (whole numbers)
│             │──> double (decimal numbers)
│             │──> String (text)
│             │──> bool (true/false)
└─────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding int for whole numbers

Concept: Introduce the int data type for storing whole numbers without decimals.

In Flutter, int is used to store numbers like 1, 42, or -7. You can use int to count things or represent quantities. Example: int apples = 5; int age = 30;

Result

Variables apples and age hold whole numbers that can be used in calculations or displayed.

Knowing int helps you store and work with whole numbers, which are common in many apps.

2

Foundation

Using double for decimal numbers

Concept: Learn the double data type for numbers with decimals.

Double stores numbers like 3.14 or -0.5. Use double when you need precision with fractions or measurements. Example: double price = 9.99; double temperature = -4.5;

Result

Variables price and temperature hold decimal numbers for precise values.

Understanding double lets you handle real-world measurements and calculations that need decimals.

3

Intermediate

Working with String for text

🤔Before reading on: do you think String can store numbers as text or only letters? Commit to your answer.

Concept: String stores text, including letters, numbers as characters, and symbols.

Strings hold words or sentences inside quotes. You can store names, messages, or even numbers as text. Example: String name = 'Alice'; String code = '12345';

Result

Variables name and code hold text that can be shown on screen or combined.

Knowing String lets you handle any text data, including numbers that are not used for math.

4

Intermediate

Using bool for true or false

🤔Before reading on: do you think bool can hold more than two values? Commit to yes or no.

Concept: Bool stores only two values: true or false, useful for decisions.

Bool helps the app decide between two options. Example: bool isLoggedIn = true; bool hasError = false;

Result

Variables isLoggedIn and hasError hold true/false values to control app behavior.

Understanding bool is key to making apps respond to conditions and user actions.

5

Intermediate

Declaring and initializing variables

🤔Before reading on: do you think you can change the value of a variable after declaring it? Commit to yes or no.

Concept: Learn how to create variables with data types and assign values.

In Flutter, you declare a variable by writing its type, name, and value. Example: int score = 10; score = 15; // value changed String greeting = 'Hi';

Result

Variables hold data that can be updated or used throughout the app.

Knowing how to declare and change variables is fundamental to storing and managing data.

6

Advanced

Type safety and errors in Flutter

🤔Before reading on: do you think Flutter allows mixing data types freely without errors? Commit to yes or no.

Concept: Flutter uses type safety to prevent mistakes by checking data types at compile time.

If you try to assign a wrong type, Flutter shows an error. Example: int number = 5; number = 'five'; // Error: String assigned to int This helps catch bugs early.

Result

Flutter prevents wrong data assignments, making apps more reliable.

Understanding type safety helps avoid common bugs and write safer code.

7

Expert

Null safety with data types

🤔Before reading on: do you think variables can hold no value (null) by default in Flutter? Commit to yes or no.

Concept: Flutter's null safety means variables must have a value or be explicitly nullable.

By default, variables cannot be null. To allow null, add a ? after the type. Example: int? maybeNumber; maybeNumber = null; // Allowed int alwaysNumber = 5; alwaysNumber = null; // Error This prevents crashes from unexpected nulls.

Result

Null safety forces you to handle missing values carefully.

Knowing null safety improves app stability by avoiding null-related errors.

Under the Hood

Flutter uses Dart language which enforces data types at compile time. Each variable reserves memory space based on its type. The Dart compiler checks that operations match the variable's type, preventing invalid actions like adding text to numbers. Null safety adds checks so variables must be initialized or marked nullable, reducing runtime crashes.

Why designed this way?

Dart was designed for fast, reliable apps. Strong typing and null safety catch errors early, improving developer productivity and app quality. Alternatives like dynamic typing allow flexibility but risk bugs. Flutter chose this balance to help beginners and experts write safe, maintainable code.

┌───────────────┐
│   Source Code │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Dart Compiler │
│ - Checks types│
│ - Enforces    │
│   null safety │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│   Machine     │
│   Code        │
│ - Memory for  │
│   each type   │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Can you store decimal numbers in an int variable? Commit to yes or no.

Common Belief: Int variables can hold decimal numbers like 3.14 without problems.

Reality: Int only stores whole numbers; decimals require double type.

Why it matters: Using int for decimals causes errors or data loss, leading to wrong calculations.

Quick: Is it okay to store numbers as Strings if you don't plan to calculate with them? Commit to yes or no.

Common Belief: Storing numbers as Strings is fine if you only display them.

Reality: While possible, storing numbers as Strings wastes memory and prevents math operations.

Why it matters: Misusing Strings for numbers can cause bugs when calculations are needed later.

Quick: Do you think bool can hold values other than true or false? Commit to yes or no.

Common Belief: Bool can store multiple states like 'maybe' or 'unknown'.

Reality: Bool only holds true or false; other states need different types or enums.

Why it matters: Misusing bool for multiple states causes logic errors and confusing code.

Quick: Can variables be null by default in Flutter without special syntax? Commit to yes or no.

Common Belief: Variables can be null unless initialized.

Reality: Flutter enforces null safety; variables must be initialized or marked nullable with ?.

Why it matters: Assuming variables can be null causes runtime crashes if not handled properly.

Expert Zone

1

Dart's type inference lets you omit explicit types in many cases, but understanding underlying types prevents subtle bugs.

2

Nullable types require careful handling with operators like '!' and '??' to avoid runtime errors.

3

Mixing int and double in expressions can cause implicit conversions; knowing when this happens avoids unexpected results.

When NOT to use

Avoid using basic data types when you need complex data structures like lists, maps, or custom objects. For flexible or unknown data shapes, consider dynamic or Object types but use them sparingly to keep type safety.

Production Patterns

In real apps, data types are combined with state management to track user input, API responses, and UI state. Null safety is used extensively to prevent crashes, and developers often create custom classes to group related data beyond basic types.

Connections

Database schemas

Data types in Flutter correspond to database column types for storing data persistently.

Understanding Flutter data types helps map app data correctly to databases, ensuring smooth data saving and retrieval.

Logic gates in electronics

Bool data type is similar to binary signals in logic gates that are either on or off.

Knowing how bool works in code connects to how computers process decisions at the hardware level.

Natural language grammar

String data type relates to how words and sentences are structured in language.

Handling Strings in code is like constructing meaningful sentences, requiring attention to order and content.

Common Pitfalls

#1 Trying to store decimal numbers in an int variable.

Wrong approach:

int price = 9.99;

Correct approach:

double price = 9.99;

Root cause:

Confusing int and double types and not knowing int only holds whole numbers.

#2 Assigning a String value to an int variable.

Wrong approach:

int count = 'five';

Correct approach:

int count = 5;

Root cause:

Not understanding that data types must match the variable's declared type.

#3 Using bool to represent more than two states.

Wrong approach:

bool status = 'maybe';

Correct approach:

enum Status { yes, no, maybe }
Status status = Status.maybe;

Root cause:

Misusing bool for multi-state logic instead of enums or other types.

Key Takeaways

Data types tell the app what kind of information a variable holds, enabling correct handling and display.

Int stores whole numbers, double stores decimals, String stores text, and bool stores true/false values.

Flutter enforces type safety and null safety to catch errors early and improve app reliability.

Choosing the right data type prevents bugs and makes your code clearer and easier to maintain.

Understanding data types is a foundation for learning more complex data structures and app logic.