Dart for Java Developers

A deep, practical mapping from Java to Dart: syntax, type system, concurrency, tooling, Flutter, and backend (Shelf, Relic, Serverpod, and the broader pub.dev ecosystem). This guide is written for engineers who already know Java and want fast mental-model transfer plus honest gaps (what one language has that the other does not).

Note on sources: This guide draws on Learn Dart in Y Minutes (community tutorial; the bundled learndart.dart mixes teaching with legacy phrasing—prefer this guide + dart.dev for sound null safety facts) and Google’s archived Flutter codelab Intro to Dart for Java Developers (Bicycle → Rectangle → factories → functional iteration).

Table of contents

1. Mental model in one page
2. Why Dart feels “Java-like” (and where it diverges)
3. Crash-course synthesis (Learn X in Y Minutes and From Java to Dart codelab)
4. Timeline: Dart history & language evolution
5. Syntax & structure
6. Type system & null safety
7. Functions, methods, parameters
8. Classes, constructors, factories
9. Inheritance, interfaces, mixins, extensions
10. Generics & variance (Java vs Dart)
11. Enums, sealed classes, patterns (Dart 2.17–3.x)
12. Collections & iteration
13. Errors & exceptions
14. Asynchrony: Future, Stream, async/await, isolates
15. Modules, libraries, part, export, packages
16. Tooling: pub, analyzer, formatter, tests
17. Compilation targets & runtime (vs JVM)
18. Flutter (what Java devs need first)
19. Backend on Dart: Shelf, Relic, Serverpod, Dart Frog, gRPC
20. Common / notable libraries (selected)
21. Feature matrix: Java ↔ Dart
22. What exists in one language but not the other
23. Migration heuristics
24. Glossary: Java ↔ Dart terminology
25. Keywords quick map
26. Operators (selected) with Java notes
27. dart:* libraries — Java mental anchors
28. Class modifiers (Dart 3)
29. Patterns, destructuring, switch expressions
30. Callable objects & operator overloading
31. typedef and type aliases
32. Dates, time zones, internationalization (intl)
33. Regular expressions
34. URIs, networking, encoding
35. Binary data: typed_data vs NIO
36. Reflection, codegen, and why Flutter differs
37. Annotations & metadata
38. JSON / immutable data classes
39. Local databases & ORM-ish
40. Dependency injection & global state
41. Build systems: Maven/Gradle ↔ pub
42. Testing landscape (beyond JUnit)
43. Package catalog (extended)
44. Expanded feature matrix
45. Soundness footguns
46. Further reading
47. Generators: sync* / async* / yield
48. Iterable, Iterator, for-in vs Java
49. Deferred & conditional imports
50. dart:ffi vs JNI (sketch)
51. Super parameters & initializer lists
52. Flutter layering (Widget / Element / RenderObject)
53. Numeric types & compilation targets caveat
54. Appendix: Java ↔ Dart cheat sheet (snippets)

Mental model in one page

Bottom line: Dart optimizes for fast iteration, UI (Flutter), and multi-target compilation. Java optimizes for massive enterprise libraries, JVM depth, and decades of JVM tooling.

Why Dart feels “Java-like” (and where it diverges)

What feels immediately familiar

• C-family syntax: curly blocks, semicolons (usually optional in Dart but often used), similar control flow (if/for/while/switch).
• Strong, static typing with type inference (var / final vs Java’s var since Java 10).
• OOP core: classes, inheritance, abstract classes, (most) methods live on types.
• Garbage collection (Dart VM) — no manual free.

What surprises Java programmers first week

Crash-course synthesis (Learn X in Y Minutes and From Java to Dart codelab)

External primers worth bookmarking:

• Learn Dart in Y Minutes — fast runnable learndart.dart tour: comments, var/final/const, nested functions, Iterable/List/Map shapes ((), [], {}), loops, ~/, generators, mixins, cascades, null-aware operators. Caveat: some prose predates sound null safety; treat runtime/typing claims in that file with skepticism and follow Dart 3 rules here.
• Google Flutter codelab — Intro to Dart for Java Developers — pedagogy from the Java Tutorial’s Bicycle → Dart: main at top level, new optional, this.field constructor shorthand, privacy via _, getters, no constructor overloading replaced by named parameters / defaults, factory constructors, implements without interface keyword, map/forEach functional style.

One-screen facts (battle-tested when you start Dart / Flutter)

Timeline: Dart history & language evolution

Dates are approximate release periods; exact patch versions vary. For authoritative per-version changes, see Dart language evolution.

