Android Studio实战项目：日历签到与计算器集成应用-CSDN博客

本文还有配套的精品资源，点击获取

简介：本项目基于Android Studio开发环境，采用Java语言实现了一个集日历签到与简易计算器功能于一体的Android应用。通过CalendarView控件和日期处理类实现用户签到记录功能，结合SQLite数据库持久化存储数据；计算器模块则通过自定义布局与事件监听机制，利用表达式栈和逆波兰表示法（RPN）完成基础运算逻辑。项目涵盖Android应用的核心结构，包括app模块、build.gradle配置、资源管理及AndroidManifest.xml组件声明，适合作为初学者的完整实践案例或进阶开发者快速原型构建的基础。
Android studio，可用项目，日历计算器

1. Android应用开发的起点——开发环境搭建与项目初始化

环境准备与Android Studio安装

首先，访问 Android开发者官网下载最新稳定版Android Studio，推荐选择包含JDK 17的捆绑版本以避免兼容性问题。安装过程中勾选 Android SDK 、 Android SDK Platform-Tools 及 Android SDK Build-Tools 组件。首次启动后，通过SDK Manager安装目标API级别（如API 34）并配置代理（如需）加速下载。

创建“日历计算器”项目

在Android Studio中选择 New Project → Empty Activity ，命名为“CalendarCalculator”，包名设为 com.example.calendarcalculator ，语言选择Java，最低SDK设置为API 21（Android 5.0）。项目生成后，Gradle将自动同步 app/build.gradle 文件中的依赖项与构建配置。

项目结构解析

核心目录包括：
- src/main/java/ ：存放Java源码，主Activity位于此目录；
- src/main/res/ ：资源文件夹， layout 存放XML布局， values 定义字符串、颜色等；
- AndroidManifest.xml ：注册Activity并声明应用权限；
- build.gradle (Module: app) ：配置编译SDK版本、defaultConfig及依赖库。

android {
    compileSdk 34
    defaultConfig {
        applicationId "com.example.calendarcalculator"
        minSdk 21
        targetSdk 34
        versionCode 1
        versionName "1.0"
    }
}

上述代码定义了应用的基本构建参数，确保兼容性和版本控制一致性。

虚拟设备与真机调试

使用AVD Manager创建Pixel系列虚拟机（如Pixel 6 API 34），启用硬件加速提升运行效率。若使用真实设备，需开启USB调试模式，并在终端执行 adb devices 验证连接状态。成功部署后，可在Logcat中查看应用启动日志。

本章奠定开发基础，下一章将深入Java面向对象机制在Android组件设计中的实际应用。

2. Java语言在Android开发中的理论与实践

Java作为Android平台最早支持的编程语言，至今仍是构建稳定、可维护应用的重要技术基础。尽管Kotlin已逐渐成为官方推荐语言，但大量现有项目及底层框架仍以Java编写，掌握其核心机制对于深入理解Android运行时行为至关重要。本章将从面向对象编程的基本范式出发，结合Android组件模型的实际交互逻辑，系统阐述Java语言如何支撑起复杂的移动应用架构。通过分析类与对象的生命期管理、组件间通信的数据封装方式以及时间处理类库的正确使用方法，揭示Java语言特性与Android运行环境之间的深层耦合关系。尤其在资源受限的移动端场景下，合理运用集合框架、避免线程安全问题、优化内存占用等实践技巧，直接影响着应用的性能表现和用户体验稳定性。

2.1 Java面向对象编程的核心概念

面向对象编程（OOP）是Java语言的基石，也是Android开发中组织代码结构的根本范式。Android的四大组件——Activity、Service、BroadcastReceiver和ContentProvider——本质上都是Java类的实例，它们通过继承、多态等方式实现功能扩展与生命周期管理。理解OOP三大特征：封装、继承与多态，不仅有助于编写结构清晰的代码，更能帮助开发者设计出高内聚、低耦合的应用模块。例如，在“日历计算器”项目中，可以将签到逻辑抽象为独立的服务类，通过接口暴露操作方法，从而实现业务逻辑与UI层的解耦。这种设计模式提升了代码复用性，并为后期单元测试提供了便利条件。

2.1.1 类与对象的基本定义及其实例化过程

类是Java中用于描述具有相同属性和行为的对象模板，而对象则是类的具体实例。在Android开发中，每一个Activity本质上就是一个类的实例，它继承自 android.app.Activity ，并通过 new 关键字由系统创建。当用户启动一个页面时，Android运行时会调用该Activity类的构造函数完成实例化，并将其加入任务栈中进行管理。这一过程看似简单，实则涉及类加载器、内存分配、垃圾回收等多个JVM机制的协同工作。

以一个简单的 User 类为例：

public class User {
    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void introduce() {
        Log.d("User", "Hello, I'm " + name + ", " + age + " years old.");
    }
}

上述代码定义了一个包含姓名和年龄两个私有字段的 User 类，并提供了一个带参构造函数和一个介绍方法。在Activity中可以通过如下方式创建其实例：

User currentUser = new User("张三", 25);
currentUser.introduce(); // 输出：Hello, I'm 张三, 25 years old.

代码逻辑逐行解读：

public class User { ... } ：声明一个公共类 User ，可在其他包中访问。
private String name; 和 private int age; ：定义两个私有成员变量，体现封装原则，外部无法直接访问。
public User(String name, int age) ：构造函数用于初始化对象状态，接收参数并赋值给成员变量。
this.name = name; ：使用 this 关键字区分同名局部变量与成员变量。
public void introduce() ：公开方法供外部调用，封装了输出逻辑。

成员	类型	访问修饰符	作用
name	String	private	存储用户姓名
age	int	private	存储用户年龄
User()	构造函数	public	初始化对象
introduce()	方法	public	执行自我介绍

classDiagram
    class User {
        -String name
        -int age
        +User(String name, int age)
        +void introduce()
    }

该UML类图展示了 User 类的结构，其中减号表示私有成员，加号表示公有成员。这种可视化表达有助于团队协作时快速理解类的设计意图。值得注意的是，在Android中频繁创建大对象可能导致GC频繁触发，影响UI流畅度。因此建议对常用数据模型采用对象池或单例模式进行优化，尤其是在列表滚动等高频场景中。

