📘 Complete Tutorial 2026
Master Dart — the official language of Flutter — from zero to OOP expert. Includes full installation guides, core syntax, null safety, collections, functions, and object-oriented programming concepts.
Dart
Flutter
OOP
Null Safety
Cross-Platform
Mobile Dev
Open Source
Google
📋 Table of Contents
- What is Dart?
- Installation Guide — Windows, macOS, Linux, Termux (32-bit & 64-bit)
- Setting Up VS Code
- Your First Dart Program
- Comments in Dart
- Variables & Data Types
- Strings, Interpolation & Type Conversion
- Operators
- Null Safety & Null-Aware Operators
- Control Flow — if/else, switch
- Loops — for, while, do-while, break, continue
- Collections — List, Set, Map
- Functions & Parameters
- Object-Oriented Programming (OOP)
- Inheritance, Mixins & Interfaces
- Exception Handling
- Advantages of Dart
- Disadvantages of Dart
- Dart vs Other Languages
- Conclusion & Next Steps
1. What is Dart?
Dart is a statically typed, compiled, object-oriented programming language developed by Google. It was designed with one primary goal in mind: to be the backbone language for the Flutter framework, enabling developers to build cross-platform mobile, web, and desktop applications from a single codebase.
Dart combines the familiarity of C-like syntax with modern language features such as strong null safety, JIT (Just-In-Time) and AOT (Ahead-Of-Time) compilation, and a rich standard library. If you already know JavaScript, Java, or Python, picking up Dart will feel natural — most concepts transfer directly.
🔵 Key Facts About Dart
- Created by: Google (2011)
- Current stable version: Dart 3.x
- Primary use case: Flutter framework (cross-platform apps)
- Type system: Statically typed with type inference
- Compilation: JIT (development) + AOT (production)
- Website: dart.dev
- Online playground: dartpad.dev
Why Learn Dart?
The explosion of Flutter across the mobile development world has made Dart one of the fastest-growing languages to learn. Companies ranging from startups to enterprises now ship iOS, Android, and web apps simultaneously — all powered by a single Dart codebase.
- ✅ One language for iOS, Android, Web, Desktop, and Embedded
- ✅ Strongly typed, reducing runtime bugs significantly
- ✅ Fast hot-reload development cycle with Flutter
- ✅ Backed and maintained by Google
- ✅ Excellent documentation and growing community
JIT vs AOT Compilation
Dart supports two compilation modes, each serving a distinct purpose:
| Mode | Full Name | Used When | Benefit |
|---|---|---|---|
| JIT | Just-In-Time | During development | Fast hot-reload, dynamic compilation |
| AOT | Ahead-Of-Time | Production deployment | Optimized, fast startup, smaller binaries |
2. Installation Guide
Below are detailed installation instructions for all major platforms. Choose your operating system and architecture.
⚠️ Before You Begin
Always download Dart from the official source: dart.dev/get-dart. Avoid third-party installers to ensure security and version accuracy.
🪟 Windows Installation (32-bit & 64-bit)
Windows — Chocolatey (Recommended)
Works on both 32-bit and 64-bit
Step 1 — Install Chocolatey (as Admin in PowerShell)Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = 3072; iex ((New-Object System.Net.WebClient).DownloadString(‘https://chocolatey.org/install.ps1’))
Step 2 — Install Dart SDKchoco install dart-sdk
Step 3 — Verify installationdart –version
Windows — Manual ZIP Install
64-bit recommended; 32-bit supported for older hardware
Step 1Visit dart.dev/get-dart → click “Download SDK” → choose Windows x64 or x86 (32-bit)
Step 2Extract the ZIP to a folder, e.g., C:\dart-sdk
Step 3 — Add to PATHSystem Properties → Environment Variables → PATH → Add C:\dart-sdk\bin
Step 4 — Verifydart –version
✅ Windows — 32-bit vs 64-bit Note
Dart’s official Windows packages are primarily 64-bit. For 32-bit systems, use the manual ZIP download and select the x86 package if available, or consider running Dart via WSL (Windows Subsystem for Linux).
🍎 macOS Installation (Intel & Apple Silicon)
macOS — Homebrew (Easiest)
Works on Intel (x86_64) and Apple Silicon (arm64)
Step 1 — Install Homebrew (if not already installed)/bin/bash -c “$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)”
Step 2 — Install Dartbrew tap dart-lang/dart
brew install dart
Step 3 — Verifydart –version
Step 4 — Update in futurebrew upgrade dart
macOS — Manual Install
Download the correct package for your chip
Step 1Visit dart.dev/get-dart → Download macOS ARM (Apple M1/M2/M3) or macOS x64 (Intel)
Step 2 — Extractunzip dart-sdk-macos-x64-release.zip
Step 3 — Add to PATH (in ~/.zshrc or ~/.bash_profile)export PATH=”$PATH:/path/to/dart-sdk/bin”
Step 4source ~/.zshrc && dart –version
🐧 Linux Installation (64-bit & 32-bit)
Ubuntu / Debian (64-bit — x86_64)
Most common Linux setup
Step 1 — Add Google’s APT keysudo apt-get update
sudo apt-get install apt-transport-https
wget -qO- https://dl-ssl.google.com/linux/linux_signing_key.pub | sudo gpg –dearmor -o /usr/share/keyrings/dart.gpg
Step 2 — Add Dart repositoryecho ‘deb [signed-by=/usr/share/keyrings/dart.gpg arch=amd64] https://storage.googleapis.com/download.dartlang.org/linux/debian stable main’ | sudo tee /etc/apt/sources.list.d/dart_stable.list
Step 3 — Installsudo apt-get update
sudo apt-get install dart
Step 4 — Add to PATHexport PATH=”$PATH:/usr/lib/dart/bin”
Linux — ARM / 32-bit Systems
Raspberry Pi, older hardware
Step 1 — Download ARM buildVisit dart.dev/get-dart → Linux ARM or Linux IA32 (32-bit)
Step 2 — Extracttar xf dartsdk-linux-arm-release.zip
Step 3 — Add to PATHexport PATH=”$PATH:$HOME/dart-sdk/bin”
Step 4 — Verifydart –version
Fedora / RHEL / CentOS
RPM-based distributions
Step 1 — Add reposudo rpm –import https://dl.google.com/linux/linux_signing_key.pub
Step 2 — Create .repo filesudo sh -c ‘echo “[dart] name=Dart Stable baseurl=https://storage.googleapis.com/download.dartlang.org/linux/debian/x86_64/stable enabled=1 gpgcheck=1 repo_gpgcheck=1 gpgkey=https://dl.google.com/linux/linux_signing_key.pub” > /etc/yum.repos.d/dart.repo’
Step 3 — Installsudo dnf install dart
📱 Termux Installation (Android — 32-bit & 64-bit)
Termux is a powerful Android terminal emulator. You can run Dart directly on Android using Termux, which is great for mobile learners and developers on the go.
Termux — Method 1 (pkg)
64-bit Android (arm64) — Recommended
Step 1 — Update packagespkg update && pkg upgrade
Step 2 — Install Dartpkg install dart
Step 3 — Verifydart –version
Termux — Method 2 (Manual)
For 32-bit Android or if pkg method fails
Step 1 — Install prerequisitespkg install wget curl unzip
Step 2 — Download ARM Dart SDKwget https://storage.googleapis.com/dart-archive/channels/stable/release/latest/sdk/dartsdk-linux-arm64-release.zip
Step 3 — Extract & configure PATHunzip dartsdk-linux-arm64-release.zip
echo ‘export PATH=”$PATH:$HOME/dart-sdk/bin”‘ >> ~/.bashrc
source ~/.bashrc
Step 4 — Verifydart –version
📱 Termux — 32-bit vs 64-bit
Most modern Android devices (Android 8+) are 64-bit. Use uname -m in Termux to check: aarch64 = 64-bit ARM, armv7l = 32-bit ARM. For 32-bit, download dartsdk-linux-arm-release.zip instead.
3. Setting Up Visual Studio Code
While you can write Dart in any text editor, Visual Studio Code (VS Code) is the most popular and feature-rich choice, offering real-time error detection, syntax highlighting, code completion, and an integrated terminal.
- Download VS Code from code.visualstudio.com — available for Windows, macOS, and Linux.
- Open VS Code → Click the Extensions icon (or press
Ctrl+Shift+X). - Search for “Dart” in the search bar.
- Install the Dart extension by Dart Code (it also installs Flutter support).
- Create a new file with the
.dartextension (e.g.,main.dart). - Open the integrated terminal: Terminal → New Terminal (
Ctrl+`). - Run your file:
dart filename.dart
🌐 No Installation? Use DartPad
Try Dart instantly in your browser at dartpad.dev — no installation required. Perfect for quick experiments, learning, and sharing code snippets.
4. Your First Dart Program
Every Dart program starts with a main() function — the entry point of execution. Here is the classic “Hello, World!” program:
Dart
// Every Dart program begins here
void main() {
print(‘Hello, World!’);
}
Run it with: dart main.dart
The void keyword means this function returns nothing. The print() function outputs text to the console. Let’s expand this:
Dart
void main() {
var firstName = ‘Muhammad’; // Type inferred as String
String lastName = ‘Hassan’; // Explicit String type
print(firstName + ‘ ‘ + lastName); // String concatenation
print(‘Full Name: $firstName $lastName‘); // String interpolation
}
Output:
Muhammad Hassan
Full Name: Muhammad Hassan
5. Comments in Dart
Comments are non-executable lines used to explain code, add documentation, or temporarily disable code during debugging. Dart supports three types:
Dart
// This is a single-line comment
/*
This is a
multi-line block comment.
Can span many lines.
*/
/// This is a documentation comment.
/// Used to document classes, methods, and variables.
/// Tools like dartdoc use these to generate API docs.
void main() {
print(‘Only this line executes’); // Inline comment
}
| Type | Syntax | Use Case |
|---|---|---|
| Single-line | // | Quick notes next to code |
| Multi-line | /* ... */ | Long explanations, disabling code blocks |
| Documentation | /// | API documentation, tool-readable |
6. Variables & Data Types
A variable is a named storage location in memory. Dart is a statically typed language, meaning each variable has a fixed type — but Dart also supports type inference, allowing the compiler to determine the type automatically.
Declaring Variables
Dart — Variable Declaration
// — Type Inference (var keyword) —
var age = 25; // Dart infers: int
var name = ‘Alice’; // Dart infers: String
var price = 9.99; // Dart infers: double
var isActive = true; // Dart infers: bool
// — Statically Typed (explicit type) —
int score = 100;
double gpa = 3.85;
String city = ‘London’;
bool isPassed = true;
// — Dynamic type (any value, any time) —
dynamic anything = 42;
anything = ‘Now a string’; // OK — dynamic allows this
// — Constants —
final maxRetries = 3; // Set once at runtime
const pi = 3.14159; // Compile-time constant
The 5 Core Data Types
| Type | Description | Example | Default Value |
|---|---|---|---|
int | Whole numbers (64-bit) | 42, -7, 0 | null |
double | Floating-point decimals | 3.14, -0.5 | null |
String | Text (UTF-16) | 'Hello' | null |
bool | True or false only | true, false | null |
dynamic | Any type, resolved at runtime | 42, 'text', true | null |
Variable Rules & Naming Conventions
- Variable names are case-sensitive (
myVar ≠ myvar) - Must start with a letter or underscore (
_) - Cannot use reserved keywords (
class,void,var, etc.) - No spaces allowed in variable names
- Use camelCase by convention:
firstName,isLoggedIn - Use PascalCase for class names:
MyClass,UserProfile
final vs const
| Keyword | When Determined | Can Be Set via Constructor? | Use Case |
|---|---|---|---|
final | Runtime (once) | Yes | Values known at runtime but unchangeable after |
const | Compile-time | No | True compile-time constants like PI, MAX_SIZE |
7. Strings, Interpolation & Type Conversion
String Definition
Dart
String s1 = ‘Single quotes’;
String s2 = “Double quotes”;
String s3 = ‘It\’s a backslash escape’; // escape apostrophe
String s4 = “It’s easy with double quotes”;
// Raw string — special characters not evaluated
String raw = r’No \n newline here’;
// Multi-line string
String poem = ”’
Roses are red,
Violets are blue,
Dart is awesome,
And Flutter too!
”’;
String Interpolation
Embed variables and expressions directly inside strings using $ or ${}:
Dart
var name = ‘Dart’;
var version = 3;
print(‘Welcome to $name version $version‘);
print(‘2 + 2 = ${2 + 2}‘); // Expressions inside ${}
print(‘Name length: ${name.length}‘);
Type Conversion
Dart — Type Conversion
// String → int
int parsed = int.parse(’42’); // → 42
// String → double
double d = double.parse(‘3.14’); // → 3.14
// int → String
String s = 42.toString(); // → ’42’
// double → String (fixed decimal places)
String pi = 3.14159.toStringAsFixed(2); // → ‘3.14’
// Invalid parse throws FormatException
try {
int.parse(‘abc’); // ❌ throws FormatException
} catch (e) {
print(‘Error: $e‘);
}
8. Operators
Dart provides a comprehensive set of operators covering arithmetic, relational, logical, bitwise, assignment, and more.
Arithmetic Operators
Dart
int a = 10, b = 3;
print(a + b); // 13 — Addition
print(a – b); // 7 — Subtraction
print(a * b); // 30 — Multiplication
print(a / b); // 3.333… — Division (always double)
print(a ~/ b); // 3 — Integer (floor) division
print(a % b); // 1 — Modulus (remainder)
print(-a); // -10 — Unary minus
Relational & Logical Operators
Dart
// Relational
print(5 == 5); // true — equality
print(5 != 3); // true — not equal
print(5 > 3); // true — greater than
print(5 <= 5); // true — less than or equal
// Logical
print(true && false); // false — AND
print(true || false); // true — OR
print(!true); // false — NOT
Assignment & Increment Operators
Dart
int x = 10;
x += 5; // x = 15 (same as x = x + 5)
x -= 3; // x = 12
x *= 2; // x = 24
x ~/= 3; // x = 8
x++; // post-increment: use x then increment
++x; // pre-increment: increment then use x
x–; // post-decrement
Ternary Operator
Dart
int score = 75;
String result = score >= 50 ? ‘Pass’ : ‘Fail’;
print(result); // Pass
Type Test Operators
Dart
var value = 42;
if (value is int) print(‘It is an integer!’); // true
if (value is! String) print(‘Not a String’); // true
9. Null Safety & Null-Aware Operators
Null safety is one of Dart’s most important modern features — introduced in Dart 2.12. It eliminates the dreaded Null Pointer Exception (NPE) by making the type system aware of nullability at compile time.
Nullable vs Non-Nullable Variables
Dart — Null Safety
// Non-nullable (default) — CANNOT hold null
int age = 25; // ✅ valid
// int age = null; // ❌ compile error
// Nullable — add ? to allow null
int? score; // ✅ defaults to null
String? name; // ✅ can be null
// var (inferred) is nullable — defaults to null if not initialized
var x; // x = null
Null-Aware Operators
Dart — Null-Aware Operators
String? username;
// 1. ?. — Null-conditional (safe call)
print(username?.length); // prints null (doesn’t throw)
// 2. ?? — Null-coalescing (provide default)
String display = username ?? ‘Guest’; // ‘Guest’ if null
// 3. ??= — Null-aware assignment (assign only if null)
username ??= ‘DefaultUser’; // sets only if username == null
// 4. ! — Null assertion (force non-null — use carefully!)
String? maybeNull = ‘Hello’;
print(maybeNull!.length); // 5 — asserts it’s not null
late Keyword
The late keyword tells Dart that you’ll initialize a non-nullable variable before using it — useful for global variables or dependency injection patterns:
Dart
late String databaseUrl; // No init yet — promise to set before use
void main() {
databaseUrl = ‘postgres://localhost:5432/mydb’;
print(databaseUrl); // ✅
}
10. Control Flow — if/else & switch
if / else if / else
Dart
int marks = 78;
if (marks >= 90) {
print(‘Grade: A’);
} else if (marks >= 75) {
print(‘Grade: B’); // ← This executes
} else if (marks >= 60) {
print(‘Grade: C’);
} else if (marks >= 50) {
print(‘Grade: D’);
} else {
print(‘Fail’);
}
switch / case
Use switch for selecting among multiple concrete values (works with int, String, and enums):
Dart
String day = ‘Monday’;
switch (day) {
case ‘Monday’:
print(‘Start of the work week’);
break;
case ‘Friday’:
print(‘Almost weekend!’);
break;
case ‘Saturday’:
case ‘Sunday’:
print(‘Weekend!’); // Fall-through example
break;
default:
print(‘Midweek day’);
}
11. Loops in Dart
Dart provides five types of looping constructs for repetitive tasks:
1. Standard for loop
Dart
for (var i = 1; i <= 5; i++) {
print(‘Iteration $i‘);
}
2. for-in loop (iterate collections)
Dart
var fruits = [‘Apple’, ‘Banana’, ‘Cherry’];
for (var fruit in fruits) {
print(fruit);
}
3. forEach (higher-order function)
Dart
fruits.forEach((fruit) {
print(‘🍎 $fruit‘);
});
// Arrow syntax shorthand
fruits.forEach((f) => print(f));
4. while loop
Dart
int count = 5;
while (count > 0) {
print(‘Count: $count‘);
count–;
}
5. do-while loop (executes at least once)
Dart
int n = 0;
do {
print(‘Runs at least once! n = $n‘);
n++;
} while (n < 3);
break & continue
Dart
// break — exit the loop entirely
for (var i = 0; i < 10; i++) {
if (i == 5) break; // Stops when i equals 5
print(i); // Prints: 0 1 2 3 4
}
// continue — skip current iteration
for (var i = 0; i < 10; i++) {
if (i % 2 == 0) continue; // Skip even numbers
print(i); // Prints: 1 3 5 7 9
}
12. Collections — List, Set & Map
Dart provides three built-in collection types, each suited for different use cases:
List (Ordered, allows duplicates)
Dart — List
// Creating a list
var numbers = [10, 20, 30, 40];
// Typed list
List<String> cities = [‘London’, ‘Paris’, ‘Tokyo’];
// Access by index (zero-based)
print(cities[0]); // London
print(cities.length); // 3
// Modify
cities[1] = ‘Berlin’; // Replace Paris with Berlin
// Constant list (immutable)
const fixed = [1, 2, 3]; // Cannot be modified
// Spread operator (copy list)
var copy = […cities, ‘Cairo’]; // Spread + add
// Collection if / for
var extended = [1, 2, if (true) 3]; // [1, 2, 3]
var doubled = [for (var n in numbers) n * 2]; // [20, 40, 60, 80]
Set (Unordered, unique values only)
Dart — Set
// Creating a set
var halogens = {‘Fluorine’, ‘Chlorine’, ‘Bromine’};
// Duplicates are ignored
halogens.add(‘Fluorine’); // No effect — already exists
print(halogens.length); // Still 3
// Typed Set
Set<int> ids = {1, 2, 3};
// Empty Set (MUST specify type — {} alone creates a Map)
Set<String> emptySet = {};
Map (Key-Value pairs)
Dart — Map
// Creating a map
var student = {
‘name’: ‘Alice’,
‘age’: 22,
‘grade’: ‘A’,
};
// Access by key
print(student[‘name’]); // Alice
print(student.length); // 3
// Add / update
student[’email’] = ‘[email protected]‘;
// Typed Map
Map<String, int> scores = {‘Math’: 95, ‘Science’: 88};
// Iterate a Map
student.forEach((key, value) {
print(‘$key: $value‘);
});
| Feature | List | Set | Map |
|---|---|---|---|
| Order | Ordered ✅ | Unordered ⚠️ | Insertion order (Dart 2+) |
| Duplicates | Allowed ✅ | Not allowed ❌ | Keys unique, values can repeat |
| Access | By index | Iteration | By key |
| Syntax | [ ] | { } | { key: value } |
| Best for | Sequential data | Unique items | Lookup tables, configs |
13. Functions & Parameters
In Dart, functions are first-class objects — they can be stored in variables, passed as arguments, and returned from other functions. Functions are instances of the Function class.
Basic Function
Dart
// Basic function with return type
int add(int a, int b) {
return a + b;
}
// Arrow function (single expression)
int multiply(int a, int b) => a * b;
// Void function (no return value)
void greet(String name) => print(‘Hello, $name!’);
void main() {
print(add(3, 4)); // 7
print(multiply(5, 6)); // 30
greet(‘Dart’); // Hello, Dart!
}
Parameter Types
Dart — Parameter Types
// 1. Required (positional) parameters
int sum(int a, int b) => a + b;
// 2. Named parameters (optional by default)
void createProfile({String? name, int? age}) {
print(‘Name: $name, Age: $age‘);
}
// 3. Named parameters with default values
void greet({String name = ‘Guest’, String lang = ‘Dart’}) {
print(‘Hello $name, welcome to $lang!’);
}
// 4. Required named parameters (Dart 2.12+)
void register({required String email, required String password}) {
print(‘Registering: $email‘);
}
// 5. Optional positional parameters
String formatName(String first, [String? middle, String? last]) {
return [first, middle, last].whereType<String>().join(‘ ‘);
}
void main() {
print(sum(3, 4));
createProfile(name: ‘Alice’, age: 30);
greet(); // Uses defaults
greet(name: ‘Bob’); // Partial named
register(email: ‘[email protected]‘, password: ‘secret’);
print(formatName(‘John’, ‘Paul’)); // John Paul
}
Anonymous (Lambda) Functions
Dart — Anonymous Functions
var numbers = [1, 2, 3, 4, 5];
// Anonymous function assigned to a variable
var square = (int n) => n * n;
print(square(5)); // 25
// Passed directly as argument (lambda/closure)
var squares = numbers.map((n) => n * n).toList();
print(squares); // [1, 4, 9, 16, 25]
// Higher-order functions
var evens = numbers.where((n) => n % 2 == 0).toList();
print(evens); // [2, 4]
14. Object-Oriented Programming (OOP)
Dart is a pure object-oriented language — everything, including numbers, functions, and even null, is an object. OOP in Dart is built around four pillars: Abstraction, Encapsulation, Inheritance, and Polymorphism.
Classes & Objects
Dart — Class Definition
class Person {
// Instance variables (properties)
String name;
int age;
// Default constructor
Person(this.name, this.age);
// Named constructor
Person.guest() : name = ‘Guest’, age = 18;
// Instance method
void introduce() {
print(‘Hi! I am $name, $age years old.’);
}
// Getter
String get bio => ‘$name ($age)’;
// Setter
set newAge(int a) {
if (a > 0) age = a;
}
}
void main() {
var p1 = Person(‘Alice’, 30);
p1.introduce(); // Hi! I am Alice, 30 years old.
print(p1.bio); // Alice (30)
p1.newAge = 31;
print(p1.age); // 31
var guest = Person.guest();
guest.introduce(); // Hi! I am Guest, 18 years old.
}
Static Members (Class-Level)
Dart — Static
class MathUtils {
static const double pi = 3.14159;
static double circleArea(double r) => pi * r * r;
}
print(MathUtils.pi); // 3.14159
print(MathUtils.circleArea(5.0)); // 78.53975
Abstract Classes
Dart — Abstract Class
abstract class Shape {
double area(); // Abstract method — no body
double perimeter(); // Must be implemented by subclasses
void describe() { // Concrete method — has a body
print(‘Area: ${area()}, Perimeter: ${perimeter()}‘);
}
}
class Circle extends Shape {
double radius;
Circle(this.radius);
@override
double area() => 3.14159 * radius * radius;
@override
double perimeter() => 2 * 3.14159 * radius;
}
void main() {
var c = Circle(5);
c.describe(); // Area: 78.53975, Perimeter: 31.4159
}
15. Inheritance, Mixins & Interfaces
Inheritance — extends keyword
Dart — Single Inheritance
class Animal {
String name;
Animal(this.name);
void speak() => print(‘$name makes a sound’);
}
class Dog extends Animal {
Dog(String name) : super(name); // Call parent constructor
@override
void speak() => print(‘$name barks: Woof!’);
}
class Cat extends Animal {
Cat(String name) : super(name);
@override
void speak() => print(‘$name meows: Meow!’);
}
void main() {
Animal a = Dog(‘Rex’);
a.speak(); // Rex barks: Woof! ← Polymorphism!
a = Cat(‘Whiskers’);
a.speak(); // Whiskers meows: Meow!
}
Mixins
Mixins allow you to reuse code across multiple class hierarchies — Dart’s solution to the lack of multiple inheritance:
Dart — Mixins
mixin Flyable {
void fly() => print(‘$this is flying!’);
}
mixin Swimmable {
void swim() => print(‘$this is swimming!’);
}
class Duck extends Animal with Flyable, Swimmable {
Duck(String name) : super(name);
}
void main() {
var duck = Duck(‘Donald’);
duck.speak(); // From Animal
duck.fly(); // From Flyable mixin
duck.swim(); // From Swimmable mixin
}
Interfaces — implements keyword
Dart — Interface
abstract class Printable {
void printInfo();
}
abstract class Saveable {
void save();
}
// A class can implement MULTIPLE interfaces
class Report implements Printable, Saveable {
String title;
Report(this.title);
@override
void printInfo() => print(‘Report: $title‘);
@override
void save() => print(‘Saving $title to disk…’);
}
| Concept | Keyword | Multiple Allowed? | Requires Override? |
|---|---|---|---|
| Inheritance | extends | No (single only) | Optional (with @override) |
| Mixin | with | Yes (multiple) | No (but can override) |
| Interface | implements | Yes (multiple) | Yes (all methods) |
16. Exception Handling
Exception handling prevents your program from crashing on unexpected errors and lets you gracefully handle runtime problems.
Dart — try / catch / on / finally
double divide(double a, double b) {
if (b == 0) throw ArgumentError(‘Divisor cannot be zero!’);
return a / b;
}
void main() {
try {
print(divide(10, 2)); // 5.0
print(divide(5, 0)); // Throws ArgumentError
} on ArgumentError catch (e) {
print(‘Caught ArgumentError: ${e.message}‘);
} on FormatException catch (e) {
print(‘Format issue: $e‘);
} catch (e, stackTrace) {
print(‘Unexpected: $e‘);
print(stackTrace);
} finally {
print(‘Cleanup — always runs regardless of error’);
}
}
| Statement | Purpose | Required? |
|---|---|---|
try | Wraps code that might throw | Yes |
on ExceptionType | Catches a specific exception type | Optional |
catch (e) | Catches any exception, exposes object | Optional |
finally | Runs always — even if no error | Optional |
throw | Manually raise an exception | Optional |
17. Advantages of Dart
✅ Advantages
- Cross-platform power — One codebase for iOS, Android, Web, Desktop
- Strong typing + type inference — Fewer runtime bugs, better tooling
- Sound null safety — Eliminates null reference errors at compile time
- JIT + AOT compilation — Fast dev cycle and optimized production builds
- Familiar syntax — Easy for Java, C#, JavaScript developers
- Rich standard library — Built-in async/await, streams, collections
- Flutter ecosystem — Access to 30,000+ pub.dev packages
- Google-backed — Active development, long-term support
- Excellent tooling — dartfmt, dart analyze, dart test built-in
- Hot reload — See changes instantly during Flutter development
- Open source — Free to use, community-driven improvements
- Ahead-of-time compilation — Native performance on mobile
❌ Disadvantages
- Smaller community — Fewer resources compared to Python or JavaScript
- Mostly tied to Flutter — Limited use cases outside the Flutter ecosystem
- Not widely adopted for backend — Node.js, Python dominate server-side
- Fewer third-party libraries — pub.dev smaller than npm or PyPI
- Flutter app size — Compiled apps can be larger than native
- Learning curve — OOP concepts and null safety can be challenging for beginners
- Limited browser support — dart2js output not always optimal
- Not a general-purpose scripting language — Less ideal for quick scripts vs Python
18. When NOT to Use Dart
While Dart excels in the Flutter ecosystem, there are scenarios where other languages may be a better fit:
| Use Case | Better Alternative | Reason |
|---|---|---|
| Machine Learning / AI | Python | TensorFlow, scikit-learn, PyTorch ecosystem |
| Backend / API servers | Node.js, Go, Python | Larger community, more production examples |
| Data science & scripting | Python, R | Richer data science libraries |
| System programming | Rust, C++ | Low-level memory control |
| Enterprise Java apps | Java / Kotlin | Spring ecosystem maturity |
| Web frontend (standalone) | JavaScript, TypeScript | Broad browser support, React/Vue ecosystem |
19. Dart vs Other Languages
| Feature | Dart | JavaScript | Python | Kotlin |
|---|---|---|---|---|
| Type System | Static + Inference | Dynamic | Dynamic | Static + Inference |
| Null Safety | Sound (built-in) | Partial (TS) | None | Sound (built-in) |
| Mobile Dev | Flutter (best-in-class) | React Native | Kivy (limited) | Android Native |
| Compilation | JIT + AOT | Interpreted/JIT | Interpreted | JIT/AOT (JVM) |
| Performance | Near-native | Fast (V8) | Moderate | Fast (JVM) |
| Syntax Familiarity | Java/C# similar | C-like | Unique | Swift/Java mix |
| Community Size | Medium | Very Large | Very Large | Large |
| Learning Curve | Low-Medium | Low | Very Low | Medium |
20. Conclusion & Next Steps
Dart is a powerful, modern, and developer-friendly programming language that strikes the perfect balance between strong typing and developer productivity. Its tight integration with Flutter makes it the go-to language for cross-platform mobile development in 2026 and beyond.
In this guide, you covered:
- ✅ Full installation on Windows, macOS, Linux, Termux (32 & 64-bit)
- ✅ VS Code setup and DartPad usage
- ✅ Variables, data types, type inference, and constants
- ✅ Strings, interpolation, and type conversion
- ✅ All operator types including null-aware operators
- ✅ Sound null safety system
- ✅ Control flow — if/else/switch
- ✅ All 5 loop types with break and continue
- ✅ Collections — List, Set, Map
- ✅ Functions, parameters, and anonymous functions
- ✅ OOP — Classes, Constructors, Getters, Setters, Static Members
- ✅ Inheritance, Mixins, Interfaces, Polymorphism
- ✅ Exception handling with try/catch/finally
🚀 What to Learn Next
- Flutter Framework — Build your first mobile app using Dart
- Async/Await & Futures — Handle asynchronous operations
- Streams — Reactive programming in Dart
- Generics — Type-safe reusable components
- Packages & pub.dev — Using third-party Dart packages
- Testing in Dart — Unit, widget, and integration tests
- Dart for Server (Shelf) — Backend development with Dart
📚 Official Resources
- dart.dev/guides — Official Dart documentation
- dartpad.dev — Online Dart playground
- pub.dev — Dart & Flutter package registry
- flutter.dev/docs — Flutter documentation
✍️ Written by Mustafa Developer | 📌 Note: This article is based on the Dart programming tutorial transcript by Mahmoud Hassan and supplementary content by a bilingual Dart/Flutter crash course. All code examples have been tested for accuracy. Installation commands may vary slightly by OS version — always refer to dart.dev/get-dart for the latest instructions.
0 Comments