Early era

• 2011: Dart unveiled; goals included structured web programming and optional typing (legacy “Dart 1” allowed dynamic escape hatches broadly).
• Dart 2 (2018): Strong typing becomes central; sound type system push begins.

Null safety and Dart 3

• Dart 2.12 (2021): Sound null safety ships (opt-in migration with tools).
• Dart 3 (2023): Null safety mandatory; removal of many legacy modes; language cleanup for long-term evolution. See: The road to Dart 3.

Modern language features (selection)

Java parallels for the same decades: lambdas (Java 8), modules JPMS (9), var (10), records (16), pattern matching for switch (17–21), virtual threads (21), etc. Dart moved quickly on UI-driven language features (e.g. records/patterns) because Flutter benefits directly.

Syntax & structure

Entry point

Java

public class Main {
  public static void main(String[] args) {
    System.out.println("Hello");
  }
}

Dart

void main() {
  print('Hello');
}

Top-level main is idiomatic. print is a core library function (not a static on System.out).

“Everything is an object” (both—but differently)

• Java: primitives (int, double, …) are not objects; wrappers exist.
• Dart: no primitive types in the Java sense; int/double/bool are types with fixed-size semantics but also objects in the unified type model; num is a supertype of int and double.

Semicolons

Dart allows omission via line ending rules (Dart style often omits semicolons outside for heads etc.).

Strings

• Single quotes '...' and double "..." are both string literals; interpolation: '$name ${obj.field}'.
• Raw strings: r'\no escape'.
• Multiline: '''...''' or """...""".

Type system & null safety

Non-null by default (sound)

• String cannot hold null.
• String? can hold null.
• Promotions and flow analysis narrow types after checks (similar spirit to Kotlin’s smart casts, not Java’s old unchecked world).

Common operators

Java mapping

dynamic vs Java Object

• dynamic opts out of static checks (similar in spirit to very loose typing; unlike using Object with casts everywhere).
• Prefer typed APIs; use Object? when you need “anything” but keep static checks.

Functions, methods, parameters

No overloading

Java

void draw(int x) {}
void draw(int x, int y) {}

Dart — use named parameters, optional positional, or different names:

void draw(int x, [int? y]) { }
void drawNamed({required int x, int? y}) { }
void drawVertical(int x) { }

Named parameters

Named args are huge in Dart APIs (Flutter widget constructors are the famous example):

Widget build() => Padding(
  padding: const EdgeInsets.all(8),
  child: Text('Hi'),
);

Think: readable call sites > Java’s builder / telescoping constructors patterns.

First-class functions

• Function types: int Function(int, int) vs Java’s functional interfaces (IntBinaryOperator, etc.).
• Tear-offs: list.sort(compareTo) passes methods as values naturally.

Classes, constructors, factories

const constructors

Dart has true immutable const objects when types support const constructors — compile-time constants. Java’s final + static is related but not the same model.

Factory constructors

class Singleton {
  Singleton._();
  static final Singleton instance = Singleton._();
}

Also idiomatic: factory constructors that may return cached instances or subtypes (think similar to static factory methods in Java EnumSet.of, List.of).

Redirecting constructors

class Point {
  final int x, y;
  Point(this.x, this.y);
  Point.origin() : this(0, 0);
}

Inheritance, interfaces, mixins, extensions

Implicit interfaces

Every class exposes an implicit interface of its instance methods. Java: implements requires explicit interface type. Dart: implements Foo where Foo is a class is normal.

Mixins

Java: default interface methods + composition patterns. Dart: mixin + with apply reusable behavior without inheritance diamonds complexity of C++.

mixin Walks {
  void walk() => print('walk');
}

class Person with Walks {}

Restrictions tightened with mixin class / class modifiers in Dart 3 — favor composition when modeling “capabilities.”

Extension methods

Java: preview/stable extension methods are newer and limited by platform. Dart: extension widely used (e.g. Flutter context.push style helpers in packages).

extension StringX on String {
  String twice() => this + this;
}

Generics & variance (Java vs Dart)

Covariance in core collections (important surprise)

Dart: List<String> is a subtype of List<Object> (if that still sounds wrong for a Java brain: in Dart’s sound variance rules for interface types, List is covariant in its type argument). That enables natural UI APIs but implies runtime checks on writes in some cases.

Java: at compile time List<String> is not a List<Object> for mutable lists (List<String> vs List<? extends Object> wildcards).

Practical advice: when porting Java mental models, re-read generic collection APIs and avoid unsound casts; trust the analyzer.

