本文还有配套的精品资源，点击获取 menu-r.4af5f7ec.gif

简介：Java通讯录手机版源码是一款利用Java语言开发的通讯录应用，突显Java的跨平台特性。它提供了标准的联系人管理功能，且基于MVC设计模式构建。源码解析涉及Android SDK、Activity、SQLite数据库、ContentProvider、Intent、XML布局文件、Adapter、权限管理、UI组件和事件监听等关键开发知识点，适合学习和提升Android应用开发技巧。
Java通讯录

1. 跨平台Java通讯录应用开发

1.1 项目简介与目标定位

在本章中，我们将开启一次令人兴奋的开发之旅，目标是构建一个跨平台的Java通讯录应用。为了实现这一目标，我们将采用多种技术，如JavaFX和Swing进行界面设计，SQLite数据库进行数据存储。在开发的过程中，我们会深入理解Java跨平台机制，并将对Java的桌面应用开发有一个全面的了解。

1.2 开发环境与技术选型

首先，我们要确定开发环境。我们将使用Java SE Development Kit (JDK)，并选择IntelliJ IDEA作为我们的集成开发环境。在技术选型上，我们决定使用Maven作为项目依赖管理工具，Spring Boot简化应用搭建和开发流程。

1.3 应用架构设计与实现

应用架构采用MVC设计模式，这是因为它具有非常清晰的分层，有助于将应用的业务逻辑、数据模型和用户界面分离开，便于开发和维护。我们将定义模型(Model)来表示通讯录中的联系人信息，视图(View)用于展示用户界面，控制器(Controller)处理用户交互和数据流转。

// 示例代码展示MVC基本结构
// Model
public class Contact {
    private String name;
    private String phone;

    // Getters and Setters
}

// View
public class ContactView {
    public void displayContact(Contact contact) {
        // UI code to display contact information
    }
}

// Controller
public class ContactController {
    private Contact model;
    private ContactView view;

    public ContactController(Contact model, ContactView view) {
        this.model = model;
        this.view = view;
    }

    public void setContactName(String name) {
        model.setName(name);
    }

    public String getContactName() {
        return model.getName();
    }

    public void updateView() {
        view.displayContact(model);
    }
}

以上代码仅展示了MVC模式的基本结构，但在实际的通讯录应用开发中，我们需要根据具体需求扩展模型、视图和控制器的功能。例如，视图可能需要显示联系人列表，并提供添加、删除联系人的操作。模型需要管理联系人的数据结构和存储逻辑，控制器则需要处理用户输入并协调模型和视图之间的数据流转。

在下一章中，我们将深入探讨MVC设计模式的细节，并通过具体的代码示例来展示如何在Java中实现MVC模式。

2. MVC设计模式基础应用

2.1 MVC模式的基本概念

2.1.1 MVC的定义与组成

MVC（Model-View-Controller）设计模式是软件工程中一个非常流行的架构模式，它将应用程序分成三个核心组件：模型（Model）、视图（View）和控制器（Controller）。这种设计模式的主要目的是实现业务逻辑与用户界面的分离，从而提高系统的可维护性和可扩展性。

  • 模型（Model） ：负责业务数据和业务逻辑的处理。它是应用程序的核心部分，所有的数据处理逻辑都应该在这里实现。模型对数据进行管理，响应数据请求，并且能够通过控制器与视图进行通信。
  • 视图（View） ：负责展示模型中的数据给用户。它为用户提供交互界面，是用户看到并与之交互的界面。在Web开发中，视图通常是HTML、CSS和JavaScript等构成的前端页面。
  • 控制器（Controller） ：作为模型和视图之间的中间件，它负责接收用户的输入并调用模型和视图去完成用户请求。控制器解析用户的输入，选择相应的模型进行处理，并且选择视图来显示处理结果。

在Java中实现MVC模式，通常需要遵循以下步骤：

  1. 创建模型类：这些类通常包含数据和操作数据的业务逻辑方法。
  2. 创建视图类：这些类包含用于显示数据的组件，以及处理用户输入的事件处理代码。
  3. 创建控制器类：这些类负责处理用户输入，调用模型更新数据，并根据更新的数据选择视图进行显示。
2.1.2 MVC在Java中的实现

在Java中，可以利用Swing或JavaFX等图形用户界面库来实现MVC模式。在Swing应用程序中，可能会有一个 JFrame 的子类作为视图， JPanel 的子类作为视图的组件，模型类可能只是普通的Java对象，而控制器通常是包含事件处理逻辑的监听器对象。