此外，Java的反射机制允许在运行时动态获取类信息并实例化对象，这在某些框架如Dagger依赖注入中被广泛使用。然而反射性能较低且破坏封装性，应谨慎使用。实际开发中更推荐通过工厂模式或Builder模式来控制对象创建流程，提升代码可控性和可测试性。

2.1.2 封装、继承与多态在Activity设计中的体现

封装、继承与多态不仅是理论概念，更是Android框架设计的核心思想。Android SDK中的组件体系正是基于这些OOP特性构建而成。以Activity为例，开发者通常继承 AppCompatActivity 类，并重写其生命周期方法，这是典型的继承应用；同时，通过设置监听器回调实现事件响应，体现了封装与多态的结合。

封装体现在将数据与操作封装在类内部，仅暴露必要的接口。例如，在自定义 CalendarManager 类中：

public class CalendarManager {
    private Calendar calendar;

    public CalendarManager() {
        calendar = Calendar.getInstance();
    }

    public String getCurrentDate() {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd", Locale.CHINA);
        return sdf.format(calendar.getTime());
    }

    public void addDays(int days) {
        calendar.add(Calendar.DAY_OF_MONTH, days);
    }
}

该类隐藏了 Calendar 对象的具体操作细节，只提供 getCurrentDate() 和 addDays() 两个公共方法供外部调用，有效降低了调用方的认知负担。

继承使得子类可以复用父类代码并扩展功能。Android中所有Activity都继承自基类：

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
}

此处 MainActivity 继承 AppCompatActivity ，自动获得ActionBar支持、主题兼容等功能。调用 super.onCreate() 确保父类完成必要初始化，这是Android组件开发的标准做法。

多态则允许同一接口调用不同实现。考虑以下按钮点击处理场景：

View.OnClickListener clickListener = new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.btn_sign_in:
                handleSignIn();
                break;
            case R.id.btn_reset:
                handleReset();
                break;
        }
    }
};
findViewById(R.id.btn_sign_in).setOnClickListener(clickListener);
findViewById(R.id.btn_reset).setOnClickListener(clickListener);

虽然两个按钮注册了相同的监听器实例，但 onClick 方法根据 v.getId() 表现出不同的行为，这就是多态的具体体现——同一个引用指向不同对象时执行不同逻辑。

特性	在Android中的典型应用	优势
封装	隐藏数据库Helper内部实现	提升安全性与可维护性
继承	Activity/Fragment继承体系	复用生命周期管理逻辑
多态	接口回调、适配器模式	支持灵活扩展与插件化

graph TD
    A[Activity] --> B[AppCompatActivity]
    B --> C[MainActivity]
    C --> D[onCreate()]
    C --> E[onStart()]
    C --> F[onResume()]

此流程图展示了Activity继承链及其生命周期方法的调用顺序。每个子类都可以选择性地重写这些方法，在不改变整体框架的前提下定制行为。这种设计极大增强了框架的灵活性，也为开发者提供了统一的编程模型。

2.1.3 抽象类与接口在回调机制中的典型应用

在Android开发中，异步任务完成后通知主线程更新UI是一种常见需求，此时抽象类与接口发挥着关键作用。两者均可定义规范，但适用场景略有不同：接口适合定义行为契约，而抽象类更适合共享部分实现。

以网络请求回调为例，可定义如下接口：

public interface OnDataLoadedListener<T> {
    void onSuccess(T data);
    void onFailure(Exception e);
}

该泛型接口规定了数据加载成功与失败的两种回调路径。在具体实现中：

public class DataFetcher {
    public void fetchData(OnDataLoadedListener<List<String>> listener) {
        new AsyncTask<Void, Void, List<String>>() {
            @Override
            protected List<String> doInBackground(Void... params) {
                try {
                    // 模拟网络耗时操作
                    Thread.sleep(2000);
                    return Arrays.asList("Item1", "Item2", "Item3");
                } catch (InterruptedException e) {
                    return null;
                }
            }

            @Override
            protected void onPostExecute(List<String> result) {
                if (result != null) {
                    listener.onSuccess(result);
                } else {
                    listener.onFailure(new RuntimeException("Fetch failed"));
                }
            }
        }.execute();
    }
}

在Activity中使用：

new DataFetcher().fetchData(new OnDataLoadedListener<List<String>>() {
    @Override
    public void onSuccess(List<String> data) {
        adapter.updateData(data);
    }

    @Override
    public void onFailure(Exception e) {
        Toast.makeText(MainActivity.this, e.getMessage(), Toast.LENGTH_SHORT).show();
    }
});

这种方式实现了调用者与执行者的完全解耦，符合依赖倒置原则。相比抽象类，接口更轻量且支持多重实现，适合此类事件驱动场景。

若存在多个相关回调需要共用状态或工具方法，则抽象类更为合适：

public abstract class BaseCallback<T> implements OnDataLoadedListener<T> {
    protected Context context;

    public BaseCallback(Context context) {
        this.context = context;
    }

    protected void showLoading() {
        // 显示进度条
    }

    protected void hideLoading() {
        // 隐藏进度条
    }

    @Override
    public void onFailure(Exception e) {
        hideLoading();
        Toast.makeText(context, "Error: " + e.getMessage(), Toast.LENGTH_LONG).show();
    }
}

子类只需关注 onSuccess 的实现即可：

new DataFetcher().fetchData(new BaseCallback<List<String>>(this) {
    @Override
    public void onSuccess(List<String> data) {
        hideLoading();
        adapter.updateData(data);
    }
});

对比项	接口	抽象类
方法类型	全部抽象（Java 8前）	可含具体实现
成员变量	只能是常量	可定义实例变量
多重继承	支持	不支持
使用场景	定义能力契约	共享基础行为

sequenceDiagram
    participant Activity
    participant DataFetcher
    participant AsyncTask
    participant Listener

    Activity->>DataFetcher: fetchData(listener)
    DataFetcher->>AsyncTask: execute()
    AsyncTask-->>AsyncTask: doInBackground()
    AsyncTask-->>AsyncTask: onPostExecute(result)
    AsyncTask->>Listener: onSuccess(data)
    Listener->>Activity: 更新UI

该序列图清晰地描绘了回调机制的工作流程。通过接口或抽象类建立契约，使得异步操作的结果能够安全地传递回UI线程，既保证了线程隔离，又实现了松散耦合。这种设计模式在Handler、Retrofit、Room等主流库中均有广泛应用，是构建健壮Android应用的基础技能之一。

