Class 颤振类继承

我正在flifter中构建我的第一个应用程序，这个应用程序使用的是

sqlite数据库

。所以我有模型和存储库

代码布局：

我有两个模型（在完成的应用程序中会有更多）

UserModel

，

TimesheetModel

，它们都扩展了

BaseModel

我有两个存储库（在完成的应用程序中将有更多存储库）

UserRepository

，

timesheetpository

，它们都扩展了

BaseRepository

我想做的是： 我希望在

BaseRepository

中有可重用的代码，例如：

getAll（）

，

countAll（）

等，这样所有扩展基本存储库的存储库都有这个功能，我需要做的就是设置表名并设置返回的

模型

错误：
您可以从我的代码中看到，因为
BaseRepository
正在返回一个
BaseModel
类型，当我调用timesheet对象上的
all（）
函数时，我得到以下错误：“List”类型不是“List”类型的子类型

我不知道如何解决这个问题，有什么建议吗

基本存储库

抽象类基本存储库{
最终字符串表；
最终模型；
BaseRepository（{this.table，this.model}）；
//检索所有项目
Future all（）异步{
最终sql=''从$table''中选择*；
最终数据=wait db.rawQuery（sql）；
列表形式=列表（）；
for（数据中的最终节点）{
final form=model.fromJson（jsonData:node）；
表格。添加（表格）；
}
申报表；
}
//按项目ID查找项目
Future findById（int-id）异步{
最终sql=''从$table中选择*
其中id=？“”；
列表参数=[id]；
最终数据=wait db.rawQuery（sql，参数）；
final form=model.fromJson（jsonData:data.first）；
申报表；
}
//清点所有物品
Future count（）异步{
final data=wait db.rawQuery（“'SELECT COUNT（*）FROM$table”“）；
int count=data[0].values.elementAt（0）；
int idforneItem=count++；
返回IDforneItem；
}
//收拾桌子
Future delete（）异步{
//截断当前数据库表
wait db.rawQuery（“”“从$table“”中删除”）；
}
}

时间表存储

类时间表存储库扩展了基本存储库{
字符串表='时间表'；
TimesheetModel=新的TimesheetModel（）；
//按项目名称搜索项目
Future findByDate（DateTime DateTime）异步{
最终字符串日期=日期格式（“yyyy-MM-dd”）。格式（日期时间）；
最终sql=''从$table中选择*，其中时间表\日期=？''；
列表参数=[日期]；
最终数据=wait db.rawQuery（sql，参数）；
列表形式=列表（）；
for（数据中的最终节点）{
final form=TimesheetModel.fromJson（jsonData:node）；
表格。添加（表格）；
}
申报表；
}
//添加新项目
未来存储（时间表模型时间表）异步{
最终sql=''插入到$table中
(
用户id，
时间表日期，
开始时间，
结束时间，
json，
上传了吗
)
值（？，，，，，，，，）''；
列表参数=[
timesheet.userId，
DateFormat（“yyyy-MM-dd”）.格式（时间表.timesheetDate），
timesheet.startTime，
timesheet.endTime，
convert.json.encode（timesheet.json），
timesheet.u已上载，
];
最终结果=wait db.rawisert（sql，参数）；
DatabaseCreator.databaseLog（'addform'，sql，null，result，params）；
}
}

调用时间表上的所有

timesheetpository时间表=timesheetpository（）；
时间表。全部（）；

基本模型

抽象类基模型{
fromJson（）；
}

时间表模型


类TimesheetModel扩展了BaseModel{
int-id；
int用户标识；
日期时间时间表日期；
字符串起始时间；
字符串结束时间；
映射json={
“任务”：“，
“详情”：“，
“注”：“注”，
};
bool已上传；
时间表模型({
这个身份证，
这个.userId，
这是时间表日期，
这个，开始时间，
这一次,，
这个.json，
这是上传的，
});
fromJson（{Map jsonData}）{
返回时间表模型(
id:jsonData['id']作为int，
userId:jsonData['user_id']作为int，
时间表日期：时间表日期，
开始时间：jsonData[“开始时间”]，
endTime:jsonData['end_time']，
是否上传：已上传，
);
}
}
如果您像这样创建all方法？我认为dart需要这种类型的信息来推断类型。不过不太确定