下面是一个简单的Swing MVC实现示例：

// Model.java
public class Model {
    private String data;

    public void setData(String data) {
        this.data = data;
        this.notifyListeners();
    }

    public String getData() {
        return data;
    }

    private final List<ModelChangeListener> listeners = new ArrayList<>();

    public void addChangeListener(ModelChangeListener listener) {
        this.listeners.add(listener);
    }

    private void notifyListeners() {
        for (ModelChangeListener listener : this.listeners) {
            listener.onModelChange(this);
        }
    }
}

// ModelChangeListener.java
public interface ModelChangeListener {
    void onModelChange(Model model);
}

// View.java
public class View extends JFrame implements ModelChangeListener {
    private Model model;

    public View(Model model) {
        this.model = model;
        this.model.addChangeListener(this);
        this.add(new DataPanel());
        this.setSize(200, 100);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setVisible(true);
    }

    @Override
    public void onModelChange(Model model) {
        DataPanel panel = (DataPanel) this.getContentPane();
        panel.updateUI(model.getData());
    }
}

// DataPanel.java
public class DataPanel extends JPanel {
    private JLabel label;

    public DataPanel() {
        this.label = new JLabel("Initial data");
        this.add(label);
    }

    public void updateUI(String data) {
        this.label.setText(data);
    }
}

// Main.java
public class Main {
    public static void main(String[] args) {
        Model model = new Model();
        new View(model);
        model.setData("Updated data");
    }
}

在这个简单的例子中， Model 是核心数据和逻辑的持有者， View 是用户的交互界面，而 View 类实现了 ModelChangeListener 接口，这样当 Model 的数据发生变化时， View 可以得到通知并更新显示内容。 DataPanel 是 View 的具体实现，它负责将数据渲染到界面上。

2.2 MVC模式的优势与实践

2.2.1 提高代码的可维护性与可扩展性

MVC模式的一个显著优势是它将应用程序划分成多个独立的部分，这种分离使得每个部分都可以独立地修改、扩展和测试，而不会影响到其他部分。例如，如果需要更换用户界面的风格，只需要修改视图层的代码而无需触及模型和控制器，反之亦然。这种分离不仅减少了各部分之间的依赖性，还使得软件更加灵活和可维护。

此外，MVC模式通常会伴随着“关注点分离”原则的应用，这也意味着不同的开发者可以同时在不同的层面上工作，从而提高开发效率。例如，设计师和前端开发人员可以专注于视图的开发，而后端开发人员可以专注于模型和控制器的开发。

2.2.2 MVC在本项目中的具体应用案例

在本章开头的简单Swing应用程序示例中，我们可以看到MVC模式在实际项目中是如何应用的。模型 Model 类负责数据的存储和更新，视图 View 负责展示数据和响应用户交互，而控制器是通过 ModelChangeListener 接口隐式实现的，它在模型数据更新时通知视图进行相应的界面更新。

在更复杂的项目中，MVC的应用可能会更加复杂，但基本原理是相同的。例如，在Web应用中，模型可能是数据库的ORM映射对象，视图可能是HTML模板，而控制器可能是处理HTTP请求的Servlet类。这种方式使得项目结构清晰，便于不同角色的开发人员协同工作。

在Java中实现MVC模式的实践中，开发者可以根据项目需求进行灵活的调整。有时候，视图和控制器可能会合并为一个组件，特别是在一些简单的GUI应用程序中，为了简化设计，可能会选择将它们整合到一起。而在大型的企业级应用中，则可能进一步细化模型和控制器，以支持更复杂的业务逻辑和数据处理需求。

MVC模式在各种Java框架和应用中都有广泛的应用，从桌面应用程序到Web应用程序，MVC都是一种行之有效的设计模式。通过这种模式，开发者可以构建出易于理解和维护的代码结构，从而提高软件的整体质量和开发效率。

3. Android SDK与API使用

3.1 Android SDK的安装与配置

3.1.1 安装Android SDK

Android SDK（Software Development Kit）是开发Android应用的软件开发工具包，它包含了一系列用于开发Android应用的库文件以及调试和测试应用的工具。安装Android SDK是开始Android开发的首要步骤。

在安装Android SDK之前，确保你的开发环境满足以下基本要求：
- Java Development Kit (JDK) 版本至少为1.8。
- 一个支持Java的IDE，如Android Studio。
- 一台连接到互联网的电脑。