Wildcards

Java ? extends T, ? super T have no direct counterpart as a unified wildcard system; Dart uses upper bounds and ** typedefs / type parameters** differently. Many Java wildcard use cases become specific type parameters or helper methods.

Enums, sealed classes, patterns (Dart 2.17–3.x)

Enhanced enums (Dart 2.17+)

enum Status {
  ok(200),
  notFound(404);

  final int code;
  const Status(this.code);
}

Java enums are strong too; Dart’s are now very expressive with fields and methods.

Sealed / exhaustive switch

Dart 3 sealed class hierarchies enable exhaustive switch—closer to algebraic data types in expression form.

Java 21 modern switch + sealed types — conceptual siblings; syntax differs.

Records (both languages)

• Java 16+ record Point(int x, int y) {}
• Dart 3 (int x, int y) record types — great for multiple returns without defining a full class.

Collections & iteration

Core in dart:core: List, Map, Set, Iterable.

Collection literals are idiomatic and compile to efficient code.

Errors & exceptions

No checked exceptions

Java: checked IOException shapes API contracts. Dart: typically throws documentation + Future error channels — no throws clause enforced.

Error vs Exception

Dart has a loose convention:

• Error: programmer mistakes / assertions / should fix code.
• Exception: recoverable failures.

Neither is checked.

Asynchrony: Future, Stream, async/await, isolates

Futures vs CompletableFuture

Dart Future<T> is the baseline async result. async/await syntax maps closely to Java’s async/await if you use frameworks that add it, but in Dart it’s language-native.

Streams vs Java reactive streams

Stream<T> is async sequences. Think RxJava-like operations exist in stream_transform, rxdart, but core Stream is smaller than Project Reactor.

Important: single subscription vs broadcast streams — learn early when wiring Flutter (e.g. UI listeners).

Isolates vs threads

Mental model: Flutter UI runs on main isolate event loop; heavy CPU work should move to workers (compute, isolates) to avoid jank.

Modules, libraries, part, export, packages

File = library

A .dart file is a library (optionally named).

part / part of

Splits one library across files (often for generated code: *.g.dart with build_runner).

export

Barrel files re-export other libraries (similar to Java aggregator patterns but simpler).

Packages (pubspec.yaml)

Think pom.xml / build.gradle + coordinates, but much leaner:

• Dependencies: hosted on pub.dev (and git/path overrides).
• Dev dependencies: generators, tests, lints.

Version solving is declarative (pub resolver).

Private Dart members: leading underscore _detail is library-private (not private keyword).

Tooling: pub, analyzer, formatter, tests

Analyzer & language server

The Dart analyzer powers IDE experience (similar spirit to IntelliJ/Java LS but often remarkably fast for incremental analysis).

Compilation targets & runtime (vs JVM)

GraalVM native image is the rough Java-side analogy for AOT, but pipeline details differ a lot.

Flutter (what Java devs need first)

Flutter is not a language change—same Dart language. What changes is:

• Widget build/rebuild model (immutable-ish widget configs vs mutable Swing/JavaFX views in typical old UIs).
• Composition over deep inheritance trees (Widget trees).
• State management libraries explode (provider, riverpod, bloc, get_it, …) — maps to Spring-ish DI only by analogy.
• Platform channels ↔ JNI-like bridges to native OS APIs.

Hot reload is a killer feature for UI iteration; Java UI historically relied on slower full restarts (with exceptions in some frameworks).

Backend on Dart: Shelf, Relic, Serverpod, Dart Frog, gRPC

Shelf

Minimal shelf middleware model — like a small servlet filter chain or Ring-style handler stacks.

Relic

Relic (from the Serverpod team) is a modern HTTP stack positioned as a next-gen basis with strong typing, routing, WebSockets, static files—Serverpod builds on it. If you see “Relic” in 2026-era Dart docs, read it as framework plumbing, not archaeology.

Serverpod

Serverpod aims at full-stack Dart: server ORM, migrations, tooling, code generation, integrated auth patterns—closest spirit to Rails/Django/Laravel (still maturing vs Spring’s 20-year ecosystem).

Dart Frog

Lightweight server from Very Good Ventures—good for APIs and BFF layers.

Aqueduct

Historical note: Aqueduct was popular years ago; check current maintenance before new projects—ecosystem moves fast.

gRPC / protobuf

Official grpc Dart package exists—good interop with Java microservices.

Comparison tone

• Spring Boot maturity: unparalleled Java depth.
• Dart backend: excellent fit when sharing models/validation with Flutter or reducing polyglot—evaluate library freshness, team skills, and ops story.

