Flutter Dart Programming Syllabus

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.

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'.

What is a constructor in Dart, and what is the shorthand for assigning fields from parameters?

A constructor initializes a new object; by default it shares the class name. The shorthand 'ClassName(this.x, this.y);' automatically assigns constructor arguments directly to the instance fields x and y.

What are named constructors in Dart, and give an example use.

Named constructors let a class have multiple constructors using 'ClassName.identifier(...)'. Example: 'Point.origin() : x = 0, y = 0;' provides an alternative way to construct an object with clear intent.

What is a factory constructor in Dart and how does it differ from a normal constructor?

A 'factory' constructor does not always create a new instance; it can return an existing/cached object or an instance of a subtype. Unlike a generative constructor, it has no automatic 'this' and must explicitly return an object.

What is an initializer list in a Dart constructor?

Code after ':' that runs before the constructor body to initialize final fields, call super constructors, or assert conditions. Example: 'Point(int x, int y) : distance = sqrt(x*x + y*y) { }'.

What are getters and setters in Dart?

Special methods providing read/write access to a property. 'get' defines a computed read-only property ('int get area => w * h;') and 'set' defines a write property ('set width(int v) => _w = v;'), used with normal field-access syntax.

What is the difference between instance members and static members in a Dart class?

Instance members belong to each object and access 'this'. Static members (declared with 'static') belong to the class itself, are shared across all instances, and are accessed via the class name without creating an object.

How does single inheritance work in Dart and what keyword is used?

A subclass extends exactly one superclass with the 'extends' keyword, inheriting its fields and methods. Example: 'class Dog extends Animal {}'. Dart supports single inheritance of implementation.

What does the 'super' keyword do in Dart inheritance?

'super' refers to the superclass. It is used to call the parent's constructor (e.g. ': super(name)') and to invoke overridden parent methods or access parent members (e.g. 'super.speak()').

What is method overriding in Dart, and what annotation is recommended?

A subclass redefines an inherited method with the same signature to provide specialized behavior. The '@override' annotation documents intent and lets the analyzer verify a member actually overrides a superclass member.

In Dart, in what order are superclass and subclass constructors executed?

The superclass constructor runs before the subclass constructor body. Order: subclass initializer list -> superclass constructor -> subclass constructor body. If not called explicitly, the default 'super()' is invoked automatically.

What is a mixin in Dart and what keyword applies one?

A mixin is a way to reuse a class's code in multiple class hierarchies without inheritance. You define it with 'mixin' and apply it using the 'with' keyword: 'class Duck extends Bird with Swimmer, Flyer {}'.

How does a mixin differ from ordinary inheritance in Dart?

A class extends only one superclass but can mix in many mixins with 'with', enabling horizontal code reuse across unrelated hierarchies. Mixins add behavior without establishing an is-a parent-child relationship, and typically cannot be instantiated on their own.

What is the 'on' clause in a Dart mixin declaration?

'mixin M on SuperType' restricts the mixin so it can only be applied to classes that extend or implement SuperType, guaranteeing the mixin access to that type's members.

What is an abstract class in Dart and can it be instantiated?

An abstract class (declared 'abstract class') defines a common interface and may contain abstract methods (no body) plus concrete methods. It cannot be instantiated directly; concrete subclasses must implement its abstract members.

What is an abstract method in Dart?

A method declared without an implementation (ending in ';' instead of a body) inside an abstract class. Every non-abstract subclass must provide a concrete override of it.

How does Dart implement interfaces, given it has no 'interface' keyword traditionally?

Every class implicitly defines an interface consisting of its public members. Another class uses 'implements' to adopt that contract and must provide concrete implementations of ALL of its members. A class can implement multiple interfaces.

What is the difference between 'extends' and 'implements' in Dart?

'extends' inherits the superclass's implementation (you may override selectively). 'implements' inherits only the contract/interface: you must re-implement every member yourself and no implementation is inherited.

What is an enum (enumeration) in Dart?

A special class representing a fixed set of named constant values. Example: 'enum Color { red, green, blue }'. Each value is a constant instance; you compare and switch over them for type-safe fixed choices.

What properties do Dart enum values provide (e.g. index, name, values)?

Each value has an 'index' (zero-based position) and a '.name' (its string name). The enum type provides a static 'values' list of all members, e.g. 'Color.values', useful for iteration.

What are enhanced enums in Dart (Dart 2.17+)?

Enhanced enums can declare fields, constructors, methods, and implement interfaces, so each enum value can carry data. Example: 'enum Planet { earth(5.97e24); const Planet(this.mass); final double mass; }'.

What is a Future in Dart asynchronous programming?

A Future represents the eventual result of an asynchronous operation. It completes either with a value or with an error at some later time, and you react to it using 'await' or '.then()'/'.catchError()'.

What do the 'async' and 'await' keywords do in Dart?

Marking a function 'async' makes it return a Future and enables 'await' inside it. 'await' suspends execution until the awaited Future completes, then resumes with its value—letting asynchronous code read like synchronous code.

What is the difference between a Future and a Stream in Dart?

A Future delivers a single asynchronous result (one value or error). A Stream delivers a sequence of asynchronous events over time (zero or more values), consumed with 'await for' or '.listen()'.

How do you consume a Stream's values using async syntax in Dart?

Inside an 'async' function use 'await for (var value in stream) { ... }' to process each event as it arrives, or call 'stream.listen((value) { ... })' for a callback-based subscription.

What is a generic in Dart and what problem does it solve?

Generics parameterize a type or function with a type variable (e.g. 'List<T>'), enabling reusable, type-safe code that works with many types while preserving compile-time type checking and avoiding casts.

How do you constrain a generic type parameter in Dart?

Use 'extends' to bound the type: 'class Cache<T extends Object> {}' or 'T max<T extends Comparable>(T a, T b)'. The bound guarantees the type argument has the members you rely on.

What is a Dart package and what file defines its metadata and dependencies?

A package is a reusable, shareable unit of Dart code (library or app). Its metadata, dependencies, and SDK constraints are declared in the 'pubspec.yaml' file at the package root.

What is pub.dev and what command adds a dependency to a Dart project?

pub.dev is the official package repository for Dart and Flutter. You add a dependency with 'dart pub add <package>' (or 'flutter pub add'), then fetch packages with 'dart pub get'.

What are the four core collection types in Dart and their key distinctions?

List: an ordered, indexable sequence allowing duplicates. Set: an unordered collection of unique items. Map: key-value pairs with unique keys. Iterable: the base interface for List and Set producing elements sequentially. (Runnable comparisons: List is ordered/duplicates; Set is unique; Map is keyed.)