安装步骤如下：
1. 下载SDK ：前往Android开发者官网下载最新版本的SDK。
2. 解压缩 ：将下载的压缩包解压到你选择的文件夹路径中。
3. 配置环境变量 ：将SDK的路径添加到系统的环境变量中，具体方法根据操作系统有所不同，但主要步骤包括编辑系统的PATH变量，加入SDK中的 tools 和 platform-tools 文件夹路径。
4. 安装额外组件 ：运行SDK Manager，安装额外的组件，比如Android平台、构建工具等。

在安装过程中，你可能需要配置一些额外的选项，如安装位置、额外组件的安装等。根据个人需要和网络条件选择合适的版本和工具包进行安装。

3.1.2 配置开发环境

配置Android开发环境是确保能够顺畅进行应用开发的重要一步。这一步骤通常包括以下几个方面：

  1. 安装Android Studio ：访问Android开发者网站下载并安装Android Studio。它是Google官方推荐的Android应用集成开发环境，它内置了Android SDK，能大大简化开发环境的配置过程。

  2. 启动Android Studio ：首次启动Android Studio时，它会引导你完成创建新的项目或导入现有项目的过程。在此过程中，Android Studio还会自动检查并下载所需的SDK组件。

  3. 设置虚拟设备 ：为了在没有实际设备的情况下测试应用，Android Studio允许你创建并配置虚拟设备（AVD）。通过AVD Manager，你可以创建多种模拟器配置，模拟不同Android版本和硬件环境。

  4. 配置SDK Manager ：为了确保你有所有需要的API级别和工具，检查并更新SDK Manager中的包。这里包括最新的平台、构建工具、第三方库等。如果在使用过程中发现缺少特定组件，可随时通过Android Studio中的SDK Manager进行安装或更新。

在完成以上步骤后，你应该已经具备了一个完整的Android开发环境，接下来就可以开始你的Android应用开发之旅了。

3.2 Android API的探索与应用

3.2.1 认识Android API

Android API是一套由Google提供的预定义类和方法集，它们允许开发者编写可以访问Android系统功能的代码。这些API不仅覆盖了从用户界面到后台服务的广泛范围，还包括硬件访问、多媒体、网络通信等众多方面。

在使用Android API之前，建议先熟悉一下它们的基本结构和分类：

  • 用户界面API ：涉及所有UI组件，如Activity、View、ViewGroup、Button等。
  • 硬件访问API ：提供对设备硬件访问的接口，例如LocationManager用于获取位置信息，SensorManager用于访问传感器数据。
  • 多媒体API ：包括Camera类用于操作相机，MediaPlayer用于处理音频和视频媒体。
  • 网络通信API ：如HttpURLConnection和Volley等用于数据的上传和下载。
  • 数据存储API ：例如SharedPreferences、SQLite数据库、ContentProvider等。
  • 辅助服务API ：如AlarmManager用于设置闹钟，NotificationManager用于发送通知等。

3.2.2 选择合适的API进行开发

在面对众多API时，开发者需要根据应用需求和目标平台选择合适的API进行开发。选择合适的API不仅关系到应用的功能实现，还会影响到应用的性能和兼容性。

在选择API时应该考虑以下因素：

  • 应用需求 ：首先明确你的应用需要实现哪些功能，然后挑选能够满足这些需求的API。例如，如果你的应用需要拍照功能，那么Camera API是你的不二选择。

  • 目标平台 ：不同的Android API版本支持不同的功能。例如，Material Design风格只在较新的Android版本中才完全支持。因此，你需要根据目标设备的Android版本来选择API。

  • 性能考虑 ：某些API提供不同的性能选择。例如，如果你的应用需要处理大量数据，可能需要使用CursorLoader而不是Cursor来提高应用性能。

  • 未来兼容性 ：随着Android版本的迭代更新，某些API可能会被废弃。因此，在选择API时应考虑到未来的兼容性问题。

举个简单的例子，如果你正在开发一个需要访问联系人信息的应用， ContactsContract 和 ContentResolver 将是你的主要API。通过它们，你可以查询联系人信息，甚至修改、删除联系人。

// 示例代码：查询联系人信息
public void getContactList() {
    ContentResolver cr = getContentResolver();
    Cursor cursor = cr.query(ContactsContract.Contacts.CONTENT_URI,
                            null, null, null, null);

    if (cursor != null) {
        while (cursor.moveToNext()) {
            String id = cursor.getString(cursor.getColumnIndex(ContactsContract.Contacts._ID));
            String name = cursor.getString(cursor.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME));
            // 根据需要进行进一步处理，例如显示联系人信息
        }
        cursor.close();
    }
}

