一、引言

二、技术背景

1. 艾宾浩斯复习理论

• 第1次复习：学习后5分钟
• 第2次复习：学习后30分钟
• 第3次复习：学习后12小时
• 第4次复习：学习后1天
• 第5次复习：学习后2天
• 第6次复习：学习后4天
• 第7次复习：学习后7天
• 第8次复习：学习后15天
• 第9次复习：学习后30天

2. 鸿蒙（HarmonyOS）的核心能力

• ​​分布式软总线​​：支持手机、平板、智慧屏等设备间的无缝协同（如词汇卡片数据跨设备同步）。
• ​​原子化服务​​：应用可拆分为独立功能模块（如“复习提醒”可作为独立原子服务运行）。
• ​​统一开发框架（ArkUI）​​：基于声明式UI范式，一套代码可适配手机、平板等不同设备屏幕。
• ​​后台任务管理​​：支持定时任务（如复习提醒通知）、持久化数据存储（如词汇库、复习记录）。
• ​​本地通知​​：通过系统级通知提醒用户按时复习，避免遗忘。

3. 词汇记忆卡片的应用价值

三、应用使用场景

1. 语言学习（英语/日语/法语等）

2. 考试备考（考研/职业资格）

3. 儿童启蒙教育

4. 跨设备同步学习

四、不同场景下详细代码实现

场景1：基于HarmonyOS的词汇卡片核心功能（ArkUI + 本地存储）

1. 项目初始化

2. 核心代码结构

entry/src/main/ets/
├── pages/
│   ├── Index.ets          // 主页（词汇列表）
│   ├── CardDetail.ets     // 单张卡片详情（翻转查看释义）
│   └── ReviewSchedule.ets // 复习计划管理
├── common/
│   └── model/
│       ├── Vocabulary.ets // 词汇数据模型
│       └── ReviewRecord.ets // 复习记录模型
└── resources/
    └── base/
        └── element/
            └── string.json // 多语言文本

3. 词汇数据模型（common/model/Vocabulary.ets）

// 词汇实体类
export class Vocabulary {
  id: string = '';          // 唯一标识（UUID）
  word: string = '';        // 词汇（如"apple"）
  meaning: string = '';     // 释义（如"苹果"）
  addTime: number = 0;      // 添加时间（时间戳）
  nextReviewTime: number = 0; // 下次复习时间（时间戳）
  reviewCount: number = 0;  // 已复习次数（用于计算艾宾浩斯间隔）
}

4. 复习记录模型（common/model/ReviewRecord.ets）

// 复习记录实体类
export class ReviewRecord {
  vocabularyId: string = ''; // 关联的词汇ID
  reviewTime: number = 0;    // 实际复习时间（时间戳）
  isRemembered: boolean = false; // 是否记住（用户反馈）
}

5. 主页（pages/Index.ets）——词汇列表与添加

import { Vocabulary } from '../common/model/Vocabulary';
import preferences from '@ohos.data.preferences';

@Entry
@Component
struct Index {
  @State vocabularies: Vocabulary[] = []; // 当前词汇列表
  private pref: preferences.Preferences | null = null;

  aboutToAppear() {
    this.loadVocabularies();
  }

  // 加载本地存储的词汇数据
  async loadVocabularies() {
    try {
      this.pref = await preferences.getPreferences(this.context, 'vocab_data');
      const data = await this.pref.get('vocab_list', '[]') as string;
      this.vocabularies = JSON.parse(data).map((item: any) => new Vocabulary(item));
    } catch (error) {
      console.error('加载词汇失败:', error);
    }
  }

  // 添加新词汇（简化版：实际可通过弹窗输入）
  async addVocabulary(word: string, meaning: string) {
    const newVocab = new Vocabulary();
    newVocab.id = this.generateUUID();
    newVocab.word = word;
    newVocab.meaning = meaning;
    newVocab.addTime = Date.now();
    newVocab.nextReviewTime = Date.now(); // 新词汇默认立即可复习

    this.vocabularies.push(newVocab);
    await this.saveVocabularies();
  }

  // 保存词汇到本地
  async saveVocabularies() {
    if (this.pref) {
      const data = JSON.stringify(this.vocabularies.map(v => v));
      await this.pref.put('vocab_list', data);
      await this.pref.flush();
    }
  }

