Complete DART Programming Bootcamp for Flutter Developers

In this section, you will learn how to set up the Dart programming environment and run your very first program. We’ll explore different ways to get started, including using DartPad for quick online practice, installing the Dart SDK for local development, and creating new projects with the dart create command. By the end of this section, you’ll have a fully functional setup and the confidence to begin coding in Dart.

In this section, you will explore how Dart handles variables and data types, which form the core of every program. You’ll learn to work with int, double, bool, String, var, dynamic, final, and const, and understand when to use each. We’ll also cover essential type conversion techniques such as int.parse, double.parse, and toString, ensuring you can seamlessly switch between different data types.

By the end, you’ll have a strong grasp of Dart’s type system and be ready to write clean, efficient, and error-free code.

In this section, you will learn how to display output in Dart using the print() function and the stdout object. We’ll explore how to format messages effectively with string interpolation, allowing variables and expressions to be embedded directly within strings. This section will also highlight the difference between print() and stdout.write(), giving you flexibility in handling console outputs.

By the end, you’ll be able to produce clear, dynamic, and well-structured output for your Dart programs.

In this section, you will understand the difference between var and dynamic in Dart. We’ll explore how var lets the compiler infer a type at compile-time, while dynamic provides complete flexibility by allowing values of any type to be assigned at runtime. You’ll also see practical examples highlighting when to use each and the potential risks of using dynamic carelessly.

By the end, you’ll be confident in choosing the right variable type for your programs to balance safety, flexibility, and performance.

In this section, you will learn the key differences between const and final variables in Dart and Flutter. We’ll explore how final is used for values that are assigned only once at runtime, while const represents values that are known and fixed at compile-time. With practical examples, you’ll see how these keywords help in writing more efficient, predictable, and memory-safe code, especially when building Flutter applications.

By the end, you’ll clearly understand when to use final and when to prefer const to make your codebase more optimized and maintainable.

In this section, you will learn how to control the flow of your Dart programs using conditional statements. We’ll cover the if and else statements, the switch statement for multiple-case scenarios, and conditional operators like the ternary ? : operator for concise decision-making. Through practical examples, you’ll understand how to make your programs respond differently based on varying conditions.

By the end, you’ll be able to implement clear and efficient conditional logic in your Dart applications.

In this section, you will learn how to execute repetitive tasks efficiently using looping statements in Dart. We’ll cover the for loop for fixed iterations, the while loop for condition-based repetition, and the do-while loop which guarantees at least one execution. Through practical examples, you’ll understand how to choose the right loop for different scenarios and write concise, readable, and efficient code.

By the end, you’ll be able to handle iterations confidently in your Dart programs.

In this section, you will learn the differences between the two common entry points in Dart programs: main() and main(List<String> args). We’ll explore how main() is used for simple programs without external inputs, while main(List<String> args) allows your program to receive command-line arguments, enabling more dynamic and flexible behavior. Through examples, you’ll understand when and how to use each form to handle program inputs effectively.

By the end, you’ll be able to structure your Dart programs for both basic and advanced use cases.

In this section, you will learn the difference between regular division (/) and integer division (~/) in Dart. The / operator returns a double result, including any fractional part, while the ~/ operator returns only the integer quotient, discarding the remainder. Through practical examples, you’ll understand when to use each operator to perform precise calculations and control the type of results in your programs.

By the end, you’ll be confident in choosing the right division operator for your Dart applications.

In this section, you will learn how Dart allows you to test and cast types using the is, is!, and as operators. The is operator checks if an object is of a specific type, is! verifies it is not of that type, and as is used to cast an object to a specific type safely. Through practical examples, you’ll understand how to write type-safe code, avoid runtime errors, and leverage Dart’s strong typing system effectively.

By the end, you’ll be confident in using these operators to handle different data types in your programs.

In this video, I explain the difference between global variables and method (or local) scope variables in Dart.
This concept is very important because it helps us understand where variables can be used and how long they live in our program.

Global Variable

A global variable is declared outside of all functions or classes.

• It can be accessed from anywhere in the file.

• It keeps its value even after the function ends.

• It’s useful when multiple functions need to share the same data.

// Global variable example

int counter = 0;

void incrementCounter() {

  counter++;

  print("Counter: $counter");

}

void main() {

  incrementCounter(); // Counter: 1

  incrementCounter(); // Counter: 2

}

? Here, the variable counter is global. Every time we call incrementCounter(), the same variable is updated, so the value keeps increasing.

Method (Local) Scope Variable

A local variable is declared inside a function.

• It only exists while that function is running.

• Once the function finishes, the variable is destroyed.

• Every time you call the function, a new variable is created.

void showCounter() {

  int counter = 0; // Local variable

  counter++;

  print("Counter: $counter");

}

void main() {

  showCounter(); // Counter: 1

  showCounter(); // Counter: 1 again

}

? Notice that even though we call the function multiple times, the counter always starts from 0 because it is local and does not keep its value between calls.

In this video, I explain how to take input from the keyboard in Dart, Getting input is a very common task because most applications need user interaction.
Taking Input in Dart (Console Application)

In Dart console programs, we use the dart:io library to read input from the keyboard.
The main method for this is stdin.readLineSync(), which reads user input as a string.

import 'dart:io';

void main() {

  print("Enter your name:");

  String? name = stdin.readLineSync(); // Taking input

  print("Hello, $name!");

}

? Here:

• stdin.readLineSync() waits for the user to type something.

• The ? makes the variable nullable, because the input might be null.

• Whatever the user types is stored in the variable name.

In this video, I explain what functions are in Dart and the different types of functions you can create.
Functions are one of the most important parts of any programming language because they allow us to organize code, reuse logic, and make our programs cleaner.

What is a Function?

A function is simply a block of code that performs a specific task.
We write the function once, and then we can call it whenever we need that task done.

Basic syntax looks like this:

void greet() {

  print("Hello, Dart!");

}

void main() {

  greet(); // Calling the function

}

? Here, greet() is a function that prints a message.

Types of Functions in Dart

1. Function with No Return Type and No Parameters

This function just performs an action and doesn’t take input or give output.

void sayHello() {

  print("Hello, World!");

}

2. Function with Parameters but No Return Type

This function takes input but does not return any value.

void greetUser(String name) {

  print("Hello, $name!");

}

void main() {

  greetUser("Alice"); // Output: Hello, Alice!

}

3. Function with Return Type but No Parameters

This function returns a value but doesn’t take any input.

int getNumber() {

  return 42;

}

void main() {

  print(getNumber()); // Output: 42

}

4. Function with Both Parameters and Return Type

This is the most common type, where the function takes input and gives back a result.