3. 日历功能模块的设计与实现路径

在现代移动应用中，日历功能不仅是时间展示的工具，更是用户行为记录、任务管理与提醒服务的核心载体。以“日历计算器”项目为例，其核心需求之一是提供一个直观且交互友好的日历界面，并在此基础上集成每日签到功能。该模块需要兼顾视觉呈现、时间逻辑处理和状态持久化三大维度。本章将深入剖析如何利用 Android 原生组件 CalendarView 搭建基础日历结构，结合 Java 的 Calendar 类完成复杂的时间运算，最终通过合理的数据结构设计实现签到状态的本地管理与实时更新。整个实现过程不仅涉及 UI 控件的技术细节，还涵盖事件驱动编程、日期算法优化以及用户体验细节打磨等多个层面。

3.1 Android原生日历控件CalendarView的技术解析

Android 提供了 CalendarView 组件作为系统级的日历展示控件，开发者无需从零构建日期网格即可快速集成标准日历功能。然而，在实际开发中，单纯使用默认样式难以满足产品化需求，如高亮特定日期、禁用历史选择或自定义点击反馈等。因此，掌握 CalendarView 的属性配置、事件监听机制及其扩展方式，成为构建个性化日历模块的第一步。

3.1.1 CalendarView的基本属性设置与事件监听绑定

CalendarView 是 Android Support Library 及后续 AndroidX 中提供的视图组件，位于 androidx.appcompat.widget.CalendarView 包下（具体路径可能因版本略有差异）。它默认以月为单位显示当前系统的日历信息，支持滑动切换月份，并允许用户点击选择某一天。为了使其适应“日历计算器”项目的整体风格与交互逻辑，首先需对其进行基本配置。

以下是初始化并配置 CalendarView 的典型代码示例：

<!-- activity_main.xml -->
<CalendarView
    android:id="@+id/calendarView"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:dateTextAppearance="@style/CustomCalendarDateText"
    android:weekNumberTextAppearance="@style/CustomWeekNumberText"
    android:shownWeekCount="6"
    android:firstDayOfWeek="2"
    android:enabled="true"
    android:background="#FFFFFF" />

上述 XML 配置中关键属性说明如下：

属性名	说明
`android:id`	控件唯一标识符，用于 Java/Kotlin 代码引用
`android:shownWeekCount`	显示周数，默认为 6 行，确保跨月时完整显示
`android:firstDayOfWeek`	设置每周起始日，1=周日，2=周一（符合中国习惯）
`android:dateTextAppearance`	自定义日期文字样式，可控制字体大小、颜色等
`android:weekNumberTextAppearance`	周标题（如“一”、“二”）的文字外观

在 Activity 中获取实例并设置监听器：

// MainActivity.java
CalendarView calendarView = findViewById(R.id.calendarView);

calendarView.setOnDateChangeListener(new CalendarView.OnDateChangeListener() {
    @Override
    public void onSelectedDayChange(@NonNull CalendarView view, int year, int month, int dayOfMonth) {
        // 注意：month 参数是从 0 开始计数（0~11）
        String selectedDate = String.format("%d-%02d-%02d", year, month + 1, dayOfMonth);
        Toast.makeText(MainActivity.this, "选择了：" + selectedDate, Toast.LENGTH_SHORT).show();
        // 更新其他UI组件，例如顶部标题栏显示选中日期
        updateTitleBar(year, month, dayOfMonth);
    }
});

代码逻辑逐行解读：

第 1 行：通过 findViewById 获取布局文件中定义的 CalendarView 实例。
第 3 行：调用 setOnDateChangeListener 注册日期变化监听器，这是响应用户点击的核心入口。
第 5–9 行：重写 onSelectedDayChange 方法。当用户点击某个日期格子时，系统自动回调此方法，并传入年、月、日参数。
第 7 行：由于 month 参数从 0 开始（即 0 表示 1 月），必须加 1 才能得到真实月份。此处使用 String.format 格式化输出标准日期字符串。
第 8 行：弹出 Toast 提示用户选择结果，便于调试。
第 10 行：调用自定义方法 updateTitleBar() 同步更新界面上方的标题，增强交互一致性。

⚠️ 注意事项 ： CalendarView 的 month 参数基于 0 起始，这与 Java 的 Calendar 类一致，但容易引发边界错误。建议封装转换工具类避免重复出错。

此外，可通过 Java 代码动态设置最小/最大可选日期范围，限制用户操作：

// 禁止选择未来日期
Calendar maxDate = Calendar.getInstance();
maxDate.set(2025, 4, 10); // 2025年5月10日（注意月份从0开始）
calendarView.setMaxDate(maxDate.getTimeInMillis());

// 允许最早选择2024年1月1日
Calendar minDate = Calendar.getInstance();
minDate.set(2024, 0, 1);
calendarView.setMinDate(minDate.getTimeInMillis());

该功能常用于签到类应用，防止用户提前打卡或回溯补签。

3.1.2 自定义高亮显示已签到日期的视觉优化方案

尽管 CalendarView 支持基本的日期选择高亮（通常为蓝色圆圈），但无法直接标记“已签到”状态。要实现自定义渲染（如红色对勾、背景色填充），必须借助适配器模式或继承重绘机制。由于 CalendarView 不开放 Adapter 接口，推荐做法是结合 Decorator 思路，在绘制阶段干预 UI 表现。

一种高效实现方式是使用第三方库 Material Calendar View （由 ProtonMail 开源维护），但若坚持使用原生控件，则可通过以下策略模拟高亮效果：

方案一：利用背景 Drawable 动态替换

预定义两个 drawable 文件：

<!-- drawable/signed_day_background.xml -->
<shape xmlns:android="http://schemas.android.com/apk/res/android">
    <solid android:color="#FFEB3B"/> <!-- 黄色背景 -->
    <corners android:radius="16dp"/>
</shape>

<!-- drawable/default_day_background.xml -->
<shape xmlns:android="http://schemas.android.com/apk/res/android">
    <solid android:color="@android:color/transparent"/>
    <corners android:radius="16dp"/>
</shape>

然后在监听器中判断是否签到，并修改对应日期的文本颜色或背景：

但由于 CalendarView 内部日期单元格不可直接访问，此方法受限。替代方案是 完全自定义日历网格 ，但这超出了本节范围。