  // 生成唯一ID（简化版）
  generateUUID(): string {
    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
      const r = Math.random() * 16 | 0;
      const v = c === 'x' ? r : (r & 0x3 | 0x8);
      return v.toString(16);
    });
  }

  build() {
    Column() {
      Text('词汇记忆卡片')
        .fontSize(24)
        .fontWeight(FontWeight.Bold)
        .margin({ bottom: 20 });

      // 词汇列表（简化：显示词汇和“复习”按钮）
      List({ space: 10 }) {
        ForEach(this.vocabularies, (vocab: Vocabulary) => {
          ListItem() {
            Row() {
              Text(vocab.word)
                .fontSize(18)
                .flexGrow(1);
              Button('复习')
                .onClick(() => {
                  // 跳转到卡片详情页（CardDetail.ets）
                  router.pushUrl({
                    url: 'pages/CardDetail',
                    params: { vocabId: vocab.id }
                  });
                });
            }
            .width('100%')
            .padding(10)
            .backgroundColor('#f5f5f5')
            .borderRadius(8);
          }
        });
      }
      .layoutWeight(1);

      // 添加词汇按钮（简化）
      Button('添加词汇')
        .onClick(() => {
          // 实际项目可通过对话框输入word和meaning
          this.addVocabulary('hello', '你好');
          this.addVocabulary('world', '世界');
        })
        .margin({ top: 20 });
    }
    .width('100%')
    .height('100%')
    .padding(16);
  }
}

6. 卡片详情页（pages/CardDetail.ets）——翻转查看释义与复习反馈

import { Vocabulary } from '../common/model/Vocabulary';
import { ReviewRecord } from '../common/model/ReviewRecord';
import preferences from '@ohos.data.preferences';

@Entry
@Component
struct CardDetail {
  @State currentVocab: Vocabulary | null = null;
  @State showMeaning: boolean = false; // 是否显示释义（翻转状态）
  private vocabPref: preferences.Preferences | null = null;
  private recordPref: preferences.Preferences | null = null;

  aboutToAppear() {
    const params = router.getParams() as Record<string, string>;
    const vocabId = params?.['vocabId'];
    if (vocabId) {
      this.loadVocabulary(vocabId);
    }
  }

  // 加载词汇和复习记录
  async loadVocabulary(vocabId: string) {
    try {
      this.vocabPref = await preferences.getPreferences(this.context, 'vocab_data');
      const data = await this.vocabPref.get('vocab_list', '[]') as string;
      const vocabularies = JSON.parse(data).map((item: any) => new Vocabulary(item));
      this.currentVocab = vocabularies.find(v => v.id === vocabId) || null;

      this.recordPref = await preferences.getPreferences(this.context, 'review_records');
    } catch (error) {
      console.error('加载词汇失败:', error);
    }
  }

  // 翻转卡片（显示/隐藏释义）
  toggleMeaning() {
    this.showMeaning = !this.showMeaning;
  }

  // 提交复习反馈（是否记住）
  async submitReview(isRemembered: boolean) {
    if (!this.currentVocab) return;

    // 更新词汇的下次复习时间（简化版：根据复习次数计算间隔）
    this.updateNextReviewTime();

    // 保存复习记录
    await this.saveReviewRecord(isRemembered);

    // 关闭页面或返回主页
    router.back();
  }

  // 计算下次复习时间（基于艾宾浩斯规则）
  updateNextReviewTime() {
    if (!this.currentVocab) return;
    const count = this.currentVocab.reviewCount + 1;
    this.currentVocab.reviewCount = count;

    // 简化的艾宾浩斯间隔（单位：毫秒）
    const intervals = [5 * 60 * 1000, 30 * 60 * 1000, 12 * 60 * 60 * 1000, 24 * 60 * 60 * 1000, 
                      2 * 24 * 60 * 60 * 1000, 4 * 24 * 60 * 60 * 1000, 7 * 24 * 60 * 60 * 1000, 
                      15 * 24 * 60 * 60 * 1000, 30 * 24 * 60 * 60 * 1000];
    const interval = intervals[Math.min(count - 1, intervals.length - 1)] || intervals[intervals.length - 1];
    this.currentVocab.nextReviewTime = Date.now() + interval;
  }