int add(int a, int b) {

  return a + b;

}

void main() {

  print(add(5, 3)); // Output: 8

}

In this video, I explain the different types of parameters we can use in Dart functions.
Parameters allow us to pass values into functions, making them more flexible and reusable. Dart supports several types of parameters, and understanding them will help you write cleaner and more powerful code.

1. Required Positional Parameters

These are the most common parameters. You must pass them in the correct order when calling the function.

void greet(String name, int age) {

  print("Hello, $name! You are $age years old.");

}

void main() {

  greet("Alice", 25); // ✅ Works

  // greet("Alice");  ❌ Error (age missing)

}

? Both name and age must be provided, and in the right order.

2. Optional Positional Parameters

These parameters are wrapped in square brackets []. They are optional, and if not passed, they default to null.

void greet(String name, [String? city]) {

  print("Hello, $name from ${city ?? "unknown place"}");

}

void main() {

  greet("Alice");            // Hello, Alice from unknown place

  greet("Bob", "New York");  // Hello, Bob from New York

}

? city is optional, and we handle null with the ?? operator.

3. Named Parameters

Named parameters are wrapped in curly braces {}. They make the function call more readable.

void greet({required String name, int age = 18}) {

  print("Hello, $name! Age: $age");

}

void main() {

  greet(name: "Alice", age: 25); // Hello, Alice! Age: 25

  greet(name: "Bob");            // Hello, Bob! Age: 18

}

? Here:

• required makes the name parameter mandatory.

• age has a default value, so if we don’t pass it, Dart uses 18.

4. Mixed Parameters (Combining)

We can combine required, optional, and named parameters in the same function.

void userInfo(String username, {int age = 18, String? city}) {

  print("User: $username, Age: $age, City: ${city ?? "Unknown"}");

}

void main() {

  userInfo("Alice"); 

  userInfo("Bob", age: 30, city: "London");

}

? Here, username is required (positional), but age and city are optional named parameters.

In this video, I explain what arrow functions are in Dart and how to use them.
Arrow functions provide a short-hand way of writing functions when the function body contains only a single expression. They make your code shorter and more readable.

What is an Arrow Function?

An arrow function uses the => symbol instead of curly braces {}.
It’s often called a fat arrow function.

Basic syntax:

returnType functionName(parameters) => expression;

Example 1: Normal Function vs Arrow Function

// Normal function

int square(int n) {

  return n * n;

}

// Arrow function

int squareArrow(int n) => n * n;

void main() {

  print(square(4));       // Output: 16

  print(squareArrow(4));  // Output: 16

}

? Both functions do the same thing, but the arrow version is shorter.

Example 2: Function Without Parameters

void sayHello() => print("Hello, Dart!");

void main() {

  sayHello(); // Output: Hello, Dart!

}

? If your function only runs one statement, you can use => directly.

Example 3: Arrow Function with Multiple Parameters

int add(int a, int b) => a + b;

void main() {

  print(add(5, 3)); // Output: 8

}

? The function directly returns the result of a + b.

⚠️ Important Note

Arrow functions can only be used for single-expression functions.
If your function needs multiple lines or statements, you must use the normal { } block.

// ❌ Not allowed with arrow function

// int sum(int a, int b) => {

//   int result = a + b;

//   return result;

// };

In this video, I explain what lambda functions, also known as anonymous functions, are in Dart.
Sometimes, we need a function that is used only once and doesn’t require a name. Instead of creating a full named function, Dart allows us to create anonymous functions, also called lambdas.

What is an Anonymous Function?

• An anonymous function is a function without a name.

• It can be stored in a variable, passed as an argument, or used inline.

• The syntax looks like this:

            (parameters) {

                     // function body

            };

Example 1: Simple Anonymous Function

void main() {

  var greet = () {

    print("Hello from an anonymous function!");

  };

  greet(); // Output: Hello from an anonymous function!

}

? Here, the function is stored in the variable greet, and we can call it just like a normal function.

Example 2: Anonymous Function with Parameters

void main() {

  var add = (int a, int b) {

    return a + b;

  };

  print(add(5, 3)); // Output: 8

}

? This anonymous function takes two parameters and returns their sum.

Example 3: Passing Anonymous Function as Argument

void main() {

  var numbers = [1, 2, 3, 4];

  numbers.forEach((n) {

    print(n * 2);

  });

}

? Here, we pass an anonymous function directly to forEach.
Every element n is doubled and printed.

In this video, I explain the concept of functions as first-class citizens in Dart.
This means that in Dart, functions are treated just like any other object. We can assign them to variables, pass them as parameters, and even return them from other functions. This gives us a lot of flexibility when writing code.

What Does "First-Class Citizen" Mean?

When we say functions are first-class citizens (or first-class objects), it means:

1. Functions can be stored in variables.

2. Functions can be passed as arguments to other functions.

3. Functions can be returned from other functions.

Example 1: Assign Function to a Variable

void greet() {

  print("Hello from Dart!");

}

void main() {

  var sayHello = greet; // Assign function to a variable

  sayHello();           // Output: Hello from Dart!

}

? Here, the function greet is assigned to the variable sayHello, and we can call it just like a function.

Example 2: Passing a Function as a Parameter

void executeFunction(void Function() action) {

  action();

}

void main() {

  executeFunction(() {

    print("This is an anonymous function passed as an argument!");

  });

}

? Here, we pass a function into another function (executeFunction).
This allows us to write flexible and reusable code.

Example 3: Returning a Function from Another Function

Function multiplyBy(int factor) {

  return (int number) => number * factor;

}

void main() {

  var doubleIt = multiplyBy(2);

  print(doubleIt(5)); // Output: 10

  var tripleIt = multiplyBy(3);

  print(tripleIt(5)); // Output: 15

}

? Here, multiplyBy returns another function. We can then use it to create different multipliers (doubleIt, tripleIt).

In this video, I explain what closures are in Dart and how they work.
Closures are a very powerful concept in programming. A closure is simply a function that remembers the variables from its surrounding scope, even after that scope has finished executing.

What is a Closure?

• A closure is a function that can capture and use variables from the scope in which it was created.

• Even if the outer function has finished running, the closure still has access to those variables.

Example 1: Basic Closure

Function makeCounter() {

  int count = 0;

  return () {

    count++;

    return count;

  };

}

void main() {

  var counter = makeCounter();

  print(counter()); // Output: 1

  print(counter()); // Output: 2

  print(counter()); // Output: 3

}

? Here:

• makeCounter defines a local variable count.

• It returns an anonymous function that increments and returns count.

• Even though makeCounter finishes executing, the inner function remembers count.

