Constructors and named parameters in Flutter - Practice Problems & Coding Challenges

Challenge - 5 Problems

📝 Syntax

intermediate

Identify the correct way to define a named parameter in a Flutter constructor

Which constructor correctly uses a named parameter for the title property in a Flutter widget class?

Flutter

class MyWidget extends StatelessWidget {
  final String title;

  MyWidget({this.title});

  @override
  Widget build(BuildContext context) {
    return Text(title);
  }
}

A MyWidget({required this.title});

B MyWidget({title});

C MyWidget(title);

D MyWidget(this.title);

💡 Hint

Remember that named parameters use curly braces and can be marked as required.

Option A correctly defines a named parameter title with the required keyword, ensuring it must be provided. Option A uses a positional parameter. Option A is invalid syntax. Option A defines a named parameter but without this. and without required, which is not recommended.

❓ ui_behavior

intermediate

What will be displayed when using a constructor with a default named parameter?

Given this widget code, what text will appear on the screen if MyWidget() is used without arguments?

Flutter

class MyWidget extends StatelessWidget {
  final String title;

  MyWidget({this.title = 'Hello'});

  @override
  Widget build(BuildContext context) {
    return Text(title);
  }
}

A null

B An empty string

C Compilation error

D Hello

💡 Hint

Check the default value assigned to the named parameter.

The constructor sets a default value 'Hello' for the named parameter title. If no argument is passed, the default is used, so the text 'Hello' appears.

❓ lifecycle

advanced

How does using named parameters with required affect widget rebuilds?

Consider a Flutter widget with a constructor using named parameters marked as required. What is the impact on widget rebuilds when the parameter values change?

A The widget rebuilds regardless of parameter changes because named parameters do not affect rebuilds.

B The widget never rebuilds if parameters are named and required.

C The widget rebuilds only if the required named parameters change values.

D The widget rebuilds only if positional parameters change, not named ones.

💡 Hint

Think about how Flutter compares widget properties to decide rebuilds.

Flutter rebuilds widgets when their properties change. Using named parameters marked as required ensures those properties are set and tracked. If their values change, Flutter triggers a rebuild.

❓ navigation

advanced

How to pass named parameters when navigating to a new screen in Flutter?

You want to navigate to DetailScreen and pass a named parameter id. Which code correctly passes the parameter?

Flutter

class DetailScreen extends StatelessWidget {
  final int id;
  DetailScreen({required this.id});

  @override
  Widget build(BuildContext context) {
    return Text('ID: $id');
  }
}

A Navigator.push(context, MaterialPageRoute(builder: (_) => DetailScreen(42)));

B Navigator.push(context, MaterialPageRoute(builder: (_) => DetailScreen(id: 42)));

C Navigator.pushNamed(context, '/detail', arguments: 42);

D Navigator.pushNamed(context, '/detail', id: 42);

💡 Hint

Check how named parameters are passed in constructors inside the builder function.

Option B correctly uses the named parameter id when creating DetailScreen. Option B passes a positional parameter which is invalid. Option B passes arguments but not as named parameters in constructor. Option B uses an invalid parameter id in pushNamed.

🔧 Debug

expert

Why does this Flutter constructor cause a runtime error?

Examine this Flutter widget constructor. Why does it cause a runtime error when instantiated without arguments?

Flutter

class MyWidget extends StatelessWidget {
  final String title;

  MyWidget({required this.title});

  @override
  Widget build(BuildContext context) {
    return Text(title);
  }
}

// Usage:
// MyWidget();

A Because the required named parameter <code>title</code> was not provided when creating <code>MyWidget</code>.

B Because the <code>title</code> field is not initialized with a default value.

C Because StatelessWidget requires a positional parameter in the constructor.

D Because the <code>build</code> method is missing a return statement.

💡 Hint

Check the meaning of required in named parameters.

The constructor marks title as required, so it must be provided when creating an instance. Calling MyWidget() without title causes a runtime error.

Practice

1. What is the main purpose of named parameters in Flutter constructors?

easy

A. To prevent object creation

B. To force all arguments to be positional

C. To make constructors private

D. To make arguments optional and improve code readability

Solution

1. Step 1: Understand named parameters

   Named parameters are enclosed in curly braces and can be optional or required, making code easier to read.