  // 保存复习记录到本地
  async saveReviewRecord(isRemembered: boolean) {
    if (!this.currentVocab || !this.recordPref) return;
    try {
      const record: ReviewRecord = {
        vocabularyId: this.currentVocab.id,
        reviewTime: Date.now(),
        isRemembered: isRemembered
      };
      const data = await this.recordPref.get('review_list', '[]') as string;
      const records = JSON.parse(data).map((item: any) => new ReviewRecord(item));
      records.push(record);
      await this.recordPref.put('review_list', JSON.stringify(records));
      await this.recordPref.flush();
    } catch (error) {
      console.error('保存复习记录失败:', error);
    }
  }

  build() {
    Column() {
      if (!this.currentVocab) {
        Text('词汇加载中...')
          .fontSize(16);
      } else {
        // 卡片主体（翻转效果通过showMeaning控制）
        Stack() {
          // 正面（词汇）
          Text(this.currentVocab.word)
            .fontSize(32)
            .fontWeight(FontWeight.Bold)
            .textAlign(TextAlign.Center)
            .width('100%')
            .height(200)
            .backgroundColor('#e3f2fd')
            .borderRadius(12)
            .onClick(() => this.toggleMeaning());

          // 背面（释义，初始隐藏）
          if (this.showMeaning) {
            Text(this.currentVocab.meaning)
              .fontSize(24)
              .textAlign(TextAlign.Center)
              .width('100%')
              .height(200)
              .backgroundColor('#f3e5f5')
              .borderRadius(12)
              .position({ x: 0, y: 0 });
          }
        }
        .width('90%')
        .height(200)
        .margin({ top: 20, bottom: 20 });

        // 复习反馈按钮
        Row() {
          Button('记住')
            .onClick(() => this.submitReview(true));
          Button('未记住')
            .onClick(() => this.submitReview(false));
        }
        .width('90%')
        .justifyContent(FlexAlign.SpaceEvenly);
      }
    }
    .width('100%')
    .height('100%')
    .padding(16);
  }
}

场景2：艾宾浩斯复习提醒（定时通知 + 后台任务）

1. 复习计划管理（pages/ReviewSchedule.ets）

import { Vocabulary } from '../common/model/Vocabulary';
import preferences from '@ohos.data.preferences';
import notification from '@ohos.notification';

@Entry
@Component
struct ReviewSchedule {
  @State pendingReviews: Vocabulary[] = []; // 待复习的词汇
  private pref: preferences.Preferences | null = null;

  aboutToAppear() {
    this.loadPendingReviews();
    this.scheduleNotifications();
  }

  // 加载需要复习的词汇（nextReviewTime <= 当前时间）
  async loadPendingReviews() {
    try {
      this.pref = await preferences.getPreferences(this.context, 'vocab_data');
      const data = await this.pref.get('vocab_list', '[]') as string;
      const vocabularies = JSON.parse(data).map((item: any) => new Vocabulary(item));
      const now = Date.now();
      this.pendingReviews = vocabularies.filter(v => v.nextReviewTime <= now);
    } catch (error) {
      console.error('加载待复习词汇失败:', error);
    }
  }

  // 调度通知（检查待复习词汇并触发提醒）
  async scheduleNotifications() {
    if (this.pendingReviews.length === 0) {
      console.log('暂无待复习词汇');
      return;
    }

    // 遍历待复习词汇，为每个词汇创建通知
    for (const vocab of this.pendingReviews) {
      this.createReviewNotification(vocab);
    }
  }

  // 创建复习通知（使用鸿蒙Notification模块）
  async createReviewNotification(vocab: Vocabulary) {
    try {
      // 请求通知权限（需在config.json中配置）
      const manager = notification.getNotificationManager();
      await manager.requestPermission();

      // 构建通知内容
      const notificationRequest = {
        id: vocab.id.hashCode(), // 使用词汇ID作为通知唯一ID
        content: {
          title: '词汇复习提醒',
          text: `该复习 "${vocab.word}" 了！`,
          badgeNumber: 1,
        },
        trigger: {
          type: notification.TriggerType.TIMESTAMP,
          timestamp: vocab.nextReviewTime, // 在nextReviewTime时间触发
        },
        importance: notification.Importance.HIGH,
      };

      // 发送通知
      await manager.publish(notificationRequest);
      console.log(`已为词汇 ${vocab.word} 安排复习通知（时间: ${new Date(vocab.nextReviewTime).toLocaleString()}）`);
    } catch (error) {
      console.error('创建通知失败:', error);
    }
  }