Common / notable libraries (selected)

This is not exhaustive—pub.dev has massive breadth. Treat as signposts.

Serverpod bundles many server concerns opinionated.

Feature matrix: Java ↔ Dart

What exists in one language but not the other

Java strengths not matched 1:1 in Dart

• JVM ecosystem depth (transactions, enterprise specs, vendor integrations).
• Mature concurrent libraries tuned for shared-memory threading (dart is different concurrency model on the UI side).
• JPMS modularization story (Dart uses packages + visibility).
• Graal + gigantic JNI/native interop stories in places (Dart has dart:ffi for C interop instead).

Dart strengths / conveniences

• Hot reload ecosystem (Flutter).
• UI-declarative widget model + one language across mobile/web/desktop (with caveats).
• Low ceremony (pub, formatter, analyzer).
• Structural patterns (extensions, mixins, named parameters) that reduce boilerplate without annotation processors everywhere.

Migration heuristics

1. Stop designing overload sets — reach for named params and small types.
2. Model absence with T?, not null everywhere + comments.
3. Embrace async/await—avoid callback pyramids like avoiding raw CompletableFuture chains in modern Java.
4. Learn isolates before porting “background thread does shared state” Java—rethink shared memory.
5. Learn List/Map variance rules before performance-critical numeric code with heavy generics.
6. Use package:lints / flutter_lints early—Dart’s analyzer is your pair programmer.
7. Prefer immutable models (final fields, freezed where helpful) especially in Flutter UIs.

Glossary: Java ↔ Dart terminology

Keywords quick map

• Java-only (concept): synchronized, strictfp, native, transient, volatile, throws as a contract keyword.
• Dart-only / distinctive: mixin, extension, on (extension / mixin constraints), with (mixin application), factory, operator, external, covariant, yield, yield* (generator forms), late, required, async, await, dynamic, library, part, export, show, hide, deferred (deferred loading).
• Overlapping but different semantics: interface (Dart 3 class modifier, not Java’s interface keyword alone), super (mixins / super parameters), new (optional in Dart).

Operators (selected) with Java notes

For every predefined Dart operator token, precedence row, and Java analogue, see Appendix — Dart operators — complete predefined set (Java notes) (aligned with dart.dev/language/operators).

dart:* libraries — Java mental anchors

Class modifiers (Dart 3) — Java intuition

Java sealed uses permits and named subclasses anywhere in allowed modules. Dart sealed subtypes sit in the same library — different packaging tradeoff.

Patterns, destructuring, switch expressions (Dart 3)

Switch expressions return values; pattern cases match structures (records, object shapes):

sealed class Msg {}
class Ping extends Msg {}
class Pong extends Msg {}

String react(Msg m) => switch (m) {
  Ping() => 'ping',
  Pong() => 'pong',
};

void tupleDemo() {
  final (x, y) = (1, 2);
  print('$x $y');
}

Think Java’s modern switch + deconstruction converging—Dart 3 doubles down on switch as expression and algebraic shapes via sealed hierarchies + records.

Callable objects & operator overloading

call: an object can behave like a function:

class DoubleFn {
  int call(int x) => x * 2;
}

Operators: implement operator + etc. Java lacks user-defined + for arbitrary classes.

typedef and type aliases

typedef JsonMap = Map<String, Object?>;
typedef IntPredicate = bool Function(int value);

Closest Java analogue: type parameter bounds + functional interfaces, not a first-class typedef.

Dates, time zones, internationalization (intl)

• DateTime handles instant vs local/utc flags; time zones usually need timezone package or careful UTC storage.
• package:intl for DateFormat, messages, plural rules — pair with Flutter localization (MaterialApp delegates).

Java ZonedDateTime remains richer for some server use cases.

Regular expressions

• Dart RegExp lives in dart:core.
• Mind multi-line / unicode / anchoring differences vs Java Pattern—always add tests for tricky inputs.

URIs, networking, encoding

• Prefer Uri.parse / Uri.https over string concatenation—similar discipline as java.net.URI.
• HTTP clients: http (minimal) vs dio (interceptors, cancel tokens, multipart ergonomics).

Binary data: typed_data vs NIO

Isolates copy messages; no shared **ByteBuffer between threads** like Java.

Reflection, codegen, and why Flutter differs

• dart:mirrors exists for VM scenarios; Flutter iOS/Android release builds do not support mirrors in typical configurations (tree shaking + AOT).
• Java: reflection ubiquitous (modulo JPMS).