2. Step 2: Identify their purpose in constructors

   They allow passing arguments by name, improving clarity and safety by avoiding positional mistakes.

3. Final Answer:

   To make arguments optional and improve code readability -> Option D

4. Quick Check:

   Named parameters = optional and readable [OK]

Hint: Named parameters use braces and improve clarity [OK]

Common Mistakes:

• Thinking named parameters force positional arguments
• Believing named parameters prevent object creation
• Confusing named parameters with private constructors

2. Which of the following is the correct syntax for a Flutter constructor with named parameters?

easy

A. MyClass({this.name, this.age});

B. MyClass(this.name, this.age);

C. MyClass[name, age];

D. MyClass(name: this.name, age: this.age);

Solution

1. Step 1: Identify named parameter syntax

   Named parameters are declared inside curly braces in the constructor parameter list.

2. Step 2: Match syntax to options

   MyClass({this.name, this.age}); uses curly braces with this.name and this.age, which is correct syntax.

3. Final Answer:

   MyClass({this.name, this.age}); -> Option A

4. Quick Check:

   Named parameters use curly braces { } [OK]

Hint: Look for curly braces around parameters [OK]

Common Mistakes:

• Using square brackets instead of curly braces
• Forgetting curly braces for named parameters
• Using colon syntax incorrectly in constructor declaration

3. What will be the output of this Flutter code?

class Person {
  String name;
  int age;
  Person({required this.name, this.age = 30});
}

void main() {
  var p = Person(name: 'Anna');
  print('${p.name} is ${p.age} years old');
}

medium

A. Anna is 30 years old

B. Anna is null years old

C. Error: Missing required parameter age

D. Anna is 0 years old

Solution

1. Step 1: Analyze constructor parameters

   The constructor requires name and has an optional age with default 30.

2. Step 2: Check object creation and print output

   Person is created with name 'Anna' only, so age defaults to 30. The print shows 'Anna is 30 years old'.

3. Final Answer:

   Anna is 30 years old -> Option A

4. Quick Check:

   Default age = 30 used [OK]

Hint: Default values fill missing optional named parameters [OK]

Common Mistakes:

• Assuming missing optional parameters cause errors
• Thinking default values are ignored
• Confusing required and optional parameters

4. Identify the error in this Flutter constructor code:

class Car {
  String model;
  int? year;
  Car({this.model, this.year});
}

void main() {
  var c = Car(model: 'Tesla');
  print(c.year.toString());
}

medium

A. model is missing and causes compile error

B. year is null and calling toString() causes runtime error

C. No error, code runs fine

D. Constructor syntax is invalid

Solution

1. Step 1: Check constructor parameters and defaults

   Both model and year are optional named parameters without defaults, so year can be null.

2. Step 2: Analyze print statement

   Calling toString() on null year does NOT cause runtime error because toString() is defined on nullable int? and returns 'null' string.

3. Final Answer:

   No error, code runs fine -> Option C

4. Quick Check:

   toString() on null returns 'null' string [OK]

Hint: Optional parameters without defaults can be null but toString() handles null safely [OK]

Common Mistakes:

• Assuming missing optional parameters have default values
• Ignoring null safety and runtime errors
• Thinking constructor syntax is wrong here

5. You want to create a Flutter class Book with a required named parameter title and an optional named parameter author with default 'Unknown'. Which constructor is correct?

hard

A. Book(this.title, {this.author = 'Unknown'});

B. Book({required this.title, this.author = 'Unknown'});

C. Book({this.title, required this.author = 'Unknown'});

D. Book({this.title = 'Unknown', required this.author});

Solution

1. Step 1: Identify required and optional named parameters

   Required named parameters use 'required' keyword inside curly braces; optional can have default values.

2. Step 2: Match correct syntax

   Book({required this.title, this.author = 'Unknown'}); correctly marks title as required and author as optional with default 'Unknown'.

3. Final Answer:

   Book({required this.title, this.author = 'Unknown'}); -> Option B

4. Quick Check:

   Required + optional with default = correct syntax [OK]

Hint: Use 'required' inside braces for required named params [OK]

Common Mistakes:

• Placing required outside braces
• Assigning default to required parameter
• Mixing positional and named parameters incorrectly