方案二：叠加 TextView 提示层（推荐轻量级做法）

在 CalendarView 上方覆盖一层透明 GridLayout ，仅在签到日期位置显示小图标：

<FrameLayout
    android:layout_width="match_parent"
    android:layout_height="wrap_content">

    <CalendarView
        android:id="@+id/calendarView"
        ... />

    <GridLayout
        android:id="@+id/signOverlay"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:alignmentMode="alignMargins"
        android:columnCount="7"
        android:rowCount="6"
        android:paddingTop="60dp" <!-- 预留标题空间 -->
        android:background="@android:color/transparent">
    </GridLayout>

</FrameLayout>

Java 代码中根据签到数据动态添加标记：

private void renderSignIndicators(Set<String> signedDates) {
    signOverlay.removeAllViews(); // 清空旧标记

    for (String dateStr : signedDates) { // 格式：yyyy-MM-dd
        TextView tick = new TextView(this);
        tick.setText("✓");
        tick.setTextColor(Color.RED);
        tick.setTextSize(12);
        tick.setGravity(Gravity.CENTER);

        GridLayout.LayoutParams params = new GridLayout.LayoutParams();
        params.width = 0;
        params.height = 80;
        params.columnSpec = GridLayout.spec(getColumnForDate(dateStr), 1, 1f);
        params.rowSpec = GridLayout.spec(getRowForDate(dateStr));
        signOverlay.addView(tick, params);
    }
}

该方法虽非完美，但在性能与灵活性之间取得平衡，适合中小型项目。

流程图：签到高亮渲染流程

graph TD
    A[启动Activity] --> B{加载本地签到记录}
    B --> C[解析HashSet<DateKey>]
    C --> D[初始化CalendarView]
    D --> E[注册日期选择监听]
    E --> F[用户点击某日期]
    F --> G{是否已签到?}
    G -- 是 --> H[显示Toast提示]
    G -- 否 --> I[执行签到逻辑]
    I --> J[更新本地缓存]
    J --> K[重新渲染overlay标记]
    K --> L[刷新UI]

3.1.3 处理用户点击选择日期后的状态更新逻辑

点击事件不仅仅是展示信息，更应触发业务状态变更。在签到场景中，每次点击需判断当前日期是否已完成签到，若未签到则记录并更新 UI；否则提示“今日已签”。

完整逻辑如下：

private Set<String> signedDays = new HashSet<>(); // 存储签到日期（格式：yyyy-MM-dd）

private void setupCalendarClickListener() {
    calendarView.setOnDateChangeListener((view, year, month, day) -> {
        String today = getTodayString(); // 当前系统日期
        String selected = String.format("%d-%02d-%02d", year, month + 1, day);

        if (selected.equals(today)) {
            if (signedDays.contains(selected)) {
                Toast.makeText(this, "今天已经签过到了！", Toast.LENGTH_SHORT).show();
            } else {
                performSignIn(selected);
            }
        } else if (selected.compareTo(today) < 0) {
            Toast.makeText(this, "不能补签过去的日期哦~", Toast.LENGTH_LONG).show();
        } else {
            Toast.makeText(this, "不能提前签到未来日期！", Toast.LENGTH_LONG).show();
        }
    });
}

private void performSignIn(String dateKey) {
    signedDays.add(dateKey);
    saveToLocalStorage(dateKey); // 如SharedPreferences
    Toast.makeText(this, "签到成功！连续第" + calculateStreak() + "天", Toast.LENGTH_SHORT).show();
    refreshSignMarkers(); // 重新绘制标记
}

参数说明：
- signedDays : 使用 HashSet<String> 存储签到日期键值，查找时间为 O(1)，适合频繁查询。
- getTodayString() : 返回当前日期的标准字符串格式，用于比较。
- saveToLocalStorage : 将签到记录保存至 SharedPreferences 或数据库，保证重启后不丢失。
- calculateStreak() : 计算连续签到天数，提升用户成就感。

该逻辑体现了典型的“输入 → 判断 → 执行 → 反馈 → 持久化”闭环，是移动端交互设计的标准范式。

3.2 基于Calendar类的时间逻辑运算实践

即使拥有 CalendarView ，仍需依赖 Java 的 Calendar 类进行深层次时间计算。Android 的日历模块高度依赖准确的日期推算能力，包括跨月切换、星期偏移、闰年判断等。这些底层逻辑直接影响日历排布的正确性。

3.2.1 获取当前系统年月日并与界面同步展示

获取当前时间是最基础的操作，但必须注意时区与格式化问题。

public class DateUtils {
    public static Calendar getCurrentDayInstance() {
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.HOUR_OF_DAY, 0);
        cal.set(Calendar.MINUTE, 0);
        cal.set(Calendar.SECOND, 0);
        cal.set(Calendar.MILLISECOND, 0);
        return cal;
    }

    public static String formatDate(Calendar cal) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 E", Locale.CHINA);
        return sdf.format(cal.getTime());
    }
}

在 Activity 中调用：

TextView titleView = findViewById(R.id.tv_title);
Calendar today = DateUtils.getCurrentDayInstance();
titleView.setText(DateUtils.formatDate(today));

输出示例： 2025年4月5日六

💡 使用 Locale.CHINA 可确保中文星期显示正确。

3.2.2 实现前后月份切换时的日历数据动态刷新

CalendarView 自带滑动翻月功能，但若需自定义导航按钮（上一月/下一月），则需手动调整：

Button btnPrev = findViewById(R.id.btn_prev_month);
Button btnNext = findViewById(R.id.btn_next_month);

btnPrev.setOnClickListener(v -> {
    long current = calendarView.getDate();
    Calendar cal = Calendar.getInstance();
    cal.setTimeInMillis(current);
    cal.add(Calendar.MONTH, -1);
    calendarView.setDate(cal.getTimeInMillis(), true, true);
});

btnNext.setOnClickListener(v -> {
    long current = calendarView.getDate();
    Calendar cal = Calendar.getInstance();
    cal.setTimeInMillis(current);
    cal.add(Calendar.MONTH, 1);
    calendarView.setDate(cal.getTimeInMillis(), true, true);
});

其中 setDate(..., true, true) 的第二个参数表示是否动画滚动，第三个参数是否立即触发 OnDateChangeListener 。

3.2.3 计算每月第一天是星期几并正确排布日历格子