Example 2: Closure Capturing Outer Variable

void main() {

  int multiplier = 3;

  var multiply = (int number) {

    return number * multiplier;

  };

  print(multiply(5)); // Output: 15

}

? The anonymous function multiply uses the variable multiplier from its outer scope.
This is possible because of closures.

Example 3: Multiple Closures with Independent State

Function createAdder(int base) {

  return (int value) => base + value;

}

void main() {

  var addFive = createAdder(5);

  var addTen = createAdder(10);

  print(addFive(3));  // Output: 8

  print(addTen(3));   // Output: 13

}

? Each closure (addFive and addTen) remembers its own value of base, creating independent states.

In this video, I explain how to create your own libraries in Dart, and how to import them into your project.
Libraries are important because they help us organize code into smaller, reusable modules. Instead of writing all the code in a single file, we can split it into multiple files and import them wherever needed.

What is a Library in Dart?

• In Dart, every file is considered a library.

• You can either use built-in libraries (like dart:io, dart:math) or create your own custom library.

• Importing a library makes its classes, functions, and variables available in your file.

Step 1: Creating a Custom Library

Let’s create a file named math_utils.dart:

// math_utils.dart

library math_utils;

int add(int a, int b) {

  return a + b;

}

int multiply(int a, int b) {

  return a * b;

}

? Here, we created a custom library called math_utils with two functions: add and multiply.

Step 2: Importing the Library in Main File

Now, let’s use this library in main.dart:

import 'math_utils.dart';

void main() {

  print(add(5, 3));      // Output: 8

  print(multiply(4, 6)); // Output: 24

}

? We imported our custom library and used its functions.

Step 3: Using Built-in Dart Libraries

Dart provides many built-in libraries. For example:

import 'dart:math';

void main() {

  print(sqrt(25)); // Output: 5.0

}

? Here, we use the built-in dart:math library for mathematical operations.

In this video, I explain how to create a single library in Dart but organize it across multiple files.
This is useful when you have a large project and want to split your code into smaller files but still keep them under one common library.

Why Use a Single Library with Multiple Files?

• Keeps code organized and modular.

• Makes maintenance easier in large projects.

• Allows you to reuse functions and classes across different files while still grouping them under one library name.

Step 1: Create the Library File

Let’s start by creating a library file called math_utils.dart.

// math_utils.dart

library math_utils;

part 'add.dart';

part 'multiply.dart';

? Here:

• We declared the library math_utils.

• We added two part files (add.dart and multiply.dart).

Step 2: Create the Part Files

//add.dart

part of math_utils;

int add(int a, int b) {

  return a + b;

}

//multiply.dart

part of math_utils;

int multiply(int a, int b) {

  return a * b;

}

? Notice the part of math_utils; declaration — this links the file to the main library.

Step 3: Use the Library in Main File

import 'math_utils.dart';

void main() {

  print(add(5, 3));      // Output: 8

  print(multiply(4, 6)); // Output: 24

}

? Now, even though add and multiply are in different files, we import only the main math_utils.dart, and we can use both functions.

In this video, I explain how to merge multiple libraries into a single library in Dart.
When working on bigger projects, sometimes we create several small libraries. But instead of importing each one separately everywhere, we can merge them under a single library and make our code cleaner.

Why Merge Multiple Libraries?

• To avoid writing too many import statements.

• To provide a single entry point for related features.

• To keep the project organized and modular.

Step 1: Create Multiple Libraries

//math/add.dart

library add;

int add(int a, int b) {

  return a + b;

}

//math/multiply.dart

library multiply;

int multiply(int a, int b) {

  return a * b;

}

? Here we created two small libraries: add and multiply.

Step 2: Create a Single Merged Library

Now, let’s create a merged library file called math_utils.dart.

library math_utils;

export 'add.dart';

export 'multiply.dart';

? Here:

• We declared a new library called math_utils.

• We used the export keyword to combine add.dart and multiply.dart into one library.

Step 3: Import the Merged Library in Main File

import 'math_utils.dart';

void main() {

  print(add(5, 3));      // Output: 8

  print(multiply(4, 6)); // Output: 24

}

? Now, we don’t need to import add.dart and multiply.dart separately.
We only import math_utils.dart, and we can use both functions.

? Key Difference: part vs export

• Use part/part of → when you want to split one single library into multiple files.

• Use export → when you want to merge multiple independent libraries into one main library.

In this video, I explain the concept of Class and Object in Dart.

A class in Dart is like a blueprint. It defines properties and behaviors using variables and methods. For example, if you create a class named Car, it can have properties like color and model, and methods like start() or drive().

An object is an instance of a class. When you create an object, you are actually bringing the class blueprint to life with real values. For example, from the Car class, we can create objects like Car myCar = Car();. Each object can have its own values, such as one car being red and another being blue.

So in short, a class defines the structure, and an object is the actual usable entity created from that class.

In this video, I explain instance, private, and local variables and methods in Dart.

An instance variable is defined inside a class, but outside any method. It belongs to the object, not the class itself. Every object you create gets its own copy of instance variables.

Instance methods, on the other hand, are functions defined inside the class that can access these instance variables.

In Dart, privacy is controlled at the library level. If you put an underscore _ before a variable or method name, it becomes private. That means it cannot be accessed outside its own file.

For example: _balance in a class BankAccount can’t be accessed directly from another file.

A local variable is created inside a method, constructor, or block. It only exists while that block is running, and you can’t use it outside.

Similarly, local methods can be defined inside another method, and they can only be used within that method.

In this video, I explain the default and parameterized constructor in Dart.
A constructor is a special method that is automatically called when you create an object. If you don’t define any constructor, Dart provides a default constructor with no parameters.
This is useful when you just want to create an object without passing any values.

A parameterized constructor allows you to pass values when creating an object. This way, you can initialize instance variables at the time of object creation.
For example, if you have a Car class with model and color, you can pass these values directly while creating the object using a parameterized constructor.

In short, the default constructor creates an object with no parameters, while the parameterized constructor lets you set values at the time of object creation.

In this video, I explain the different types of constructors in Dart: Named, Const, Private, and Factory.

1. Named Constructor

Dart does not support constructor overloading like some other languages.
Instead, we can create multiple constructors by giving them names.
For example, Car.fromJson() or Car.named().
Named constructors are useful when you want to initialize objects in different ways.

2. Const Constructor

A const constructor allows you to create compile-time constant objects.
If all instance variables are final, and you mark the constructor as const, then Dart can reuse the same object instead of creating new ones.
This makes the object immutable and improves performance.

3. Private Constructor

A private constructor is declared by starting its name with an underscore _.
It is mainly used to restrict object creation from outside the file.
This is very helpful in patterns like singleton, where you only want one object of a class.