  build() {
    Column() {
      Text('复习计划管理')
        .fontSize(24)
        .fontWeight(FontWeight.Bold);
      Text(`待复习词汇: ${this.pendingReviews.length} 个`)
        .fontSize(16)
        .margin({ top: 10 });
    }
    .width('100%')
    .height('100%')
    .padding(16);
  }
}

五、原理解释

1. 艾宾浩斯复习计划的核心逻辑

• 第1次复习：词汇添加后立刻可复习（nextReviewTime = addTime）。
• 第2次复习：addTime + 5分钟（间隔5分钟）。
• 第3次复习：addTime + 5分钟 + 30分钟（累计间隔）。
• 后续复习按固定间隔（如12小时、1天、2天等）递增。

2. 鸿蒙的关键技术实现

• ​​本地存储（Preferences）​​：用于持久化词汇数据（如词汇内容、复习次数）和复习记录（如用户是否记住），确保数据在应用关闭后不丢失。
• ​​定时通知（Notification + WorkScheduler）​​：通过系统级通知在用户设定的复习时间点触发提醒，即使应用未在前台运行也能通知用户。
• ​​跨设备同步（分布式软总线，可选）​​：若需支持多设备（如手机和平板），可通过鸿蒙的分布式能力将词汇库和复习进度同步至关联设备（需额外配置分布式服务）。

3. 数据流转流程

+---------------------+       +---------------------+       +---------------------+
|  用户添加词汇       | ----> |  保存到本地存储     | ----> |  设置首次复习时间   |
|  (Index.ets)        |       |  (Preferences)      |       |  (nextReviewTime)   |
+---------------------+       +---------------------+       +---------------------+
          |                           |                           |
          |  用户复习词汇         |                           |
          |------------------------>|                           |
          |  提交反馈（记住/未记住）|                           |
          |------------------------>|                           |
          |                           |  更新复习次数和     |
          |                           |  下次复习时间       |
          |                           |  (updateNextReviewTime)|
          |                           |                           |
          v                           v                           v
+---------------------+       +---------------------+       +---------------------+
|  系统在nextReviewTime| ----> |  触发通知（Notification）| ----> |  用户点击通知复习   |
|  时间触发通知       |       |  (定时任务)         |       |  (跳转CardDetail)   |
+---------------------+       +---------------------+       +---------------------+

六、核心特性

七、原理流程图及原理解释

原理流程图（词汇记忆卡片+复习提醒流程）

+---------------------+       +---------------------+       +---------------------+
|  用户添加新词汇     | ----> |  保存词汇到本地     | ----> |  设置首次复习时间   |
|  (输入word/meaning) |       |  (Preferences)      |       |  (nextReviewTime)   |
+---------------------+       +---------------------+       +---------------------+
          |                           |                           |
          |  用户进入主页       |                           |
          |------------------------>|                           |
          |  查看词汇列表       |                           |
          |------------------------>|                           |
          |  点击“复习”按钮     |                           |
          |------------------------>|                           |
          |                           |  检查当前时间是否   |
          |                           |  >= nextReviewTime  |
          |                           |------------------------>|
          |                           |  是：触发通知提醒   |
          |                           |  (Notification)     |
          |                           |------------------------>|
          |                           |  用户点击通知       |
          |                           |  进入CardDetail页   |
          |                           |------------------------>|
          |                           |  查看释义（翻转）   |
          |                           |  提交反馈（记住/    |
          |                           |   未记住）          |
          |                           |------------------------>|
          |                           |  更新复习次数和     |
          |                           |  下次复习时间       |
          |                           |  (updateNextReviewTime)|
          |                           |------------------------>|
          |                           |  保存到本地         |
          |                           |  (Preferences)      |
          v                           v                           v
+---------------------+       +---------------------+       +---------------------+
|  定期同步复习进度   | ----> |  （可选：分布式同步）| ----> |  多设备数据一致     |
+---------------------+       +---------------------+       +---------------------+

原理解释

