Flutter Dart Programming Syllabus

Dart Programming syllabus — full chapter and topic list

Expand any chapter to see its topics and sub-topics. This is the whole examinable outline for Dart Programming in Flutter, not a summary of it.

1. 1

   Introduction to Dart

   1 topic

   • What is Dart?
     • History of Dart
     • Dart vs Other Languages
     • Why Dart for Flutter?
2. 2

   Dart Basics

   3 topics

   • Syntax and Structure
     • Variables and Data Types
     • Operators
     • Control Flow Statements
   • Functions
     • Defining Functions
     • Function Parameters
     • Anonymous Functions
     • Arrow Functions
   • Error Handling
     • Try-Catch-Finally
     • Custom Exceptions
3. 3

   Object-Oriented Programming in Dart

   5 topics

   • Classes and Objects
     • Defining Classes
     • Creating Objects
     • Constructors
     • Instance Variables and Methods
   • Inheritance
     • Extending Classes
     • Method Overriding
     • Super Keyword
   • Mixins and Abstract Classes
     • Using Mixins
     • Creating Abstract Classes
   • Interfaces
     • Implementing Interfaces
     • Difference Between Interfaces and Abstract Classes
   • Enums
     • Defining Enums
     • Using Enums
4. 4

   Advanced Dart Concepts

   4 topics

   • Asynchronous Programming
     • Future and Async-Await
     • Streams
     • Handling Asynchronous Errors
   • Generics
     • Defining Generics
     • Using Generics in Collections
     • Generic Methods
   • Dart Packages
     • Using Pub Package Manager
     • Creating and Publishing Packages
   • Data Collections
     • Lists
     • Sets
     • Maps
     • Iterators

Dart Programming flashcards for Flutter

22 of 51 cards from the Dart Programming deck — real questions with worked answers.

1. What is Dart and who developed it?

   Dart is an open-source, client-optimized programming language developed by Google. It is designed for building fast apps on any platform (mobile, web, desktop, server) and is the language used to write Flutter apps.

2. What are the two main compilation modes Dart supports, and where is each used?

   JIT (Just-In-Time) compilation is used during development for hot reload and fast iteration. AOT (Ahead-Of-Time) compilation compiles to fast, predictable native machine code for production release builds.

3. Is Dart statically or dynamically typed, and what feature relaxes explicit typing?

   Dart is statically typed (types checked at compile time), but it provides type inference. The 'var' keyword lets the compiler infer the type, and 'dynamic' opts out of static checking entirely.

4. What is the entry point of every Dart program?

   The top-level 'main()' function. Execution begins there; it can optionally take a List<String> of command-line arguments: 'void main(List<String> args) {}'.

5. In Dart, what is the difference between 'final' and 'const'?

   'final' means the variable can be assigned only once and is set at runtime. 'const' is a compile-time constant that must be known at compile time and is deeply immutable. Every const is implicitly final.

6. What is Dart's sound null safety, and what do '?' and '!' mean?

   Sound null safety makes types non-nullable by default, so variables cannot hold null unless declared nullable with '?' (e.g. String?). The '!' null-assertion operator asserts a nullable value is non-null, throwing at runtime if it is null.

7. What does the null-aware access operator '?.' do in Dart?

   It safely accesses a member only if the receiver is non-null; if the receiver is null, the whole expression evaluates to null instead of throwing. Example: 'user?.name'.

8. What is the null-coalescing operator '??' in Dart, and its assignment form '??='?

   'a ?? b' returns 'a' if it is non-null, otherwise 'b'. 'a ??= b' assigns 'b' to 'a' only if 'a' is currently null.

9. What are Dart's built-in numeric types and their relationship?

   Dart has 'int' (integers) and 'double' (64-bit floating point). Both are subtypes of 'num'. An int can be assigned to a num or double variable, but a double is not automatically an int.

10. How do you write a single-line and a multi-line comment, plus a documentation comment, in Dart?

    Single-line: '// comment'. Multi-line: '/* ... */'. Documentation comment: '/// doc comment' (or '/** */'), used by dartdoc to generate API docs.

11. What is string interpolation in Dart and its syntax?

    Embedding expressions inside string literals using '$'. Use '$variable' for a simple identifier and '${expression}' for any expression. Example: 'Hello $name, sum is ${a + b}'.

12. What is the difference between required and optional named parameters in a Dart function?

    Named parameters are written in braces, e.g. 'f({int? a, required int b})'. By default named params are optional and nullable; adding 'required' forces the caller to provide them. Optional ones can also have default values.

13. How do you declare optional positional parameters with defaults in Dart?

    Wrap them in square brackets and optionally give defaults: 'void f(int a, [int b = 0, String c = "x"]) {}'. The caller may omit trailing positional optionals.

14. What is an arrow function (fat-arrow syntax) in Dart?

    A shorthand for a function whose body is a single expression: '=> expr' is equivalent to '{ return expr; }'. Example: 'int square(int x) => x * x;'.

15. What is a first-class function in Dart, and what type represents a function?

    Functions are first-class objects: they can be assigned to variables, passed as arguments, and returned from other functions. The 'Function' type (or a typedef) represents a function value.

16. What is a closure in Dart?

    A closure is a function object that captures and retains access to variables in its lexical scope, even when the function is used outside that scope. Each closure keeps its own copy of the captured state.

17. How does Dart's exception handling try/catch/finally work?

    Code that may fail goes in 'try'. 'catch (e)' or 'on ExceptionType catch (e, s)' handles errors (e = object, s = stack trace). 'on Type' filters by type. 'finally' always runs whether or not an exception occurred.

18. In Dart, what is the difference between 'Exception' and 'Error'?

    'Exception' represents conditions a program can reasonably anticipate and recover from (e.g. FormatException). 'Error' represents programming mistakes that should not be caught (e.g. RangeError, AssertionError), indicating bugs to fix.

19. How do you throw an exception in Dart, and can you throw arbitrary objects?

    Use the 'throw' keyword: 'throw FormatException("bad");'. Dart lets you throw any non-null object, but throwing an Exception or Error subclass is the recommended convention.

20. What does the 'rethrow' keyword do in a Dart catch block?

    'rethrow' re-throws the currently caught exception, preserving its original stack trace, so an outer handler can process it after the inner block does partial handling.

21. What is the purpose of the 'assert' statement in Dart, and when does it run?

    'assert(condition, [message])' throws an AssertionError if the condition is false. It runs only in development/debug mode and is stripped out in production (AOT) builds, so it has no runtime cost in release.

22. What is a class in Dart, and what are the two implicit members every object has?

    A class is a blueprint defining fields (state) and methods (behavior) for objects. Every object implicitly has a 'runtimeType' (its Type) and a 'hashCode', and inherits members from the root class 'Object'.

See more Dart Programming flashcards →

Planning Dart Programming for Flutter

Dart Programming (Flutter) FAQ