4. Factory Constructor

A factory constructor does not always create a new object.
Instead, it can return an existing object, or even return a subclass object.
This is useful for implementing design patterns such as singleton or when you want to control how objects are created.

✅ In short:

• Named constructor → multiple ways to initialize objects.

• Const constructor → creates immutable, compile-time objects.

• Private constructor → restricts object creation.

• Factory constructor → gives control over object creation, may return existing objects.

In this video, I explain the initializer list in Dart constructors.

Sometimes, when you create a constructor, you may want to initialize instance variables before the constructor body runs.
In Dart, this can be done using an initializer list, which is written after a colon : and before the constructor body.

For example, you can use it to:

• Initialize final variables that must be assigned a value at creation.

• Call a superclass constructor with values.

• Perform quick assignments before the constructor executes.

✅ In short, the initializer list in Dart is a powerful way to assign values to instance variables or call the parent constructor before the main constructor body is executed.

In this video, I explain inheritance in Dart.

Inheritance is an object-oriented programming feature that allows one class to use the properties and methods of another class. The class that gives its features is called the parent or superclass, and the class that inherits them is called the child or subclass.
Inheritance helps with code reusability and makes programs easier to manage.

Types of Inheritance in Dart

1. Single Inheritance
In this video, I explain single inheritance in Dart.
Here, a single subclass inherits from one superclass.
For example, a Car class can inherit from a Vehicle class.

2. Multilevel Inheritance
In this video, I explain multilevel inheritance in Dart.
In this type, a class is derived from another class, which is also derived from another class.
For example: ElectricCar inherits from Car, and Car inherits from Vehicle.

3. Hierarchical Inheritance
In this video, I explain hierarchical inheritance in Dart.
Here, multiple classes inherit from a single superclass.
For example, both Car and Bike classes can inherit from Vehicle.

⚠️ Note: Dart does not support multiple inheritance directly, but you can achieve similar functionality using mixins and interfaces.

✅ In short:

• Inheritance allows code reusability by letting subclasses use properties and methods of a superclass.

• Dart supports single, multilevel, and hierarchical inheritance.

• Multiple inheritance is not supported but can be done with mixins or interfaces.

In this video, I explain about this, super, and static keyword in Dart:

1. this Keyword
In this video, I explain about the this keyword in Dart.
The this keyword refers to the current object of the class.
It is mainly used to:

• Differentiate between instance variables and parameters when they have the same name.

• Call another constructor inside the same class using this.namedConstructor().

2. super Keyword
In this video, I explain about the super keyword in Dart.
The super keyword refers to the parent class.
It is used to:

• Access parent class variables and methods.

• Call the parent class constructor from the child class.
  This makes it easy to reuse code from the superclass.

3. static Keyword
In this video, I explain about the static keyword in Dart.
The static keyword is used to define class-level variables and methods.
That means they belong to the class itself, not to any particular object.

• A static variable has only one copy, shared by all objects.

• A static method can be called directly using the class name, without creating an object.

✅ In short:

• this → refers to the current object.

• super → refers to the parent class and its members.

• static → creates class-level members shared across all objects.

In this video, I explain about calling one constructor from another constructor in Dart.

In Dart, this is done using the this keyword followed by the constructor name.
It allows you to reuse constructor code and avoid duplication.

For example, you can have a default constructor that initializes some common values, and then call it from a named constructor using : this() syntax.

This feature is very useful when a class has multiple constructors, and you want all of them to share some common initialization logic.

✅ In short: calling constructor by constructor in Dart is a way to make your code cleaner by reusing initialization code across multiple constructors using the this() syntax.

In this video, I explain about method overriding in Dart.

Method overriding happens when a child class provides its own implementation of a method that is already defined in the parent class. This allows the subclass to customize or change the behavior of the inherited method.

In Dart, we use the @override annotation before the method to clearly indicate that we are overriding a parent class method.

For example, a Vehicle class may have a method move(), and a Car class that extends Vehicle can override the move() method to provide its own implementation.

✅ In short:

• Method overriding lets a child class change the behavior of a parent class method.

• We use the @override annotation in Dart.

In this video, I explain about setter and getter methods in Dart.

A getter method is used to read or access the value of a private variable from outside the class. It looks like a property but works like a method, making code clean and readable.

A setter method is used to update or modify the value of a private variable from outside the class. It allows you to apply conditions or validation before assigning a value.

For example, if you have a private variable _age, you can create a getter to return its value and a setter to ensure that only valid values are assigned.

In short, getters provide read-only access and setters provide controlled write access to class variables.

✅ In short:

• Getter → used to read private variable values.

• Setter → used to update private variable values with validation.

In this video, I explain about encapsulation in Dart.

Encapsulation is one of the main principles of object-oriented programming. It means wrapping data and methods together inside a class and restricting direct access to the data from outside the class.

In Dart, we achieve encapsulation by making variables private using an underscore _, and then providing getter and setter methods to access or update them safely.

This way, the internal state of an object is protected from unwanted changes, and you can apply conditions or validation when values are assigned.

For example, a BankAccount class may have a private variable _balance, and you can only read or update it through getters and setters with proper rules.

✅ In short:

• Encapsulation means hiding internal data and providing controlled access.

• In Dart, it is done using private variables with getters and setters.

• It helps to keep data safe and secure from direct modification.

In this video, I explain about the abstract class, and interface in Dart.

1. Abstract Class
It can contain abstract methods without implementation, as well as normal methods with implementation.
The main purpose of an abstract class is to provide a blueprint for other classes.
For example, you can have an abstract class Animal with an abstract method makeSound(), and subclasses like Dog and Cat must provide their own implementation of makeSound().

2. Interface
Dart does not have a separate interface keyword. Instead, every class can act as an interface.
You can implement an interface using the implements keyword.
When a class implements an interface, it must provide an implementation for all the methods defined in that interface. This is useful when you want to enforce that multiple classes follow the same contract or behavior.

3. Abstraction with Abstract Class and Interface
Abstraction means hiding the implementation details and only showing the essential features to the user.

• An abstract class is best used when you want to provide a base class with some common code plus some abstract methods.

• An interface is best used when you want to force classes to follow a certain contract, without providing any implementation.

✅ In short:

• Abstract class → provides a blueprint with both defined and undefined methods.

• Interface → forces classes to implement all methods of the interface.

• Both help in achieving abstraction, which hides implementation details and exposes only essential functionality.

In this video, I explain about method overloading in Dart.

In many programming languages like Java or C++, method overloading means creating multiple methods with the same name but different parameter lists.