1. ​​词汇添加​​：用户在主页输入新词汇（如“apple”和“苹果”），应用将词汇对象（包含ID、词汇、释义、添加时间等）保存到本地存储（Preferences），并初始化nextReviewTime为当前时间（新词汇可立即复习）。
2. ​​复习计划计算​​：每次用户复习词汇后，根据当前的reviewCount（复习次数）从预定义的艾宾浩斯间隔数组中选取对应的间隔（如第1次复习间隔5分钟，第2次30分钟等），计算下次复习时间（nextReviewTime = 当前时间 + 间隔）。
3. ​​通知触发​​：应用在启动时（或定期检查）扫描所有词汇，筛选出nextReviewTime <= 当前时间的待复习词汇，并通过鸿蒙的Notification模块在对应时间点发送系统通知（标题为“词汇复习提醒”，内容为具体词汇）。
4. ​​用户交互​​：用户点击通知后进入卡片详情页，查看词汇释义（通过翻转卡片），并反馈是否记住（选择“记住”或“未记住”），应用根据反馈更新复习记录和下次复习时间。
5. ​​数据持久化​​：所有词汇数据（包括添加时间、复习次数、下次复习时间）和复习记录（是否记住、复习时间）均保存在本地Preferences中，确保应用关闭后数据不丢失，且支持离线使用。

八、环境准备

1. 开发环境要求

• ​​操作系统​​：Windows 10/11、macOS 10.15+或Linux（推荐Windows 11或macOS Monterey）。
• ​​开发工具​​：DevEco Studio（鸿蒙官方IDE，版本3.1 Release及以上，需配置JDK 11和Gradle 7.3）。
• ​​SDK​​：HarmonyOS SDK（通过DevEco Studio自动下载，选择API Version 9或更高）。
• ​​真机/模拟器​​：华为真机（需开启开发者模式）或鸿蒙模拟器（通过DevEco Studio创建，支持Phone、Tablet等设备类型）。

2. 项目创建

1. 打开DevEco Studio，选择“Create Project”。
2. 选择“Application”→“Empty Ability”，填写项目名称（如“VocabularyCard”），选择目标设备（如Phone）。
3. 确认项目模板后，等待依赖下载完成。

3. 权限配置（config.json）

// module.json5 (关键权限配置)
{
  "module": {
    "requestPermissions": [
      {
        "name": "ohos.permission.NOTIFICATION_INTERACTIVE",
        "reason": "用于发送复习提醒通知"
      },
      {
        "name": "ohos.permission.DISTRIBUTED_DATASYNC", // 可选：跨设备同步
        "reason": "用于多设备词汇数据同步"
      }
    ]
  }
}

九、实际详细应用代码示例实现

完整代码结构

entry/src/main/ets/
├── pages/
│   ├── Index.ets          // 主页（词汇列表+添加）
│   ├── CardDetail.ets     // 卡片详情（翻转+复习反馈）
│   └── ReviewSchedule.ets // 复习计划管理（通知调度）
├── common/
│   └── model/
│       ├── Vocabulary.ets // 词汇模型
│       └── ReviewRecord.ets // 复习记录模型
└── resources/
    └── base/
        └── element/
            └── string.json // 文本资源

运行步骤

1. ​​创建项目​​：按环境准备步骤使用DevEco Studio创建鸿蒙应用。
2. ​​复制代码​​：将上述Index.ets、CardDetail.ets、ReviewSchedule.ets及模型文件代码复制到对应目录。
3. ​​配置权限​​：在module.json5中添加通知权限（如上述配置）。
4. ​​运行调试​​：连接华为真机或启动模拟器，选择目标设备并点击“Run”，验证词汇添加、翻转查看、复习提醒功能。

十、运行结果

正常情况（功能生效）

• ​​词汇管理​​：用户可在主页输入新词汇（如“hello”和“你好”），点击“复习”按钮查看卡片。
• ​​卡片翻转​​：在CardDetail.ets页面，点击词汇卡片可翻转显示释义（如“hello”→“你好”），提交“记住”或“未记住”反馈。
• ​​复习提醒​​：系统在词汇的nextReviewTime时间点触发通知（如“该复习 'hello' 了！”），用户点击通知后进入复习页面。
• ​​数据持久化​​：关闭应用后重新打开，词汇列表和复习进度保持不变。

