Dart

Getting Started

Fundamental Dart concepts and basic syntax for beginners.

Hello World

Basic Dart program structure with main function and output.

Simple Hello World

A basic Dart program with main function that prints a greeting using print().

Code

1
void main() {
2
  print('Hello, World!');
3
}

Execution

1
dart main.dart

Output

1
Hello, World!

Every Dart application must have a main() function.
main() is the entry point of the program.

Multiple print statements

Demonstrates calling print() multiple times to output different lines.

Code

1
void main() {
2
  print('Welcome to Dart');
3
  print('Dart is awesome!');
4
  print('Multi-platform development');
5
}

Execution

1
dart main.dart

Output

1
Welcome to Dart
2
Dart is awesome!
3
Multi-platform development

print() adds a newline automatically.
Statements must end with semicolons in Dart.

String interpolation

Uses string interpolation with $ syntax to embed variables in strings.

Code

1
void main() {
2
  String name = 'Dart';
3
  int version = 3;
4
  print('Welcome to $name version $version!');
5
}

Execution

1
dart main.dart

Output

1
Welcome to Dart version 3!

Use $ for simple variable insertion.
Use ${expression} for complex expressions in strings.

Variables

Declaring and working with variables in Dart, including type inference and null safety.

Variable declaration with type annotation

Demonstrates explicit variable declaration with type specification.

Code

1
void main() {
2
  String name = 'Alice';
3
  int age = 30;
4
  double salary = 50000.50;
5
  bool isActive = true;
6

7
  print('$name is $age years old');
8
  print('Salary: $salary');
9
  print('Active: $isActive');
10
}

Execution

1
dart main.dart

Output

1
Alice is 30 years old
2
Salary: 50000.5
3
Active: true

Type annotation comes before variable name.
Dart supports String, int, double, bool, and other types.

Type inference with var

Uses var keyword for type inference; Dart infers type from the assigned value.

Code

1
void main() {
2
  var name = 'Bob';
3
  var count = 5;
4
  var price = 19.99;
5

6
  print('Name: $name');
7
  print('Count: $count');
8
  print('Price: $price');
9
}

Execution

1
dart main.dart

Output

1
Name: Bob
2
Count: 5
3
Price: 19.99

var keyword makes code cleaner when type is obvious.
Dart still enforces strict typing after inference.

Final and const variables

Demonstrates final variables (runtime constant) and const (compile-time constant).

Code

1
void main() {
2
  final String finalName = 'Charlie';
3
  const int maxRetries = 3;
4

5
  print('Final name: $finalName');
6
  print('Max retries: $maxRetries');
7

8
  // finalName = 'David'; // Error: can't assign
9
  // maxRetries = 5; // Error: can't assign
10
}

Execution

1
dart main.dart

Output

1
Final name: Charlie
2
Max retries: 3

final variables cannot be reassigned after initialization.
const is for compile-time constants; more restrictive than final.

Null Safety

Understanding Dart's null safety feature and nullable vs non-nullable types.

Non-nullable and nullable types

Demonstrates non-nullable (String) and nullable (String?) type declarations.

Code

1
void main() {
2
  String name = 'Alice'; // Non-nullable
3
  String? nickName; // Nullable
4

5
  // name = null; // Error: can't assign null
6
  nickName = 'Ali';
7
  nickName = null; // OK
8

9
  print('Name: $name');
10
  print('Nickname: $nickName');
11
}

Execution

1
dart main.dart

Output

1
Name: Alice
2
Nickname: null

By default, types are non-nullable in Dart.
Add ? to make a type nullable.

Null-aware operators

Uses null-aware operators (?., ??, ??=) for safe null handling.

Code

1
void main() {
2
  String? text;
3

4
  // Using ?. null-aware operator
5
  int? length = text?.length;
6

7
  // Using ?? null coalescing operator
8
  String value = text ?? 'Unknown';
9

10
  // Using ??= null assignment
11
  text ??= 'Hello';
12

13
  print('Length: $length');
14
  print('Value: $value');
15
  print('Text: $text');
16
}

Execution

1
dart main.dart

Output

1
Length: null
2
Value: Unknown
3
Text: Hello