虽然 CalendarView 自动处理排版，但如果需自定义日历网格（如实现更复杂的装饰），则必须掌握首日偏移计算：

public int getFirstDayOfWeekInMonth(int year, int month) {
    Calendar cal = Calendar.getInstance();
    cal.set(year, month, 1); // 设置为该月第一天
    int dayOfWeek = cal.get(Calendar.DAY_OF_WEEK); // 返回1~7，1=周日
    return (dayOfWeek + 5) % 7; // 转换为0=周一,...,6=周日
}

此函数返回该月1号对应的“周一为0”的索引，可用于数组填充或 GridView 定位。

月份	1号星期	返回值（周一=0）
2025-04-01	二	1
2025-05-01	四	3

该算法广泛应用于自定义日历控件开发中。

3.3 用户签到功能的状态管理机制

签到功能的本质是一个布尔状态机：每个日期要么“已签”，要么“未签”。如何高效存储、查询和更新这些状态，决定了功能的稳定性和扩展潜力。

3.3.1 利用HashSet或Boolean数组标记签到状态

两种主流方案对比：

方案	优点	缺点	适用场景
`HashSet<String>`	查找快、内存紧凑、易于序列化	需字符串拼接	签到分散、跨度大
`boolean[]` 数组	访问极快、索引直接	固定长度、浪费空间	连续时间段内密集签到

推荐使用 HashSet<String> ，因其更具通用性。

private Set<String> loadSignedDaysFromPrefs() {
    SharedPreferences sp = getSharedPreferences("sign_data", MODE_PRIVATE);
    Set<String> defaults = new HashSet<>();
    return sp.getStringSet("signed_dates", defaults);
}

3.3.2 签到成功提示Toast与本地缓存即时更新联动

确保 UI 反馈与数据持久化同步进行：

private void saveToLocalStorage(String dateKey) {
    SharedPreferences sp = getSharedPreferences("sign_data", MODE_PRIVATE);
    Set<String> set = new HashSet<>(signedDays);
    sp.edit().putStringSet("signed_dates", set).apply();
}

使用 apply() 异步提交，避免阻塞主线程。

3.3.3 防止重复签到的逻辑判断与用户体验优化

除了禁止重复操作外，还可加入防抖机制：

private long lastClickTime = 0;

if (System.currentTimeMillis() - lastClickTime < 1000) {
    return; // 防止快速连点
}
lastClickTime = System.currentTimeMillis();

同时可结合震动反馈提升感知：

Vibrator vib = (Vibrator) getSystemService(Context.VIBRATOR_SERVICE);
vib.vibrate(VibrationEffect.createOneShot(50, VibrationEffect.DEFAULT_AMPLITUDE));

综上所述，日历功能模块的实现不仅是控件调用，更是时间逻辑、状态管理和用户体验设计的综合体现。通过合理运用原生 API 与 Java 工具类，可在有限资源下构建出高性能、易维护的日历签到系统。

4. 本地数据持久化技术选型与SQLite深度整合

在移动应用开发中，用户数据的持久化是保障功能完整性与用户体验连续性的核心环节。尤其对于“日历计算器”这类具备状态记录特性的应用，签到行为的历史必须能够跨会话保存并可靠读取。Android平台提供了多种本地存储方案，包括SharedPreferences、文件系统和SQLite数据库。其中，SQLite以其结构化、高效查询和事务支持能力，在复杂数据管理场景中占据主导地位。本章将深入探讨为何选择SQLite作为日历签到模块的数据存储引擎，并通过完整的代码实现路径展示其与Android组件系统的无缝集成。

4.1 SQLite数据库在Android平台的技术优势分析

SQLite是一种轻量级、自包含、无服务器的嵌入式关系型数据库引擎，广泛应用于移动端、嵌入式设备乃至桌面应用程序中。它以单个磁盘文件的形式存在，无需独立进程或网络连接即可运行，这种特性使其成为Android平台上最理想的本地持久化解决方案之一。相较于其他存储方式，SQLite不仅支持标准SQL语法，还具备ACID（原子性、一致性、隔离性、持久性）事务保证，适用于需要频繁增删改查且数据结构相对固定的业务场景。

4.1.1 轻量级嵌入式数据库与移动端适配性探讨

SQLite的设计哲学强调“够用即好”，其整个数据库引擎被编译为一个C库，通常仅占用几百KB的空间，对内存和CPU资源消耗极低。这一特点决定了它非常适合运行在资源受限的移动设备上。更重要的是，SQLite直接集成于Android操作系统内核之中，所有Android版本均原生支持该数据库，开发者无需引入第三方依赖即可使用完整的SQL功能。

从架构角度看，SQLite采用单文件数据库模型，每个数据库对应一个 .db 文件，存储在应用私有目录下的 /data/data/<package_name>/databases/ 路径中，天然具备访问隔离性和安全性。这意味着不同应用之间的数据无法相互读写，除非显式配置ContentProvider共享机制。

此外，SQLite支持丰富的数据类型（如INTEGER、TEXT、REAL、BLOB），允许定义主键、外键、索引、触发器等高级特性，能有效支撑复杂的业务逻辑建模。例如，在日历签到功能中，我们可以设计一张签到记录表，包含日期字段（TEXT）、签到时间戳（INTEGER）、连续签到天数（INTEGER）等多个维度信息，并通过索引优化按月查询性能。

特性	描述
存储形式	单一文件存储，便于备份与迁移
并发支持	支持多读一写，适合低并发场景
事务机制	完整ACID支持，确保操作一致性
SQL兼容性	支持大部分标准SQL-92语法
零配置	无需服务器、无需管理员权限

graph TD
    A[Android App] --> B(SQLite Database)
    B --> C[/data/data/com.example.calendarcalc/databases/sign_in.db]
    C --> D[Table: sign_in_records]
    D --> E[Columns: _id, date, timestamp, streak_count]
    E --> F[Primary Key: _id AUTOINCREMENT]
    F --> G[Index on date for fast lookup]

上述流程图展示了SQLite在Android应用中的典型部署结构：应用通过 SQLiteOpenHelper 访问位于私有目录中的数据库文件，数据表设计遵循规范化原则，并建立必要索引以提升查询效率。

4.1.2 SQLiteOpenHelper类的创建流程与版本控制策略