通过上述章节的介绍，我们深入理解了Android SDK和API的安装、配置与应用。这为进一步的Android应用开发打下了坚实的基础，接下来的章节将会带领大家深入了解Android界面组件的应用和数据处理等更多高级话题。

4. Android界面组件的应用

Android 应用的用户界面是与用户进行交互的最直接方式。第四章将详细介绍 Android 界面组件的应用，包括 Activity 的生命周期管理和数据传递、XML 布局文件的结构与使用，以及 Adapter 如何将数据与 UI 进行绑定。本章节将深入探讨这些组件的高级应用，以及如何优化用户界面，使之更加生动和友好。

4.1 Android Activity的应用和管理

4.1.1 Activity生命周期

Activity 是 Android 应用中负责与用户直接交互的一个组件，它具有自己的生命周期，这个生命周期包括几个关键状态：创建（Creation）、启动（Start）、恢复（Resume）、暂停（Pause）、停止（Stop）和销毁（ Destruction）。理解并正确管理 Activity 生命周期，对于开发稳定且用户友好的应用至关重要。

生命周期方法
  • onCreate() : Activity 创建时调用，用于初始化设置，如加载布局、绑定数据等。
  • onStart() : Activity 对用户可见时调用，紧接着 onCreate() 或 onRestart() 。
  • onResume() : Activity 开始与用户交互前调用。
  • onPause() : 当另一个 Activity 启动并覆盖当前 Activity 时调用。
  • onStop() : 当 Activity 不再对用户可见时调用。
  • onDestroy() : Activity 被销毁前调用，通常用于清理资源。
public class MyActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_my);
        // 初始化 UI 和绑定数据
    }

    @Override
    protected void onStart() {
        super.onStart();
        // Activity 开始对用户可见
    }

    @Override
    protected void onResume() {
        super.onResume();
        // Activity 可以与用户进行交互
    }

    @Override
    protected void onPause() {
        super.onPause();
        // Activity 不再获得焦点，但仍可见
    }

    @Override
    protected void onStop() {
        super.onStop();
        // Activity 不再对用户可见
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        // Activity 销毁前，执行清理工作
    }
}

在上述代码中，每个生命周期方法都有一个默认的实现，我们通过覆盖它们来自定义行为。例如，在 onCreate() 中，我们通常会初始化应用的界面布局，并且配置一些初始数据。值得注意的是，在 onPause() 或 onStop() 方法中，应该处理好如保存数据、取消网络请求等清理操作，以保证应用的流畅和数据的安全。

4.1.2 Activity间的数据传递

当一个 Activity 需要启动另一个 Activity 并传递数据时，可以利用 Intent 对象。Intent 在 Activity 之间传递信息时扮演着消息传递者的角色。

Intent intent = new Intent(CurrentActivity.this, NextActivity.class);
intent.putExtra("key", "value");
startActivity(intent);

在上述代码中， CurrentActivity 通过创建一个指向 NextActivity 的 Intent，使用 putExtra() 方法添加需要传递的数据，然后调用 startActivity() 方法启动新 Activity。 NextActivity 可以通过 getIntent() 方法获取启动它的 Intent，并使用 getStringExtra() 方法来接收传递的数据。

4.2 XML布局文件定义Android界面

4.2.1 XML布局的结构与元素

XML布局文件用于定义应用用户界面的布局结构，它描述了界面的视图层级。在 Android 中，我们使用 XML 布局文件来设计用户界面，并通过各种布局管理器来管理组件的位置和大小。常用的布局有 LinearLayout、RelativeLayout、FrameLayout 等。

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <TextView
        android:id="@+id/textView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World!" />

    <Button
        android:id="@+id/button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Click Me" />
</LinearLayout>

上述代码展示了一个垂直线性布局，其中包含一个 TextView 和一个 Button。 android:layout_width 和 android:layout_height 属性分别控制布局和组件的宽度和高度。 android:orientation 属性定义了 LinearLayout 的方向，垂直或水平。

4.2.2 设计响应式布局的方法

为了提升用户体验，Android 应用界面需要能够适应不同屏幕尺寸和方向。设计响应式布局通常会使用到布局权重、dp 单位、视图的可见性控制等技巧。

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:weightSum="1">

    <TextView
        android:id="@+id/textView"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_weight="0.7"
        android:text="This is a responsive layout."
        android:textSize="18sp" />

    <Button
        android:id="@+id/button"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_weight="0.3"
        android:text="Click Me"
        android:textSize="16sp" />