build_runner ≈ “annotation processing” culture: The JVM has compile-time annotation processors (APT) wired through javac / Gradle / Maven (-processor, annotationProcessor dependencies). Dart has no separate javac-style processor hook in the language itself—instead, packages such as build, source_gen, and build_runner implement a declarative, file-generating build graph. You put dev_dependency: build_runner and dev_dependency: <generator> in pubspec.yaml, annotate code (e.g. @JsonSerializable()), then run dart run build_runner build (or watch). That workflow is the standard replacement for Java’s Lombok / MapStruct / Dagger / Room–style codegen when you need *.g.dart, *.freezed.dart, mocks, serializers, etc.

Practical rule: if you type import 'dart:mirrors' in app code, stop—reach for build_runner-driven generators (json_serializable, freezed, drift, injectable, mockito codegen, …), the same way you’d reach for annotation processors in a Java service.

Annotations & metadata

Built-ins include @override, @Deprecated. Create const annotation classes — runtime reflection is limited compared to Java’s Annotation reflection APIs; codegen fills the gap. Custom annotations in Dart are often inputs to build_runner generators (same role as Java annotation processor arguments), not something you reflectively query at runtime like getDeclaredAnnotations() on the JVM.

JSON / immutable data classes

Local databases & ORM-ish (Flutter/mobile/server vary)

Server-side Postgres often pairs with postgres driver + framework migrations (e.g. Serverpod).

Dependency injection & global state

Riverpod ≈ “recompute graph + caching + test overrides”. Not a servlet container.

Build systems: Maven/Gradle ↔ pub

Note: Java annotation processing is a compiler plugin convention; Dart’s parallel is build_runner orchestrating builder packages—not a keyword in the language, but the default industrial approach to generated sources.

Testing landscape (beyond JUnit)

• Unit: package:test, group/setUp/tearDown feel like JUnit rules-lite.
• Widget: flutter_test + WidgetTester (think UI unit with fake async).
• Goldens: screenshot diffing for widgets.
• Integration / E2E: integration_test driving real devices/emulators.

Mocks: mockito (codegen) or mocktail (lambda-friendly).

Package catalog (extended, still incomplete)

Always verify platform support (iOS/Android/Web/Desktop/Server) before you commit.

Expanded feature matrix — language surface area

Soundness footguns (avoid!)

Further reading

• Official: https://dart.dev — language tour, evolution, null safety.
• Flutter: https://flutter.dev
• Learn Dart in Y minutes — learnxinyminutes.com/docs/dart (runnable tour; watch for outdated “optional typing” prose; Dart 3 is sound).
• From Java to Dart codelab (archived Flutter-io mirror): codelabs.flutter-io.cn/.../from-java-to-dart
• pub.dev — check pub points, popularity, maintenance, null safety before you adopt a package.
• Serverpod / Relic — Serverpod blog & docs for full-stack Dart; Relic on pub.dev is the HTTP stack Serverpod builds on.
• Kotlin’s migration guides are a loose analogue for nullability habits — but Dart’s ? types and Flutter’s widget rules are their own discipline; don’t assume Kotlin === Dart.

Generators: sync* / async* / yield

Dart has lazy iterable generators and async* streams using yield / yield*:

yield* delegates to another iterable/stream—useful for composing tree walks or parsers.

Iterable, Iterator, for-in vs Java

• Iterable<E> in Dart is like Java’s Iterable<T> — provides Iterator<E> iterator.
• for (final x in xs) is sugar over iterator.moveNext().
• Extension methods on Iterable (map, where, fold…) resemble Stream API ergonomics but Iterable is synchronous.

Key distinction: Java Stream is often one-shot; Dart Iterable can be re-iterated if the underlying iterable supports it (and some are single-use like Iterator patterns—read docs per concrete type).

Deferred & conditional imports

Deferred

import 'heavy.dart' deferred as heavy; — loads library later; await heavy.loadLibrary() before use. Roughly dynamic plugin loading (not OS .so like JNI—Dart bundle loading).

Conditional

Split VM vs web implementations:

import 'stub.dart'
  if (dart.library.io) 'io_impl.dart'
  if (dart.library.html) 'html_impl.dart';

Use when platform APIs diverge (dart:io vs dart:html)—think separate *-jvm / *-android artifacts in Maven but resolved at compile time per target.

dart:ffi vs JNI (sketch)

Panama in modern Java is spiritually closer ergonomically than legacy JNI, but Dart dart:ffi is still its own API surface.

Super parameters & initializer lists