异常情况（排查指南）

• ​​通知未触发​​：检查module.json5中是否添加了ohos.permission.NOTIFICATION_INTERACTIVE权限，或真机的通知权限是否开启（设置→通知→应用权限）。
• ​​词汇数据丢失​​：确认Preferences存储路径正确（默认应用沙盒内），或检查代码中是否存在未调用的saveVocabularies()方法。
• ​​复习时间计算错误​​：验证updateNextReviewTime()方法中的间隔数组是否符合艾宾浩斯规则，或打印nextReviewTime值调试。

十一、测试步骤及详细代码

测试目标

1. 词汇添加后是否可正常复习（翻转查看释义）。
2. 复习反馈（记住/未记住）是否更新下次复习时间。
3. 系统通知是否在nextReviewTime时间点触发。

测试代码（手动验证+自动化）

手动验证步骤

1. ​​添加词汇​​：在主页点击“添加词汇”按钮（或直接调用addVocabulary('test', '测试')），确认词汇出现在列表中。
2. ​​复习卡片​​：点击词汇的“复习”按钮，验证卡片翻转后显示释义，提交反馈后检查是否更新下次复习时间（可通过打印日志或调试模式查看nextReviewTime）。
3. ​​触发通知​​：修改设备的系统时间为接近nextReviewTime的时刻，观察是否收到复习提醒通知。

自动化测试（单元测试示例）

// tests/VocabularyTest.ets
import { Vocabulary } from '../common/model/Vocabulary';

describe('词汇模型测试', () => {
  it('复习次数更新后应计算下次复习时间', () => {
    const vocab = new Vocabulary();
    vocab.id = '1';
    vocab.addTime = Date.now();
    vocab.reviewCount = 0;
    vocab.nextReviewTime = Date.now();

    // 模拟第一次复习（reviewCount=1）
    vocab.reviewCount = 1;
    vocab.updateNextReviewTime = () => { // 假设已注入该方法
      const interval = 5 * 60 * 1000; // 5分钟
      vocab.nextReviewTime = Date.now() + interval;
    };
    vocab.updateNextReviewTime();

    expect(vocab.nextReviewTime).toBeGreaterThan(Date.now());
  });
});

十二、部署场景

1. 个人设备部署

• ​​安装方式​​：将应用打包为.hap文件（通过DevEco Studio的“Build→Build HAP”），通过华为应用市场或侧载（需开启“允许安装未知来源应用”）安装到个人手机/平板。
• ​​适用场景​​：用户个人学习使用，数据存储在本地，无需联网。

2. 企业培训分发

• ​​定制化部署​​：企业可基于该应用开发内部词汇库（如行业术语），通过鸿蒙的​​企业证书​​签名打包，分发给员工设备（支持批量安装）。
• ​​数据隔离​​：每个员工的词汇数据独立存储，保障隐私。

3. 教育机构集成

• ​​多语言扩展​​：教育机构可扩展词汇库至多语言（如英语-日语、法语-中文），并通过分布式能力同步至学生设备（如平板课堂）。

十三、疑难解答

常见问题及解决方案

十四、未来展望

技术趋势

• ​​AI个性化推荐​​：结合用户的历史复习数据（如哪些词汇易忘），通过机器学习动态调整复习间隔（比艾宾浩斯规则更精准）。
• ​​多模态学习​​：集成语音朗读（TTS）、图片联想（如词汇配图）和例句播放，提升记忆的趣味性和深度。
• ​​分布式协作​​：支持家庭/班级场景下的词汇库共享（如家长为孩子创建儿童词汇库，教师为学生同步考试词汇）。
• ​​云同步与备份​​：通过鸿蒙的云服务将词汇数据和复习进度备份至云端，实现多设备无缝切换。

挑战

• ​​离线与在线平衡​​：在无网络环境下保证核心功能（如复习提醒），同时支持在线同步扩展（如云词汇库）。
• ​​用户粘性提升​​：通过游戏化设计（如打卡奖励、成就系统）激励用户坚持复习，避免中途放弃。
• ​​跨平台兼容​​：若需扩展至iOS/Android，需适配不同系统的通知机制和存储方案（如鸿蒙的Preferences vs iOS的UserDefaults）。

十五、总结