</LinearLayout>

在这个例子中，使用 weightSum 属性定义了子视图可以分配的总权重，而 layout_weight 属性则定义了子视图在可用空间中应该占据的比例。这使得无论设备屏幕大小如何变化，界面元素都能按比例进行调整，从而保持布局的一致性。

4.3 数据与UI绑定的Adapter使用

4.3.1 Adapter模式简介

Adapter 模式是设计模式中的一种，主要用于将一个类的接口转换成客户希望的另外一个接口。在 Android 开发中，Adapter 用于在数据集合和 UI 组件之间进行适配。

例如，在 ListView 或 GridView 中使用 Adapter 来填充数据。最常用的 Adapter 包括 ArrayAdapter、CursorAdapter 和 BaseAdapter。其中，BaseAdapter 是最通用的一个适配器，因为它提供了所有必要的方法来实现自己的适配器。

4.3.2 实现数据与UI绑定的实例

假设我们要为一个简单的新闻应用实现一个新闻列表界面，可以使用 ArrayAdapter 将新闻标题列表绑定到 ListView 上。

// 定义一个新闻对象类
public class News {
    private String title;

    public News(String title) {
        this.title = title;
    }

    public String getTitle() {
        return title;
    }
}

// 在 Activity 中使用 ArrayAdapter
public class NewsActivity extends AppCompatActivity {
    private ListView listView;
    private List<News> newsList = new ArrayList<>();

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

        listView = findViewById(R.id.listView);

        // 添加一些测试数据
        newsList.add(new News("Android 12 Launch"));
        newsList.add(new News("Kotlin for Android"));
        newsList.add(new News("Jetpack Compose Tutorial"));

        // 初始化 ArrayAdapter
        ArrayAdapter<News> arrayAdapter = new ArrayAdapter<>(this,
                android.R.layout.simple_list_item_1, newsList);

        // 将 adapter 绑定到 listView
        listView.setAdapter(arrayAdapter);
    }
}

在这个例子中，我们首先定义了一个 News 类，然后在 NewsActivity 中创建了几个 News 实例并添加到列表中。我们使用 ArrayAdapter 将这个列表绑定到 ListView 。 ArrayAdapter 的构造函数接受三个参数：当前的 Context、列表项的布局模板和数据集合。最后，通过调用 setAdapter() 方法将 ArrayAdapter 实例与 ListView 关联起来。

通过以上步骤，我们成功将数据集合与 UI 组件进行了绑定，实现了数据驱动 UI 的效果。这种数据与视图的分离方式，不仅提高了代码的可维护性，还使得 UI 更加灵活。

5. Android持久化存储解决方案

持久化存储是移动应用开发中不可或缺的部分，它保证了数据的长期保存，即使应用被关闭后也能恢复。在Android平台上，最常见的持久化存储方式有SQLite数据库和ContentProvider。本章节将深入探讨这些技术的实现和优化。

5.1 SQLite数据库在Android中的应用

5.1.1 SQLite基础介绍

SQLite是一个轻量级的数据库，它不需要一个单独的服务器进程或系统，可以直接嵌入应用程序中使用。在Android平台上，SQLite被广泛应用于应用数据的持久化存储。它可以存储结构化数据，并提供了SQL语言支持，便于操作数据。

SQLite数据库是使用文件存储形式，每个数据库都对应一个文件。这些数据库文件的扩展名为 .db ，默认保存在应用的私有目录中，即 /data/data/<package_name>/databases/ 。这意味着，除非应用具有root权限，否则其他应用无法访问这些数据库文件。

5.1.2 Android中SQLite的使用方法

在Android中操作SQLite数据库，可以使用 SQLiteDatabase 类提供的API。这包括创建、打开、读写数据库以及关闭数据库。

SQLiteDatabase db = null;
try {
    db = openOrCreateDatabase("myDatabase", Context.MODE_PRIVATE, null);
    // 执行数据库操作，如创建表、插入数据等
} catch (SQLiteException e) {
    e.printStackTrace();
} finally {
    if (db != null) {
        db.close();
    }
}

上述代码创建或打开一个名为 myDatabase 的数据库，并保持私有访问权限。需要注意的是，数据库操作应该放在合适的生命周期内，比如 onCreate() 方法中，并且要确保在操作完成后关闭数据库连接。

5.1.3 创建和使用自定义SQLiteOpenHelper