Dart allows forwarding constructor parameters to super constructors compactly (super parameters), and : initializer lists run before constructor bodies—useful for final field assignment from computed values.

Think telescoping constructors in Java but with less boilerplate.

Flutter layering (Widget / Element / RenderObject)

Three trees (simplified mental model):

1. Widget — immutable configuration (“do I want padding?”). Compare to a declarative description.
2. Element — life cycle of who owns State; holds reference between frames.
3. RenderObject — layout & paint; mutated during layout.

Java UI frameworks (Swing) historically emphasized mutable component graphs more; Flutter’s setState / rebuild reconciles new widget descriptions against existing elements/render objects.

Numeric types & compilation targets caveat

• On the native Dart VM, int is a 64-bit integer (overflow wraps / is defined per operation—see language spec); use BigInt for arbitrary-precision integer math (Java BigInteger analogue).
• When compiling to JavaScript, integers are limited to IEEE-754 safe integers (~±2⁵³) unless you use BigInt patterns appropriate for JS compilation—do not assume Java long-range arithmetic portably without checks.

Treat numeric code that must run on Flutter Web and mobile as a cross-platform concern: tests on both targets.

Appendix: Java ↔ Dart cheat sheet (snippets)

Paired Java vs Dart examples. Prefer sound Dart 3 / null-safe snippets; remove ? only where the teaching point is nullable types.

How to read

• “Not in Java” / “Not in Dart” called out in notes.
• Learn X in Y Minutes + From Java to Dart codelab patterns appear explicitly (Bicycle, Rectangle, ~/, cascades, map).

Entry point & top-level members

Java

public class Demo {
  public static int answer = 42;

  public static void main(String[] args) {
    System.out.println(answer + " " + args.length);
  }
}

Dart — top-level main, variables, functions (no class wrapper required):

int answer = 42;

void main(List<String> args) {
  print('$answer ${args.length}');
}

Comments

Java — //, /* */, /** */ Javadoc.

Dart — same + /// doc comments drive dartdoc (like Javadoc for API extraction).

/// One-line doc.
// runtime comment
/*
 block
*/

Variables: var, final, const, late

Java

final String name = "Ann";
var count = 1; // Java 10+

Dart

var count = 1; // inferred as int; cannot later assign bool
final name = 'Ann'; // single assignment, inferred String
const pi = 3.14; // compile-time constant
late String description; // non-nullable, assigned before use

Nullable types (?) — Kotlin-like, not Java primitives

Java (modern style / annotations)

@Nullable String nick;
String s = nick; // still needs null check for safety

Dart

String? nick;
String s = nick!; // bang — avoid; prefer ?. ?? or flow checks

Common operators — arithmetic and “not like Java”

Full list: Appendix — Dart operators (complete predefined set, Java notes)

Java

int a = 7 / 3;        // 2 (int division)
double x = 7 / 3.0;

Dart

var q = 7 / 3;        // 2.5 — because / always promotes to double when needed
var t = 7 ~/ 3;       // 2 — truncating integer division (Learn X in Y Minutes)

Java — increment

for (int i = 0; i < n; i++) {}

Dart

for (var i = 0; i < n; i++) {}

Null-aware and cascades (no direct Java equivalent)

Dart only (style from null-aware history — see also Learn X in Y Minutes):

String? name;
var len = name?.length;
var display = name ?? 'guest';
name ??= 'anon';
cascadeExample() {
  final sb = StringBuffer()
    ..write('a')
    ..write('b'); // cascade: same receiver
}

Java (verbose analog)

String name = null;
Integer len = name != null ? name.length() : null;

String interpolation & multiline (codelabs + Learn X in Y Minutes)

Java

String msg = "Hello, " + name + "!";
var block = """
    line1
    line2
    """;

Dart

final msg = 'Hello, $name!'; // or ${expr}
final block = '''
line1
line2
''';
final raw = r'\n stays literal';

if / ternary

Java if (cond) {} else {}, cond ? a : b

Dart identical shape; condition must be bool (no implicit truthiness from arbitrary objects).

Loops: for, enhanced for, forEach

Java

for (int i = 0; i < xs.size(); i++) { var x = xs.get(i); }
for (var x : xs) {}
xs.forEach(x -> System.out.println(x));

Dart (codelab functional style)

for (var i = 0; i < xs.length; i++) {
  final x = xs[i];
}
for (final x in xs) {}
xs.forEach(print);
// or: xs.map(scream).forEach(print);

while / do-while

Same structure in both languages.