?. calls a method only if object is not null.
?? provides default value if left side is null.
??= assigns only if variable is null.

Data Types

Dart's built-in data types including collections and commonly used types.

Numbers

Working with int and double numeric types in Dart.

Integer operations

Demonstrates various arithmetic operations on integers.

Code

1
void main() {
2
  int a = 10;
3
  int b = 3;
4

5
  print('Addition: ${a + b}');
6
  print('Subtraction: ${a - b}');
7
  print('Multiplication: ${a * b}');
8
  print('Division: ${a / b}');
9
  print('Integer Division: ${a ~/ b}');
10
  print('Remainder: ${a % b}');
11
}

Execution

1
dart main.dart

Output

1
Addition: 13
2
Subtraction: 7
3
Multiplication: 30
4
Division: 3.3333333333333335
5
Integer Division: 3
6
Remainder: 1

~/ performs integer division (floor division).
% returns the remainder of division.

Double and arithmetic

Shows operations on double type with decimal values.

Code

1
void main() {
2
  double x = 10.5;
3
  double y = 3.2;
4

5
  print('Sum: ${x + y}');
6
  print('Product: ${x * y}');
7
  print('Power: ${x.pow(2)}');
8
  print('Absolute: ${(-5.5).abs()}');
9
}

Execution

1
dart main.dart

Output

1
Sum: 13.7
2
Product: 33.6
3
Power: 110.25000000000001
4
Absolute: 5.5

pow() method calculates power; requires import 'dart:math'.
abs() returns absolute value.

Strings

String manipulation, interpolation, and multi-line strings in Dart.

String creation and interpolation

Demonstrates string interpolation with variables and expressions.

Code

1
void main() {
2
  String firstName = 'John';
3
  String lastName = 'Doe';
4
  int age = 28;
5

6
  // String interpolation
7
  print('Full name: $firstName $lastName');
8
  print('Age: $age');
9
  print('Message: ${firstName.toUpperCase()} is $age years old');
10
}

Execution

1
dart main.dart

Output

1
Full name: John Doe
2
Age: 28
3
Message: JOHN is 28 years old

Use $ for simple variables and ${expr} for complex expressions.
String methods like toUpperCase() work on interpolations.

Multi-line strings

Uses triple quotes for multi-line strings preserving formatting.

Code

1
void main() {
2
  String poem = '''
3
  Roses are red,
4
  Violets are blue,
5
  Dart is awesome,
6
  And so are you!
7
  ''';
8

9
  print(poem);
10
  print('Length: ${poem.length}');
11
}

Execution

1
dart main.dart

Output

1
Roses are red,
2
Violets are blue,
3
Dart is awesome,
4
And so are you!
5
Length: 68