为了更好地管理数据库版本和操作，通常会自定义一个继承自 SQLiteOpenHelper 的类。该类中包含两个重要的回调方法： onCreate(SQLiteDatabase db) 和 onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) 。

public class DatabaseHelper extends SQLiteOpenHelper {

    private static final String DATABASE_NAME = "myDatabase";
    private static final int DATABASE_VERSION = 1;

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

    @Override
    public void onCreate(SQLiteDatabase db) {
        db.execSQL("CREATE TABLE IF NOT EXISTS contacts (" +
                "id INTEGER PRIMARY KEY AUTOINCREMENT," +
                "name TEXT, " +
                "phone_number TEXT)");
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        db.execSQL("DROP TABLE IF EXISTS contacts");
        onCreate(db);
    }
}

在 onCreate 方法中创建表结构，如果数据库版本发生变化（比如添加新的字段）， onUpgrade 方法会被调用，你可以在此方法中执行数据库结构的更新操作。

5.1.4 数据的CRUD操作

数据的创建（Create）、读取（Read）、更新（Update）和删除（Delete）操作是SQLite数据库操作的核心。

SQLiteDatabase db = null;
try {
    db = getWritableDatabase();
    ContentValues values = new ContentValues();
    values.put("name", "John");
    values.put("phone_number", "1234567890");

    // Insert
    long newRowId = db.insert("contacts", null, values);

    // Read
    Cursor cursor = db.query("contacts", new String[] { "name", "phone_number" },
            null, null, null, null, null);
    if (cursor.moveToFirst()) {
        String name = cursor.getString(cursor.getColumnIndex("name"));
        String phoneNumber = cursor.getString(cursor.getColumnIndex("phone_number"));
    }

    // Update
    values.clear();
    values.put("phone_number", "0987654321");
    int rowsUpdated = db.update("contacts", values,
            "name = ?",
            new String[] { "John" });

    // Delete
    db.delete("contacts", "name = ?", new String[] { "John" });
} catch (Exception e) {
    e.printStackTrace();
} finally {
    if (db != null) {
        db.close();
    }
}

5.1.5 参数说明和执行逻辑

在执行数据库操作时，需要提供相应的参数。例如，在 query 方法中，第一个参数是表名，第二个参数指定需要查询的列，接下来的参数是用于筛选的where子句以及where子句中占位符的值。

以上代码段展示了如何创建一个数据库并进行简单的CRUD操作。这些操作应该在合适的线程中执行，例如在Android中通常会在一个单独的线程或者使用 AsyncTask 来避免阻塞UI线程。

5.2 ContentProvider在数据共享中的作用

5.2.1 ContentProvider概述

ContentProvider 是Android中用于在不同应用之间共享数据的接口。它提供了一套标准的API，使得其他应用可以通过内容解析器（Content Resolver）来访问数据，而不必关心数据的存储细节。

使用 ContentProvider 可以共享的数据包括图片、音频、视频文件，以及联系人信息等。 ContentProvider 对外提供统一的视图（URI），其他应用通过这个视图来访问数据。

5.2.2 创建和使用自定义ContentProvider

创建自定义 ContentProvider ，需要继承 ContentProvider 类并实现其六个抽象方法： query 、 insert 、 delete 、 update 、 getType 和 onCreate 。

public class MyContentProvider extends ContentProvider {
    public static final String AUTHORITY = "com.example.myapp.MyContentProvider";

    @Override
    public boolean onCreate() {
        return true;
    }

    @Override
    public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
        // 根据uri确定数据源，执行查询操作，并返回Cursor
    }

    @Override
    public Uri insert(Uri uri, ContentValues values) {
        // 执行数据插入操作，并返回新插入数据的URI
    }

    @Override
    public int delete(Uri uri, String selection, String[] selectionArgs) {
        // 执行数据删除操作
    }

    @Override
    public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
        // 执行数据更新操作
    }

    @Override
    public String getType(Uri uri) {
        // 返回数据MIME类型
    }
}

5.2.3 ContentResolver的使用

客户端应用通过 ContentResolver 来与 ContentProvider 交互。可以调用 query() 、 insert() 、 delete() 、 update() 等方法来进行数据操作。

ContentResolver contentResolver = getContentResolver();
Uri uri = Uri.parse("content://com.example.myapp.MyContentProvider/contacts");

Cursor cursor = contentResolver.query(uri, new String[] { "name", "phone_number" }, null, null, null);
if (cursor != null && cursor.moveToFirst()) {
    String name = cursor.getString(cursor.getColumnIndex("name"));
    String phoneNumber = cursor.getString(cursor.getColumnIndex("phone_number"));
    cursor.close();
}