Future<List<T extends BaseModel>> all() async {

Future all（）异步{
我不会像您这样解析JSON，因为您需要传递模型的空实例才能创建同一对象的有效实例。但为了让您的体系结构正常工作，您需要做一些更正：

1-使用泛型

BaseRepository

抽象类基本存储库{
BaseRepository（{this.table，this.model}）；
最终字符串表；
最终T模型；
//检索所有项目
Future all（）异步{
最终sql=''从$table''中选择*；
最终数据=wait db.rawQuery（sql）；
返回data.map（（节点）{
返回model.fromJson（jsonData:node）；
}).toList（）；
}
Future findById（int-id）异步{
最终sql=''从$table中选择*
其中id=？“”；
最终数据=wait db.rawQuery（sql[id]）；
返回model.fromJson（jsonData:data.first）；
}
//清点所有物品
Future count（）异步{
final data=wait db.rawQuery（“'SELECT COUNT（*）FROM$table”“）；
int count=data[0].values.elementAt（0）；
int idforneItem=count++；
返回IDforneItem；
}
//收拾桌子
Future delete（）异步{
//截断当前数据库表
wait db.rawQuery（“”“从$table“”中删除”）；
}
}

2-正确调用超级构造函数

时间表存储

类时间表存储库扩展了基本存储库{
///我想你不应该
abstract class MySuperClass {
  int id;

  MySuperClass({this.id});

  MySuperClass fromMap(Map<String, dynamic> map);

  Map<String, dynamic> toMap();
}

class MySubClassA extends MySuperClass {
  String name;

  MySubClassA({int id, this.name}) : super(id: id);

  @override
  MySubClassA fromMap(Map<String, dynamic> map) {
    return MySubClassA(
      id: map['id'],
      name: map['name'],
    );
  }

  @override
  Map<String, dynamic> toMap() {
    Map<String, dynamic> myMap = Map<String, dynamic>();
    myMap['id'] = id;
    myMap['name'] = name;
    return myMap;
  }
}

class MySubClassB extends MySuperClass {
  int postcode;

  MySubClassB({int id, this.postcode}) : super(id: id);

  @override
  MySubClassB fromMap(Map<String, dynamic> map) {
    return MySubClassB(
      id: map['id'],
      postcode: map['postcode'],
    );
  }

  @override
  Map<String, dynamic> toMap() {
    Map<String, dynamic> myMap = Map<String, dynamic>();
    myMap['id'] = id;
    myMap['postcode'] = postcode;
    return myMap;
  }
}

enum MyEnum { classA, classB }

extension MyEnumExtension on MyEnum {
  static final tableNames = {
    MyEnum.classA: 'table_a',
    MyEnum.classB: 'table_b',
  };

  String get tableName => tableNames[this];
}

Future<List<Map<String, dynamic>>> _getItemMapList(MyEnum myEnum) async {
  Database db = await this.db;

  var result = await db.query(myEnum.tableName);
  return result;
}

Future<List<MySuperClass>> getItemList(MyEnum myEnum) async {
  var itemMapList = await _getItemMapList(myEnum);

  List<MySuperClass> itemList;

  switch (myEnum) {
    case MyEnum.classA:
      itemList= List<MySubClassA>();
      break;
    case MyEnum.classB:
      itemList= List<MySubClassB>();
      break;
  }

  for (int i = 0; i < itemMapList.length; i++) {
    switch (myEnum) {
      case MyEnum.classA:
        itemList.add(MySubClassA().fromMap(itemMapList[i]));
        break;
      case MyEnum.classB:
        itemList.add(MySubClassB().fromMap(itemMapList[i]));
        break;
    }
  }

  return itemList;
}

Future<List<T>> all() async {
  final sql = '''SELECT * FROM $table''';
  final data = await db.rawQuery(sql);

  return data.map((node) {
    return model.fromJson(jsonData: node);
  }).toList();
}