在Android中，直接操作SQLite需借助 android.database.sqlite.SQLiteOpenHelper 抽象类。该类封装了数据库的创建、升级与降级逻辑，是进行数据库生命周期管理的标准入口。开发者需继承此类并重写 onCreate() 和 onUpgrade() 方法，从而实现初始化建表与结构演进。

以下是一个用于签到记录管理的 SignInDatabaseHelper 实现示例：

public class SignInDatabaseHelper extends SQLiteOpenHelper {
    private static final String DATABASE_NAME = "sign_in.db";
    private static final int DATABASE_VERSION = 1;

    public static final String TABLE_SIGN_IN = "sign_in_records";
    public static final String COLUMN_ID = "_id";
    public static final String COLUMN_DATE = "date";
    public static final String COLUMN_TIMESTAMP = "timestamp";
    public static final String COLUMN_STREAK = "streak_count";

    private static final String CREATE_TABLE =
        "CREATE TABLE " + TABLE_SIGN_IN + "(" +
        COLUMN_ID + " INTEGER PRIMARY KEY AUTOINCREMENT," +
        COLUMN_DATE + " TEXT UNIQUE NOT NULL," +
        COLUMN_TIMESTAMP + " INTEGER NOT NULL," +
        COLUMN_STREAK + " INTEGER DEFAULT 0" +
        ");";

    public SignInDatabaseHelper(Context context) {
        super(context, DATABASE_NAME, null, DATABASE_VERSION);
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
        db.execSQL(CREATE_TABLE);
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        if (oldVersion < 2) {
            // 示例：v2新增连续签到字段
            db.execSQL("ALTER TABLE " + TABLE_SIGN_IN +
                       " ADD COLUMN " + COLUMN_STREAK + " INTEGER DEFAULT 0");
        }
    }
}

代码逻辑逐行解读：

第3–7行：定义常量，包括数据库名称、版本号及表名和字段名。使用大写命名规范提高可读性。
第9–16行：构建建表语句，使用 TEXT UNIQUE NOT NULL 约束确保每日最多一条记录，避免重复插入。
第18–21行：构造函数调用父类 SQLiteOpenHelper ，传入上下文、数据库名、游标工厂（null表示默认）和版本号。
第24–26行： onCreate() 在首次创建数据库时执行，执行DDL语句完成表结构初始化。
第29–35行： onUpgrade() 处理数据库版本升级。当检测到旧版本小于目标版本时，可通过 ALTER TABLE 动态添加列或重建表。

参数说明：
- DATABASE_VERSION ：版本号控制升级逻辑，每次结构调整需递增；
- UNIQUE 约束防止同一天多次签到插入；
- AUTOINCREMENT 确保主键唯一增长，便于后续关联查询。

该设计模式实现了数据库初始化与演化过程的解耦，使后期维护更加安全可控。

4.1.3 数据表设计范式在签到记录表中的具体应用

良好的数据库设计应遵循关系数据库规范化原则，减少冗余、提升一致性。针对签到记录表，我们应考虑以下几点：

第一范式（1NF） ：确保每列不可再分。当前设计中， date 字段以 YYYY-MM-DD 字符串形式存储，符合单一值要求；
第二范式（2NF） ：非主属性完全依赖于主键。此处主键为 _id ，但实际业务主键应为 date ，故设置 date 为唯一键更为合理；
第三范式（3NF） ：消除传递依赖。当前字段间无间接依赖，满足要求。

为进一步增强扩展性，未来可拆分出用户表（User）与签到记录表（SignInRecord）形成一对多关系，实现多账户支持。此时需引入外键约束：

CREATE TABLE users (
    user_id INTEGER PRIMARY KEY AUTOINCREMENT,
    username TEXT NOT NULL
);

CREATE TABLE sign_in_records (
    _id INTEGER PRIMARY KEY AUTOINCREMENT,
    user_id INTEGER,
    date TEXT NOT NULL,
    timestamp INTEGER,
    FOREIGN KEY(user_id) REFERENCES users(user_id) ON DELETE CASCADE
);

此结构支持多用户环境下的签到隔离与统计分析，体现数据库设计的前瞻性思维。

4.2 日历签到数据的增删改查操作实现

完成数据库基础建设后，下一步是实现对签到记录的CRUD（创建、读取、更新、删除）操作。这些操作构成了日历功能的核心数据交互链路，直接影响用户体验的真实性与响应速度。

4.2.1 定义Contract类规范字段命名提升代码可维护性

为了集中管理数据库元信息，避免硬编码导致维护困难，Android推荐使用Contract类模式。该类作为静态容器，统一声明表名、列名与URI等常量。

public final class SignInContract {
    private SignInContract() {}

    public static class SignInEntry implements BaseColumns {
        public static final String TABLE_NAME = "sign_in_records";
        public static final String COLUMN_DATE = "date";
        public static final String COLUMN_TIMESTAMP = "timestamp";
        public static final String COLUMN_STREAK = "streak_count";
    }
}

通过静态内部类组织结构，外部可通过 SignInContract.SignInEntry.COLUMN_DATE 引用字段名，极大提升了重构安全性。

4.2.2 使用ContentValues封装插入数据的标准化做法

向数据库插入数据应使用 ContentValues 对象，而非拼接SQL字符串，以防SQL注入风险。

public long insertSignInRecord(String date, long timestamp, int streak) {
    SQLiteDatabase db = this.getWritableDatabase();
    ContentValues values = new ContentValues();
    values.put(SignInContract.SignInEntry.COLUMN_DATE, date);
    values.put(SignInContract.SignInEntry.COLUMN_TIMESTAMP, timestamp);
    values.put(SignInContract.SignInEntry.COLUMN_STREAK, streak);

    return db.insert(SignInContract.SignInEntry.TABLE_NAME, null, values);
}

ContentValues 本质是 HashMap<String, Object> 的包装类，专用于数据库操作。第二个参数指定“空列占位符”，设为 null 表示不允许全空行插入。

4.2.3 查询历史签到记录并在CalendarView上渲染标记

查询操作返回 Cursor 对象，需遍历提取结果集并更新UI状态。