5.2.4 共享数据的安全性和效率

ContentProvider 对外共享数据时，需要考虑数据的安全性。Android为 ContentProvider 提供了权限系统，可以在 AndroidManifest.xml 中声明不同的权限，以控制不同应用对数据的访问。

此外，为了保证数据访问的效率，应该在 ContentProvider 中合理使用缓存机制，并且在不需要的时候及时关闭 Cursor 。

通过本章节的介绍，我们可以看到SQLite和ContentProvider在Android平台进行持久化存储和数据共享中扮演着核心角色。理解并掌握它们的实现机制和使用方法，对于构建健壮、高效、可维护的Android应用至关重要。

6. Android组件间通信与权限管理

6.1 Intent在Android组件间通信的使用

6.1.1 Intent的基本概念与分类

在Android开发中，Intent是一种消息传递机制，用于实现组件间的通信。它可以启动一个活动（Activity）、一个服务（Service）或者发送广播（Broadcast）。Intent允许组件之间进行交互，无论是应用内部还是跨应用。

Android中的Intent可以分为显式Intent和隐式Intent两种：

  • 显式Intent明确指定了要启动的组件的类名。通常用于应用内部的组件跳转。
  • 隐式Intent则不指定具体的目标组件，而是通过一系列的描述性参数（如action, category, data等）来表明需要执行的操作。系统会根据这些描述信息，决定哪个组件可以处理这个Intent。

6.1.2 实现组件间通信的示例

以下是一个简单的示例，演示了如何使用Intent在两个Activity之间传递数据。

// 在当前Activity中启动另一个Activity并传递数据
Intent intent = new Intent(CurrentActivity.this, TargetActivity.class);
intent.putExtra("extra_data", "Hello, Android!");
startActivity(intent);

在 TargetActivity 中，我们可以通过以下方式接收传递的数据：

// 在TargetActivity中获取传递过来的数据
Intent intent = getIntent();
String receivedData = intent.getStringExtra("extra_data");

6.1.3 Intent的高级用法

除了基本的组件间通信，Intent还可以用于执行广播、服务绑定、内容解析等高级功能。以下是一个Intent用于发送广播的示例：

Intent broadcastIntent = new Intent("com.example.CUSTOM_INTENT");
broadcastIntent.putExtra("data_key", "data_value");
sendBroadcast(broadcastIntent);

在这段代码中，我们创建了一个自定义的Intent，然后通过 sendBroadcast() 方法发送广播。

6.2 Android权限管理实践

6.2.1 Android权限模型

Android是一个以安全为核心的操作系统，权限模型是其安全体系的重要组成部分。在Android中，应用必须在清单文件（AndroidManifest.xml）中声明需要使用的权限，系统会在应用运行时对权限进行控制。

Android权限分为两类：

  • 应用权限（Application Permissions）：这些权限被应用声明，系统会提示用户授予权限。
  • 系统权限（System Permissions）：这些权限已经预定义在系统中，并且需要设备管理员的授权。

6.2.2 自定义权限与权限请求示例

在一些情况下，应用需要使用自定义权限来限制对某些组件或数据的访问。以下是如何声明自定义权限和请求权限的示例。

首先，在 AndroidManifest.xml 中声明自定义权限：

<permission android:name="com.example.custom_permission"
            android:label="@string/permission_label"
            android:protectionLevel="normal"/>

然后，在需要权限的组件上使用 <uses-permission> 标签声明：

<uses-permission android:name="com.example.custom_permission"/>

在代码中，使用 checkCallingOrSelfPermission() 方法检查是否拥有权限：

String permissionName = "com.example.custom_permission";
int hasPermission = checkCallingOrSelfPermission(permissionName);
if (hasPermission == PackageManager.PERMISSION_GRANTED) {
    // 已授予权限，执行相关操作
} else {
    // 未授予权限，请求权限
    requestPermissions(new String[]{permissionName}, PERMISSION_REQUEST_CODE);
}

当请求权限时，需要处理用户的权限授予结果：

@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
    if (requestCode == PERMISSION_REQUEST_CODE) {
        if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
            // 权限被用户授予权限，可以执行操作
        } else {
            // 权限被用户拒绝，可以根据需要处理
        }
    }
}

在这一节中，我们详细介绍了Intent在组件间通信中的应用，并深入探讨了Android权限模型及其管理实践。这些知识对于构建安全且功能丰富的Android应用至关重要。