However, in Dart, method overloading is not supported.
You cannot define two methods with the same name inside a class, even if their parameters are different.

Instead, Dart provides other ways to achieve similar functionality:

• You can use optional positional parameters.

• You can use named parameters with default values.

• You can also use method overriding in subclasses, but that is different from overloading.

So, while Dart does not support method overloading directly, you can still handle multiple method use cases by designing your constructors and methods with flexible parameters.

✅ In short:

• Method overloading is not supported in Dart.

• Use optional or named parameters to achieve similar behavior.

In this video, I explain about polymorphism in Dart.

Polymorphism is one of the main principles of object-oriented programming.
The word polymorphism means many forms.
It allows the same method or function to behave differently based on the object that is calling it.

In Dart, polymorphism is mainly achieved through inheritance and method overriding.
For example, if a parent class Animal has a method makeSound(), and subclasses like Dog and Cat override this method, then the same method call makeSound() will produce different results depending on whether the object is a dog or a cat.

Polymorphism is also heavily used in Flutter. For example, when you call the build() method on a widget, each widget type has its own implementation of build().

✅ In short:

• Polymorphism means one interface, many implementations.

• Achieved in Dart using inheritance and method overriding.

• It allows the same method to behave differently for different objects.

In this video, I explain about the Enums data type in Dart.

An enum in Dart is a special data type used to represent a fixed set of constant values.
Enums make the code more readable, type-safe, and organized by giving meaningful names instead of using plain numbers or strings.

For example, you can use an enum Days to represent the days of the week like monday, tuesday, or wednesday.
This avoids mistakes such as typing wrong strings and helps keep your code clean.

In Dart, enums can also have additional features such as properties, methods, and even mixins in the newer versions.
This makes them more powerful compared to basic enums in other languages.

✅ In short:

• Enums represent a group of fixed constant values.

• They make code cleaner and less error-prone.

• Useful for things like days, colors, statuses, or roles.

In this video, I explained about Dart Exception Handling with Try, On, Catch, and Finally.

Exception handling in Dart is an essential concept that helps developers write safe, reliable, and error-free code. By using try, you can test a block of code for errors; with on, you can handle specific exceptions; with catch, you can capture and process the exception details; and with finally, you can execute code that runs regardless of whether an error occurred or not.

This tutorial covers:

• The difference between try, on, and catch.

• How to handle specific exceptions gracefully.

• Using finally to ensure cleanup code always runs.

• Practical coding examples to demonstrate real-world usage.

By the end of this video, you will have a solid understanding of Dart’s exception handling mechanism and how to use it to build robust applications.

In this video, I explained about Dart Custom or User Defined Exception.

Sometimes, the built-in exceptions in Dart are not enough to handle specific situations in your application. That’s where custom exceptions come in — they allow you to create your own exception classes to handle errors in a more meaningful and descriptive way.

This tutorial covers:

• What a custom (user-defined) exception is in Dart.

• How to create a custom exception class.

• Throwing and catching user-defined exceptions.

• Practical examples to make your code more readable and maintainable.

By the end of this video, you will understand how to implement and use custom exceptions in Dart to make your error handling more powerful and application-specific.

In this video, I explained about Dart Array or List.

In Dart, arrays are represented by the List class, which is one of the most commonly used data structures for storing multiple values. Lists allow you to manage collections of items, perform iterations, and apply various operations like adding, removing, or updating elements.

This tutorial covers:

• What arrays (lists) are in Dart.

• Difference between fixed-length and growable lists.

• How to create, access, and update list elements.

• Common list operations such as add, remove, insert, and iteration.

• Practical coding examples to demonstrate real-world usage.

By the end of this video, you will clearly understand how Dart Lists work and how to use them effectively to manage collections of data in your applications.

In this video, I explained about Dart Set.

A Set in Dart is an unordered collection of unique items, which means it automatically removes duplicates and ensures that each element appears only once. Sets are especially useful when you need to store distinct values and perform operations like union, intersection, or difference.

This tutorial covers:

• What a Set is in Dart and how it differs from a List.

• How to create and initialize a Set.

• Adding, removing, and checking elements in a Set.

• Performing common Set operations like union, intersection, and difference.

• Practical coding examples to demonstrate real-world use cases.

By the end of this video, you will understand how to work with Sets in Dart and use them to handle collections of unique data efficiently.

In this video, I explained about Dart Map.

A Map in Dart is a collection of key-value pairs, where each key is unique, and it is used to store and retrieve data efficiently. Maps are one of the most powerful and commonly used data structures in Dart for handling structured information.

This tutorial covers:

• What a Map is in Dart and why it is useful.

• How to create and initialize a Map.

• Adding, updating, and removing key-value pairs.

• Accessing values using keys.

• Iterating through keys, values, and entries.

• Practical coding examples to demonstrate real-world use cases.

By the end of this video, you will clearly understand how to work with Maps in Dart and apply them effectively in your applications.

In this video, I explained about Dart Queue.

A Queue in Dart is a collection that follows the FIFO (First In, First Out) principle, meaning the first element added is the first one to be removed. Queues are useful when you need to manage tasks or data in an ordered sequence, such as scheduling or processing requests.

This tutorial covers:

• What a Queue is in Dart and how it differs from List or Set.

• How to create and initialize a Queue using the dart:collection library.

• Adding elements with add and addFirst.

• Removing elements with removeFirst and removeLast.

• Iterating through elements in a Queue.

• Practical coding examples to demonstrate real-world use cases.

By the end of this video, you will understand how to work with Queues in Dart and when to use them in your applications.

In this video, I explained about Dart LinkedList.

A LinkedList in Dart is a collection that provides efficient insertion and deletion of elements compared to Lists, especially when working with large datasets. Unlike normal Lists, a LinkedList is made up of nodes that are connected to each other, allowing dynamic memory allocation and flexible data handling.

This tutorial covers:

• What a LinkedList is in Dart and how it works.

• Importing and using the dart:collection library.

• Creating and initializing a LinkedList.

• Adding and removing nodes efficiently.

• Traversing and iterating through a LinkedList.

• Practical coding examples to demonstrate real-world scenarios.

By the end of this video, you will understand how to use LinkedList in Dart and when it is the right choice for your application’s data structure needs.

In this video, I explained about Dart SplayTreeSet.

A SplayTreeSet in Dart is a collection of unique elements that are automatically arranged in a sorted order using a self-balancing binary search tree called a splay tree. It is part of the dart:collection library and is very useful when you need both uniqueness and sorting together.

This tutorial covers:

• What a SplayTreeSet is and how it differs from a normal Set.

• Importing and using the dart:collection library.

• Creating and initializing a SplayTreeSet.