public Set<String> getAllSignedDates() {
    Set<String> signedDates = new HashSet<>();
    SQLiteDatabase db = this.getReadableDatabase();
    Cursor cursor = db.query(
        SignInContract.SignInEntry.TABLE_NAME,
        new String[]{SignInContract.SignInEntry.COLUMN_DATE},
        null, null, null, null, null
    );

    while (cursor.moveToNext()) {
        String date = cursor.getString(
            cursor.getColumnIndexOrThrow(SignInContract.SignInEntry.COLUMN_DATE)
        );
        signedDates.add(date);
    }
    cursor.close();
    return signedDates;
}

获取签到日期集合后，可在 CalendarView 的自定义适配器中判断是否高亮显示：

calendarView.setOnDateChangeListener((view, year, month, dayOfMonth) -> {
    String selectedDate = String.format(Locale.CHINA, "%d-%02d-%02d", year, month + 1, dayOfMonth);
    if (signedDates.contains(selectedDate)) {
        Toast.makeText(this, "您已于今日签到！", Toast.LENGTH_SHORT).show();
    } else {
        performSignIn(selectedDate); // 执行签到
    }
});

该机制实现了数据驱动视图的核心闭环，确保用户每次打开应用都能准确看到历史签到状态。

操作类型	方法名	关键参数	返回值
插入	insertSignInRecord	date, timestamp, streak	新记录ID或-1
查询	getAllSignedDates	——	HashSet
删除	deleteRecordByDate	date	影响行数

sequenceDiagram
    participant UI as CalendarView
    participant DB as SQLite Database
    participant Helper as SignInDatabaseHelper

    UI->>Helper: queryAllSignedDates()
    Helper->>DB: SELECT date FROM sign_in_records
    DB-->>Helper: Cursor with results
    Helper-->>UI: Return Set<String>
    UI->>UI: Highlight dates in view

此序列图清晰呈现了从界面请求到数据返回的完整调用链，体现了MVC分层思想在本地持久化中的落地实践。

4.3 数据访问层的封装与异常处理机制

随着业务逻辑的增长，直接在Activity中调用数据库操作会导致代码臃肿、难以测试。引入DAO（Data Access Object）模式可有效分离关注点，提升系统可维护性。

4.3.1 构建DAO模式分离业务逻辑与数据库操作

DAO接口定义数据访问契约，其实现类封装具体的SQL执行逻辑。

public interface SignInDao {
    long insert(SignInRecord record);
    List<SignInRecord> getAllRecords();
    boolean isSignedForDate(String date);
    int deleteByDate(String date);
}

public class SQLiteSignInDao implements SignInDao {
    private SignInDatabaseHelper dbHelper;

    public SQLiteSignInDao(Context context) {
        this.dbHelper = new SignInDatabaseHelper(context);
    }

    @Override
    public long insert(SignInRecord record) {
        SQLiteDatabase db = dbHelper.getWritableDatabase();
        ContentValues cv = new ContentValues();
        cv.put(SignInContract.SignInEntry.COLUMN_DATE, record.getDate());
        cv.put(SignInContract.SignInEntry.COLUMN_TIMESTAMP, record.getTimestamp());
        cv.put(SignInContract.SignInEntry.COLUMN_STREAK, record.getStreakCount());

        return db.insert(SignInContract.SignInEntry.TABLE_NAME, null, cv);
    }
}

该模式便于后期替换为Room或其他ORM框架，增强架构弹性。

4.3.2 捕获SQL异常并提供友好的错误反馈机制

数据库操作可能因磁盘满、并发冲突等原因失败，必须妥善捕获异常。

try {
    long result = dao.insert(record);
    if (result == -1) {
        showError("签到失败：数据已存在");
    } else {
        showSuccess("签到成功！");
    }
} catch (SQLException e) {
    Log.e("DB_ERROR", "Insert failed", e);
    showError("数据库异常，请稍后重试");
}

通过日志记录与用户提示双通道反馈，既保障调试便利又维护体验流畅。

4.3.3 数据库升级迁移过程中保留旧数据的解决方案

当版本升级涉及表结构调整时，简单的 DROP TABLE 会导致数据丢失。正确做法是在 onUpgrade() 中使用临时表过渡：

@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
    if (oldVersion == 1 && newVersion == 2) {
        db.beginTransaction();
        try {
            db.execSQL("ALTER TABLE sign_in_records RENAME TO temp_sign_in");
            db.execSQL(CREATE_TABLE); // 新结构
            db.execSQL("INSERT INTO sign_in_records (date, timestamp) " +
                       "SELECT date, timestamp FROM temp_sign_in");
            db.execSQL("DROP TABLE temp_sign_in");
            db.setTransactionSuccessful();
        } finally {
            db.endTransaction();
        }
    }
}

通过事务包裹确保迁移原子性，最大限度保护用户数据资产。

综上所述，SQLite不仅是Android本地持久化的首选工具，更是构建健壮、可扩展应用架构的关键基石。合理运用OpenHelper、Contract、DAO等设计模式，结合严谨的异常处理与版本管理策略，方能在真实项目中发挥其最大效能。

5. 计算器功能实现与项目整体集成部署

5.1 计算器界面布局设计与响应式交互实现

在“日历计算器”应用中，除了日历签到功能外，用户对基础数学运算也有实际需求。因此，在本节中我们将构建一个具备完整四则运算能力的科学型计算器界面，并确保其在不同屏幕尺寸设备上的良好适配性。

我们采用 ConstraintLayout 作为根布局容器，因其支持扁平化结构和强大的约束机制，能够有效提升UI渲染效率并减少嵌套层级。以下是核心布局代码片段：

<androidx.constraintlayout.widget.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <TextView
        android:id="@+id/tvExpression"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:text=""
        android:textSize="24sp"
        android:gravity="end"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintHorizontal_bias="0.0"/>

    <TextView
        android:id="@+id/tvResult"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:text="0"
        android:textSize="36sp"
        android:gravity="end"
        app:layout_constraintTop_toBottomOf="@id/tvExpression"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintEnd_toEndOf="parent" />

    <!-- 按钮网格示例 -->
    <Button
        android:id="@+id/btn_0"
        android:layout_width="0dp"
        android:layout_height="0dp"
        android:text="0"
        android:onClick="onDigitClick"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintEnd_toStartOf="@id/btn_dot"
        app:layout_constraintDimensionRatio="2:1" />
    <!-- 其他按钮通过类似方式定义 -->

</androidx.constraintlayout.widget.ConstraintLayout>