switch — classic vs Dart 3 patterns

Java (pre–pattern matching style)

switch (k) {
  case 1:
    System.out.println("one");
    break;
  default:
    break;
}

Dart — still supports break in statement switches; Dart 3 adds expression switch with patterns (no break between cases in expression form):

String label(int k) => switch (k) {
  1 => 'one',
  _ => 'other',
};

Dart — classic statement switch (still used; Learn X in Y Minutes style — each case falls through only with continue labels; normally end with break or return):

void demo(int v) {
  switch (v) {
    case 1:
      print('one');
      break;
    default:
      print('other');
  }
}

Exceptions

Java — checked + unchecked.

try {
  throw new IOException("x");
} catch (IOException e) {
  throw new RuntimeException(e);
} finally {
  System.out.println("done");
}

Dart — no checked exceptions; throw any object.

try {
  throw StateError('x');
} on StateError catch (e) {
  rethrow;
} catch (e, st) {
  // stack trace
} finally {
  print('done');
}

Classes: fields, this constructor, no public keyword

Java Tutorial Bicycle style (multiple getters / setters)

public class Bicycle {
  private int cadence;
  private int speed = 0;
  private int gear;

  public Bicycle(int cadence, int speed, int gear) {
    this.cadence = cadence;
    this.speed = speed;
    this.gear = gear;
  }
}

Dart codelab — shorthand + _ privacy (library scope)

class Bicycle {
  int cadence;
  int _speed = 0;
  int get speed => _speed;
  int gear;

  Bicycle(this.cadence, this.gear); // speed internal

  void applyBrake(int decrement) => _speed -= decrement;
}

No method / constructor overloading — use named parameters

Java — overload constructors

public Rectangle() { this(0,0,0,0); }
public Rectangle(int w, int h) { this(0,0,w,h); }

Dart — single constructor with named optional + defaults (codelab Rectangle)

class Point {
  final int x, y;
  const Point(this.x, this.y);
}

class Rectangle {
  Point origin;
  int width, height;

  Rectangle({this.origin = const Point(0, 0), this.width = 0, this.height = 0});
}

Factory: top-level function vs factory constructor (codelab)

Option A — Dart top-level

Shape shapeFactory(String type) {
  return switch (type) {
    'circle' => Circle(2),
    'square' => Square(2),
    _ => throw ArgumentError(type),
  };
}

Option B — factory on type

abstract class Shape {
  factory Shape(String type) {
    return switch (type) {
      'circle' => Circle(2),
      'square' => Square(2),
      _ => throw ArgumentError(type),
    };
  }
  num get area;
}

Java analog is often static factory methods (Boolean.valueOf, etc.).

implements every class interface — CircleMock pattern (codelab)

Dart

abstract class Report {
  String build();
}

class HtmlReport implements Report {
  @override
  String build() => '<html/>';
}

Java

interface Report { String build(); }
class HtmlReport implements Report {
  @Override public String build() { return "<html/>"; }
}

Inheritance & super

Java

class Child extends Base {
  Child(int x) { super(x); }
}

Dart

class Child extends Base {
  Child(super.x);
}

Mixins — order matters (with M1, M2)

Java has single inheritance; default interface methods approximate some sharing.

Dart — mixins compose left-to-right; if two mixins supply the same member name, resolution follows Dart’s linearization (document the exact app in language spec when it matters for overrides).

class Vehicle {}

mixin Engine on Vehicle {
  String sound() => 'vroom';
}

mixin Horn on Vehicle {
  String beep() => 'beep';
}

class Car extends Vehicle with Engine, Horn {}

void main() {
  final c = Car();
  print(c.sound());
  print(c.beep());
}

Design takeaway: put the “most specific” mixin last when you layer overrides—same discipline as multiple interface defaults in Java, but with mixin + super semantics.

Extension methods (Kotlin-like)

Dart

extension StrX on String {
  String twice() => this + this;
}

Java — no extension methods until recent preview features; historically static helpers.

operator overloading & call

Dart

class Vec2 {
  final int x, y;
  const Vec2(this.x, this.y);
  Vec2 operator +(Vec2 o) => Vec2(x + o.x, y + o.y);
}

class Multiplier {
  final int k;
  const Multiplier(this.k);
  int call(int n) => k * n; // callable object
}

Java — no operator+; use plus(Vec2 o).

Generics — reification vs erasure

Java (erasure at runtime)

List<String> xs = new ArrayList<>();
// xs.getClass() is List, not List<String>

Dart

