late initialization error field _id has not been initialized - flutter

Question

Hello guys in tis application when i add delete or update student in emulator it says late initialization error field _id has not been initialized this is because it wrote in student.dart late int _id; i don't want to make a value for _id in order to be able to add a new value
class Student {
late int _id ;
late String _name;
late String _description;
late int _pass;
late String _date;
Student(this._name, this._description, this._pass, this._date);
Student.withId(
this._id, this._name, this._description, this._pass, this._date);
String get date => _date;
int get pass => _pass;
String get description => _description;
String get name => _name;
int get id => _id;
set date(String value) {
_date = value;
}
set pass(int value) {
if (value >= 1 && value <= 2) {
_pass = value;
}
}
set description(String value) {
if (value.length <= 255) {
_description = value;
}
}
set name(String value) {
if (value.length <= 255) {
_name = value;
}
}
Map<String, dynamic> toMap() {
var map = Map<String, dynamic>();
map["id"] = this._id;
map["name"] = this._name;
map["description"] = this._description;
map["pass"] = this._pass;
map["date"] = this._date;
return map;
}
Student.getMap(Map<String, dynamic> map) {
this._id = map["id"];
this._name = map["name"];
this._description = map["description"];
this._pass = map["pass"];
this._date = map["date"];
}
}
when i write late int _id ; it says late initialization error this is the entire code https://github.com/abdelrahman992-cpu/studentfinal

Answer 1

You need to be careful when marking a variable as being late. You must instantiate the variable with a value before you ever access it. In your case, the default constructor for Student doesn't instantiate _id with a value, so anywhere in your code afterward that tries to access _id is going to throw this error.
You can either give _id a default value to ensure it is instantiated:
Student(this._name, this._description, this._pass, this._date)
: _id = -1;
Student.withId(this._id, this._name, this._description, this._pass, this._date);
Or mark it as nullable:
int? _id;
late String _name;
late String _description;
late int _pass;
late String _date;
Having said all this, there is no reason for your fields to be marked as late. That keyword is reserved for situations where your fields cannot be logically made nullable but their values won't exist until some time after the object has been created.
For example, if the instance represents some data that exists in some asynchronous source:
class RemoteData {
final String name;
late final List<String> rows;
RemoteData(this.name);
// Must call fetch before using any instance of this class
Future<void> fetch() async {
rows = await SomeRemoteDataSource.getRows();
}
}
...
final data = RemoteData('foo');
// fetch hasn't been called on data so it's in a dangerous error-prone state
// print(data.rows); // Uncommenting this line will result in an error
await SomeRemoteDataSource.initialize();
await data.fetch();
// Now it's safe to use data because rows has been initialized
print(data.rows);
In general, the use of late is discouraged for the following reasons:
You almost never actually need it.
When you think you do need it, it's usually better to refactor your code so you don't need it anymore.
The reason is that Dart expects all non-nullable fields of a class to have a value by the time the constructor is finished. The late keyword disables that behavior for a field, allowing the class to be created without the field having a value. But there's a catch - if the field doesn't have a value by the time it's accessed for the first time, Dart will throw an error. This is an example of a race condition, and it should be avoided at all costs since you can easily shoot yourself in the foot even if you think you know what you're doing.
For example, if you created RemoteData and then tried to access rows without first calling fetch, the code would throw an error. And even sneakier, there's no guarantee that even fetch would properly instantiate rows, either. (What if the call to SomeRemoteDataSource.getRows() never completes or throws an error?) So the RemoteData class would be better off being refactored so that the call to SomeRemoteDataSource.getRows() happened before the object was created, and then the rows passed in along with the name to the constructor itself.
In your case, all of the fields are being instantiated in the constructor as is normal for a class's fields, so there's no reason whatsoever for the fields to be marked as late. As such, get rid of late since it can only cause harm to your code to leave it in.