• Adding and removing elements while maintaining sorted order.

• Iterating through elements in ascending order.

• Practical coding examples to demonstrate real-world use cases.

By the end of this video, you will understand how to work with SplayTreeSet in Dart and use it when you need a collection that is both unique and sorted automatically.

In this video, I explained about Dart SplayTreeMap.

A SplayTreeMap in Dart is a collection of key-value pairs that are automatically sorted by their keys using a self-balancing binary search tree called a splay tree. It is part of the dart:collection library and is ideal when you need a Map that maintains its keys in a sorted order.

This tutorial covers:

• What a SplayTreeMap is and how it differs from a normal Map.

• Importing and using the dart:collection library.

• Creating and initializing a SplayTreeMap.

• Adding, updating, and removing key-value pairs.

• Iterating through sorted keys and values.

• Practical coding examples to demonstrate real-world use cases.

By the end of this video, you will understand how to use SplayTreeMap in Dart and when it is the best choice for your application’s data structure needs.

In this video, I explained about Dart HashMap.

A HashMap in Dart is a collection of key-value pairs that provides very fast access, insertion, and deletion of data by using a hash-based structure. It is part of the dart:collection library and is widely used when performance is important and you don’t need the keys to be sorted.

This tutorial covers:

• What a HashMap is in Dart and how it differs from a normal Map.

• Importing and using the dart:collection library.

• Creating and initializing a HashMap.

• Adding, updating, and removing key-value pairs efficiently.

• Accessing values using keys.

• Iterating through keys, values, and entries.

• Practical coding examples to demonstrate real-world use cases.

By the end of this video, you will understand how to use HashMap in Dart and when it is the best option for building high-performance applications.

In this video, I explained about Dart HashSet.

A HashSet in Dart is a collection of unique elements that provides very fast insertion, lookup, and deletion operations by using a hash-based structure. It is part of the dart:collection library and is especially useful when you need uniqueness and high performance, without caring about the order of elements.

This tutorial covers:

• What a HashSet is in Dart and how it differs from a normal Set.

• Importing and using the dart:collection library.

• Creating and initializing a HashSet.

• Adding, checking, and removing elements.

• Iterating through elements in a HashSet.

• Practical coding examples to demonstrate real-world use cases.

By the end of this video, you will understand how to use HashSet in Dart and when it is the best choice for applications requiring fast and efficient handling of unique data.

In this video, I explained about Dart UnmodifiableListView.

An UnmodifiableListView is a special type of List that provides a read-only view of another list. It ensures that once the list is created, elements cannot be added, removed, or modified directly, making your data safe from accidental changes.

This tutorial covers:

• What UnmodifiableListView is and why it’s useful.

• Importing and using the dart:collection library.

• Creating and initializing an UnmodifiableListView.

• Attempting modifications and understanding the errors.

• Practical coding examples to demonstrate when to use it.

By the end of this video, you will understand how to use UnmodifiableListView in Dart to create read-only, safe collections.

In this video, I also explained about Dart UnmodifiableMapView.

An UnmodifiableMapView is a read-only view of a Map in Dart, which prevents adding, updating, or removing key-value pairs. It is part of the dart:collection library and is helpful when you want to expose data safely without the risk of modifications.

This tutorial covers:

• What UnmodifiableMapView is and how it differs from a normal Map.

• Importing and using the dart:collection library.

• Creating and initializing an UnmodifiableMapView.

• Trying to modify data and understanding why it fails.

• Practical coding examples to demonstrate real-world use cases.

By the end of this video, you will understand how to use UnmodifiableMapView in Dart to keep your key-value data secure and immutable and you will also understand how to use UnmodifiableListView in Dart to create read-only, safe collections.

In this video, I explained about Dart & Flutter Null Safety.

Null safety is one of the most important features in Dart, introduced to prevent null reference errors and make applications more stable. With null safety, Dart helps you clearly define which variables can be null and which cannot, reducing bugs and improving code quality.

This tutorial covers:

• Nullable Type (?) – Declaring variables that can hold null values.

• Null-aware Operator (!) – Forcing non-null values safely.

• Default Value Operator (??) – Providing fallback values when variables are null.

• Assign-if-null Operator (??=) – Assigning values only when the variable is null.

• Late Keyword (late) – Deferring variable initialization until it’s needed.

• Null-aware Access (?.) – Accessing properties or methods safely without null errors.

With practical coding examples, you’ll learn how each operator works and when to use them in your Dart and Flutter projects.

By the end of this video, you will have a clear understanding of null safety in Dart, and how to use it effectively to write cleaner, safer, and more reliable applications.

In this video, I explained about Dart Typedef or Function-Type Aliases.

A typedef in Dart is a powerful feature that allows you to create a custom name for a function type. This makes your code more readable, reusable, and easier to maintain when working with functions as parameters, callbacks, or higher-order functions.

This tutorial covers:

• What typedef is in Dart and why it is useful.

• How to create and use function-type aliases.

• Passing typedefs as function parameters.

• Using typedefs in callbacks and higher-order functions.

• Practical coding examples to demonstrate real-world use cases.

By the end of this video, you will understand how to use typedef in Dart effectively to simplify complex function signatures and improve code readability.

n this video, I explained about Dart Callable Class.

A callable class in Dart is a class that allows its instances to be called like functions by implementing the special call method. This feature makes your code cleaner and more expressive, especially when building utilities, wrappers, or function-like objects.

This tutorial covers:

• What a callable class is in Dart and why it’s useful.

• How to define the call method inside a class.

• Creating objects that behave like functions.

• Passing callable class objects as function arguments.

• Practical coding examples to demonstrate real-world scenarios.

By the end of this video, you will understand how to use callable classes in Dart and apply them in situations where classes and functions work together seamlessly.

In this video, I explained about Dart Mixins.

Mixins in Dart are a way to reuse code across multiple classes without using traditional inheritance. They allow you to add functionalities to classes in a flexible and efficient way.

This tutorial covers:

• Creating & Using Mixins – How to define a mixin and apply it to classes.

• Handling Conflicts in Mixins – What happens when multiple mixins define the same method or property, and how Dart resolves such conflicts.

• Practical coding examples showing how mixins make code cleaner and reusable.

By the end of this video, you will understand how to create and use mixins in Dart, and how to manage conflicts when combining multiple mixins in your classes.

In this video, I explained about Dart Extension Methods.

Extensions in Dart allow you to add new functionalities to existing classes—without modifying the original class or creating a subclass. This makes your code more powerful, clean, and expressive.

This tutorial covers:

• What extension methods are in Dart and why they are useful.

• How to create and use an extension on built-in types like String or int.