void main() {
  final xs = <int>[1, 2];
  print(xs.runtimeType); // List<int> — type argument preserved (reified)
}

async / await / Future / Stream

Java (CompletableFuture)

CompletableFuture.supplyAsync(() -> 1)
  .thenApply(x -> x + 1)
  .join();

Dart

Future<int> load() async {
  final x = await Future.value(1);
  return x + 1;
}

Generators: sync* / async*

Dart (Learn X in Y Minutes style)

Iterable<int> countUp(int n) sync* {
  for (var i = 0; i < n; i++) {
    yield i;
  }
}

Stream<int> tick() async* {
  for (var i = 0; i < 3; i++) {
    await Future.delayed(Duration(milliseconds: 100));
    yield i;
  }
}

Java — no direct language feature; use Stream.iterate / reactive APIs.

Isolates (not OS threads)

Dart

import 'dart:isolate';

Future<int> heavy(int n) async {
  return Isolate.run(() {
    // no shared mutable heap with spawner — message-passing / copying
    var s = 0;
    for (var i = 0; i < n; i++) s += i;
    return s;
  });
}

typedef & function types

Dart

typedef IntPred = bool Function(int x);
typedef StringMap = Map<String, Object?>;

bool positive(int x) => x > 0;

void main() {
  final IntPred p = positive;
  print(p(1));
}

Java — IntPredicate, Predicate<Integer>, etc.

Imports: dart: / relative / package: / show / hide / as / deferred

Dart

import 'dart:convert';
import 'dart:math' as math;
import 'package:path/path.dart' show join;
import 'helper.dart' hide Secret;
import 'slow.dart' deferred as slow;

Future<void> later() async {
  await slow.loadLibrary();
  slow.doWork();
}

Java — import static, module path; no deferred import analog in the language proper.

Enhanced enum (Dart 2.17+)

Dart

enum HttpCode {
  ok(200),
  notFound(404);

  final int code;
  const HttpCode(this.code);
}

Java — enums strong since Java 5; enhanced with fields/methods similarly.

Records & patterns (Dart 3) / Java 16+ record

Java 21-style

record Point(int x, int y) {}

Dart 3

void main() {
  final r = (1, 2); // Record type
  final (a, b) = r;   // destructure
  print('$a $b');
}

JSON / immutable unions — freezed (pub.dev)

No single Java built-in; think Lombok + Jackson patterns. freezed generates immutable data classes, copyWith, JSON serialization (with json_serializable), and union “sealed” types—add build_runner and run:

dart run build_runner build --delete-conflicting-outputs

See freezed README for the exact annotation syntax (it evolves between major versions).

assert / debug* compilation

Dart

void check(int x) {
  assert(x >= 0, 'must be non-negative');
}

Stripped in release Flutter/AOT builds by default for assert.

Cascade revisit (codelab “method cascades”)

Dart — “everything is a builder” (mutable configuration fluently)

void fill(StringBuffer sb) {
  sb
    ..write('a')
    ..write('b');
}

Java — typically StringBuilder chained calls return this manually.

Dart operators — complete predefined set (Java notes)

Official reference and precedence: Operators | dart.dev. Many symbols can also be implemented as class members (user-defined operator), similar in spirit to C++/C#—Java does not allow user-defined +, [], etc.

Precedence (highest → lowest) — reproduced from the language docs; each row is higher than rows below it.

Note (spread): Per dart.dev, ... / ...? are part of collection / map literals, not ordinary binary operators; “precedence” is best read as lowest in the sense that the spread operand can be any expression.

Every token — Java analogue or “Dart only”

Tiny examples — Dart-only / confusing vs Java

// ~/ vs /
assert(5 / 2 == 2.5);
assert(5 ~/ 2 == 2);

// == calls Object== / overridden ==
final s1 = 'a';
final s2 = String.fromCharCode(97);
assert(s1 == s2); // true — content equality for String

// is / as
Object o = 1;
if (o is int) print(o + 1); // promoted to int
final x = o as int;

// Null-aware and assert-non-null
String? n;
print(n?.length);
print(n!.length); // runtime if n is null

// Cascade (not nested-dot default)
final sb = StringBuffer()..write('a')..write('b');

// Spread in literal
final inner = [2, 3];
List<int>? tail;
final outer = [1, ...inner, if (true) 4, ...?tail];

Java (contrast for == on reference types):

String a = new String("x");
String b = new String("x");
System.out.println(a == b);        // false — identity
System.out.println(a.equals(b));   // true — value

End of appendix snippets — see main chapters for variance, isolates detail, and tooling.