Dart Interview Questions

Analogy categoryAnalogies

Core Language Concepts You'll Be Asked About

Interviewers commonly probe whether you understand that Dart is a class-based, single-inheritance, object-oriented language where 'everything is an object', even functions and numbers are instances, and that it has sound null safety enforced at compile time rather than just at runtime. Be ready to explain the difference between var, final, and const (mutability and when the value is fixed: never fixed for var, at runtime for final, at compile time for const), and why Dart's type system is described as 'sound': the analyzer guarantees that a variable typed as non-nullable can never hold null at runtime.

🏏

Cricket analogy: Explaining var vs final vs const in an interview is like explaining the difference between a substitute who can be swapped anytime, var, a player locked in once the toss happens, final, and a player who was contracted before the season even started, const.

Async Programming Questions

Expect questions distinguishing Future (a single async value that completes once, use for one-off I/O like an HTTP request) from Stream (a sequence of async values over time, use for things like a WebSocket feed or a series of button taps), and how Dart's event loop processes the microtask queue, Future callbacks and async/await continuations, before the event queue, I/O callbacks, timers, and UI events, which explains why a Future.microtask() can 'jump the line' ahead of an already-scheduled Timer.run(). You should also be able to explain isolates: since Dart is single-threaded per isolate, CPU-bound work (like parsing a huge JSON file) should be offloaded via compute() in Flutter or Isolate.run() in pure Dart to avoid janking the UI thread.

🏏

Cricket analogy: A Future is like a single ball bowled that eventually gets one outcome, out, four, or dot; a Stream is like ball-by-ball commentary for the whole over, a continuous sequence of events you subscribe to as they happen.

OOP, Mixins, and Interfaces

A classic interview question is 'what's the difference between abstract classes, mixins, and interfaces in Dart?' The answer: Dart has no separate interface keyword, any class implicitly defines an interface that another class can implement (forcing it to provide its own implementation of every member); abstract classes (abstract class Shape) can have both abstract and concrete members and are meant to be extend-ed as a base type in a single-inheritance chain; mixins (mixin CanFly) use the with keyword to add reusable behavior to multiple unrelated classes without participating in that single-inheritance chain, and since Dart 3 you can constrain a mixin to only apply to subtypes of a given class using on. Also expect factory constructors (factory Logger._internal()) used for singleton patterns or returning a cached/subtype instance instead of always allocating new.

🏏

Cricket analogy: A mixin is like a fielding drill, safe hands, that any player regardless of position, batsman or bowler, can pick up via with, while abstract class inheritance is like a strict batting lineage where a player extends techniques from one specific coaching tree only.

dart

class Logger {
  Logger._internal();
  static final Logger _instance = Logger._internal();

  factory Logger() => _instance;

  void log(String message) => print('[LOG] $message');
}

void main() {
  final a = Logger();
  final b = Logger();
  print(identical(a, b)); // true - same singleton instance
  a.log('Interview prep complete');
}

Flutter-Adjacent Questions: const and ==/hashCode

Interviewers often ask why const constructors matter for performance: a const widget is a compile-time constant, so Flutter's framework can recognize it's identical across rebuilds and skip reconstructing that subtree entirely, which is why const Text('Hello') is preferred over a plain Text('Hello') inside a frequently-rebuilding widget. Another common question involves overriding == and hashCode together: if you override == for value equality (comparing fields instead of identity) without also overriding hashCode, objects that are equal can end up in different hash buckets, silently breaking their behavior in a Set or as Map keys, since the contract requires equal objects to produce equal hash codes.

🏏

Cricket analogy: const widgets skipping rebuilds is like a scoreboard operator recognizing the batting team's name hasn't changed between overs and not bothering to redraw that panel, saving effort every single delivery.

When discussing collection performance in an interview, know the Big-O basics: List index access and Map/Set lookups are O(1) on average (hash-based), but List.contains() and List.remove() are O(n) since they scan linearly — a common follow-up question is 'why is List.contains slow for large lists?'

Overriding == without also overriding hashCode is a classic interview trap: your class will compile fine, but using instances as Map keys or storing them in a Set can silently produce duplicate entries or failed lookups because Dart's hash-based collections rely on the ==/hashCode contract being honored together.

Know that Dart is class-based, single-inheritance, and 'everything is an object', with sound null safety enforced at compile time.
Distinguish var (always mutable), final (set once at runtime), and const (fixed at compile time).
Future represents one async value that completes once; Stream represents a sequence of async values over time.
Dart's event loop processes the microtask queue before the event queue, which affects ordering of Future callbacks versus Timers.
Mixins (with) add reusable behavior across unrelated classes; abstract classes (extends) define a single-inheritance base type; any class implicitly defines an interface (implement).
const constructors let Flutter skip rebuilding unchanged widget subtrees — a real performance detail interviewers probe.
Overriding == without hashCode breaks the equal-objects-must-have-equal-hashCodes contract, corrupting Set/Map behavior.