• Adding custom methods and properties to existing classes.

• Organizing extensions in large projects.

• Practical coding examples to demonstrate real-world use cases.

By the end of this video, you will understand how to use extensions in Dart to enhance existing classes and write cleaner, reusable code.

In this video, I explained about Asynchronous Programming Concepts in Dart.

Asynchronous programming is one of the most important concepts in Dart and Flutter because it helps you write non-blocking code, making your apps faster and more responsive.

This tutorial covers:

1. What is Asynchronous Programming? – Understanding the basics.

2. Why Asynchronous Programming? – Benefits and real-world use cases.

3. Asynchronous Execution Flow (Event Loop Diagram) – Visualizing how async tasks are handled.

4. Asynchronous Execution Flow Explained – Breaking down how Dart schedules and executes async operations.

5. What Dart provides for Asynchronous Programming – Exploring Future, async/await, and Stream.

With practical explanations and diagrams, you’ll learn how Dart handles asynchronous operations behind the scenes.

By the end of this video, you will have a clear understanding of asynchronous programming in Dart and why it’s essential for building efficient Flutter applications.

In this video, I explained about the Basics of Future in Dart.

A Future in Dart represents a value that will be available at some time in the future—either after a successful computation or when an error occurs. Understanding Futures is the first step toward mastering asynchronous programming in Dart and Flutter.

This tutorial covers:

• What a Future is and why it’s needed in Dart.

• How synchronous vs. asynchronous execution works.

• Creating and using a Future.

• Handling results with then() and catchError().

• Practical coding examples to demonstrate real-world usage.

By the end of this video, you will understand the fundamentals of Futures in Dart and how to use them to write non-blocking, efficient code in your applications.

In this video, I explained about Future with async and await in Dart.

While Futures are powerful, using them with then() and catchError() can sometimes make code harder to read. The async and await keywords simplify asynchronous programming by making async code look and feel like synchronous code.

This tutorial covers:

• What async and await mean in Dart.

• How to write asynchronous functions using async.

• Awaiting a Future result with await.

• Handling errors with try-catch in async functions.

• Practical coding examples that demonstrate clean and readable async code.

By the end of this video, you will understand how to use async/await with Futures in Dart to write concise, clean, and more maintainable asynchronous code in your Flutter applications.

In this video, I explained about Future with then() and catchError() in Dart.

Futures represent values that will be available at a later time, and using then() and catchError() is one of the fundamental ways to handle their results and errors. This approach is especially useful when you want to chain multiple async operations together.

This tutorial covers:

• How to use the then() method to process the result of a Future.

• How to handle errors gracefully with catchError().

• Chaining multiple then() calls for sequential async operations.

• Understanding success vs. error callbacks.

• Practical coding examples to demonstrate real-world scenarios.

By the end of this video, you will understand how to work with Futures using then() and catchError() in Dart, and when to prefer this approach over async/await.

In this video, I explained about the use of Future.value() in Dart.

The Future.value() constructor is a simple way to create a Future that is already completed with a given value. It’s very useful when you want to work with asynchronous APIs but already have a result available immediately.

This tutorial covers:

• What Future.value() is and why it’s used.

• How to create a Future with an immediate result.

• Difference between Future.value() and normal async operations.

• Using Future.value() in testing and mocking scenarios.

• Practical coding examples to demonstrate real-world use cases.

By the end of this video, you will understand how to use Future.value() in Dart to simplify asynchronous programming when you need an instantly completed Future.

In this video, I explained about the use of Future.error() in Dart.

The Future.error() constructor is used to create a Future that is already completed with an error. This is helpful when you want to simulate or handle failures in asynchronous operations without actually performing the operation.

This tutorial covers:

• What Future.error() is and why it’s used.

• How to create a Future that completes with an error.

• Handling errors with catchError() and try-catch.

• Difference between throwing an exception vs. using Future.error().

• Practical coding examples to demonstrate real-world use cases.

By the end of this video, you will understand how to use Future.error() in Dart to represent failures in asynchronous code and handle them effectively.

In this video, I explained about Error Handling for Future in Dart.

When working with asynchronous code, errors can occur just like in synchronous operations. Dart provides multiple ways to handle errors in Futures, ensuring your app remains stable and bug-free.

This tutorial covers:

• Why error handling is important in Futures.

• Handling errors using catchError().

• Handling errors with try-catch inside async/await.

• Using onError for specific exception types.

• Best practices for writing safe and clean async code.

• Practical coding examples to demonstrate real-world scenarios.

By the end of this video, you will clearly understand how to handle errors in Futures using different techniques, and how to choose the right approach for your Dart and Flutter applications.

In this video, I explained about the use of Future.wait() in Dart.

The Future.wait() method allows you to run multiple Futures in parallel and wait until all of them are completed. This is very useful when you have several asynchronous tasks that can run together, and you only need to proceed once all results are ready.

This tutorial covers:

• What Future.wait() is and when to use it.

• Running multiple Futures in parallel.

• Collecting results as a list after all Futures complete.

• Handling errors when one or more Futures fail.

• Practical coding examples to demonstrate real-world use cases.

By the end of this video, you will understand how to use Future.wait() in Dart to manage multiple asynchronous operations efficiently.

In this video, I explained about the use of Future.sync() in Dart.

The Future.sync() constructor is used to execute a function immediately in a synchronous way, but still return its result wrapped inside a Future. This is helpful when you want to ensure that both synchronous and asynchronous computations can be handled uniformly as Futures.

This tutorial covers:

• What Future.sync() is and why it’s useful.

• Difference between Future.sync() and Future.value().

• Executing synchronous code in a Future context.

• Handling results and errors from Future.sync().

• Practical coding examples to demonstrate real-world scenarios.

By the end of this video, you will understand how to use Future.sync() in Dart to simplify asynchronous programming by treating synchronous results as Futures.

In this video, I explained about the use of Future.microtask() in Dart.

The Future.microtask() constructor is used to schedule a function to be executed as soon as possible, but before any event in the event queue. It is added to the microtask queue, which has higher priority than the event queue.

This is especially useful when you want to run a piece of code immediately after the current synchronous execution, without waiting for other asynchronous tasks or events. Developers often use it for small tasks like updating state, running quick computations, or ensuring code executes before timers, I/O operations, or user interactions.

By using Future.microtask(), you can:

• Schedule lightweight tasks that should run instantly after the current code.

• Handle priority tasks before event-loop operations.

• Improve responsiveness of your application by controlling execution order.

It’s an important concept to understand when dealing with asynchronous programming in Dart, as it helps in writing more efficient and predictable code.

In this video, I explained about the use of FutureGroup in Dart.