7. Android UI组件和事件监听

7.1 Android UI组件的使用

7.1.1 常用UI组件介绍

在Android开发中，用户界面(UI)组件是构建交互式应用的基石。一些常用的UI组件包括：

  • TextView : 显示文本信息。
  • Button : 触发用户点击事件的按钮。
  • ImageView : 显示图片的组件。
  • EditText : 用户输入文本的组件。
  • CheckBox : 提供勾选功能，表示多个选项中的一个。
  • RadioButton : 在一组选项中选择一个。
  • ListView : 列表形式展示数据，适用于滚动显示大量信息。

7.1.2 UI组件的布局与样式定制

组件的布局和样式定制是通过XML布局文件和Java代码共同完成的。

XML布局

在XML布局文件中，我们可以定义UI组件的结构和属性。例如：

<LinearLayout
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:orientation="vertical"
    android:padding="16dp">

    <TextView
        android:id="@+id/textView_title"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Title"
        android:textSize="24sp"/>

    <Button
        android:id="@+id/button_click"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Click Me"/>

    <!-- 其他组件... -->
</LinearLayout>
Java代码样式定制

在Java代码中，我们可以进一步定制组件的样式和行为。例如，改变按钮的文本大小：

Button button = findViewById(R.id.button_click);
button.setTextSize(18);

7.2 Android UI事件监听与处理

7.2.1 事件监听机制概述

UI事件监听是响应用户交互操作的核心机制。在Android中，常见的事件监听包括：

  • OnClickListener : 用于监听点击事件。
  • OnLongClickListener : 用于监听长按事件。
  • OnTouchListener : 监听触摸事件，包括触摸开始、移动和结束。
  • TextWatcher : 监听文本的变化，适用于EditText组件。

7.2.2 编写事件处理代码的示例

下面是一个简单的事件处理示例，展示了如何为一个按钮添加点击事件的监听器：

Button button = findViewById(R.id.button_click);

button.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        // 用户点击按钮后执行的代码
        Toast.makeText(getApplicationContext(), "Button clicked!", Toast.LENGTH_SHORT).show();
    }
});

在上述代码中，我们使用 setOnClickListener 方法为按钮设置了一个点击事件监听器。当用户点击按钮时，会触发 onClick 方法，并显示一个短暂的提示消息。

按钮样式调整

进一步地，我们可以在事件处理代码中调整按钮的样式：

button.setBackgroundColor(Color.RED); // 设置背景颜色为红色
button.setTextColor(Color.WHITE); // 设置文本颜色为白色

通过监听器，我们不仅可以执行简单的显示提示任务，还可以根据用户的交互触发更为复杂的数据处理和界面更新逻辑。

总结上文，我们介绍了如何在Android中使用各种UI组件并定制它们的布局和样式，以及如何监听和处理用户的交互事件，从而构建一个功能完善且用户友好的应用界面。

本文还有配套的精品资源，点击获取 menu-r.4af5f7ec.gif

简介：Java通讯录手机版源码是一款利用Java语言开发的通讯录应用，突显Java的跨平台特性。它提供了标准的联系人管理功能，且基于MVC设计模式构建。源码解析涉及Android SDK、Activity、SQLite数据库、ContentProvider、Intent、XML布局文件、Adapter、权限管理、UI组件和事件监听等关键开发知识点，适合学习和提升Android应用开发技巧。


本文还有配套的精品资源，点击获取
menu-r.4af5f7ec.gif

Logo
亚马逊云科技技术品牌专区

更多推荐

2026年AI大模型API聚合平台深度横评：六大中转站能力维度拆解与选型指南

然而市场上的API聚合平台林立，技术选型信息繁杂。本文从协议兼容性、模型覆盖、并发能力、计费透明度与企业级功能五个维度，对OpenRouter、硅基流动、星链4SAPI、阿里云百炼、移动MOMA和Vercel AI Gateway展开横向对比，帮助架构师与决策者厘清差异，匹配实际业务需求。2026年的API聚合与AI中转服务已形成差异化生态：有的以算力优势推动开源普惠，有的以云原生合规支撑政企重构

avatar 亚马逊云科技技术品牌专区
cover

AI电话系统技术选型：语音识别精度、高并发调度与CRM集成评估

avatar 亚马逊云科技技术品牌专区
cover

一文带你了解人工智能顶会ICML 2026 获奖论文

avatar 亚马逊云科技技术品牌专区