Triple quotes (''' or """) are used for multi-line strings.
Preserves newlines and indentation.

String methods

Demonstrates common string manipulation methods.

Code

1
void main() {
2
  String text = 'Dart Programming';
3

4
  print('Original: $text');
5
  print('Uppercase: ${text.toUpperCase()}');
6
  print('Lowercase: ${text.toLowerCase()}');
7
  print('Contains "Prog": ${text.contains("Prog")}');
8
  print('Index of "P": ${text.indexOf("P")}');
9
  print('Substring: ${text.substring(0, 4)}');
10
}

Execution

1
dart main.dart

Output

1
Original: Dart Programming
2
Uppercase: DART PROGRAMMING
3
Lowercase: dart programming
4
Contains "Prog": true
5
Index of "P": 5
6
Substring: Dart

contains() checks if substring exists.
indexOf() returns position of first match or -1.
substring() extracts part of string.

Collections

Working with lists, maps, and sets in Dart.

Lists

Creates and manipulates lists with type parameters.

Code

1
void main() {
2
  List<int> numbers = [1, 2, 3, 4, 5];
3
  List<String> colors = ['red', 'green', 'blue'];
4

5
  print('Numbers: $numbers');
6
  print('First: ${numbers.first}');
7
  print('Last: ${numbers.last}');
8
  print('Length: ${numbers.length}');
9

10
  numbers.add(6);
11
  print('After add: $numbers');
12
}

Execution

1
dart main.dart

Output

1
Numbers: [1, 2, 3, 4, 5]
2
First: 1
3
Last: 5
4
Length: 5
5
After add: [1, 2, 3, 4, 5, 6]

Lists are ordered, mutable collections.
Use List<Type> for typed lists.
add() appends element to end of list.

Maps

Creates and manipulates maps with key-value pairs.

Code

1
void main() {
2
  Map<String, int> scores = {
3
    'Alice': 90,
4
    'Bob': 85,
5
    'Charlie': 92
6
  };
7

8
  print('Scores: $scores');
9
  print('Alice: ${scores['Alice']}');
10
  print('Keys: ${scores.keys}');
11
  print('Values: ${scores.values}');
12

13
  scores['David'] = 88;
14
  print('After add: $scores');
15
}

Execution

1
dart main.dart

Output

1
Scores: {Alice: 90, Bob: 85, Charlie: 92}
2
Alice: 90
3
Keys: (Alice, Bob, Charlie)
4
Values: (90, 85, 92)
5
After add: {Alice: 90, Bob: 85, Charlie: 92, David: 88}

Maps store key-value pairs where keys are unique.
Use Map<KeyType, ValueType> for typed maps.

Sets and iteration

Creates and manipulates sets (unordered, unique collections).

Code

1
void main() {
2
  Set<String> languages = {'Dart', 'Java', 'Python'};
3

4
  print('Languages: $languages');
5
  print('Length: ${languages.length}');
6
  print('Contains Dart: ${languages.contains("Dart")}');
7

8
  languages.add('JavaScript');
9
  languages.add('Dart'); // Duplicate, ignored
10

11
  for (var lang in languages) {
12
    print('- $lang');
13
  }
14
}

Execution

1
dart main.dart

Output

1
Languages: {Dart, Java, Python}
2
Length: 3
3
Contains Dart: true
4
- Dart
5
- Java
6
- Python
7
- JavaScript

Sets contain only unique elements.
Duplicates are automatically ignored.

Control Flow

Decision making and loop structures in Dart.

Conditional Statements

If, else, and switch statements for decision making.

If and else statements

Demonstrates if-else if-else chain for multiple conditions.

Code

1
void main() {
2
  int age = 20;
3

4
  if (age < 13) {
5
    print('Child');
6
  } else if (age < 18) {
7
    print('Teenager');
8
  } else if (age < 65) {
9
    print('Adult');
10
  } else {
11
    print('Senior');
12
  }
13
}

Execution

1
dart main.dart

Output

1
Adult

Use more specific conditions first in if-else chains.
The last matching condition executes.

Ternary operator

Uses ternary operator for short conditional assignments.

Code

1
void main() {
2
  int score = 75;
3
  String result = score >= 60 ? 'Pass' : 'Fail';
4

5
  print('Score: $score');
6
  print('Result: $result');
7

8
  String grade = score >= 90 ? 'A' :
9
                 score >= 80 ? 'B' :
10
                 score >= 70 ? 'C' : 'F';
11
  print('Grade: $grade');
12
}

Execution

1
dart main.dart

Output

1
Score: 75
2
Result: Pass
3
Grade: C

Ternary operator: condition ? trueValue : falseValue
Can chain ternary operators for multiple conditions.

Switch statement

Uses switch statement for multi-way branching on a single value.

Code

1
void main() {
2
  String day = 'Monday';
3

4
  switch (day) {
5
    case 'Monday':
6
      print('Start of work week');
7
      break;
8
    case 'Friday':
9
      print('Almost weekend!');
10
      break;
11
    case 'Saturday':
12
    case 'Sunday':
13
      print('Weekend');
14
      break;
15
    default:
16
      print('Midweek');
17
  }
18
}

Execution

1
dart main.dart

Output

1
Start of work week

Use break to prevent fall-through to next case.
Multiple cases can execute same code (case fallthrough).

Loops

For, while, and do-while loops for iteration.

For loops

Demonstrates traditional for loop and for-in loop over collections.

Code

1
void main() {
2
  // Traditional for loop
3
  for (int i = 0; i < 5; i++) {
4
    print('Count: $i');
5
  }
6

7
  print('---');
8

9
  // For-in loop
10
  List<String> fruits = ['Apple', 'Banana', 'Cherry'];
11
  for (var fruit in fruits) {
12
    print('Fruit: $fruit');
13
  }
14
}

Execution

1
dart main.dart

Output

1
Count: 0
2
Count: 1
3
Count: 2
4
Count: 3
5
Count: 4
6
---
7
Fruit: Apple
8
Fruit: Banana
9
Fruit: Cherry

Traditional for: for (init; condition; increment)
For-in loop iterates over collections directly.

While and do-while loops

Shows while loop (checks condition before) and do-while (checks after).

Code

1
void main() {
2
  // While loop
3
  int count = 0;
4
  while (count < 3) {
5
    print('While: $count');
6
    count++;
7
  }
8

9
  print('---');
10

11
  // Do-while loop
12
  int num = 0;
13
  do {
14
    print('Do-while: $num');
15
    num++;
16
  } while (num < 3);
17
}

Execution

1
dart main.dart

Output

1
While: 0
2
While: 1
3
While: 2
4
---
5
Do-while: 0
6
Do-while: 1
7
Do-while: 2

While loop tests condition before executing body.
Do-while loop executes body at least once.

Break and continue

Uses break to exit loop early and continue to skip iteration.

Code

1
void main() {
2
  // Break example
3
  for (int i = 0; i < 10; i++) {
4
    if (i == 5) break;
5
    print('Break loop: $i');
6
  }
7

8
  print('---');
9

10
  // Continue example
11
  for (int i = 0; i < 5; i++) {
12
    if (i == 2) continue;
13
    print('Continue loop: $i');
14
  }
15
}

Execution

1
dart main.dart

Output

1
Break loop: 0
2
Break loop: 1
3
Break loop: 2
4
Break loop: 3
5
Break loop: 4
6
---
7
Continue loop: 0
8
Continue loop: 1
9
Continue loop: 3
10
Continue loop: 4

break exits the loop immediately.
continue skips remaining code in current iteration.

Functions & Methods

Declaring and using functions in Dart with parameters and return types.

Function Basics

Function declaration, parameters, and return types.

Basic function declaration

Demonstrates function declaration with parameters and return types.

Code

1
void greet(String name) {
2
  print('Hello, $name!');
3
}
4

5
int add(int a, int b) {
6
  return a + b;
7
}
8

9
void main() {
10
  greet('Alice');
11
  int result = add(5, 3);
12
  print('Sum: $result');
13
}

Execution

1
dart main.dart

Output

1
Hello, Alice!
2
Sum: 8

ReturnType functionName(parameters) { body }
Use void for functions that don't return a value.

Optional and named parameters

Uses named parameters in curly braces for flexible function calls.

Code

1
void printInfo(String name, {int? age, String? city}) {
2
  print('Name: $name');
3
  if (age != null) print('Age: $age');
4
  if (city != null) print('City: $city');
5
}
6

7
void main() {
8
  printInfo('Alice');
9
  printInfo('Bob', age: 30);
10
  printInfo('Charlie', age: 25, city: 'NYC');
11
}

Execution

1
dart main.dart

Output

1
Name: Alice
2
Name: Bob
3
Age: 30
4
Name: Charlie
5
Age: 25
6
City: NYC

Named parameters are optional by default.
Required named parameters use 'required' keyword.

Arrow functions and default values

Uses arrow syntax (=>) for concise function body and default parameter values.

Code

1
int square(int x) => x * x;
2

3
void printMessage(String msg, {String prefix = 'INFO'}) {
4
  print('[$prefix] $msg');
5
}
6

7
void main() {
8
  print('Square of 5: ${square(5)}');
9

10
  printMessage('Application started');
11
  printMessage('Error occurred', prefix: 'ERROR');
12
}

Execution

1
dart main.dart

Output

1
Square of 5: 25
2
[INFO] Application started
3
[ERROR] Error occurred

=> syntax works only for single expressions.
Default values provided with = in parameter list.

Advanced Functions

Anonymous functions, closures, and higher-order functions.

Anonymous functions and callbacks

Demonstrates anonymous functions used with collection methods.

Code

1
void main() {
2
  List<int> numbers = [1, 2, 3, 4, 5];
3

4
  // Anonymous function with forEach
5
  numbers.forEach((num) {
6
    print('Number: $num');
7
  });
8

9
  print('---');
10

11
  // Arrow syntax anonymous function
12
  List<int> squared = numbers.map((x) => x * x).toList();
13
  print('Squared: $squared');
14
}

Execution

1
dart main.dart

Output

1
Number: 1
2
Number: 2
3
Number: 3
4
Number: 4
5
Number: 5
6
---
7
Squared: [1, 4, 9, 16, 25]

Anonymous functions are lambdas without explicit declaration.
Use => for concise anonymous function bodies.

Closures

Demonstrates closures that capture variables from outer scope.

Code

1
Function makeMultiplier(int factor) {
2
  return (int value) {
3
    return value * factor;
4
  };
5
}
6

7
void main() {
8
  var double = makeMultiplier(2);
9
  var triple = makeMultiplier(3);
10

11
  print('2 * 5 = ${double(5)}');
12
  print('3 * 5 = ${triple(5)}');
13
}

Execution

1
dart main.dart

Output

Closures capture variables from enclosing scope.
Each closure maintains its own captured state.

Object-Oriented Programming

Classes, objects, inheritance, and advanced OOP concepts in Dart.

Classes & Objects

Defining classes, creating objects, and using constructors.

Basic class definition

Demonstrates class definition with properties, constructor, and methods.

Code

1
class Person {
2
  String name;
3
  int age;
4

5
  Person(this.name, this.age);
6

7
  void displayInfo() {
8
    print('Name: $name, Age: $age');
9
  }
10
}
11

12
void main() {
13
  var person = Person('Alice', 30);
14
  person.displayInfo();
15
  print('${person.name} is ${person.age} years old');
16
}

Execution

1
dart main.dart

Output

1
Name: Alice, Age: 30
2
Alice is 30 years old

Constructor syntax: ClassName(parameters)
Use this.property for automatic field assignment.

Multiple constructors

Shows named constructors for different object initialization patterns.

Code

1
class Point {
2
  double x, y;
3

4
  Point(this.x, this.y);
5

6
  Point.origin() : x = 0, y = 0;
7

8
  Point.fromList(List<double> coords) : x = coords[0], y = coords[1];
9

10
  void display() => print('($x, $y)');
11
}
12

13
void main() {
14
  var p1 = Point(3, 4);
15
  var p2 = Point.origin();
16
  var p3 = Point.fromList([5, 6]);
17

18
  p1.display();
19
  p2.display();
20
  p3.display();
21
}

Execution

1
dart main.dart

Output

1
(3.0, 4.0)
2
(0.0, 0.0)
3
(5.0, 6.0)

Named constructors use ClassName.constructorName syntax.
Use: for initializer list before constructor body.

Getters and setters

Uses getters and setters for computed properties and controlled access.

Code

1
class Rectangle {
2
  double width, height;
3

4
  Rectangle(this.width, this.height);
5

6
  double get area => width * height;
7

8
  set width(double w) {
9
    if (w > 0) width = w;
10
  }
11

12
  String get dimensions => '$width x $height';
13
}
14

15
void main() {
16
  var rect = Rectangle(5, 3);
17
  print('Area: ${rect.area}');
18
  print('Dimensions: ${rect.dimensions}');
19
}

Execution

1
dart main.dart

Output

1
Area: 15.0
2
Dimensions: 5.0 x 3.0

Getters compute values on-the-fly.
Setters allow controlled property assignment.

Inheritance & Polymorphism

Extending classes, method overriding, and polymorphic behavior.

Class inheritance and super

Demonstrates inheritance with extends and method overriding.

Code

1
class Animal {
2
  String name;
3

4
  Animal(this.name);
5

6
  void makeSound() {
7
    print('$name makes a sound');
8
  }
9
}
10

11
class Dog extends Animal {
12
  Dog(String name) : super(name);
13

14
  @override
15
  void makeSound() {
16
    print('$name barks');
17
  }
18
}
19

20
void main() {
21
  var dog = Dog('Rex');
22
  dog.makeSound();
23
}

Execution

1
dart main.dart

Output

1
Rex barks

Use extends to inherit from a class.
Use super() to call parent constructor.
Use @override annotation when overriding methods.

Abstract classes and interfaces

Uses abstract classes and implements contracts for polymorphism.

Code

1
abstract class Shape {
2
  double get area;
3
  void display();
4
}
5

6
class Circle implements Shape {
7
  double radius;
8

9
  Circle(this.radius);
10

11
  @override
12
  double get area => 3.14159 * radius * radius;
13

14
  @override
15
  void display() => print('Circle with radius $radius, area: ${area.toStringAsFixed(2)}');
16
}
17

18
void main() {
19
  var circle = Circle(5);
20
  circle.display();
21
}

Execution

1
dart main.dart

Output

1
Circle with radius 5, area: 78.54

Abstract classes define contract with unimplemented methods.
implements keyword creates interface implementation contract.

Async Programming

Futures, async/await, and streams for asynchronous operations.

Futures & Promises

Working with Future objects for asynchronous operations.

Creating and handling futures

Demonstrates Future creation and handling with then/catchError.

Code

1
Future<String> fetchData() {
2
  return Future.delayed(Duration(seconds: 1), () {
3
    return 'Data loaded';
4
  });
5
}
6

7
void main() {
8
  print('Fetching data...');
9

10
  fetchData().then((data) {
11
    print('Result: $data');
12
  }).catchError((error) {
13
    print('Error: $error');
14
  });
15

16
  print('Request sent');
17
}

Execution

1
dart main.dart

Output

1
Fetching data...
2
Request sent
3
Result: Data loaded

Future represents a value that will be available later.
then() executes when Future completes successfully.
catchError() handles exceptions in Future.

Future.wait and multiple futures

Uses Future.wait to handle multiple concurrent futures.

Code

1
Future<int> calculateSum(int a, int b) {
2
  return Future.delayed(Duration(milliseconds: 500), () => a + b);
3
}
4

5
void main() async {
6
  print('Starting calculations...');
7

8
  var result = await Future.wait([
9
    calculateSum(5, 3),
10
    calculateSum(10, 2),
11
    calculateSum(7, 4)
12
  ]);
13

14
  print('Results: $result');
15
}

Execution

1
dart main.dart

Output

1
Results: [8, 12, 11]

Future.wait waits for all futures to complete.
Returns list of results in same order as inputs.

Async/Await

Using async/await syntax for cleaner asynchronous code.

Basic async/await

Demonstrates async function with await for sequential async operations.

Code

1
Future<int> fetchNumber() {
2
  return Future.delayed(Duration(seconds: 1), () => 42);
3
}
4

5
void main() async {
6
  print('Fetching number...');
7

8
  int number = await fetchNumber();
9
  print('Number: $number');
10

11
  int doubled = number * 2;
12
  print('Doubled: $doubled');
13
}

Execution

1
dart main.dart

Output

1
Fetching number...
2
Number: 42
3
Doubled: 84

await pauses execution until Future completes.
await can only be used in async functions.

Error handling with try-catch

Uses try-catch-finally for robust async error handling.

Code

1
Future<String> riskyOperation(bool shouldFail) {
2
  return Future.delayed(Duration(milliseconds: 500), () {
3
    if (shouldFail) {
4
      throw Exception('Operation failed');
5
    }
6
    return 'Success';
7
  });
8
}
9

10
void main() async {
11
  try {
12
    var result = await riskyOperation(false);
13
    print('Result: $result');
14

15
    await riskyOperation(true);
16
  } catch (e) {
17
    print('Error caught: $e');
18
  } finally {
19
    print('Operation completed');
20
  }
21
}

Execution

1
dart main.dart

Output

1
Result: Success
2
Error caught: Exception: Operation failed
3
Operation completed

try-catch works with await for async exceptions.
finally block always executes regardless of success or error.

Advanced Features

Generics, extensions, pattern matching, and advanced language features.

Generics

Creating reusable generic classes and methods.

Generic classes and methods

Implements generic Stack class that works with any type.

Code

1
class Stack<T> {
2
  final List<T> items = [];
3

4
  void push(T value) => items.add(value);
5
  T pop() => items.removeLast();
6
  bool get isEmpty => items.isEmpty;
7
}
8

9
void main() {
10
  var intStack = Stack<int>();
11
  intStack.push(1);
12
  intStack.push(2);
13
  print('Popped: ${intStack.pop()}');
14

15
  var stringStack = Stack<String>();
16
  stringStack.push('Hello');
17
  stringStack.push('World');
18
  print('Popped: ${stringStack.pop()}');
19
}

Execution

1
dart main.dart

Output

1
Popped: 2
2
Popped: World

Use <T> as type parameter placeholder.
Specify concrete type when instantiating: Stack<int>().

Bounded generic types

Demonstrates bounded generics restricting type parameter to subtype.

Code

1
class Comparable<T extends num> {
2
  T value;
3

4
  Comparable(this.value);
5

6
  bool isGreaterThan(T other) => value > other;
7

8
  T getDouble() => (value * 2) as T;
9
}
10

11
void main() {
12
  var intComp = Comparable<int>(10);
13
  print('10 > 5? ${intComp.isGreaterThan(5)}');
14

15
  var doubleComp = Comparable<double>(3.5);
16
  print('3.5 > 2.0? ${doubleComp.isGreaterThan(2.0)}');
17
}

Execution

1
dart main.dart

Output

1
10 > 5? true
2
3.5 > 2.0? true

Use extends to bound type parameter to specific type.
Allows using methods specific to bound type.

Extensions & Error Handling

Extension methods, custom exceptions, and error handling patterns.

Extension methods

Demonstrates extension methods adding functionality to existing types.

Code

1
extension StringExtensions on String {
2
  bool get isEmail => contains('@');
3

4
  String capitalize() {
5
    if (isEmpty) return this;
6
    return this[0].toUpperCase() + substring(1);
7
  }
8
}
9

10
void main() {
11
  String text = 'hello world';
12
  print('Capitalized: ${text.capitalize()}');
13

14
  String email = 'user@example.com';
15
  print('Is email: ${email.isEmail}');
16
}

Execution

1
dart main.dart

Output

1
Capitalized: Hello world
2
Is email: true

Extensions add methods to classes without inheritance.
Can add getters, setters, and methods.

Custom exceptions and error handling

Defines custom exception and handles specific exception types.

Code

1
class InvalidAgeException implements Exception {
2
  String message;
3
  InvalidAgeException(this.message);
4

5
  @override
6
  String toString() => message;
7
}
8

9
void validateAge(int age) {
10
  if (age < 0 || age > 150) {
11
    throw InvalidAgeException('Age must be between 0 and 150');
12
  }
13
}
14

15
void main() {
16
  try {
17
    validateAge(25);
18
    print('Age is valid');
19

20
    validateAge(-5);
21
  } on InvalidAgeException catch (e) {
22
    print('Error: $e');
23
  } catch (e) {
24
    print('Unexpected error: $e');
25
  }
26
}

Execution

1
dart main.dart

Output

1
Age is valid
2
Error: Age must be between 0 and 150

Implement Exception interface for custom exceptions.
Use on clausefor specific exception catching.

Dart

Getting Started

Hello World

Accessibility

Best Practices

Common Errors

Keywords

Simple Hello World

Multiple print statements

String interpolation

Variables

Accessibility

Best Practices

Common Errors

Advanced Notes

Keywords

Variable declaration with type annotation

Type inference with var

Final and const variables

Null Safety

Accessibility

Best Practices

Common Errors

Keywords

Non-nullable and nullable types

Null-aware operators

Data Types

Numbers

Accessibility

Best Practices

Common Errors

Keywords

Integer operations

Double and arithmetic

Strings

Accessibility

Best Practices

Common Errors

Keywords

String creation and interpolation

Multi-line strings

String methods

Collections

Accessibility

Best Practices

Common Errors

Keywords

Lists

Maps

Sets and iteration

Control Flow

Conditional Statements

Accessibility

Best Practices

Common Errors

Keywords

If and else statements

Ternary operator

Switch statement

Loops

Accessibility

Best Practices

Common Errors

Keywords

For loops

While and do-while loops

Break and continue

Functions & Methods

Function Basics

Accessibility

Best Practices

Common Errors

Keywords

Basic function declaration

Optional and named parameters

Arrow functions and default values

Advanced Functions

Accessibility

Best Practices

Common Errors