The FutureGroup class, available in the async package, is used to manage and coordinate multiple Future objects as a single group. It allows you to add several futures into the group and then wait until all of them are completed before proceeding.

This is very helpful when you need to perform multiple asynchronous operations together, such as fetching data from different APIs, reading files, or running parallel computations, and then continue execution only after all results are ready.

By using FutureGroup, you can:

• Add multiple futures dynamically into a group.

• Track when all futures have completed successfully or with errors.

• Simplify code when handling a collection of asynchronous tasks.

• Improve readability compared to manually handling multiple Future.wait() calls in complex scenarios.

It is a powerful utility for developers working with complex asynchronous workflows in Dart, making the code more structured and manageable.

In this section, I explained about Stream.fromIterable, a convenient way to create a stream from an existing collection or iterable in Dart.

The fromIterable constructor allows you to take any iterable (like a list, set, or any class that implements Iterable) and turn it into a Stream. This is particularly useful when you want to process a collection of items asynchronously, one element at a time, instead of handling them all at once.

Syntax:

Stream<T> Stream.fromIterable(Iterable<T> elements)

• T → The type of elements in the iterable.

• elements → The iterable collection you want to convert into a stream.

In this section, I explained about Stream with async*, a powerful way in Dart to create asynchronous streams using generator functions.

The async* keyword is used when you want to produce a sequence of values asynchronously and return them as a Stream. Unlike Stream.fromIterable, which converts an existing collection into a stream, async* allows you to generate values dynamically over time and emit them using the yield keyword.

Syntax:

Stream<T> myStream() async* {

  // generate and yield values asynchronously

  yield value1;

  yield value2;

  ...

}

• async* → Marks the function as an asynchronous generator that returns a Stream.

• yield → Emits a single value into the stream.

• yield* → Emits all values from another stream.

In this section, I explained about Stream with await for, a simple and elegant way in Dart to consume data from a stream asynchronously.

The await for loop is used inside an async function to listen to each event from a stream one by one. It pauses execution until a new value arrives, making it a clean way to handle asynchronous streams without manually attaching a listener.

Syntax:

await for (var value in stream) {

  // process each value

}

• await for → Waits for each value emitted by the stream.

• value → Represents the current item from the stream.

• The loop ends automatically once the stream is closed.

In this section, I explained about Stream with yield and yield*, which are used inside an async* generator function to produce values for a stream in Dart.

Both yield and yield* help you emit data into a stream, but they work slightly differently:

• yield → Emits a single value into the stream.

• yield* → Emits all values from another stream or iterable into the current stream.

Syntax:

Stream<T> myStream() async* {

  yield value;   // single value

  yield* otherStream; // all values from another stream

}

In this section, I explained about Stream.fromFutures, which is used in Dart to create a stream from a collection of futures.

The fromFutures constructor takes a list (or iterable) of Future objects and turns them into a Stream. Each future is resolved asynchronously, and when it completes, its result (or error) is emitted into the stream.

Syntax:

Stream<T> Stream.fromFutures(Iterable<Future<T>> futures)

• futures → A collection of futures to be converted into a stream.

• The stream emits values in the order the futures complete, not necessarily the order they appear in the list.

In this section, I explained about Stream with StreamController, which gives you full control over creating and managing a stream in Dart.

A StreamController acts as a bridge between the producer (who adds data, errors, or completion signals) and the consumer (who listens to the stream). Unlike constructors like fromIterable or fromFutures, a StreamController lets you decide when and how data enters the stream.

Syntax:

var controller = StreamController<T>();

// adding data

controller.sink.add(value);

// accessing the stream

controller.stream.listen(...);

// closing the stream

controller.close();

• controller.sink → Used to add values, errors, or a done event.

• controller.stream → The actual stream that consumers listen to.

In this section, I explained about the use of Stream Transformations, which allow you to modify, filter, or combine the data flowing through a stream in Dart.

Streams are powerful because they let you treat asynchronous events like a sequence of data. By applying transformations, you can process data as it arrives, instead of waiting for everything to complete.

Common Stream Transformations:

1. map() → Transforms each element.

2. where() → Filters elements based on a condition.

3. take(n) → Takes only the first n elements.

4. skip(n) → Skips the first n elements.

5. expand() → Expands each element into multiple events.

6. asyncMap() → Applies an async operation to each element.

In this section, I explained about the use of Stream Subscription, which represents the connection between a stream and a listener in Dart.

When you listen to a stream, you get back a StreamSubscription object. This subscription lets you control how you receive data from the stream, such as pausing, resuming, or canceling the listening process.

Syntax:

StreamSubscription<T> subscription = stream.listen(

  (data) {

    // handle data

  },

  onError: (error) {

    // handle error

  },

  onDone: () {

    // handle stream completion

  },

  cancelOnError: false,

);

• listen() → Attaches a listener and returns a StreamSubscription.

• onData → Handles each event.

• onError → Handles errors.

• onDone → Runs when the stream is closed.

• cancelOnError → Automatically cancels on error if set to true.

In this section, I explained about the use of Stream.periodic, which creates a stream that generates events at fixed time intervals in Dart.

The Stream.periodic constructor is very useful when you need to emit values repeatedly after a given duration — for example, timers, counters, or polling tasks.

Syntax:

Stream<T> Stream.periodic(Duration period, [T computation(int computationCount)?])

• period → The interval between each event.

• computation (optional) → A function that generates the event value. It receives the event count (starting from 0).

In this section, I explained about the use of Stream.handleError, which is a transformation method in Dart used to intercept and handle errors in a stream without stopping the stream flow.

Normally, if a stream emits an error, it can disrupt the listener unless you explicitly catch it. With handleError, you can catch and process errors while still allowing the rest of the data events to continue flowing.

Syntax:

Stream<T> handleError(

  Function onError, {

  bool test(dynamic error)?

})

• onError → A function that handles the error.

• test (optional) → A predicate function to decide which errors to handle. Errors not passing the test are forwarded to the stream’s listeners.

In this section, I explained about the use of StreamGroup, which is a utility from the async package in Dart that allows you to merge multiple streams into a single stream.

Normally, when you have several streams (for example, data coming from multiple sources), you’d have to listen to each one separately. With StreamGroup, you can combine them and listen to just one unified stream.

Import:

import 'package:async/async.dart';

Syntax:

var group = StreamGroup<T>();

group.add(stream1);

group.add(stream2);

var combinedStream = group.stream;

• StreamGroup.add(stream) → Adds a stream to the group.

• StreamGroup.stream → Returns the merged stream of all added streams.

• StreamGroup.close() → Stops accepting new streams and closes when all streams finish.