上述布局通过 app:layout_constraint* 属性实现了精确的位置控制，配合 layout_width="0dp" （即 MATCH_CONSTRAINT ）实现横向拉伸填充，结合 dimensionRatio 确保按钮保持宽高比一致，从而在各种分辨率下均呈现均匀美观的按键排列。

为降低代码冗余，所有数字与操作符按钮共享同一个点击监听方法，通过 View.getTag() 或 View.getId() 区分来源：

public void onOperatorClick(View view) {
    Button btn = (Button) view;
    String op = btn.getText().toString();
    String currentExpr = tvExpression.getText().toString();

    // 防止连续输入运算符
    if (!currentExpr.isEmpty() && isLastCharOperator(currentExpr)) {
        return;
    }

    tvExpression.append(op);
}

动态更新使用两个 TextView 分别显示表达式输入过程和最终结果，符合现代计算器交互范式。

5.2 表达式求值算法设计：逆波兰表示法（RPN）原理与编码

传统中缀表达式（如 3 + 4 * 2 ）无法直接按顺序计算，需考虑运算符优先级。为此我们引入 逆波兰表示法 （Reverse Polish Notation, RPN），将表达式转换为无括号的后缀形式（如 3 4 2 * + ），便于用栈结构高效求值。

中缀转后缀流程（调度场算法）

该算法由Edsger Dijkstra提出，核心思想是使用栈暂存运算符：

当前字符	动作
数字	直接输出到队列
左括号	压入栈
右括号	弹出运算符至输出，直到遇到左括号
运算符	弹出优先级 ≥ 当前运算符的栈顶元素，再压入当前

我们定义优先级映射表如下：

private static final Map<String, Integer> PRECEDENCE = new HashMap<>();
static {
    PRECEDENCE.put("+", 1);
    PRECEDENCE.put("-", 1);
    PRECEDENCE.put("*", 2);
    PRECEDENCE.put("/", 2);
    PRECEDENCE.put("%", 2);
    PRECEDENCE.put("^", 3); // 幂运算
}

转换函数实现：

public Queue<String> infixToPostfix(String expr) {
    Stack<String> operatorStack = new Stack<>();
    Queue<String> output = new LinkedList<>();
    List<String> tokens = tokenize(expr);

    for (String token : tokens) {
        if (isNumber(token)) {
            output.offer(token);
        } else if (token.equals("(")) {
            operatorStack.push(token);
        } else if (token.equals(")")) {
            while (!operatorStack.isEmpty() && !operatorStack.peek().equals("(")) {
                output.offer(operatorStack.pop());
            }
            operatorStack.pop(); // 移除 '('
        } else if (PRECEDENCE.containsKey(token)) {
            while (!operatorStack.isEmpty() &&
                   !operatorStack.peek().equals("(") &&
                   PRECEDENCE.get(operatorStack.peek()) >= PRECEDENCE.get(token)) {
                output.offer(operatorStack.pop());
            }
            operatorStack.push(token);
        }
    }

    while (!operatorStack.isEmpty()) {
        output.offer(operatorStack.pop());
    }

    return output;
}

RPN求值逻辑

利用另一个栈存储操作数，遍历后缀表达式：

public double evaluateRPN(Queue<String> postfix) {
    Stack<Double> stack = new Stack<>();

    while (!postfix.isEmpty()) {
        String token = postfix.poll();
        if (isNumber(token)) {
            stack.push(Double.parseDouble(token));
        } else {
            double b = stack.pop();
            double a = stack.pop();
            switch (token) {
                case "+": stack.push(a + b); break;
                case "-": stack.push(a - b); break;
                case "*": stack.push(a * b); break;
                case "/": 
                    if (b == 0) throw new ArithmeticException("Division by zero");
                    stack.push(a / b); break;
                default:
                    throw new IllegalArgumentException("Unknown operator: " + token);
            }
        }
    }

    return stack.pop();
}

此设计支持扩展更多运算符（如 sin , sqrt ），只需修改优先级表与求值逻辑即可。

5.3 综合功能整合与项目调试发布全流程

Fragment整合至主Activity

我们将日历模块与计算器模块分别封装为 CalendarFragment 和 CalculatorFragment ，并通过 ViewPager2 或底部导航实现切换：

public class MainActivity extends AppCompatActivity {
    private ViewPager2 viewPager;
    private TabLayout tabLayout;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        viewPager = findViewById(R.id.viewPager);
        tabLayout = findViewById(R.id.tabLayout);

        ViewPagerAdapter adapter = new ViewPagerAdapter(this);
        viewPager.setAdapter(adapter);

        new TabLayoutMediator(tabLayout, viewPager,
            (tab, position) -> tab.setText(position == 0 ? "日历" : "计算器")
        ).attach();
    }
}

对应的 ViewPagerAdapter ：

class ViewPagerAdapter extends FragmentStateAdapter {
    public ViewPagerAdapter(FragmentActivity fa) { super(fa); }

    @NonNull
    @Override
    public Fragment createFragment(int position) {
        return position == 0 ? new CalendarFragment() : new CalculatorFragment();
    }

    @Override
    public int getItemCount() { return 2; }
}

使用Logcat排查异常

在真机运行时可能出现如下问题：
- 空指针异常：检查 findViewById 是否正确绑定ID；
- SQLite锁冲突：数据库未关闭导致 ANR；
- 内存泄漏：Handler持有Activity引用未释放。

建议添加日志：

Log.d("Calculator", "Processing expression: " + expr);
Log.e("DatabaseError", "Failed to insert record", e);

使用Android Studio的 Logcat 面板过滤包名，定位关键错误堆栈。

生成签名APK并发布测试

步骤如下：
1. Build > Generate Signed Bundle / APK
2. 创建密钥库（ .jks 文件），填写别名、密码、有效期等
3. 选择 APK 格式，构建类型为 release
4. 完成后在 app/release/ 下获取 app-release.apk

可通过以下命令验证APK完整性：

apksigner verify app-release.apk

上传至内测平台如 [Firebase App Distribution] 或蒲公英进行灰度发布，收集用户反馈。

graph TD
    A[编写功能代码] --> B[单元测试与UI测试]
    B --> C[本地Debug运行]
    C --> D[使用Logcat分析崩溃]
    D --> E[修复内存泄漏]
    E --> F[生成Release签名APK]
    F --> G[上传至测试平台]
    G --> H[收集用户反馈]
    H --> I[迭代优化]

本文还有配套的精品资源，点击获取