安卓初学者入门指南-一-

安卓初学者入门指南（一）

原文：Android for Absolute Beginners

协议：CC BY-NC-SA 4.0

一、Android 简介

欢迎开始您的 Android 开发者之旅。也许你已经拥有并使用一部安卓手机、平板电脑或其他设备。你将置身于一个伟大的公司，全世界每天都有超过 10 亿台基于 Android 操作系统的设备在使用。即使你认为你还没有使用 Android，你可能会惊讶地发现它已经进入了一系列惊人的设备和产品，其中许多你可能已经使用过，甚至没有意识到 Android 的强大功能正在帮助你。

Android 现在为手机和平板电脑之外的一系列设备提供支持，包括智能手表、健身设备、汽车娱乐和导航系统、游戏控制台、玩具、厨房电器、花园浇水系统、管道和加热控制，甚至烧烤！是的，烧烤！使用安卓系统的设备的扩张没有放缓的迹象，但最受欢迎和最有可能找到安卓系统的地方仍然是手机和平板电脑。作为一名初露头角的 Android 开发人员，这意味着您将学习适用于这里提到的所有(或至少许多)设备类型的许多方面，但您最初的重点可能是学习如何为 Android 手机和平板电脑构建应用。

使用 Android:最好的部分

移动和智能手机的发展是过去十年或更长时间里最激动人心的技术故事之一。你可能没有亲身经历过每一个转折，但你很可能接触过一个或多个最近智能手机时代的设备，你可能听说过诺基亚、苹果、微软、谷歌和安卓等名字在许多组合中被提及。

今天，Android 向您展示了从过去 10 年这些公司和平台之间的所有重大技术大战中获得的好处，并让您驾驭这一浪潮，提供出色的工具、功能，并帮助您走上 Android 应用开发的道路。在本书撰写之际，这或许是 Android 目前最具吸引力的地方。它与所有智能手机和移动技术(以及苹果的 iOS)并驾齐驱，选择 Android，您可以立即获得它提供的优势，包括

1. 开发者工具和平台:我们将在本书中讨论这些项目，包括 Android Studio、Android SDK、Google Play 服务和 Google Play 在线商店等等。

2. 一个巨大的现有市场:当我说超过 10 亿的用户在等待你的应用时，我不是在开玩笑，还有更多潜在的未来用户在地平线上。如图 1-1 所示，Android 的全球市场渗透率令人惊叹。

3. 一个由志同道合的开发者组成的全球社区:你并不是一个人在追求你的 Android 应用开发梦想。有几万、几十万甚至可能几百万其他开发者有经验可以分享。

4. A rock-solid technology foundation: Android started life using the Java programming language as the predominant technology with which to build applications. Today it also supports Kotlin and C++. We will stick to Java for the examples and techniques explored in this book, as it is one of the most widely used, widely respected, and mature development technologies in existence – the vast majority of Android applications are built with Java.

   

   图 1-1

   Android 在智能手机用户中的全球市场份额

我可以继续列举更多关于 Android 开发世界的广度和深度及其优势的例子，但是我将让本书的其余部分来帮助演示更多的例子。

使用 Android:挑战

如果我不指出 Android 在许多方面都是幸运的，但也有挑战，我就不会诚实。好消息是，这些挑战中有许多是众所周知的，也很容易解决。以下是新开发人员可能很快就会遇到的一些领域:

1. 你正在开发小型设备。无论我们谈论的是 Android 手机、Android 平板电脑、车载仪表盘，还是一系列其他外形因素，你需要处理的一个常见约束是屏幕的大小。当我们讨论用虚拟设备模拟 Android 设备时，我们将深入探讨这个主题，但请始终记住，您坐在为 Android 构建的台式机或笔记本电脑上的体验与您的用户在手机和平板电脑上的体验是不同的。

2. 超越屏幕思考。不要让小屏幕成为你在应用中提供强大特性和超酷功能的唯一途径！正如您将看到的，后面的章节将探讨声音和音频、车载传感器、振动等内容。不要成为屏幕的俘虏——你有更多的工具可以使用。

3. 替代品只需轻轻一扫。每个拥有安卓设备的人——实际上是任何智能手机——都有许多应用的第一手经验。用户可以选择，而且用户还可以在手机上运行一系列其他应用。这意味着您的应用可能会共享资源和用户的注意力，用户可以做各种您从未想过的事情！

4. 安卓并不总是安卓。我们将在本书中涵盖 Android 的最新版本，包括 Android 版本 11，在撰写本文时它已有近一年的历史，并预览 Android 版本 12，它将在今年晚些时候发布，作为谷歌 Android 更新的典型年度发布周期的一部分。然而，在市场上，我在本章前面提到的十亿甚至更多的用户正在使用早期的 Android 版本。不仅仅是 Android 10 或 Android 9，而是可以追溯到 Android 4 甚至更早的版本！在鼓励(甚至允许)用户升级方面，Android 有着复杂的历史，在决定瞄准这个十亿用户市场的时候，这一点要记住。

无论你做什么，都不要因为这几点而灰心丧气。当你开始开发 Android 应用时，更多地把它们看作是要学习的第一套课程。

了解 Android 的传统及其对您的影响

Android 可以追溯到 2003 年，那一年 10 月，帕洛阿尔托的一群开发人员聚在一起，使用 Linux 内核作为他们梦想的具有更强大界面的设备新时代的基础。在经历了成长期的挣扎后，谷歌于 2005 年收购了 Android 业务，其前联合创始人安迪·鲁宾加入谷歌，继续为智能手机和其他设备开发操作系统。

2008 年，在经历了几次失败后，谷歌及其合作伙伴 HTC 和 T-Mobile 发布了第一款手机，被称为“梦想”或“G1”，这取决于你在哪个国家。我自己的 G1 至今仍在运行，但不再是我的日常电话。图 1-2 显示了我的 G1 在原始锁定屏幕。

图 1-2

作者最初的 G1 安卓手机，来自 2008 年

在第一次发布之后，Android 的势头慢慢增强，操作系统的更新开始以甜点的名字作为代号出现——纸杯蛋糕、甜甜圈、艾克蕾尔等等，代表版本 1.5、2.0 和 2.1。

在第一次公开发布的时候，谷歌还与电信公司、芯片公司和手机制造商合作创建了开放手机联盟，旨在建立一个广泛的联盟来支持 Android 的未来。谷歌还建立了“安卓开源项目”，作为安卓基础开源代码的保管人。

随着许多新版本的软件和许多新制造商的加入，Android 的故事还有很多。但是以上几点是 Android 开发者在构建应用时必须应对的几个问题的未知开端。

随着许多公司开始制造基于 Android 的手机，谷歌并不直接控制如何在每个制造商的设备上维护 Android，也不直接控制主要市场的电信公司如何作为合同、销售等的一部分管理手机的消费者生命周期。在 Android 最初发布后的几年里，出现了一个有许多不同设备的市场，运行许多不同版本的 Android，升级保证非常不完整。这在 Android 世界中被称为碎片问题。

对于开发人员来说，这意味着为 Android 构建应用需要付出额外的努力，考虑野外设备的数量以及它们运行的 Android 版本。在写这本书的时候，谷歌已经做出了一系列努力来减少这种担忧，并鼓励制造商升级设备。这产生了一些影响。Google 还增加了一系列开发人员特性，以减轻开发人员处理这个变化多端的市场所需的工作量，我们将在后面的章节中讨论其中的几个特性。

在结束这个话题时，图 1-3 显示了 2020 年中期全球使用的 Android 版本的当前分布情况。

图 1-3

2020 年使用的 Android 版本和 API 级别

请注意这些数字的自我吹捧。你不用报告每个 Android 版本使用的设备的绝对比例，而是显示运行特定版本或更高版本的设备的“累积分布”。很容易通过算术计算出真实的绝对百分比。例如，11.2%的设备运行 Android 6.0“棉花糖”，这是其 84.9%的累积分布和 Android 7.0 的 73.7%的累积分布之间的差异。在撰写本文时，Android 11 已经发布了几个月，但尚未在统计数据中显示出来。Android 12 定于今年晚些时候发布，对 Android 11 只做了微小的调整。请放心，Android 11 和之后的 Android 12 将会在排行榜上扶摇直上，成为学习 Android 开发的良好基础。

从这个讨论中得出的结论是，为了瞄准一定比例的 Android 设备，你将希望采用过去几个版本的 Android 功能，而不是仅仅迎合前沿。

了解 Android 的未来

像 Android 这样已经拥有数十亿用户的系统，已经可以被认为是一个巨大的成功。但是在大量的新领域，Android 还有大量的增长和机会。例如，现在大量的注意力集中在 Android 将如何成为未来“混合”计算的一部分。在这种混合模式下，一些设备使用 Android 进行部分操作，就像今天的智能手机一样提供应用，但转而使用 Chrome OS 等第二个操作系统来执行其他任务。

Android 本身也将遵循一条定期更新的道路，就像 Google Play 和其他云产品等许多伟大的在线服务一样，这将进一步推动 Android 设备和 Android 应用的可能性。

对这本书的其余部分有什么期待

Android for Absolute Beginners旨在带领读者踏上编写软件的第一次旅程，学习为未来的应用开发目标做准备的实践、技术和方法，以及构建计算机程序的许多基础知识。当然，我们将使用 Android 作为您学习的目标环境，激发您的灵感，以及涵盖您在软件开发的其他领域将会遇到的许多主题的基础。

我把这本书分成了四大部分，每一部分都旨在让你在阅读内容和例子的过程中，不断加深对如何为 Android 编写应用以及 Android 本身的理解。每一部分的章节涵盖了以下主题。

详述剩余章节的更多内容

章 1 **，安卓简介:**你在看！您已经介绍了 Android 的大部分内容，只需几页就可以着手开发您的第一个 Android 应用。

第 2 ，介绍 Android Studio: 我们将看看构建 Android 应用最流行的工具集——Android Studio——以及如何获得这款免费软件。我们还将简要介绍 Android Studio 的一些替代产品，以及如何及时了解新版本、新特性和 Android 应用构建方式的其他变化。最后，我们将介绍“仿真”Android 手机的概念，即 Android 虚拟设备(AVD)，这是一种让您的计算机模拟 Android 手机的方式，并提供了一个测试您的应用的平台，而无需修改您的实际手机。

章 3 **，你的第一个安卓应用，已经！:**对，没错。您将直接创建您的第一个 Android 应用。没必要等到你读完这本书！我们的第一个例子将非常简单，但它将为我们在所有剩余章节中展开奠定基础。

章 4 **，探索你的第一个项目:**在这一章中，我们将对你在第三章中创建的例子进行虚拟放大，浏览你的第一个应用的每一部分，开始理解它们来自哪里，它们做什么，以及它们为什么会在那里。

章节 5 **，Android Studio 深度:**如果你打算为你的未来开发使用一套集成的工具，那么深入了解它们的功能将是必须的。在这一章中，我们将探索 Android Studio 的所有关键方面，包括代码编辑功能、调试器、分析工具等等。

章节 6 **，掌握你的整个开发者生态系统:**这让你对你在开发旅程中可以并且将要使用的所有工具有了更全面的了解。本章将探讨位于 Android Studio 集成环境之外但对其至关重要的工具，包括 Java 开发工具包(JDK)、Gradle、代码和应用的源代码控制系统、Android 虚拟设备的管理以及环境的其他关键部分。我们还会看看你的开发者硬件的哪些方面会影响你的 Android 开发之路。

章节 7 **，介绍 Java 用于 Android 开发:**准备用 Java“升一级”？不管你目前的知识水平如何，本章都将强调 Android 开发所需的 Java 编码的关键领域，以及扩展你的 Java 专业知识的更多资源。

章节 8 **，介绍 XML 用于 Android 开发:**Android 应用行为的很多方面都是由 XML(可扩展标记语言)数据控制的。本章将带您了解 XML 的基础知识，以及如何将 XML 应用于 Android 应用的各个方面，包括应用的清单、用户界面等等。

第 9 **，探索 Android 概念:核心 UI 小部件:**在第八章的基础上，我们探索如何用菜单、屏幕小部件(如字段、列表、图像和其他可视项目)等常规组件来布局 Android 用户界面。本章还将介绍活动的关键概念 Android 用户界面的基础构件。最后，我们将给出 Android Jetpack 的概述，它是一个现代的库，在提供向后兼容性的同时提供了现代的布局方法。

第 第 10 **，探索 Android 概念:**布局和更多:本章扩展了您对所有 Android 用户界面组件的理解，并进一步建立在第 8 和 9 章的工作基础上。

章节 11 **，了解活动:**借助前面章节的 UI 概念，您将探索活动作为所有 Android 应用的基本构建块的全部功能。

章节 12 **，片段介绍:**您将学习更广泛的片段概念，它为许多不同的屏幕尺寸和布局选项提供了动力。

章节 13 **，使用 Android 的声音、音频和音乐:**在这一章中，我们将探索您的应用的音频的所有方面，包括在应用中播放音频和使用声音，录制音频，甚至在 Android 设备上创建音频。

章节 14 **，为 Android 处理视频和电影:**如果你是崭露头角的史蒂文·斯皮尔伯格、索菲亚·科波拉，甚至只是 YouTube 明星，这一章就是为你准备的。我们将介绍 Android 的视频捕获和回放功能，以及如何将这些功能应用到您的应用中。

章节 15 **，介绍通知:**通过使用 Android 提供的事件框架和通知系统，扩展到应用的边界之外。

第 第 16 **章，通过通话探索设备功能:**除了屏幕上显示的内容，您的 Android 世界还有更多可能性。我们将了解呼叫能力、访问传感器和其他信息。

章节 17 **，理解意图、事件、接收者:**在每一个 Android 应用的幕后，丰富的后台功能让事情保持运转。本章涵盖了 Android 平台的核心概念，并展示了它们如何塑造和影响您的应用。

章 18 **，介绍 Android 服务:**在这一章中，我们将探索如何使用其他代码和其他应用来丰富您自己的应用，以及它能为您的用户做些什么。

章节 19 ，在 Android 中处理文件: Android 使你能够处理多种数据、配置和其他文件。本章将开始你的旅程，了解 Android 应用可以在哪里以及如何利用传统文件来增强你的用户体验。

章节 20 **，使用 Android 中的数据库:**数据驱动着每一个应用，知道如何为应用存储、管理和使用数据是让它们变得伟大的关键。本章将涵盖 Android 提供的多种数据处理方式。

带着对即将完成的事情的预尝，没有比现在更好的开始了。第二章在下一页等待！

二、Android Studio 简介

在这一章中，我们将介绍 Android Studio，它是为 Android 应用编写软件的主要工具。虽然有一系列其他软件可供您依赖，但 Android Studio 集成开发环境(IDE)将是实现您想法的核心。你可以把它想象成你用来编写进一步软件的软件。

如果您过去做过任何类型的软件开发，您可能会发现一些熟悉的概念。如果是这种情况，请随意跳到本章后面的章节，直接进入为您选择的平台安装 Android Studio 的机制。你当然可以继续阅读，看看这个话题是否有新的或有趣的东西。

现在让我们深入研究作为 Android 应用开发人员，您将使用的最重要的工具集——Android Studio！

了解集成开发环境(IDE)的含义

在我们开始之前，让我们为那些没有遇到过 IDE 这个术语或者对编程完全陌生的人定义一下 IDE 的含义。术语集成开发环境几乎是不言自明的，但也不尽然。如果我们把它拆开，“开发环境”只是指开发人员进行开发的环境(从软件的角度来说)。这就好比说微软 Word 或谷歌文档是作者的“写作环境”——他们写作的地方。

术语“集成”也很简单，但是了解什么是集成是全面理解 IDE 的关键。把我们的写作类比延伸得更远一点，作为一名软件开发人员，你也要写作，但是在你的情况下，它将是人类可读的 Java 和其他几种语言的编程代码。为此，每个 IDE 都包括(集成)一个代码编辑器，您可以在其中编写实际的原始代码。目前为止，一切顺利。

正如 Microsoft Word 为作者提供了一些额外的捆绑工具，如拼写检查和在线词典定义查找，IDE 也引入了其他工具，并以集成的方式将它们提供给软件开发人员。除了代码编辑器之外，通常还有语言参考工具，以便您可以查找软件库是如何工作的，构建工具来获取您编写的代码并将其编译成软件的工作片段，调试工具来帮助您识别和理解问题和错误，以及许多其他工具，如性能分析器、代码格式化器、语法高亮器、实时检查工具、网络监视器等等。

IDE 的关键是所有这些工具都集成在一起，或多或少能很好地协同工作，而不需要开发人员在工具之间手动传递东西。在 ide 出现之前，这是开发人员不太光彩的生活。有了像 Android Studio 这样的 IDE 来处理平凡、复杂和重复的操作，您就可以自由地专注于编写应用的创造性问题解决方面，而不必担心底层管道。

Android Studio 的历史和起源

当 Google 首次发布 Android 开发工具时，它瞄准了当时最流行的开源开发环境之一 Eclipse。它发布了一套插入 Eclipse 的工具，称为 Android Developer Tools，简称 ADT。这个组合——Eclipse 和 ADT——让许多 Android 开发者满意了很多年。十年过去了，虽然 Eclipse 仍然是一个非常受欢迎的 IDE，但一系列其他 IDE 的地位已经上升或下降，谷歌如果不热衷于走在这些变化的前沿，那就什么都不是。

2013 年，谷歌宣布它正在与 JetBrains 合作，JetBrains 是一家开发了名为 IntelliJ IDEA 的现代 IDE 的公司，主要专注于为那些构建基于 Java 的应用的人提供一流的开发体验，新的合作产品将基于 IntelliJ IDEA，名为 Android Studio，并作为完全免费的 Android 开发 IDE 发布。Android Studio 版本于 2014 年晚些时候发布。在随后的几年中，谷歌宣布 Android Studio 将成为开发 Android 应用的首选 IDE，并将停止关注和投资其他工具。这并没有阻止 Eclipse 爱好者继续使用 Eclipse、ADT 和一系列其他工具——我们将在本章末尾触及这些替代工具。

为您的平台下载 Android Studio 安装程序

现在，您已经有了足够的背景知识来理解 Android Studio 的重要性，以及它将在您未来的 Android 应用开发中扮演的角色。是时候拿到 Android Studio，开始编码了！

下载 Android Studio 安装包的首选位置是 Android 官方网页本身。你可以在首页 www.android.com/ 开始，或者在 https://developer.android.com/studio 直接进入开发者下载页面。

我应该注意的是，当在印刷(或电子)书籍中调用网站 URL 时，一般的警告是适用的。URL 可以而且确实会随着时间而改变。如果你在文章发表后的某个时候读到这篇文章，那么 https://developer.android.com/studio 的直接链接可能已经改变——但是 www.android.com/ 的主页将会一直存在，并帮助你导航到谷歌未来可能将下载页面移动到的任何地方。

对于 Linux 操作系统用户来说，至少还有另一种选择，即使用快照打包方法，我们稍后将对此进行讨论。

使用 Android Studio 版本

到达下载网站后，你会立即看到一个“下载 Android Studio”选项，如图 2-1 所示。仔细看按钮下面的文字。在我的例子中，它显示为“4.0 for Linux 64 位(865 MB)”。

图 2-1

developer.android.com/studio 下载页面，显示 Android Studio 4.0

“4.0”指的是 Android Studio 的版本，这就打开了版本、Android、Android Studio 和 Android 软件开发工具包(SDK)的话题。作为一名开发人员，你需要知道的最重要的一点是，Android 版本——在人们的设备上运行的软件——与 Android Studio 的版本没有直接联系，这意味着当你使用 Android Studio 开发应用时，你有多种方法来控制你的应用将支持哪些 Android 版本(以及哪些设备)。

了解 Android Studio 和 Android SDK 如何协同工作

Android 操作系统版本提供了一系列功能，开发人员可以通过将 Android SDK 集成到他们的代码中来访问这些功能。谷歌定期发布 Android SDK 版本，有些情况下一年发布几次。您安装的 Android Studio 可以安装和使用许多不同版本的 Android SDK——事实上您几乎肯定会这样做。然后，在创建应用时，您将能够指定如何选择 SDK 版本以及支持 SDK 特性的 Android 版本。我们将在第三章中详细介绍这一过程，所以不要在这一点上对版本“舞蹈”感到不知所措。

为 Android Studio 做准备

Android Studio 是 Android 开发的领先 IDE，其原因在本章前面已经介绍过。它几乎拥有新手和有经验的 Android 开发者开发各种应用所需的一切。差不多！作为一名新的 Android 应用开发者，你需要考虑一些其他的因素来完善你的开发者工作环境。

总的来说，值得庆幸的是，这些考虑因素数量很少，很容易掌握。实质上，它们如下:

1. 我将在 Android 开发中使用什么台式机或笔记本电脑硬件？

2. 我将在台式机/笔记本电脑上运行什么操作系统？

3. 在使用 Android Studio 之前，我的系统需要什么先决条件？

4. 在开发过程中，我将使用哪些 Android 手机(如果有的话)？

让我们从推荐的最低入门要求的角度来依次看看这些，这样你就可以在本章的后面快速安装 Android Studio 了。

为 Android 开发选择台式机或笔记本电脑硬件

首先，好消息。几乎你现有的任何一台电脑都将是你 Android 开发之旅的一个很好的起点。几乎所有过去十年的电脑都有基本的计算“咕噜声”来支持 Android Studio，并允许您在构建第一个应用时学习核心概念。事实上，一些开发人员从来不愿意放弃他们的“日常驱动”机器，因为他们的需求并不那么繁重。

然而，可能会有那么一天，你会想一想你对 Android 应用开发有多认真，以及你能从更好的设备中获得什么好处。或者，您现在可能正在市场上购买一台新计算机，并希望提前计划计算资源，以使应用开发更快、更高效，等等。我们将在第六章探索更强大的开发硬件、附件和完整的开发环境的所有方面。如果你正在考虑如何给你的电脑增压或者为 Android 开发购买新设备，你可以随意跳到前面阅读第六章。但对于那些只想确保他们被现有设备覆盖的人来说，如果你根据谷歌推荐的 Android Studio 最低配置进行确认，这里有一些关键的考虑因素:

1. CPU:这里的好消息是，过去几年的几乎所有 CPU 对于开始 Android 开发都绰绰有余。

2. 内存:谷歌推荐最少 4 GB 的内存，并建议 8 GB 是首选的基本级别。大部分内存将用于虚拟设备仿真，其余用于 Android Studio 本身。您可以使用比最小值更少的值勉强度日，但是在测试您的应用时，性能会受到影响。

3. 存储:虽然推荐的最低存储容量是 2 GB，而谷歌的偏好是 4 GB，但事实是存储容量越大越好。2 GB 将为您提供一个基本的 Android Studio 安装、一个虚拟设备，以及大量尝试删除不需要的项目以释放空间的常规清理工作。4 GB 好一点。如果可以的话，清理一下，确保你有 5-10gb 的空间，让自己的生活更轻松。

4. 屏幕:谷歌推荐屏幕分辨率至少 1280 × 800。然而，没有说明的是，这是对 Android Studio 本身的建议，您将在这里编写代码和测试您的应用。当您考虑到您的开发环境与用户手机上的屏幕有很大的不同时，屏幕分辨率是一个需要考虑的问题。现在，请注意谷歌的指南，但我们将在第 6 和其他章节中重新讨论屏幕的话题。

为您的计算机选择操作系统

谷歌使 Android Studio 可用于所有流行的操作系统，包括 Linux、macOS、Windows 和它自己的 Chrome OS(本质上是 Linux 的一个重新皮肤化的版本)。除非你想买一台新电脑，否则无论你现在的电脑是什么操作系统都是不错的选择。在第六章中，我们将进一步探究理想开发者设置的细节，包括操作系统的选择。

继续下载安装程序

既然您已经熟悉了 Android Studio 版本的细微差别以及您的硬件和操作系统选择，现在您可以继续下载并安装 Android Studio。正如本章前面提到的，从 https://developer.android.com/studio 页面，你的操作系统应该被自动检测到，并且该平台的下载按钮应该是突出的。在前面的例子中，当从 Linux 机器上访问站点时，您看到了这一点。在我的 MacBook 上，我看到一个“下载 Android Studio”的选项出现在前面和中间，下面有“4.0 for Mac”的文字。

如果你从不同的机器上下载，而不是从你计划用于 Android 开发的机器上下载，确保你为你打算使用的机器选择了正确的 Android Studio 版本。如果目标机器有不同的操作系统，向下滚动页面到标题“Android Studio 下载”，在那里你会看到 Android Studio 支持的每个操作系统的选项。

Windows Alternatives

Android 开发者网站上的安装选项列表包括两种 Windows 版本。第一个是可执行安装程序，文件名格式为“Android-studio-ide-193.6514223-windows . exe”(“Android-studio-ide”后面的数字串是内部版本号和发布号，会随时间变化)。第二个是 zip 文件，文件名格式为“Android-studio-ide-193.6514223-windows . zip”，我建议您使用常规可执行安装程序的第一个选项。这将为您解决各种问题，包括您通常在 Windows 下使用的帐户的目录位置和 Windows 权限，以及共享计算机上的任何其他帐户。

单击相关选项，下载适用于您的操作系统的 Android Studio 版本，并记下您的浏览器将下载内容放置在何处。在 macOS、Linux 和 Windows 上，这通常是用户的“下载”目录，但是如果您选择将它放在其他地方，它可能会有所不同。

随着 Android Studio 4.0 的发布，总下载量在大小上接近 1 GB，因此可能需要几分钟才能完成下载。

在 Windows 上安装 Android Studio

假设您遵循使用 Windows 可执行安装程序的建议路径，您可以通过双击可执行文件从下载位置启动安装程序。在撰写本文时，这意味着文件 android-studio-ide-193.6514223-windows.exe。所有最新版本的 Windows 都将提示您允许通过用户访问控制(UAC)机制继续安装，以确保您明确同意完成安装所需的提升权限。

安装完成后，您应该会看到 Android Studio 的一个新的开始菜单项。

在 macOS 上安装 Android Studio

与 macOS 上的大多数应用安装一样，安装 Android Studio 非常简单。在 Mac 上打开 Finder，浏览到您下载 Android Studio 安装程序的目录。您应该看到一个 dmg 文件，其名称类似于“Android-Studio-ide-193.6514223-MAC . dmg”——这是 Android Studio 4.0 安装程序的 DMG 文件。双击这个磁盘镜像文件，你的 Mac 将首先验证下载，这真的意味着它将检查 Google 准备磁盘镜像所使用的代码签名证书和/或公证。一旦验证完成，您应该会看到如图 2-2 所示的典型 DMG 安装窗口。

图 2-2

适用于 macOS 的 Android Studio DMG 安装窗口

将 Android Studio 应用图标拖到 Applications 文件夹，这将触发您的 Mac 复制任何 Mac 应用的安装包。一旦完成，Android Studio 就可以从应用菜单和文件夹中使用了。

在 Linux 上安装 Android Studio

你下载的 Linux 的 Android Studio 安装程序是一个 gzip 压缩的 tarball，文件名如android-studio-ide-193.6514223.tar.gz。就 Android Studio 而言，将该文件解压缩到您选择的目录中就构成了安装。决定你想把 Android Studio 安装在哪里:例如，你可能想把它放在你的用户账户的主目录下或者其他目录下，比如/opt。当您打开压缩的 tarball 时，您会看到它在您指定的位置创建了一个名为“android-studio”的目录，所有的文件和子目录都位于该目录下。这意味着您没有必要创建一个名称相似的父目录。例如，我不需要创建一个/home/grant/android-studio目录，因为解包 tarball 也会创建叶级——我真的不想要一个/home/grant/android-studio/android-studio路径，因为那是不必要的多余。您为 Android Studio 选择的目录将被许多 Android Studio 内部文档称为“安装主目录”。

打开你喜欢的 shell，比如 bash 或者 zsh，将目录更改为你想要放置 Android Studio 的父目录下。确保您对目标位置拥有写权限。注意您下载压缩的 tarball 文件的位置——在我的例子中，这是/home/grant/Downloads目录，我也可以将其称为~/Downloads。如下运行 tar 命令，该命令指示它解压缩、解压缩并验证最终的文件扩展集:

tar -xvzf ~/Downloads/android-studio-ide-193.6514223.tar.gz

几个屏幕的状态应该滚动过去，最终您应该返回到您的 shell 提示符。运行 ls 或打开您最喜欢的文件管理器，您应该会看到现在创建的 android-studio 目录。在该目录中，您将找到一个名为Install-Linux-tar.txt的文件，您可以阅读该文件以获得一些关于进一步调整安装以及如何实际运行 Android Studio 二进制文件的基本说明。我来给你破悬念！您将在 android-studio 目录下看到一个 bin 目录，其中有一个名为studio.sh的 shell 脚本。执行这个 shell 脚本来启动 Android Studio。我们将在本书的后面回到Install-Linux-tar.txt文件中提到的其他一些配置选项。

Snap To It!

除了典型的 Linux 安装选项，还有其他选择，其中一个选择遵循了近年来 Linux 上应用打包版本的趋势，即完全自包含，将所有依赖项和库捆绑到一个包中。这种方法的典型代表是 Canonical(Ubuntu fame)和 Flatpak 推广的 Snap bundling，后者源于 XDG 的 freedesktop.org 作品。

对于支持 Snap 包的 Linux 发行版(理论上是所有发行版)，您可以让您的包管理器安装 Snap for Android Studio。例如，在 Ubuntu 20.04 下，你可以简单地运行

sudo snap install android-studio

对 Snap 方法有一点要注意:从官方网站 https://developer.android.com 下载将提供最新的 Android Studio 补丁版本，依赖 Snap 方法意味着依赖 Snap 包的维护者和打包者来保持它的最新。从理论上讲，这种维护是完全可能的，有些人认为这很容易，或者比依赖于正常安装软件的维护和修复更容易。但是，您从在线软件包存储库中检索的快照软件包可能不是最新的。

安装后继续安装 Android Studio

当 Android Studio 安装在您的电脑上时，您需要执行一些一次性设置操作来开始使用。幸运的是，Android Studio 本身会指导您完成这些设置步骤。如果你在安装之后还没有启动 Android Studio，你应该现在就启动。您应该会看到如图 2-3 所示的闪屏。

图 2-3

启动 Android Studio 时显示的闪屏

一旦 Android Studio 第一次加载，闪屏将消失，您应该会看到设置向导的开始，这可能会闪过，然后会提示您从您机器上的任何 Android Studio 早期版本导入设置，如图 2-4 所示。

图 2-4

首次运行 Android Studio 时显示的导入设置选项

出于本章的目的，我们将假设没有要导入的旧设置。您可以选择“不导入设置”选项，然后单击“确定”按钮。然后，设置过程会提示您一个关于共享使用数据的问题，例如使用的功能和访问的库，如图 2-5 所示。

图 2-5

Android Studio 安装期间的数据共享提示

如果你想与谷歌分享你的使用统计数据，这完全取决于你。它不会影响 Android Studio 的功能或行为，尽管它有助于在未来版本中修复错误和改进。

在您做出使用统计选择后，您将看到 Android Studio 设置向导的登录页面，如图 2-6 所示。

图 2-6

Android Studio 安装向导主页

在这一点上你没有太多的选择。您可以单击“下一步”按钮继续安装向导，也可以单击“取消”按钮在以后返回。

假设你喜欢冒险——我觉得这是一个安全的赌注，因为你已经买了这本书——单击下一步开始安装向导的最后部分。您可以选择标准或定制安装类型，如图 2-7 所示。

图 2-7

Android Studio 安装向导中的安装类型选择页面

自定义安装选项将允许您做一些事情，如更改安装位置，选择要下载的 Android SDK 版本，以及类似的选择。我们将在第五章中更详细地讨论这些项目。现在，您可以选择标准安装类型，然后单击 Next 按钮。

你的下一个选择基本上是装饰性的，你可以选择让用户界面使用“亮”或“暗”的主题，如图 2-8 所示。

图 2-8

Android Studio 中选择用户界面主题的选项

对于那些使用有机发光二极管显示器的人来说，亮暗主题之间的用电差异微乎其微。对于其他人来说，这只是一种化妆品偏好。出于本书的目的，我将使用浅色主题，因为这将为本书的任何印刷版本节省墨水。一旦您决定了自己的偏好，请单击“下一步”按钮继续。

倒数第二个设置向导屏幕将会出现，这是图 2-9 所示的验证设置视图。

图 2-9

Android Studio 设置向导中的验证设置屏幕

您可能习惯于简单地跳过这些确认屏幕，但是我鼓励您滚动浏览显示的摘要。不是因为有任何隐藏的“陷阱”,而是为了确保您意识到在安装过程中还会下载多少。如果您选择前面描述的标准安装类型，Android Studio 将继续为您的平台下载最新的 Android SDK 版本和最新的虚拟设备仿真器。这些可以很容易地总计另外 500 MB-1gb 的下载，这你至少应该知道。如果您已经尝试了自定义安装类型选项，在这个阶段，您可能会下载相当多的 SDK 版本和模拟器引擎，这可能会很快增长到数千兆字节的额外下载。一旦你对你所做的选择感到满意，点击下一步按钮，Android Studio 将自动开始所有剩下的自动化和下载步骤。在某些情况下，如果您的硬件支持直接仿真，您将会看到如图 2-10 所示的附加屏幕。

图 2-10

Android Studio 的咨询屏幕通知您加速的仿真性能

使用您的硬件仿真加速功能没有坏处，所以接受这个选项，您最终会看到下载组件进度屏幕，如图 2-11 所示。

图 2-11

下载组件进度屏幕的初始视图

根据计算机和互联网连接的速度，组件下载和配置过程至少需要几分钟。如果您看到细节在某些地方停滞不前，请不要惊慌，因为这通常表示 Android Studio 安装向导正在下载大型组件，如 Android SDK 包。最终，您应该会看到详细信息停止滚动，一条神奇的线显示在窗口的底部，如图 2-12 所示。

图 2-12

Android Studio 安装向导中已完成的组件下载视图

您希望在过程结束时看到的神奇的文本行是“Android SDK 是最新的。”这意味着下载和配置步骤已经完成，Android Studio 已经准备就绪。你可以点击 Finish 按钮，你会看到 Android Studio 本身的启动屏幕，如图 2-13 所示。

图 2-13

欢迎使用 Android Studio 屏幕

我们将在接下来的章节中回到这里介绍的选项。现在，您可以放心了，因为您已经成功安装了 Android Studio 以及我们将在接下来的章节中使用的 SDK 和模拟器组件。

使用 Android Studio 的替代产品

如果说软件世界——尤其是软件开发——提供了什么，那就是选择！无论是网络浏览器、电子邮件包，还是你对游戏的偏好，都有很多选择。为 Android 开发应用没有什么不同，尽管 Android Studio 中有一个很强的默认。尽管如此，还有其他选择，即使你不打算使用其中的任何一个，知道替代 ide 和其他工具的存在也是有用的，因为你会在网上、会议上和其他讨论 Android 开发的论坛上看到它们。

这里有一个简短但不详尽的列表，列出了您在初露头角的 Android 应用开发生涯中可能会遇到的备选方案。

黯然失色

正如本章前面提到的，Eclipse 是谷歌支持 Android 开发的第一个 IDE。大约在 2007 年安卓出现之初，谷歌需要提供引人注目的开发者产品，以使其新收购的智能手机操作系统吸引开发者。当时，它选择开源 Eclipse IDE 作为官方认可的开发环境。这一选择被普遍接受，并被认为是一个巨大的乘数和推动者，让数百万安卓开发人员免费获得工具，使他们能够开发一波又一波的安卓应用。

直到 2014 年 Android Studio 1.0 发布之前，Eclipse 一直备受瞩目。即使在那次发布之后，Eclipse 仍然享受着谷歌的全力支持，直到 2016 年 Android Studio 2.2 的发布。谷歌当时宣布，它将不再支持 Eclipse 作为一流的开发环境，也不会保证 Android 开发工具在未来不会出现错误。

这听起来好像 Eclipse 不再是构建 Android 应用的可行环境。没有比这更偏离事实的了。现实是，Google 不再为想要使用 Eclipse 的开发人员提供修饰、便利或直接支持。然而，两个主要的主题确保了 Eclipse 仍然是寻求使用它的开发人员的一个选择。

首先，Eclipse 在处理 Android 应用的基础上积累了十多年的微调、集成和专业知识。最终，构建 Android 应用的工作归结为处理文本 Java 代码、XML 数据和相关工件。正如我们将在本书的第二部分中看到的，这些方面不会因为您选择了不同的 IDE 来帮助您而改变。

第二，随着时间的推移，Eclipse 是最受欢迎的 IDE 之一，它具有超越 Android 的优势，这意味着它通常是处理构建超越单一目标平台的应用的开发环境中的首选 IDE。

这并不是说选择 Eclipse 作为您的 IDE 会像 Android Studio 一样流畅或高效。一旦你超越了本书的范围，你会发现许多当代的在线信息来源会假设你使用的是 Android Studio 而不是 Eclipse。但是你们中的一些人——尤其是有经验的开发人员——将会看到 Eclipse 已经吸引人的地方。如果您正在开始您的开发之旅，并且还没有足够的 Eclipse 经验，那么我强烈建议您使用 Android Studio 作为您的 IDE。

IntelliJ IDEA

在这一章的开始，我解释了 Android Studio 的起源，并概述了它基于 IntelliJ 理念的基础。所以你可能会想，如果这是 Android Studio 所基于的，为什么我会选择 IntelliJ IDEA，这有什么区别，我为什么要关心呢？

很棒的问题！本质上，作为一个新的开发人员，没有压倒性的理由考虑选择 IntelliJ IDEA 作为您的 IDE 选择。然而，经验丰富的开发人员，或者那些为更多平台而不仅仅是 Android 开发基于 Java 的应用的开发人员，通常会发现在一个 IDE 上实现标准化是提高效率的重要驱动因素。还有一些 IntelliJ 背后的公司 JetBrains 只在完整的商业包中提供的功能，例如与 Spring Framework for Java 无缝协作的能力。如果您属于这些类别，我们非常欢迎您将 IntelliJ IDEA 作为首选 IDE。

要了解更多关于如何使用 IntelliJ IDEA 专门进行 Android 开发的信息，请查看 JetBrains(拥有并构建 IntelliJ IDEA 的公司)关于这一主题的网页，网址为 www.jetbrains.com/help/idea/android.html 和 www.jetbrains.com/help/idea/getting-started-with-android-development.html 。

针对多种操作系统和移动平台的工具

在第一章中，你看到了智能手机市场份额的分解，Android 占据了绝大多数份额。不要让这蒙蔽了你的双眼，让你看不到存在替代品的现实，比如苹果的 iPhone，还有工具可以帮助开发者瞄准这两个平台，甚至一些你可能没有听说过的其他平台。一些关键的多平台 ide 和开发环境包括 Xamarin、PhoneGap、Flutter 和 Apache Cordova 等产品。

跨平台工具本身就应该有一本书，事实上，上面提到的这些工具不止有一本专门针对它们的书，还有数不清的在线内容。如果你对他们所提供的感兴趣，我强烈建议你从他们各自在互联网上的产品主页开始，然后从那里扩大你的搜索范围。

传统的平台无关开发工具

为了总结这一章和开发者工具的主题，我应该带你回到这一章的最开始。ide 的出现是为了帮助开发人员处理所有用于创建现代应用的工具。这包括代码编辑器、调试器、编译器等等。但是 ide 并不适合所有人。

一些读者可能是经验丰富的开发人员，他们非常乐于组装自己的工具来帮助创建 Android 应用。有很多开发人员喜欢选择自己的编辑器，比如 Vim、Emacs 或 Sublime Text 编译和构建管道工具，如 Ant、Jenkins 和 Hudson 以及其他用于性能管理、调试等的工具。

如果你想走这条路，谷歌在本章开始提到的 Android Studio 下载页面提供了一套 Android 命令行开发工具。这些工具包括 sdkmanager，负责下载和管理多个 Android SDK 包；adb，它是 Android 开发者桥工具，用于将你的应用从你的开发者机器移动到你的虚拟和真实设备；以及更多。

虽然这本书不是针对那些想走这条路的开发人员，但至少你知道这是一个可行的选择。现在，我们假设你对使用 Android Studio 很满意，我们将在下一章直接深入开发你的第一个 Android 应用，从下一页开始！

三、你的第一个 Android 应用！

Android Studio 安装在您的计算机上后，您就可以开始创建您的第一个 Android 应用了。是的，现在！对于那些不熟悉 Java 代码开发的读者，不要惊慌。我们将在本章开始我们的例子，没有假定的 Java 知识或诀窍。对于那些了解 Java 的读者来说，请继续阅读，因为我们将涵盖创建 Android 虚拟设备(或 AVD)的重要的第一步，在其上运行本章中的示例以及未来章节中的示例。

创建您的第一个 Android 虚拟设备

更广泛的 Android Studio 集成环境中提供的最有用的特性之一是创建 Android 虚拟设备(avd)的能力。有了 AVD，你就有能力模拟一个真正的 Android 设备，控制它的一系列功能和特性，而不必有一个实际的物理设备。

AVD 方法并不意味着禁止您使用真实的设备来测试和使用您的应用，但是如果您考虑一下我们在前两章中提到的过多的 Android 设备、版本和外形因素，您就会明白，作为一名开发人员，即使只拥有运行 Android 的设备中的一小部分也是不切实际的。avd 可以帮助您缩小您拥有的(和能够负担的)和您的用户群实际使用的之间的差距。

要开始创建你的第一个 AVD，启动 Android Studio(如果它还没有运行的话),你会看到闪屏，然后是欢迎使用 Android Studio 屏幕，你可能还记得第二章中的内容。在欢迎屏幕的右下方，您应该看到一个齿轮图标和菜单选项Configure，您应该点击它以显示一系列配置选项，如图 3-1 所示。

图 3-1

欢迎使用 Android Studio 屏幕上的配置菜单

您将看到配置项目列表中的第一个选项是 AVD 管理器选项。点击此选项，AVD 管理器将在几秒钟后启动，您将看到如图 3-2 所示的 Android 虚拟设备管理器介绍屏幕。

图 3-2

Android 虚拟设备管理器欢迎屏幕

在屏幕中间，你应该会看到如图 3-2 所示的按钮，上面写着+ Create Virtual Device...。继续并单击该按钮开始 AVD 创建过程。然后你会看到虚拟设备配置硬件选择屏幕，如图 3-3 所示。

图 3-3

用于创建新 AVD 的选择硬件选项

硬件选择屏幕中有很多内容，但不要感到不知所措。这里的众多选项传达了你将在真实世界的设备中发现的变量，所以这真的不奇怪。让我们一步一步地了解各个领域，这样您就可以开始熟悉 AVD 管理器以及创建和使用 AVD 了。

从硬件选择屏幕的左侧开始，类别列表根据外形和使用模式对设备仿真器进行分组。你应该至少能看到图 3-3 所示的五个普通选项，电视、电话、Wear OS(原 Android Wear)、平板、汽车。您可以随意点击每一项，查看设备列表(屏幕中间)和维度详细信息窗口的变化，但完成后，请选择电话作为类别。选择 Phone 后，您应该会看到如图 3-3 所示的预打包仿真设备的原始列表。

在这一点上，我们不会急于选择第一批器件中的一个作为我们 AVD 的基础。相反，花一点时间滚动列表，记下一些数据点，这些数据点将在本书的后面重新出现，并将逐渐变得更有意义，对您的应用设计产生更大的影响。

在设备定义列表的上端，您会看到智能手机的品牌和型号，其中一些可能非常熟悉。各种像素选项，如 Pixel 3、Pixel 2 等，以及 AVD 图像尽可能模拟具有这些名称的真实物理设备。类似地，Nexus 6、Nexus 5 等是模仿其同名物的物理特征的虚拟设备，无论是板载存储、工作内存、屏幕分辨率还是其他功能。在您滚动查看列表的其余部分之前，请看一下显示在Resolution和Density列中的值。您将看到两者的测量值，以像素布局表示分辨率(例如，像素 2 AVD 为 1080 × 1920)和每英寸点数或 dpi 表示密度(像素 2 也是 420 dpi)。您可能熟悉笔记本电脑或台式机屏幕的分辨率和密度测量，而不会对您在这里看到的值有所顾虑。但值得将这些与列表中的其他 avd 进行比较。

如果您进一步向列表底部滚动，您将开始看到一系列更隐晦的设备名称，如图 3-4 所示。

图 3-4

更多 AVD 模板可供您使用

这些设备没有任何相关的品牌名称，但它们确实拥有一些指标，通过使用通常与各种屏幕尺寸和分辨率相关的缩写来表明它们提供了什么。我们会在本书中遇到这些术语，所以现在你可以用书签标记名称，比如 QVGA、WQVGA、mdpi、hdpi 等等，不要在意它们的意思。

似乎所有这些当前和历史选项还不够，您将在设备定义列表下方看到两个按钮，允许指定您自己的自定义虚拟设备配置文件和从其他来源导入配置文件。就我们的目的而言，不需要这些选项，但您可以欣赏它们提供的价值——特别是对于那些最终可能想要设计针对非常具体、非典型设备的应用的人。

当我们深入研究用户界面设计时，我们将在第 9 、 10 和 11 章中重温 Android 设备分辨率和密度的概念和原理。现在，您可以滚动回到设备定义列表的顶部，并选择 Pixel 2 预配置的设备定义。点击下一步按钮，您应该会看到如图 3-5 所示的系统图像选择屏幕。

图 3-5

AVD 管理器中的 AVD 系统图像选择屏幕

选择系统映像可以被认为是对您之前选择的设备定义的补充。虽然您的设备选择选择了 AVD 的硬件方面，但系统映像决定了关键的软件方面:Android API/SDK 级别和 ABI，这基本上是决定在软件中模拟哪种芯片架构，英特尔的 x86 还是基于 Arm 的架构之一，以及这些部分最匹配的 Android 版本。

Android Software Development Kit: A Second Look

在第二章中，我介绍了术语 SDK，即软件开发工具包。虽然很容易解析这句话，并认为“太好了，这是一个帮助我开发软件的工具包”，但还是有必要回顾一下 Android SDK 真正提供了什么。首先，Android SDK 是一组软件库，是访问任何 Android 智能手机及其操作系统的功能和能力所需的基本工具。你可以将 SDK 视为一个杠杆，让你将谷歌内置于 Android 中的所有功能和能力应用到你自己的应用中，而无需从头开始构建一切。

Android SDKs 每个 Android 版本都有后续版本——提供了到 Android Studio 的连接，让您可以轻松调用 Android 行为；建立工具，让你把你的代码变成一个工作的 Android 程序；允许您管理仍在开发中并以“草案”形式运行的应用的平台工具，包括“adb”，Android 调试桥，用于从仍在开发中的代码控制仿真器或真实设备上的行为；以及更多。哦，SDK 提供了仿真器框架和设备仿真本身！

根据您之前是否在您选择使用的计算机上使用过某个版本的 Android Studio，或者之前是否完成过该向导，您将会看到列出的版本名称，如“R”或“Oreo ”,名称旁边有或没有下载链接。简而言之，如果系统映像已经在你的机器上，它不会显示下载链接。如果它还没有在您的机器上使用，下载链接将会显示，您可以直接从系统映像阶段单击它来获取相关的系统映像。

你需要至少有一个系统映像供你的 AVDs 使用，所以如果你看到的都是带有下载链接的系统映像名，你应该选择下载最新的。在图 3-5 所示的例子中，这将是 Android“R”系统映像。选择下载将触发许可接受屏幕，如图 3-6 所示。

图 3-6

AVD 系统映像的许可接受屏幕示例

我不是律师，当然也不在电视上演律师！更严重的是，这意味着我不能告诉你许可文本的含义。如果你担心，就去找法律顾问。但是从一个外行的角度来看，用于 Android 系统映像的开源许可通常不会让你失眠。我假设您接受了显示的文本，并点击了“下一步”按钮，现在正盯着图 3-7 所示的 Android 虚拟设备(AVD)配置验证屏幕。

图 3-7

Android 虚拟设备(AVD)配置验证屏幕

使用此屏幕检查您对新 AVD 的配置是否满意，最重要的是，给它起一个好记的名字。您可以随意称呼您的 AVDs 无需保留型号或使用可能继承自某个预配置系统映像的名称，尽管将其作为名称的一部分有助于快速提醒您仿真设备的功能。选择一个名称，然后点击完成按钮，前往 AVD 管理器主屏幕，如图 3-8 所示。

图 3-8

填充的 AVD 管理器主屏幕

现在，您应该会在可用模拟设备列表中看到新创建的 AVD。这就是创建您的第一个 Android 虚拟设备的全部内容——您现在可以编写自己的应用并在其上运行了！

已经开始创建您的第一个 Android 应用了！

您已经具备了开始使用您的第一个 Android 应用的所有先决条件。还有很多东西需要学习，但你已经有了关键的东西，包括 Android Studio 和一个新创建的 Android 虚拟设备，可以随时试用你写的任何东西。希望这种蓄势待发的状态不会让你感到惊讶。我在第二章中概述了 ide 的一些好处，您将在设置新应用的脚手架和框架方面直接体验到这些。

没有任何进一步的悬念，让我们开始吧。如果你已经按照本章前面的步骤完成了 AVD 的创建，你可能会回到你在本章前面看到的 Android Studio 主屏幕，如图 3-1 。在主屏幕上，选择屏幕顶部Start a new Android Studio project选项，您将很快看到创建新项目向导的第一个屏幕。

无论什么原因，如果你看不到主屏幕，或者重启了 Android Studio，它没有显示主屏幕向导，你可能会看到一个空的 Android Studio 屏幕或者一个已经加载了预先存在的项目的屏幕，如图 3-9 所示。

图 3-9

主屏幕消失时显示的 Android Studio

别慌！你也可以从这里开始一个新项目，但是打开文件菜单，选择New ➤ New Project。这也将启动创建新项目向导。不管你选择了哪条路径，你应该很快就会看到如图 3-10 所示的向导

图 3-10

Android Studio 中的创建新项目向导

向导的第一页已经提示您选择要构建的应用类型。在屏幕上方，您会看到设备类别，如手机和平板电脑、Wear OS、电视等。目前，我们将坚持使用电话和平板电脑向导选项。看着手机和平板电脑下面显示的图标，你可能会挠头，不知道activity、fragment,等术语是什么意思。不要害怕。你很快就会掌握这些。在这个阶段，您可以将这个屏幕视为 Android Studio，询问您到底需要为您的新应用进行多少引导，以及您希望它代表您放置哪些现成的部分。例如，如果您希望开发一个依赖地图和导航功能的应用，Google Maps 活动模板为开发人员添加了一系列现成的地图、GPS 和位置支持选项。这个屏幕上的其他选项同样带来了其他好处，比如对 Google AdMob 广告活动的广告库支持。

我们将从一个非常普通的 Android 应用开始，创建这个简单应用的变体，展示我们在接下来的章节中讨论的每个功能。所以现在，你可以选择空活动选项。不要让 Empty 这个词迷惑了你，因为 Empty Activity 选项仍然部署了应用所需的大部分样板文件和基本项目结构。选中 Empty Activity，单击 Next 按钮，您应该会看到 Configure Your Project 屏幕，如图 3-11 所示。

图 3-11

Android Studio 中的配置您的项目屏幕

这个屏幕上显示的选项是你和添加你自己的代码和应用之间的所有障碍。对于当前的 MyFirstApp 项目，您需要指定以下设置:

名称:这应该是一个对您的应用有意义的名称。它是运行应用时将出现在屏幕上的标题，它是将出现在 Android 启动器屏幕上应用图标下的标题，如果你在 Google Play 商店或其他地方发布该应用，它是将出现在那里的名称。出于我们的目的，输入MyFirstApp作为名称。

包名:在一个有成千上万的开发者为 Android 开发成千上万个应用的世界里，你如何确保两个应用在命名上不冲突？Android 利用了从 Java 标准派生的包名的基本机制，而不是强制使用唯一的名称(尽管 Google Play 这样的地方在这方面有一些限制)。我们将在第七章中讨论更多关于 Java 包命名的内容，所以现在你可以使用一个从我自己的域名中派生出来的包名—org.beginningandroid.myfirstapp.

保存位置:保存位置是磁盘上的文件夹，该应用的整个代码层次将存储在该文件夹中。这将包括菜单子文件夹，保存像源代码，配置文件，图像，视频等内容，这取决于我们如何完善这个应用。首先，新项目使用的空间将低于 1 MB。但这可能会增长很快，所以最好选择磁盘上有足够空闲空间的位置。如果您对缺省值满意，您可以接受它——在您的操作系统上的用户主目录下的一个名为AndroidStudioProject/MyFirstApp的目录。

语言:打开你看到的选择列表，你会看到两个选项:Kotlin 或 Java。Kotlin 是 Android 支持创作应用的语言家族中的新成员。Java 是第一种，而且仍然是 Android 开发中使用最多、最流行的语言。选择 Java 作为 MyFirstApp 的语言。

最低 SDK:这是我们从第二章和本章开始讨论 Android 版本、Android Studio 版本和 Android SDK 版本的地方。您在这里的选择将决定该应用使用哪个版本的 SDK，因此在很大程度上决定了它将与 Android 设备历史上的哪些设备兼容。较新版本的 Android SDK 提供了对新功能的支持，而旧版本更有可能在旧设备上得到支持，因此支持的设备也更多。您将在您的选择旁边看到额外的文本，表明在全球使用的已激活 Google 设备中，有多少百分比支持您选择的 SDK 版本。对于新功能和广泛支持之间的最佳权衡，没有完美的答案。目前，我们的初始应用不会使用最新发布的 Android SDK 的任何前沿特性，所以您可以使用默认的 API 16，它最初是为了配合几年前的 Android 4.1 Jelly Bean 发布而发布的。如果您愿意，可以滚动列表选择另一个 SDK 版本。如果您选择的 SDK 版本当前没有安装在您的计算机上，它将与完成设置该初始应用所采取的步骤一起被下载–请确保考虑每个 SDK 版本所使用的 100 MB 以上的磁盘空间。

使用传统的 android.support 库:多年来，谷歌尝试了许多方法来处理活跃的 android 设备使用的版本碎片。一种方法是(现在仍然是)使用不依赖于任何特定 SDK 版本的附加支持库，并让应用利用这个支持库。微妙之处在于，与任何特定设备的 Android 安装相比，谷歌更有能力推送支持库的更新。在接下来的章节中，当我们讨论 androidx 和 Jetpack 时，我们会对此进行更多的讨论。目前，您可以将该设置保留为缺省的未选中状态，这意味着我们不会引入对这些库的支持。

你现在离一个可运行的 Android 应用只有一步之遥了。单击 Finish 按钮，Android Studio 就会活跃起来，为您的新 Android 应用及其项目文件夹生成结构和框架。过了一会儿，你最终应该会看到完整的项目和 Android Studio 的完整开发者界面出现，如图 3-12 所示。

图 3-12

Android Studio 显示了打开进行编辑的 MyFirstApp 项目

编写您的第一个代码

如果你查看新项目的布局，如图 3-12 所示，你会看到一个文件夹/目录层次结构，有各种各样的名字，比如manifests、java、res,等等。我们将探索完整的项目布局，您看到的目录，填充它们的启动文件，以及您在下一章构建的部分。

现在，为了让您获得一个具有个人风格的工作应用，我们将跳过对这些项目的解释，直接开始编辑您的第一个应用组件。使用您在 Android Studio 布局左侧看到的项目层次视图，向下点击res文件夹，然后点击layout子文件夹。您应该会看到一个名为activity_main.xml的类似文件的条目(因为这些实际上是文件！).双击activity_main.xml文件，会在 Android Studio 的编辑器视图中打开，如图 3-13 所示。

图 3-13

在 Android Studio 中打开您的第一个源文件

看代码截图很繁琐，所以让我们看看activity_main.xml文件的内容。您的文件应该类似于清单 3-1 。

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
       android:text="Hello World!"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

</androidx.constraintlayout.widget.ConstraintLayout>

Listing 3-1The contents of the activity_main.xml file in a new Android Studio project

这个文件中有几个不同的部分将来会让我们感兴趣，但是现在我们只对这里的一部分代码感兴趣，你可以看到粗体部分。您会注意到，在文件的中间是这样一行

android:text="Hello World!"

继续编辑双引号内的字符串，因此它不是读"Hello World!"，而是读类似"Hello Android!"或任何你喜欢的东西。编辑完该文件后，保存您的更改。您刚刚对 Android 应用进行了首次自定义编辑！

准备运行您的应用

现在，您已经准备好让 Android Studio 在本章前面创建的 AVD 模拟器中运行您的新应用。为了让 Android Studio 做到这一点，当您要求它运行应用时，它需要知道您的特定偏好是什么。例如，您是希望它正常运行，以便与它进行交互，还是希望它以调试模式或其他方式运行，以便仔细检查代码中发生了什么，或者您的应用与 Android 主机设备、您可能调用的其他 API 或基于云的 API 等外部服务之间的交互发生了什么？

Android Studio 通过所谓的运行配置来控制这些运行应用的替代方法。这些是运行应用时关于“运行”确切含义的预设说明。

你可以触发 Android Studio 来引导你设置你的第一次运行配置，只需要立即运行你的应用。打开Run菜单，选择Run...选项。在没有任何预先存在的运行配置的情况下，Android Studio 现在会提示您编辑配置，如图 3-14 所示。

图 3-14

编辑首次运行配置的提示

Note

通过从“运行”菜单中选择“编辑配置…”选项，您始终可以直接编辑运行配置，而无需强制运行应用。

无论您以何种方式触发了第一次运行配置的创建，您都会看到显示的运行/调试配置屏幕。屏幕上的文本将指示单击“+”按钮来添加新的配置，您应该这样做。您将看到如图 3-15 所示的选项列表。

图 3-15

选择新的基本运行配置

选择列表顶部的 Android 应用选项，然后您将看到如图 3-16 所示的详细配置屏幕。

图 3-16

新运行配置的详细配置

您需要进行两项设置。第一个设置是为您的运行配置提供一个容易记住的名称。我建议你使用运行配置 1 这个名字。接下来，您需要指定在运行应用时，运行配置应该启动哪个代码模块。列表中唯一的选项是 app，这很幸运，因为这是你想要的选项。您可以在图 3-16 中看到这两种设置。

单击应用和确定按钮保存您的配置。

安装(附加)SDK 包

根据您在本章前面如何选择应用的最低 SDK 设置以及首次安装 Android Studio 时选择的选项，您的计算机上可能没有安装 Android Studio 用于构建应用的相关 SDK 包。你可以很容易地发现这一点，因为你在 Android Studio 中的默认视图在屏幕的左下角包括了当前的构建状态。

如果您在“Build: Sync”区域看到如下的错误或警告，您可能需要下载一个 SDK 包来匹配为您的项目选择的包:

License for package Android SDK Platform 29 not accepted

或者

Module 'app': platform 'android-29' not found

警告或错误中提到的版本号在您的安装中可能会有所不同。无论是什么版本，都可以通过调用 SDK 管理器特性(IDE 提供的另一项集成)轻松解决这个问题。从 Android Studio 的工具菜单中，选择 SDK 管理器选项，您应该会看到 SDK 管理器出现，如图 3-17 所示。

图 3-17

Android SDK 管理器

要添加您的项目所需的 SDK，只需选中相关版本旁边的框——在我的例子中，就是“Android 10.0 (Q)”，这相当于 API 级别 29，或者换句话说，Android SDK 的版本 29。单击 Apply 按钮，SDK 管理器将触发此版本 SDK 的下载。如果你坐下来想一想，你会意识到，随着你构建越来越多的应用，并可能为它们选择不同的目标 SDK 版本，你最终可能会在你的机器上安装相当多不同版本的 Android SDK，这些将占用相当大的磁盘空间。我们将在第六章中再次讨论这个主题，届时我们将深入了解您的整个开发人员系统设置。

一旦任何所需 Android SDK 版本的下载完成，您应该会看到如图 3-18 所示的状态。

图 3-18

Android SDK 管理器指示成功下载并安装了新的 SDK 版本

此时，您需要让 Android Studio 刷新集成的 Gradle 构建工具的配置，以便它意识到新的 SDK 已经就绪。Android Studio 可以采取所有必要的步骤来做到这一点——因此，如果您对作为构建工具的 Gradle 一无所知，请不要惊慌。只需打开File菜单，选择显示Sync Project with Gradle Files的选项。

当这个同步活动完成时，在屏幕左下方的构建窗口中，您应该看到先前的警告和错误现在都消失了，唯一出现的消息应该是MyFirstApp successful at some-date-and-time。

运行应用

Android Studio 中的完整设置满足了您的应用和 Gradle 的同步需求，并准备好构建您的应用，您的运行配置现在应该可以实际运行您的新应用了。继续从运行菜单中选择运行，或直接选择Run 'Run Config 1'跳过运行配置选择步骤。

一系列操作现在将自动发生，但它们可能需要一点时间——最多几分钟，具体取决于您计算机的性能。首先，将调用 Gradle 来构建您的应用。我们将在后面的章节中更详细地介绍这一过程，但现在您需要知道的是，Gradle 正在将您编写的所有代码、您的应用引用的库、相关的 Android SDK 和其他管道整合在一起，并生成一个可以作为您的应用部署的包。这被称为安卓包，或 APK。

接下来，Android Studio 调用您的 AVD，在模拟器启动一段时间后，它会复制 Gradle 构建的 APK。基于您的运行配置，Android Studio 知道您想要运行应用模块，实际上触发您的新 MyFirstApp 应用在 AVD 中运行，就像您在 Android launcher 窗口中按下它的图标一样。

你的应用会运行，你的不朽的话“你好安卓！”(或者你选择的任何东西)应该出现在一个名为 MyFirstApp 的应用屏幕中，就像你在图 3-19 中看到的那样。

图 3-19

在 AVD 中运行 MyFirstApp Android 应用

就这样！您已经编写并运行了您的第一个 Android 应用。干得好。深呼吸，因为在第四章中，我们将深入到引擎盖下，详细检查 Android Studio 刚刚为您构建的一切。

四、探索你的第一个项目

在第三章中，我向你介绍了在 AVD 上编写和运行你的第一个 Android 应用所需要的一切，目标是让你很快沉浸在 Android Studio、仿真器和你的第一部分编码中。我们很快就有结果了！但是当我们快速浏览的时候，你几乎肯定会有一大堆没有答案的问题冒出来。在这一章中，我们将开始深入许多主题，从你的新 Android 项目的结构和特性开始。这应该开始回答这些问题，并建立你的知识。

查看整个 Android 项目结构

为了熟悉 Android 项目各个部分的结构和目的，从 30000 英尺(或者 10000 米，对于公制单位来说)的视角开始会有所帮助。从上一章来看你的项目的整个布局，结果是惊人的大。虽然您只编辑了一个文件，但是 new project 向导已经为您创建了许多其他文件，并且在创建项目时，还会复制或添加其他文件，如 Java 库、Android SDK 等等。

要查看这个完整视图，请使用 Android Studio 窗口的左侧窗格，即所谓的项目浏览器视图，来展开 app 文件夹；然后是它下面的文件夹比如 manifests、java 等等；以及从顶层向下的所有其他文件夹。您将最终得到一个类似于图 4-1 的整个项目的视图(注意，为了节省空间，我并排显示了长项目浏览器的连续视图)。

图 4-1

项目浏览器中项目的逻辑 Android 视图

您看到的默认视图称为 Android 视图，旨在简化项目所有组成部分的显示方式。这种简化的目标是让您专注于您(开发人员)编写或编辑的部分，而将其他大部分支持文件排除在外。

从这个完整的项目 Android 视图中，您可以看到项目被分解成五个主要的文件组，它们代表了项目的不同部分。

使用清单

在项目浏览器的 Android 视图中显示的第一组文件是您的清单文件。对于像 MyFirstApp 这样的新项目，您只需要关注一个清单文件，即名为AndroidManifest.xml .的文件

这是您的 Android Manifest 文件，它的作用就像是您的 Android 应用的主控制文件。在 Android Manifest 文件中，您能够控制您的应用的许多主要参数和行为，包括声明您的应用需要什么权限才能运行，它可以与什么服务交互，组成应用的活动，以及应用需要和支持的 Android SDK 级别。

我们将在本章后面更深入地讨论这些核心概念，包括定义 Android 意义上的活动和服务。现在，让我们看看您的AndroidManifest.xml文件的内容，您可以在清单 4-1 中看到。

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="org.beginningandroid.myfirstapp">

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">

        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

Listing 4-1The contents of your new AndroidManifest.xml file

正如您可能从文件名中猜到的那样，内容是 XML 格式的。对于第一次接触 XML 的人来说，第八章提供了 Android 开发中 XML 的完整介绍。一旦熟悉了 XML 的基础知识，就可以跳过这个主题，回到这一点。

Android 使用 XML 文档的根元素<manifest>,然后引入两个关键属性:名称空间声明和包声明。就名称空间而言，Android 惯例是只在属性级别使用它们，而不是在元素中使用它们。包名org.beginningandroid.myfirstapp对你来说应该很熟悉，因为这是我们在第三章的项目设置向导中提供的包名。除了提供这种必要的映射来确保应用的完全限定包名的唯一性之外，这种技术还允许我们在将来需要引用应用本身时使用简写。

您可以在清单中看到这一点，第一个<activity>元素以<activity android:name=". MainActivity">的形式被引入。这里，前导点是在<manifest>包属性中引用的完整包名的简写。实际上，这意味着内部引用的名称要短得多，所以在这个例子中，用.MainActivity代替org.beginningandroid.myfirstapp.MainActivity。我知道我更喜欢打哪一个。

清单文件还包括其他关键功能。例如，android:icon和android:roundIcon属性引用了两个资源文件，这两个文件在 Android 设备的启动器屏幕和小部件屏幕上为您的应用提供了方形和圆形图标版本。l 属性保存了你的应用的名字。

另一个重要的条目是前面提到的<activity android:name=".MainActivity">。这个条目，包括子元素<intent-filter>，向 Android 指示当应用启动并且键意图android.intent.action.MAIN被触发时，它应该响应哪个活动。我们将在这一章中很快详细介绍这些概念，但是现在你可以认为这是一种 Android 方式来标记你的应用启动时第一次向用户显示的内容。

与 Java 共舞

Android 项目浏览器视图的第二和第三个主要区域是 Java 源文件。这些是文本文件，其中编写了 Java 代码，使您的应用具有生命力，并执行您希望应用具有的动作、特性和行为。

您将看到两个高级文件夹，一个用于Java，一个用于Java (generated)。事实上，在这个阶段，这两个区域中的所有文件都已经为您生成了，但是一般来说，当您开发应用时，您将更改Java树中的文件，添加新文件，等等，并让 Android Studio 及其集成工具自动处理Java (generated)文件。

现在有一个文件需要特别注意，那就是在Java ➤ org.beginningandroid.myfirstapp文件夹下的MainActivity文件。磁盘上的文件其实叫MainActivity.java，项目浏览器中的 Android 视图是隐藏文件扩展名的。这个MainActivity文件是应用启动时运行的代码，它基于前面提到的 Android Manifest 文件中的配置。

我们将在这一章的后面以及本书以后的许多章节中深入探讨活动的含义。

利用资源变得足智多谋

新项目中文件的第四个主要区域是资源文件，位于res文件夹及其子文件夹中。在不同类别的资源中，有相当多的项目为您生成。

可抽的

Drawables 是 Android 将在屏幕上绘制或渲染的东西，作为应用的一部分。这意味着既有正常的图像，如艺术作品、图表和其他静态图像，也有在运行时根据指令生成的图像。

第一种 drawables 表示在您可能熟悉的典型图像文件中，如 GIF、JPEG 和 PNG 文件。Android 有放大和缩小图像的机制，以适应各种密度的屏幕/显示器，还可以让你存储同一张图像的不同分辨率版本，以避免缩放。在第十四章中，我们将深入研究图像、照片和艺术品的创作以及 Android 应用的技术。

Android 支持的第二种可绘制图像是它在运行时根据 XML 文件中提供的规范创建的矢量图像。您可以在您的新项目中看到两个提供矢量图形指令的 XML 文件示例—ic_launcher_background.xml和ic_launcher_foreground.xml。

布局

在第 9 和 10 章中，我们将详细探讨应用的布局和 UI 设计，涵盖一系列选项和风格。当您在第三章创建新项目时，您会记得为您的项目选择了“空活动”选项。Android Studio 使用这个选项来设置默认布局，它出现在 layout 子文件夹下的文件activity_main.xml中。

同样，这是一个 XML 文件，Android 在定义活动的初始布局和行为特征时大量使用了 XML。如果您将一个活动想象成 Android 应用中的一个屏幕或窗口，然后由用户使用，那么 XML 布局就提供了如何创建和呈现界面的描述。当您的MainActivity Java 代码想要在屏幕上绘制活动时，会使用这个activity_main.xml布局。这个过程在 Android 世界中被称为“膨胀”，适用于布局整个活动界面的过程，以及它的任何子集，如创建一个菜单或在另一个布局中动态添加一个布局。随着应用的增长，该文件夹中活动布局 XML 文件的数量也会增加。

贴图

你可以把mipmap文件夹看作是drawable文件夹的一个特例。如果 drawables 是用于任何目的的图像或艺术品，则 mipmap 条目专门用于您的应用和 Android 设备的启动器屏幕的图标文件。ic_launcher文件夹保存了图标的方形版本，ic_launcher_round保存了相同图标的圆形版本。每个文件的多个实例以不同的分辨率(显示密度)存储，Android 将根据设备的显示特征以及应用或设备可能使用的任何显式配置覆盖，自动确定使用哪个密度版本。

我们将在后面的章节中更多地讨论显示密度及其含义。

在价值中寻找价值

在values文件夹中，您会发现专门用于保存字符串、尺寸、样式和其他参考信息的文件。这种方法体现了几乎所有编程语言和环境中都有的简单抽象技术。与其在应用代码和配置文件中添加可能经常在许多地方重复的硬编码值，不如使用抽象来引用代码以外的某个值的单个定义，这样会使代码更干净，更不容易出错。这在许多方面都有帮助，例如为许多不同的屏幕尺寸和分辨率创建和使用价值资源提供了一个管理良好的机制。

在您当前的项目中，您可以看到应用名称出现在strings.xml文件中。与其将我们的"MyFirstApp"作为字符串嵌入到项目中任何需要的地方，不如在strings.xml文件中引用这个条目。如果我们需要改变这个值，我们可以在一个地方完成，并且知道所有的引用都会自动正确地更新。虽然我们自己不会这样做，但这在诸如将应用国际化和本地化为其他语言等方面有具体的好处。

用 Gradle 文件构建一切

到目前为止，组成你的第一个 Android 应用的各种类型的独立文件的数量正在增长，达到两位数。将所有这些文件放在一起创建一个最终的、可工作的 Android 应用是构建系统的工作，Android Studio 默认依赖于一个名为 Gradle 的构建工具集。

Gradle Scripts文件夹向您展示了各种脚本，这些脚本完成了从组成组件构建完整应用的工作。现在最值得注意的两个文件是同名的build.gradle文件。您会注意到第一个标记为项目的——在本例中是Project: MyFirstApp。第二个标注为Module: app。

“为什么是两个build.gradle档？”你可能会问。最长的答案是，事实上你可以有两个以上的。你现在看到的是所有 Android 项目都有的项目级build.gradle文件。然后你会看到为项目定义的每个模块增加了一个build.gradle文件，允许每个模块处理任何特定于模块的构建活动和参数。因为您的项目只定义了一个"app"模块，所以您只看到了另外一个build.gradle文件，总共有两个。随着我们阅读本书的进展，我们将使用将多个模块合并到一个给定项目中的例子，因此您将在相关项目中看到额外的build.gradl e 文件。

现在，项目级的 build.gradle 文件是最令人感兴趣的，您可以在清单 4-2 中查看它的内容。

apply plugin: 'com.android.application'

android {
    compileSdkVersion 29
    buildToolsVersion "30.0.0"

    defaultConfig {
        applicationId "org.beginningandroid.myfirstapp"
        minSdkVersion 16
        targetSdkVersion 29
        versionCode 1
        versionName "1.0"

        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }

    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }

}

dependencies {
    implementation fileTree(dir: "libs", include: ["*.jar"])
    implementation 'androidx.appcompat:appcompat:1.1.0'
    implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
    testImplementation 'junit:junit:4.12'
    androidTestImplementation 'androidx.test.ext:junit:1.1.1'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'

}

Listing 4-2The project-level build.gradle file

您有各种配置设置来控制如何构建您的应用，这些设置属于几个关键领域。这些是 SDK 版本控制和应用版本控制，目标应用构建的类型，以及作为项目基础所需的依赖项、插件和库的包含。

了解 SDK 版本参数

您将观察到几个提到 SDK 版本的参数，包括compileSdkVersion、minSdkVersion和targetSdkVersion。这些服务有不同但互补的目的:

1. compileSdkVersion:指示 Android Studio 在实际编译和构建应用时使用哪个版本的 SDK——从您可能已经安装的许多版本中选择。通常你会选择最新版本的 Android SDK。

2. minSdkVersion:设置应用中使用本机 API 特性的阈值，并暗示确定支持应用的 Android 和 Android SDK 的最早版本。这反过来会设置可能使用您的应用的最老的设备。在可能的情况下，新 API 级别中引入的特性将由支持库或 Android Jetpack(稍后讨论)处理。

3. targetSdkVersion:控制应用将尝试使用的最新 API 特性，即使compileSdkVersion是比这个版本更高的版本。这意味着您可以从较新的 SDK 提供的编译时效率中受益，但是在您明确提升targetSdkVersion之前，不会被迫对您的应用的行为进行重大更改。

了解应用版本

在发布 Android 应用时，就像几乎所有其他软件一样，版本化的概念用于表示修复 bug、添加新功能、改进现有行为等的后续版本。

Android 使用两个参数，您可以在 build.gradle 文件中找到。最重要的是versionCode参数，传统上它是跟踪应用给定构建/发布版本号的参数。versionCode参数是一个整数，当你释放新的值时，它只会增加。

Note

在内部，从 SDK 版本 28 开始，Android 也提供了更新的versionCodeMajor参数。这是一个long值，而不是一个integer，所以可以容纳更高的值。这目前只能通过在 Android Manifest XML 文件中加入versionCodeMajor="n"符号来成功设置。Gradle 构建文件目前不支持此参数。

Android 还提供了一种向用户显示某种有意义的人类可读版本的机制，来源于versionName字符串值。作为一名开发人员，如果您想尝试向用户传达诸如主要版本和次要版本之类的信息，这将对您有所帮助，这是软件开发的一个传统(尽管不是必需的)习惯。

包括向前和向后版本支持的库

现在要注意的 Gradle 构建文件的最后一个方面是依赖部分。我不会深入讨论现阶段声明的每个依赖项，因为我们将在后面的测试、手机/版本兼容性等章节中讨论它们的细节时，再回到每个依赖项。我将强调的一个常见方面是许多依赖项的名称空间。您会注意到主要组件的名称是androidx。名称androidx指的是 Android Jetpack，它是 Android 方式的最新更新和刷新，Android 允许您作为开发人员针对许多不同版本的 SDK，而无需事先了解它们——实际上，使您的应用免受后来的 SDK 版本中合并的一些更改的影响，同时还允许您构建具有当代 SDK 版本功能的应用，并让 Android 和 Jetpack 担心如何在不明确支持您的 SDK 版本的旧版本 Android 设备上运行时模仿这样的新行为。Jetpack 还有助于减少用 Java 编写软件的冗长，减少样板代码，并帮助您遵循 Android 开发人员社区随着时间的推移而学到的良好实践。

Jetpack 正在取代一种更老的方法，即 Android 支持库，但是在许多参考资料和讨论中，您仍然会看到支持库，并且在未来的一段时间内，这两种支持库将会并存。

解释关键的 Android 应用逻辑构建模块

现在，您对 Android Studio 中的项目结构和布局有了一些了解。但是在这一章的几个地方，我已经提到了 Android 应用的一些基本的逻辑构建块，比如活动和服务。现在是时候多了解一下这些构件是什么，以及它们是如何组合在一起使您的应用变得生动的。

活动

如果你使用过任何现有的 Android 应用，你会体验到它与大多数带有用户界面的软件有一些共同的主题。像其他有用户界面的软件一样，Android 使用了“屏幕”或“视图”的概念，用户可以在这里与你的程序进行交互。Android 调用这些活动，无论你想让你的用户阅读文本，观看视频，输入数据，打电话，玩游戏，或者你有什么，你的用户都会通过与你设计的一个或多个活动屏幕或布局进行交互来完成这些。

Activities 是 Android 中最容易开发、计算成本最低的部分之一，您应该在应用中慷慨地创建和使用它们。这不仅有助于你的用户从你的应用中获得良好的体验，而且 Android 操作系统在设计时就考虑到了活动的扩散，并在管理这些活动方面提供了很多帮助。

意图

Intents 是 Android 的内部消息传递系统，允许在应用之间以及与 Android 环境之间传递信息。通过这种方式，您的应用可以触发操作，并与 Android 和其他应用共享数据，它还可以监听正在发生的事件，并在适当的时候采取行动。

Android 操作系统已经有了非常广泛的应用可以与之交互的意图，作为开发者，你也可以定义和开发自己的意图供自己使用。

服务

服务是计算世界中的一个常见概念，虽然在 Android 中处理它们时有细微的差别，但许多常见概念仍然适用。服务是通常没有用户界面，而是在后台运行的应用。服务提供了多个应用通常需要的一系列特性、功能或行为。服务通常是长期存在的，在后台运行，根据需要帮助您的应用和其他程序。

内容供应器

您的应用可能想要使用许多您自己无法控制的数据类型和派生。许多其他应用都有类似的数据需求，因此 Android 附带了内容供应器的概念，这是一种抽象数据集和数据源的方式。这种抽象试图简化与各种数据源的交互，包括文件、数据库、流协议和其他访问数据的方式，为开发人员带来一些逻辑一致性。您不必为要使用的每组数据或每种数据类型学习不同的自定义数据处理方式，只需学习一次内容提供者方法，就可以在许多不同的内容提供者数据源中重复使用它。

您还可以构建和共享您自己的内容提供者，促进与其他应用的数据共享和交互。

摘要

现在，您已经了解了典型的 Android 开发项目是如何构建的，以及 Android 应用的一些主要构件是如何在逻辑上和构建应用的过程中组合在一起，从而创建一个完整的应用的。我们将继续在本章所描述的基础上进行构建，扩展我们对其中许多部分的探索，以便您了解越来越复杂的应用是如何构建的。

五、Android Studio 深入

像 Android Studio 这样的 IDE 的长期用户通常会对他们选择的 IDE 有多重要形成一种非常强烈、非常狭隘的观点——不仅对他们的生产力，而且对他们编写应用的乐趣。在这一章中，我的目标是展示和探索 Android Studio 的一些关键特性，这些特性将使您在构建 Android 应用时更加高效和快乐。

Android Studio 本身就是一个巨大的话题。有整本书都是关于 Android Studio 本身以及如何充分利用它作为 IDE 的。这本书的发布商 Apress 的一些很好的例子是 Android Studio IDE 快速参考(由 Ted Hagos 编写，ISBN 978-1-4842-4953-6)和 Learn Android Studio 系列(也由 Ted Hagos 编写)。在本书中，我们没有足够的时间将剩下的章节都用来讲述 Android Studio 本身，但是如果这一章让你对一个伟大的 IDE 所提供的可能性感到兴奋，你就知道下一步该去哪里了。现在，让我们深入研究 Android Studio 的一些关键部分，你现在应该开始了解。

从项目浏览器开始

回到第四章，我们简要介绍了项目浏览器和它的一些功能，展示了 Android 透视图和项目文件透视图。我们简要地研究了项目的这两个视图，但是没有详细讨论其他的项目浏览器视图选项。这让我们想知道，所有这些其他的观点是为了什么？

很高兴你问了。概括地说，Project Explorer 的其他视图选项旨在满足两个兼容的需求。首先，这些视图为您提供了查看项目的不同方式，通常强调或专注于一个特定的领域，以便您的时间可以用于完成工作，而不是与 Android Studio 的布局进行斗争。其次，这些观点也支持你作为开发人员的个人偏好和愿望，以及你更喜欢的工作方式。

轻松切换项目浏览器视图

让我们来看看这些视图中的一些，您可以探索所有其他视图，感受一下您喜欢的内容。图 5-1 显示了我们的 MyFirstApp 项目切换到使用项目源文件视图(同样，不是很长的图像，我并排粘贴了两个屏幕)。

图 5-1

Android Studio 项目资源管理器中的项目源文件视图

您可以在 src 文件夹层次结构下看到一些熟悉的条目，例如，myfirstapp Java 源文件及其 MainActivity 代码。如果您在这个视图中稍微浏览一下，就会看到其他的源文件，比如用于测试代码的模板文件，以及一些可编辑的 XML 文件，这些文件控制着可视化布局、可重用的字符串值等等。

但最值得注意的是没有显示出来的东西。您再也看不到 Gradle 构建文件、IntelliJ IDEA 首选项和配置文件、构建工件以及其他非代码项目。所有这些都是隐藏的，所以您可以专注于代码！“为什么要这样做？”我听到你问了。除了我在前面提到的个人偏好和专门化观点之外，Project Files 视图尤其是一些开发人员的最爱，他们发现当他们处于“流动”状态时工作得最好:一种精神状态，在这种状态下，您深深地沉浸在代码中，没有分心。

另一个流行的视图是项目视图，它看起来就像许多传统的 Java IDEs 一样，展示了项目的元素和组成部分。图 5-2 显示了这个视图，你会注意到一些直接的不同，特别是外部库和引用是如何出现的。

图 5-2

Android Studio 项目浏览器中的项目视图

我强烈建议您探索 Project Explorer 中的所有视图选项，并找到最适合您工作方式的变体。

需要记住的一点是，不管你使用什么视图或者切换视图多少次，Android Studio 都不会改变你的项目或者移动文件。它只是给你一个不同的虚拟视图。

使用项目浏览器上下文菜单

与您可能使用过的许多其他应用一样，Android Studio 提供了上下文菜单，您可以通过右键单击鼠标(或在 Mac 上按住 command 键单击)来访问这些菜单。当您在 Project Explorer 中浏览视图时，您应该调用您所看到的所有内容的上下文菜单，以便对所提供的内容有所了解。无论是比较、查找等文件管理操作，快速编辑选择，还是开始更严肃的代码管理操作，上下文菜单都是您应该熟悉使用的专业工具之一。

上下文菜单中的所有选项都可以在 Android Studio 的主菜单中找到，但这些选项通常被隐藏在三到四层菜单中。

使用 Android Studio 运行和调试

正如你在第三章中所看到的，让 Android Studio 运行你的程序的一个主要方法，无论是仿真的还是在设备上运行的，就是配置一个运行配置。我们稍后将再次讨论运行配置，但最好知道还有其他方式来运行您的应用。

使用运行配置运行:概述

我们在第三章的目标是让你的第一个应用尽可能快地运行，所以我们跳过了许多运行配置的细节。有一些关键的方面值得重新审视，因为您很快就会想要创建具有不同特征的进一步运行配置，以便在应用开发的不同阶段为您提供帮助。

通过 Android Studio 的运行➤编辑配置…菜单，调出“运行配置 1”的详细信息(或之前您用来保存运行配置的任何名称)。你应该会看到熟悉的屏幕显示你的运行配置，如第三章的图 3-16 所示。对于任何运行配置，有各种选项分布在四个子窗口中。其中一些您可以在自己的时间里探索，但是您需要熟悉的主要配置项目如下。

运行配置:常规选项

Module:指定 make 过程的目标模块，如果没有指定，则意味着整个项目都应该是目标。实际上，这有助于更大的多模块项目，在某些情况下，您可能只想重建/重新制作一个特定的模块——通常是因为这是唯一改变的模块。

install Options–Deploy:指示 Android 应用构建完成后应该发生什么。是应该在设备或模拟器上运行，因此需要部署它，还是您只对确认应用将干净无误地构建，而不需要实际运行它感兴趣？

启动选项–启动:该设置控制当成功的构建被部署和启动时会发生什么。应用应该按照 Android Manifest XML 文件运行并启动默认活动，还是应该在这个特定的运行配置中使用不同的起点(例如应用中的替代活动或根本没有活动)？

安装标志和启动标志目前不在我们运行配置的讨论范围之内。

运行配置:杂项

杂项选项控制在部署和启动构建时，如何“清理”您的目标环境。所谓清理，我指的是日志、应用的先前版本等等作为运行配置的一部分被留下或清理的工件。

Logcat:我们将在本章的后面更多地讨论 Logcat，但是这些设置决定了 Logcat 的输出是否应该默认地通过 Logcat 工具显示给你，以及之前运行的输出是否应该被清除。如果任其增长，这些日志会变得非常大，所以如果这些日志变得难以处理，请记住清除日志设置。

安装选项:如果什么都没有改变，您可能想跳过再次部署您的应用，这可以在您更广泛的工作流中节省时间。知道自己不会影响正在运行的应用实例是很重要的，例如，在保存状态或从已知的良好启动条件下运行时。

运行配置:调试器

那些在编写任何类型的软件方面经验丰富的读者会意识到，这不是一项完美的任务。事情出错，意外的行为发生，应用由于不可预知的原因而失败，等等！

一旦您花了一些时间编写、调试和审查代码，调试器屏幕上显示的选项随着时间的推移会变得更有意义。无论您的经验水平如何，都需要注意以下关键选项:

调试类型:本质上，这为 Android Studio 提供了关于项目中预期的代码类型的指导。这可以显式地设置为 Java、Native(通常指通过 Android 的本地开发工具包扩展的 C++)、Dual(Java 和 Native)或 autodetect。确切地指定预期的语言，而不是依赖于自动检测的一个优点是，在让 Android Studio 检查您的项目的语言类型时，您将节省少量时间，而不是让它为不存在的语言加载调试工具。

显示静态/全局变量:当出现问题时，许多开发人员首先使用的工具之一是检查工具——也就是说，当出现问题时，显示部分代码的当前状态的工具，例如分配给特定变量的值。该选项将静态/全局变量以及您在整个代码的方法中定义的变量添加到您的视图中。

调试优化代码时发出警告:语言编译器的一个非常有用的特性是，它们能够优化人类编写的代码，使其运行更高效。发生这种情况时，运行的代码严格来说并不是您编写的代码，即使结果应该是相同的。此设置允许您在转到调试已为您优化的代码时得到警告。

符号目录和 LLDB 选项等其他设置超出了本书的范围。

运行配置:分析

任何形式的 Android 评测工具都花了很长时间才达到开发人员所需的成熟度和洞察力，以帮助他们了解他们的应用正在产生的环境需求。甚至在几年前，在 Android Studio 和 Eclipse 中，工具仍然达不到大多数人的期望。今天，这些工具一直在变得越来越好，当我们在后面的章节中深入研究这些领域时，我们将触及其中的一些。其中一些改进的选项可以直接在运行配置中进行配置，如下所示:

启用高级概要分析:对于任何使用 API 级别为 26 或更低的目标 SDK 的人来说，试图确定您的应用的即时环境中正在发生什么可能会令人沮丧，例如，网络行为和流量、处理或丢弃的事件等等。Enable Advanced Profiling 选项打开了为旧的目标 API 级别捕获更多指标的能力。对于任何以当代 API 级别为目标的人来说，例如 30+，这现在是 Android Studio 和相关工具中标准剖析行为的默认部分。

启动时开始记录 CPU 活动:该设置旨在分析应用使用时 CPU 周期的消耗情况。这至少有两个好处:第一是了解你的应用的各个部分将如何执行，这在考虑用户满意度时很重要——一个缓慢的应用可能会导致用户对你的应用感到失望。第二个好处是去掉了一个抽象层次。因为 CPU 使用是智能手机电池最繁重的事情，CPU 活动记录可以帮助您了解您的应用在使用时是否会成为电池消耗的重要因素。CPU 活动设置可能不会在您早期的 Android 学习经历中开始使用，但一旦您开始探索 CPU 密集型 Android 功能，如视频使用、设备上的计算等，它将成为您开发人员工作流程的支柱。

使用 avd 和连接的设备跑得更远

在第三章中，我们经历了创建初始运行配置的步骤，然后使用我们创建的第一个名为Pixel 2 API 30的 AVD 来实际运行您的应用，并向您显示最终的活动屏幕。使用 AVDs 是 Android Studio 为您提供的最强大的功能之一，使您能够跨大量虚拟设备进行测试和实验。

从技术上来说，AVD 管理器是一个独立的工具，Android Studio 集成并提供它来简化你的生活——这是我在第二章中介绍的“集成”咒语。除了能够从 Android Studio 中的工具菜单或工具栏按钮(显示为微型手机图标)启动 AVD 管理器，您还可以直接从命令行或 shell 运行 AVD 管理器的命令行版本，作为 SDK 工具目录中的独立工具。

为了找到 SDK 工具目录，从您的 Android 安装路径的根目录(例如，在 macOS 上的~/Library/Android或者在第二章中您为您在 Linux 或 Windows 下的安装选择的 Android 目录)，您将找到一个sdk子目录。在sdk子目录中，跟随进一步的子目录tools ➤ bin。包含在其中，您会发现一个名为avdmanager的二进制可执行文件。你可以从它的名字中猜出这是独立的 AVD 管理器可执行文件。如果您在查找 SDK 工具目录时遇到任何问题，请使用操作系统的搜索功能。

当您从命令行运行时，您会得到命令行输出，如清单 5-1 所示，这取决于您传递给 avdmanager 命令的选项。

$ avdmanager list avd

Available Android Virtual Devices:
    Name: Pixel_C_Tablet_API_30
  Device: pixel_c (Google)
    Path: /Users/alleng/.android/avd/Pixel_C_Tablet_API_30.avd
  Target: Google APIs (Google Inc.)
          Based on: Android API 30 Tag/ABI: google_apis/x86
    Skin: pixel_c
  Sdcard: 128 MB

Listing 5-1Command-line output for the avdmanager tool

重温 AVD 管理器

现在你有很多方法来启动 AVD 管理器，继续从 Android Studio 工具菜单启动它，因为我们将为将来的练习创建第二个 AVD。如果你需要帮助，你可以重温第二章 2 的逐屏操作说明，但这里是我们第二个 AVD 的目标:

类别-平板电脑:我们想创造一个平板电脑大小的 AVD，这将有助于用书中的例子测试更大的设备。

名称和类型——Pixel C table t API 30:这是最好的多功能平板电脑之一，也是最近推出的一款直接从谷歌安装了简单安卓系统的平板电脑，是测试平板设备的绝佳基准。

系统映像–R(API level 30):这是最新的 SDK，它带来了 Android 为平板设备提供的最新功能。

注意您可能会看到 R 系统映像旁边有一个蓝色的下载链接。这表明您的计算机上尚未安装必要的英特尔 x86 系统映像。您需要单击下载链接并继续安装系统映像，以便此 AVD 能够成功启动并运行。

AVD 名称–Pixel C table t API 30:您可以使用您喜欢的任何名称，但是当我们在 AVD 管理器中看到 AVD 时，或者当正在运行、测试和调试您的代码时，作为正在运行的仿真器进程之一，此示例名称添加了一些有用的线索。

完成后，您应该在您的虚拟设备窗口中看到(至少)两个 avd，如图 5-3 所示。

图 5-3

AVD 管理器中配置了多个 AVD

创建第二个(或第三个或第四个)AVD 的目的不仅仅是显示 AVD 管理器的另一个屏幕截图。要使用 Android Studio 在多个设备或 avd 上同时运行相同代码的能力，需要有两个或更多 avd。

在您的 Android 开发工作中，有许多原因会让您想在不同的 avd 和设备上同时测试这种能力。在前面的章节中，我们提到了世界各地销售和使用的设备的多样性，支持的 Android 版本和 SDK 版本的分散性，以及其他因素，这些因素意味着您的应用可能会在许多微妙不同的设置中运行。首先，在几个设备上并行运行你的应用可以帮助你发现你的用户在现实世界中可能看到的一些怪癖和差异。这种能力的第二个主要好处是可以看到你的应用在小屏幕上一次显示一个活动的效果，而在大屏幕上——比如平板电脑——你的活动可能会缩放到不同的大小，或者使用片段作为多活动显示的一部分出现(我们将在第十一章中介绍)。使用多设备或 AVD 测试的第三个原因是观察 Android 如何在不同显示密度和分辨率的屏幕上缩放或插入特定分辨率的图像。

您应该立即在多个 avd 上测试运行 MyFirstApp 应用。您可以从工具➤选择器件菜单选项或图 5-4 所示的器件选择等效工具栏下拉菜单中触发此操作。

图 5-4

设备选择工具栏下拉菜单

选择“在多个设备上运行”选项，将会出现一个名为“选择部署目标”的对话框。选择两个或更多的设备或 avd，例如，我们在书中迄今为止已经创建的 Pixel C Tablet 和 Pixel 2 AVDs，如图 5-5 所示。

图 5-5

选择多个目标以在 Android Studio 中启动您的应用

同时启动多个 avd 将花费一些时间，但是经过一点耐心，您应该会看到您的 avd 启动，并且 MyFirstApp 应用部署并运行在所有 avd 上，如图 5-6 所示。

图 5-6

同时部署在多个 avd 上的应用

在真实设备上运行您的代码

虚拟设备对任何开发人员来说都是一个福音，但是有时候在真实设备上看到你的代码是一件很平常的事情。在最近发布的 Android Studio 中，谷歌在真实设备上测试和运行应用方面取得了巨大进步。历史上，将应用部署到真实的手机上需要一长串命令行步骤，虽然今天您仍然可以走这条路，但 Android Studio 使检测和使用通过 USB 电缆连接到您的开发人员机器的 Android 设备变得很容易。

为了在开发应用时使用 Android 手机测试它们，您需要在手机上启用开发者选项。谷歌一直有一个窍门来实现这一点，那就是打开手机上的设置，滚动到关于手机选项。“关于电话”屏幕上的最后一个选项是内部版本号。点击显示的数字七次(是的，七次)，你会看到一个倒计时出现，让你知道你只剩下几个点击在开发者模式启用之前。

一旦你点击了足够多的版本号，你会看到一个屏幕通知，开发者选项现在已经启用，一个新的菜单选项将出现在设置下，显示开发者选项。默认情况下，它会启用一个名为 USB 调试的子选项。仔细检查你手机上的情况，如果还没有启用，就打开它。

在手机上启用开发人员模式后，通过 USB 电缆将其连接到您的开发人员计算机。您的手机应该会被自动检测到，然后 Android Studio 会将其识别为运行您的 Android 应用的潜在目标。

为了进行测试，从菜单中选择Run ➤ Select Device，或者打开 avds 设备工具栏上的下拉菜单，如图 5-7 所示。

图 5-7

从 Android Studio 选择连接的开发人员模式 Android 设备

选择您的连接设备，在我的例子中是 Nexus 5 手机。等待几秒钟，Android Studio 将构建、打包和部署应用到连接的设备，然后您应该会看到您的应用加载并在您的手机上运行，如图 5-8 所示。

图 5-8

在连接的 Android 手机上运行 MyFirstApp

调试而不是运行您的代码

任何刚接触应用开发的人最终都需要了解当您的代码“出错”时会发生什么无论是意外的结果、奇怪的行为、应用崩溃还是其他问题，调试都是解决应用问题的主要方法。

调试是一个巨大的主题，所以我们不会在专门讨论 Android Studio 工具的章节中试图掌握它，我们将首先关注 Android Studio 中的主要调试工具，然后在整本书中，我们将在介绍更复杂的 Android 应用时扩展调试和相关主题。您也可以在本书网站上阅读更多关于调试的主题，网址为 www.beginningandroid.org 。

在 Android Studio 中，有助于调试的四个关键概念如下。

设置和清除断点

断点是源代码中的一个标记，它指示要在何处中断或停止代码的执行，以便更详细地检查行为或问题。要在代码中设置断点，在项目浏览器中双击文件或对象，打开您想要处理的代码——在我的例子中，它将是 MainActivity.java 文件。在文件打开的情况下，点击文件旁边显示的行号右侧的暗灰色空白处，如图 5-9 所示。

图 5-9

在 Android Studio 中为调试设置断点

您应该会看到在您单击的地方出现一个红圈，表示设置了一个断点。如果出于任何原因，这似乎没有使代表断点的红圈出现，请打开“工具”菜单并选择“切换行断点”。再次单击或再次选择切换选项将删除断点。

启动应用进行调试

正如您可以通过单击运行选项或选择已设置的运行配置来运行应用一样，您也可以启动应用进行调试。这实际上做了同样的事情，调用 Gradle 来构建您的应用，将应用部署到指定的设备或 AVD，等等。一个不同之处是 Android Studio 会帮助你调试。

要在调试模式下启动应用，只需从运行菜单中选择调试“运行配置 1”(或类似选项)。除了构建和部署步骤，您还会看到 Android Studio 中的下方视图会自动打开并显示调试窗口，可以访问调试器、控制台和其他调试工具，如图 5-10 所示。

图 5-10

Android Studio 中自动触发的调试视图

根据您正在调试的内容，如果您已经设置了断点，您还会看到运行菜单中的附加菜单项被激活，如图 5-11 所示。

图 5-11

调试选项，可以单步执行、遍历和跳出 Android Studio 中的部分代码

我将在下一个标题下解释这些“步进”选项。

调试时逐句通过代码

你在图 5-11 中看到的“单步执行”、“单步进入”、“单步退出”等选项对于仔细检查你的代码正在做什么是不可或缺的。通过一次单步执行、跳过或跳出一行代码，而不是运行整个代码库，您可以一次单步执行应用逻辑中的一个操作，并且与其他工具(如变量检查和查看活动 ui 中的视觉或行为变化)相结合，您可以看到每行逻辑的结果。

附加调试器

您可能并不总是清楚在哪里设置断点或者单步执行或遍历代码。有时，您可能想更深入地了解应用中发生的事情，以理解一些无法解释的行为或问题。这就是调试器工具的用武之地。我们无法在短短几页，甚至一整章的时间里对调试器进行公正的评价，所以我们不会强调这一点。你可以在本书的网站 www.beginningandroid.org 找到更多关于调试器强大功能的信息。

要调用调试器，并让它将自己附加到正在运行的应用上，以帮助您了解正在发生的事情，您可以使用运行菜单中的最后一个选项——将调试器附加到 Android 进程。您的应用必须已经在运行，这样才能工作。

查看您的跑步记录

现在，您已经看到了足够多的在 AVD 或真实设备上运行的第一个应用的例子，您可能想知道我所说的“查看您运行的内容”是什么意思要解开这个谜团，除了查看完成的应用中呈现的活动之外，还有更多“看到”您的应用运行的内容。

Android Studio 提供了几个非常有用的工具，有些人会说是关键的工具，让您可以查看应用由 Gradle 脚本(或其他工具)构建时发生了什么，以及应用运行时发生了什么的诊断和日志信息。

在 Android Studio 窗口的底部，状态栏的正上方，你会看到一组按钮，可以让你快速访问这些工具，它们的名称类似于TODO, Build, Logcat,等等，如图 5-12 所示。

图 5-12

在 Android Studio 中轻松访问事件日志、构建输出、Logcat 等

让我们看看这里的一些关键工具，这样您就可以放心地将它们应用到您不断扩展的开发人员工具集中。

了解您的体型

构建工具在构建输出窗口中向您显示构建过程的摘要，这可能是一条“构建:已完成”消息，带有一个绿色勾号和一些计时信息，如图 5-13 所示，也可能是一组阻止构建工作的错误或问题。

图 5-13

Android Studio 中项目构建的构建输出视图

您还将看到实际执行应用构建的任务列表(在我的例子中，有 20 个单独的构建步骤)和一个到 Build Analyzer 的链接，它提供了对每个任务花费的时间以及如何改进的更深入的探究。

了解事件日志中的事件

补充构建工具的另一个工具是事件日志。事件日志显示所发生的操作的高级视图，例如将新构建的应用加载到设备或 AVD 上所采取的步骤，以及这些步骤中发现的任何问题。清单 5-2 显示了构建 MyFirstApp 应用并在多个 AVD 实例上启动它的事件日志输出。

22:17 Executing tasks: [:app:assembleDebug] in project /Users/alleng/AndroidStudioProjects/MyFirstApp

22:17 Gradle build finished in 9 s 5 ms

22:17 Install successfully finished in 11 s 455 ms.

22:17 Install successfully finished in 2 s 612 ms.

22:18 Emulator: emulator: INFO: QtLogger.cpp:68: Warning: Error receiving trust for a CA certificate ((null):0, (null))

22:18 Emulator: Process finished with exit code 0

Listing 5-2The Event Log from building and launching MyFirstApp on two AVDs

您可能在事件日志中看到的典型错误可能会停止构建或后期构建活动，例如为计算机上不存在的模拟设备指定 SDK 或基本映像。事件日志中后一个问题的示例如下:

Emulator: emulator: ERROR: This AVD's configuration is missing a kernel file! Please ensure the file "kernel-ranchu" is in the same location as your system image.

了解 Logcat

Logcat 是测试和调试工具库中最有用的工具之一。它的工作是在您的应用运行时，以及当您的应用意外停止运行、崩溃、出现问题、冻结等时，帮助从设备或 AVD 收集诊断和运行时信息。

Logcat 将提供一个类似控制台的界面来检查和查看来自设备或仿真器的关键系统消息，包括所有重要的堆栈跟踪，如当应用在运行时遇到错误或异常时，发生了什么和发生了什么错误。这种能力在以下情况下非常有用:代码可能在一个环境中运行得非常好，比如在开发人员工作站上运行 AVD，但在特定品牌或型号的手机上运行时会遇到意想不到的问题。

要使用 Logcat，只需在应用运行时，或者在设备或 AVD 执行其他任务(如启动)时，单击工具栏上的按钮。默认情况下，您会看到一长串 Logcat 条目，这些条目是从您的应用和设备中收集的，如图 5-14 所示。

图 5-14

Android Studio 中的 Logcat 输出

这个示例 Logcat 输出是相当无害的，但是当出现问题时，Logcat 中的堆栈跟踪和其他诊断信息是非常宝贵的。

重新审视 SDK 管理器

Android Studio 提供的主要工具的最后一个方面是重温你在第三章中第一次看到的 SDK 管理器。通过打开“工具”菜单并选择 SDK 管理器条目，您可以随时调用和使用 SDK 管理器。您可以这样做来查看您已经安装的 SDK 版本以及任何未安装或有更新的版本，如图 5-15 所示。

图 5-15

重新审视 Android SDK 管理器

正如您所料，您可以检查您没有的任何 SDK 版本，然后单击 Apply，SDK Manager 将开始在后台下载和安装这些版本。当你在两种情况下工作时，你很可能需要这样做:第一，当你确保你有代表普通或流行的 Android 版本的 SDK 时，例如 4.4“kit kat”，第二，当你测试新的功能时，因为谷歌结合新版本的 Android 发布了新的 SDK。

但是使用 SDK 管理器还有另一个原因，那就是它能够帮助你为 Android Studio 体验添加额外的好东西。切换到 SDK 管理器中的第二个标签，标题为 SDK 工具，您将看到一个额外的宝库，很快就会成为您最喜爱的工具。在本书的其余部分，我们将在相关章节中重新讨论这些工具，但是我将标记开发人员经常使用的两种工具。这些是 Android SDK 命令行工具，提供了从命令行管理和控制 SDK 包的额外功能，以及各种附加的 Google Play 库和 SDK，帮助您构建使用谷歌专有的 Google Play 服务的依赖项和库的应用。

您可以现在就下载这些内容，或者等到本书的后面部分再下载。

突出 Android Studio 的其他主要功能

本章介绍了 Android Studio 的一些关键特性，这些特性可用于在构建应用时管理、执行、检查和诊断应用，以及管理和使用相关的 SDK 和构成应用开发工作一部分的其他工具。

但是到目前为止，Android Studio 中您将使用的最大的工具集是那些与编写代码、审查代码、详细检查代码、重写代码等直接相关的工具。我们将在本书的第二部分介绍 Android Studio 的许多方面，同时介绍 Android 应用编码的许多部分。

摘要

本章已经向你介绍了任何软件开发人员的主要工具，IDE。现在，您应该可以放心地探索 Android Studio 中的更多选项，因为您知道您总能找到项目所需的核心工具。

六、掌控您的整个开发者生态系统

为 Android 开发做准备不仅仅是安装 Android Studio。虽然你可以做到这一点，也只能做到这一点，但你最终会发现，你的电脑及其运行的软件的其他方面，将对你作为一名 Android 开发人员的生产力、抱负和能力产生巨大影响。这一章并不详尽，但确实给了你许多重要的基本考虑，以及到哪里去进一步了解的链接。继续读！

选择专用开发人员硬件

在第二章中，我介绍了一份简短的清单，列出了严肃的 Android 开发者可能会感兴趣的电脑方面。这里再总结一下:

1. 我将在 Android 开发中使用什么台式机或笔记本电脑硬件？

2. 我将在台式机/笔记本电脑上运行什么操作系统？

3. 在使用 Android Studio 之前，我的系统需要什么先决条件？

4. 在开发过程中，我将使用哪些 Android 手机(如果有的话)？

我当时提出的格言仍然适用。几乎所有你手边最近几年生产的电脑都可以作为不错的开发人员工作站。无论是台式电脑还是笔记本电脑，它都能完成工作。

但是这本书不仅仅是关于完成工作。如果你真的渴望成为一名专业的 Android 开发人员，那么就像其他专业人员依赖工具和设备来提高效率和杠杆作用一样，你也应该考虑一下什么工具会促进你的开发工作和你制作优秀应用的能力。

让我们首先看看如果你正在寻找在构建 Android 应用时会给你带来不公平优势的开发者硬件，你可能要考虑的因素。

确定哪种 CPU 最适合您

2020 年，x86 _ 64 CPUs 有很多选择:AMD 的锐龙和 Threadripper 以及英特尔的 Core 系列 CPU。您可以找到许多关于哪个最好的意见，通常这些判断会考虑原始 CPU 速度(时钟频率)、封装中的内核数量、不同级别的板载高速缓存以及其他几个特性。

对于专门的 Android 开发机器来说，任何当代的英特尔或 AMD CPU 都足够了。如果你正在寻找 2020 年时代 CPU 的具体建议，你应该看看英特尔酷睿 i5 和酷睿 i7 CPUs 以及 AMD 锐龙 7 和锐龙 9 CPUs。这些处理器具有足够的速度、可观的内核数量(通常为四个或更多)，以及良好的 L1/L2/三级高速缓存。

AMD 和英特尔都有更强大的 CPU，但通常你会看到这些 CPU 有更多的内核，偶尔还支持其他东西。在 Android 开发领域，内核越多并不总是越好。为您并行运行的关键活动是您在 Android Studio 中工作并在一个或多个 avd 中查看结果的任何同步活动，以及对于足够大的多项目应用，并行构建活动(如果 Gradle 被配置为支持它们)。我的建议是，省下最贵的酷睿 i9 和类似的 AMD 处理器的钱，把这些钱用在开发者设置的其他部分，比如更多的内存或更好的屏幕。

另一个越来越受欢迎的 CPU 架构是 Arm。Arm 是当今世界上几乎所有移动设备的核心，其基础是获得 Arm 架构许可的“片上系统”(SOC)设计的广泛流行。基于 Arm 的台式机已经出现，甚至 Arm 服务器市场也刚刚兴起，但这里有一个有趣的难题。

虽然今天全球销售和使用的绝大多数 Android 设备都是由 Arm 处理器构建的，但使用基于 Arm 的计算机来处理计算繁重的工作负载(如构建/编译 Android 应用)仍然是一个挑战。可以做到；毫无疑问。但是速度和性能的权衡仍然很重要。最大的障碍是你期望使用的工具是否适用于基于 Arm 的计算机。最值得注意的是，Android Studio 不适用于 Arm——它只能在 x86 架构的计算机上运行。同样，谷歌只为 x86 封装了 Android SDK 的许多版本，而不是 Arm。这意味着如果你选择一个基于 Arm 的开发机器，你将需要用你自己的构建工具引导你的所有工作，解决没有容易捆绑的 Android SDKs 的问题，等等。我不会推荐这种挑战。

内存太多永远不够！

我有时希望给自己添加内存就像给台式电脑添加内存一样简单。现在，为了更好的开发者火力，你和我将不得不满足于购买 RAM。

如果你回想一下第二章，你会记得谷歌推荐 Android Studio 的内存最低为 4 GB，首选的基本内存为 8 GB。买只有 4 GB 内存的新电脑其实挺难的。所以，引用一部著名电影的话，8 就够了吧？

别这么快！你当然可以在 8 GB 内存的电脑上高效地开发 Android 应用。事实上，我正在编写这本书的很大一部分，并在 2015 年的 MacBook Air 上构建一些你看到的例子，MacBook Air 有 8 GB 的内存，所以这不仅仅是理论上的可能。然而，我可以告诉你，它有其明显的局限性和挫折。一些值得注意的例子是我试图运行 Android Studio 和 AVD，以及我在本章后面和整本书中讨论的用于图像和视频处理的开源工具。8 GB 很快就耗尽了，MacBook 尽职尽责地开始增加——并越来越多地使用——磁盘上的交换空间，以平衡实际内存和我对它提出的更高要求。

相比之下，我信赖的台式电脑。它甚至更老，是近十年前的“老式”Dell Precision 工作站-我不确定戴尔是否还会生产这些工作站。但它有 32 GB 的内存，使用 Android Studio、多个 avd 和其他几个工具时不会漏拍。

Note

你可以从我的设置中看出，我在推荐你购买硬件时并没有收取加盟费或回扣。如果你有时间机器，请跳回到 2010 年或 2015 年购买你的版本我的硬件！

如果你正在指定你自己的 Android 开发者系统，我给你的简洁建议是:没有人抱怨他们有太多的 RAM！如果可以，至少要 32gb；对于奢侈品来说，64 GB 对于未来几年的 Android 开发来说已经足够了。

对于那些希望购买或获得笔记本电脑作为主要开发机器的人来说，请特别注意您的首选型号可以占用的最大内存是多少，以及在购买后内存是否可以更改。也就是说，内存是否焊接或固定在适当的位置，如果不采取昂贵的、可能导致保修失效的措施，就无法更换或交换？你可能会发现自己被限制在 16 GB 以内——如果你能选择一个支持 32 GB 的型号，你将来会感谢你自己(也许还会感谢我！).

全部储存起来！

随着您开始构建越来越多的 Android 应用，您对磁盘空间的需求将会增加，以容纳各种项目、资源等等。很明显，有些地方会消耗磁盘空间，比如磁盘上用于存储源代码文件(非常小)以及图像和视频文件(可能非常非常大)的空间。

当你想到它们时，有一些 Android 开发的特定方面是显而易见的，例如不同版本的 Android SDKs，每个版本可能需要高达 1 GB。

在考虑您的存储需求时，avd 是一个隐藏因素。因为很容易产生一个新的 AVD 图像来测试屏幕大小或设备格式，所以很容易在你知道之前就有 20 个、30 个或更多的 AVD。如果你真的想测试各种尺寸和分辨率的屏幕，最起码要有几十个 avd。

有了几十个或几十个 avd，您可以轻松地吃掉 50 GB 或更多。avd 最大的存储问题之一是您选择允许多少板载存储或模拟 SD 卡存储。这些选项是通过分配您的磁盘存储来模拟的，这意味着如果您想要模拟最新的 128 GB 存储的一加 7 设备，那么您的 AVD 将消耗 128 GB 或更多的实际磁盘空间！当然，您不必为模拟 SD 卡和设备上存储使用如此大的分配，但通常您至少会有一个可用的数量，所有这些加起来。

当您开始 Android 应用开发之旅时，实际的存储空间应该是 50 GB。这将让你可以制作几代 Android SDK 和大量不同大小和配置的 avd，以及 Android Studio 和其他工具。为了适应未来，特别是对于各种用于测试目的的 avd，您应该以 100 GB 或更多为目标。

与存储大小同样重要的是存储类型及其相关速度。传统的旋转硬盘驱动器当然便宜，但代价是数据传输速度，或 IOPS(每秒输入/输出操作数)。固态硬盘(SSD)等现代存储选项可显著提升数据传输性能，从而加快构建和运行 avd、部署大型应用、依赖重要图像和视频的应用以及任何数据密集型计算或操作的运行速度。

如果可以选择，请始终选择固态存储选项，尤其是如果您计划进行任何数据密集型或计算密集型开发。对于那些正在寻找专用笔记本电脑以满足开发需求的人来说，鉴于近年来这个市场向固态硬盘的巨大转变，你会发现自己被宠坏了。

观看这一切！

如果你想成为一名专注于 Android 应用的开发者，你将会经常盯着屏幕。有鉴于此，你可能要考虑如何充分利用你将看到的屏幕，以及你是否想要一个以上的屏幕。

当谈到显示器或显示器时，许多开发者的快乐将基于深深的个人因素。你喜欢大屏幕吗？你喜欢多屏吗？不同方向的屏幕对你有帮助吗——横向还是纵向？你会把笔记本电脑的屏幕和固定屏幕混合在一起吗？除此之外，还有更多的考虑因素，但我会指出两个将对您产生长期有益影响的关键特征:大小和密度。

当谈到屏幕尺寸时，有一些实用性会让你相信至少一个大屏幕是值得花费的。回头看看第五章的图 5.6，你会看到两个 avd 并排运行，一个代表普通手机屏幕，另一个代表平板电脑屏幕。你不会惊讶地发现，图中的视图几乎占据了我的 MacBook Air 的所有 13 英寸屏幕。如果你仔细看，你可以看到隐藏在 AVD 屏幕后面的我的 Android Studio 会话的微小片段。但你只能看到这些。如果没有一系列非常尴尬的妥协，这种尺寸的屏幕不可能在 Android Studio 和 AVD 中并行开发。你可以在 Android Studio 中调整屏幕和窗口的大小，你可以平铺窗口，试图在运行单个 AVD 的情况下将所有东西都挤进去，如图 6-1 所示

图 6-1

在 13 英寸的笔记本电脑屏幕上同时运行 Android Studio 和 AVD

如果你认为这有助于实时调试或同时比较不同的布局，让我声明这不是那种东西。只是很大的痛苦！相比之下，在 24 英寸的屏幕上，Android Studio 和多个 avd 愉快地生活在一个拥有充足空间的屏幕上，如图 6-2 所示。

图 6-2

在 24 英寸屏幕上运行 Android Studio 和多个 avd

我会让这些数字说一千个字。当你看完之后，我关于屏幕尺寸的结束语就不需要更多的支持了。如果可以，买个大屏！

谈到屏幕质量，特别是像素密度，我们再次进入一些非常主观的领域。在 2020 年的市场上，当这本书正在编写时，你可以从多代“高密度”中选择，以及 4k，5k，甚至 8k！你的个人品味和偏好将是最重要的考虑因素，但我建议你记住以下两点:

1. 查看运行中的屏幕。如果可以的话，去一家零售商那里，他们可以向你展示实际连接到任何一种电脑上的屏幕。这可以让您感受显示器的实际表现，并让您体验亮度、白平衡、对比度和刷新率等因素，以满足您对屏幕性能的要求。

2. 瞄准一个分辨率密度和你计划开发的应用一样高或者更高的屏幕。我们将在本书的其余部分更多地讨论 Android 屏幕分辨率选项和机制。为了确保您的开发和测试尽可能向您展示您的作品、图像、视频和其他应用资源在真实设备上的外观，请确保您为您的开发系统选择的屏幕至少与您的目标设备一样好，如果不是更好的话。否则，你会对现实世界中运行的事物产生扭曲的想法。

连接这一切！

开发人员设置需要考虑的其他方面包括:

1. 键盘和鼠标:看起来很普通，但是你会经常使用这些外设。不要满足于你不喜欢的人！

2. USB 端口和电缆:如果你计划用 Android 设备对你的应用进行广泛的测试，那么有足够的 USB 端口和电缆以及合适的适配器是值得的。大多数旧的 Android 设备使用 micro-USB 连接器，最近的型号切换到 USB-C 风格的连接器。

3. 充电电缆、充电座和设备:同样，如果你打算使用很多真正的 Android 设备，保持它们的电源就有点麻烦了。虽然它们可以通过 USB 连接到您的开发人员机器进行充电，但历史 USB 协议版本的功耗是有限的。直到 USB-C,“标准”USB 才可以汲取超过 500 mA 的电流。在可能的情况下，留出空间，并考虑插入墙上插座的电量。

很容易忽略这些要点，但是它们有助于使您的开发人员体验更加顺畅和愉快，如果您忽略它们，您会发现它们会增加摩擦和挫折，破坏您的最佳努力。

测试手机和平板电脑

让我从测试手机这个话题开始，首先我要说明的是，并没有什么铁一般的规则要求你必须有一部 Android 手机来测试你的应用。许多应用都是在完全模拟的环境(如 AVDs 等)中测试的基础上构建和发布的。

然而，许多应用是基于一系列 Android 设备上的真实世界测试和反馈构建的，在真实世界的情况下，可以检测和解决这些古怪和差异。而且有区别！虽然 Android SDK 和 Android 的核心平台功能(几乎)是通用的，但手机供应商和电话公司有无数种方式来调整和改变 Android 的默认行为。通常，这些“电信公司”这样做是为了试图将自己与其他电话公司区分开来，或者从一个更愤世嫉俗的角度来看，他们试图将自己注入一个位置，希望他们的用户认为他们比实际上更重要。

不管是什么原因，你会发现自己在 Android 开发者之旅的某个时候会问自己是否需要花钱购买不同的 Android 手机来测试你的应用。我不能给你一个明确的答案，但我可以给你一些建议，帮助你决定花多少宝贵的时间和金钱来购买测试手机。

选项 1:全虚拟测试

当你开始你的开发之旅时，坚持使用 Android 虚拟设备是一个非常好的策略。老实说，它在许多成功的开发人员的整个职业生涯中为他们服务。随着 Android Studio、Android SDKs 以及来自英特尔等其他供应商的支持工具的每次发布，走这条路而不在专用测试硬件上花费任何额外的时间或金钱越来越可行。

缺点是，有时您将难以复制真实世界的体验，例如欣赏应用的真实性能，并且您还可能成为我在前面提到的电信公司引入的“特殊功能”的受害者。

选项 2:开始虚拟化，并使用顶级设备进行扩充

广泛使用 avd 并有选择地增加一些关键硬件选择的混合方法恰好是我的偏好。这有几个原因:

1. 使用 AVDs 越来越有效，如前面选项 1 所述。

2. 市场的很大一部分由一家厂商代表:三星。购买一台三星设备(或几台设备)会让你接触到世界各地使用的大多数真正的 Android 设备。

3. 谷歌自己已经推出了几代连续品牌的安卓设备，先是 Nexus 系列，最近是 Pixel 系列。拥有这些设备中的一个，您就可以看到您的应用在没有电信“增强”的设备上的外观和行为

如果你采用这种方法，购买少量的手机可以让你测试大量潜在用户的真实体验。

选项 3:买，买，再买一些

尝试测试所有边缘情况、怪癖、奇怪行为和 bug 的选项吸引了一些开发人员。在 Android 领域做到这一点需要很大的耐心，更重要的是要有雄厚的财力！您可以轻松地收集几十个、几十个甚至几百个设备，但仍然无法涵盖您的用户在现实世界中可能遇到的所有奇怪的设备及其奇怪的问题。此时，你的银行余额可能也会出现一些奇怪的问题！

我不推荐这种方法，但是我承认我没有将 Android 开发和应用推进到会暴露很多这些问题的高要求领域。我试图积累一个设备测试库，如图 6-3 所示。

图 6-3

我收集的安卓设备，跨越了十多年的安卓历史

我在 20 多台设备前停下来，我的银行存款感谢了我！

选项 4:其他人的硬件

关于云计算，我最喜欢的一个笑话是，它只是在别人的硬件上运行你的代码。如果你明白我的日常工作，那就更有趣了！然而，幽默的背后是一个有用的见解，即在真实设备上测试您的 Android 应用最好是在其他人负责拥有和提供这些设备时进行。

在写这本书的时候，有一系列的商业选择可以让你在一系列真实的设备上测试你的应用，你不必自己去买。您可以租用或支付访问即服务，并获得在各种手机上进行测试的所有好处，无需购买手机的前期成本，也无需维护手机的后续成本。

这超出了本书的范围，无法一一列举这些服务，但是这里有一些你现在可以从商业供应商那里获得的主要选项，你当然可以从那里搜索到与之竞争的选项:

1. AWS 设备农场:AWS 设备农场来自所有云的供应商——亚马逊。Amazon 提供对来自众多制造商的大约 400 种不同设备的访问，并提供有用的工具来管理您浏览器中的测试工作负载。更多详情请点击 https://aws.amazon.com/device-farm/ 。

2. 谷歌 Firebase 测试实验室:谷歌版本的许多 Android 设备都可以远程访问(它们也可以访问各种苹果 iPhones 和 iPads)。Google 还提供了一些很棒的附加工具，用于 UI 测试和自动化他们设备上的测试运行。更多详情请点击 https://firebase.google.com/docs/test-lab/ 。

3. 三星远程测试实验室:作为 800 磅重的 Android 设备的大猩猩，三星是测试你的应用的显而易见的选择。三星的远程测试实验室拥有他们测试实验室中几乎所有可用的设备，加上方便的工具，应该在您的测试即服务候选名单上。更多详情请点击 https://developer.samsung.com/remote-test-lab 。

还有其他可用的商业服务，以及从世界各地的 Android 开发者社区共享或借用设备的选项。将上述内容视为一个起点，而不是一个明确的指南。

使用构建工具构建

如前几章所述，Gradle 是 Android Studio 使用的构建工具，用于将 Android 应用的所有部分整合在一起并创建成品。Gradle 也有丰富的选择，可以(事实上也确实)跨越整本书。我鼓励你开始探索 Gradle 选项来扩展你构建 Android 应用的能力。这里有三个快速提示，让你开始并帮助你找到更多。

更新 gradle.properties 文件

不要害怕打开项目的 gradle.properties 文件，看看它显示的设置。默认文件中有很多解释性的注释，您应该可以放心尝试。例如，您将看到一个为 Java VM 设置内存的条目，如下所示:

org.gradle.jvmargs=-Xmx2048m

尝试将该值更改为Xmx1024m,看看这会如何影响构建时间——您实际上将 JVM 的可用内存减半。如果你有足够的内存，试试Xmx4096m给 JVM 两倍的默认内存，看看这样是否能加快速度。随着您对 Gradle config 了解的越来越多，请重新访问您的属性文件以应用您所学到的内容。

使用 Gradle 命令行

Gradle 的许多功能都巧妙地集成到了 Android Studio 中，并在您执行各种操作时触发。但是你的项目也会有一个 Gradle 的命令行工具，名为 gradlew。它位于项目的根目录中。如果您在那里打开一个 shell 或命令提示符并运行命令行可执行文件，如下所示

./gradlew

您将看到一个有用的列表，其中列出了 Gradle 提供的非常有用的命令行选项和工具。你也可以跑步

./gradlew --help

获取所有命令行选项和工具的详尽列表。首先要研究的一个非常有用的选项是概要分析选项，它查看构建应用时需要花费的时间。调用它并查看清单 6-1 中的结果。

Welcome to Gradle 6.1.1.

To run a build, run gradlew <task> ...

To see a list of available tasks, run gradlew tasks

To see a list of command-line options, run gradlew --help

To see more detail about a task, run gradlew help --task <task>

For troubleshooting, visit https://help.gradle.org

BUILD SUCCESSFUL in 24s
1 actionable task: 1 executed

See the profiling report at: file:///Users/alleng/AndroidStudioProjects/MyFirstApp/build/reports/profile/profile-2020-09-01-10-08-13.html
A fine-grained performance profile is available: use the --scan option.

Listing 6-1Invoking Gradle profiling from the command line

Gradle 生成了一个 HTML 格式的报告，并将其放在输出中显示的文件中。在您选择的浏览器中打开该文件，您将看到 Gradle 对项目构建时间的见解，如图 6-4 所示。

图 6-4

Gradle 分析报告

访问 gradle.org 了解更多信息

网上有大量关于 Gradle 的信息，该项目的主页是一个很好的起点。一旦你尝到了它的厉害，你会发现它成了你的首选工具之一。

用源代码管理管理您的代码

许多严肃的开发人员面临的另一个大问题是如何管理他们的源代码、项目和相关资源。源代码控制是使用专用数据库的概念，该数据库擅长管理软件源代码的基于文件的性质，有时也被称为版本控制，并同时解决两个大问题。首先，随着你开发工作的增长，你可能会有几十甚至几百个项目，每个项目都有大量的文件和相关资源，正如你在第四章中看到的。源代码控制系统使得管理这些文件集变得简单得多，并且为您的编码工作提供了可靠的备份和真实的来源。源代码控制的第二个好处是它给你提供了试验、修改和犯错误的自由，如果需要的话，可以恢复到早期的版本(通常是一个可以工作的版本)。

Android Studio 提供了对三种不同系统的直接集成支持:Git、Mercurial 和 Subversion。对于开发人员社区的某些部分来说，每一种都很受欢迎，如果您有偏好，就坚持使用它。要启用与项目的源代码控制集成，请在 Android Studio 中打开 VCS 菜单，并选择“启用版本控制集成”选项。它将显示如图 6-5 所示的对话框，供您选择您选择的版本控制选项。

图 6-5

启用源代码管理

启用源代码管理后，您将会在 VCS 菜单中看到更多可用的选项，在任何项目视图的上下文菜单中也可以看到这些选项。第一次尝试使用一个特性时，比如导入一个 Git 分支或者从 Subversion 中签出一个项目，系统会提示您输入访问所选系统所需的 URL 和凭证。从那里，您将能够使用您在图 6-6 的菜单中看到的一系列功能。

图 6-6

VCS 菜单中启用的源代码管理功能

源代码控制是一个很大的话题，正如您已经猜到的，有大量关于这些工具的专门书籍和资源。如果你是源代码控制工具的新手，我可以推荐你访问 https://git-scm.com/ 、 www.mercurial-scm.org/ 或 https://subversion.apache.org/ 来开始使用 Android Studio 原生支持的任何系统。

完善您的软件库

除了我在本章中已经提到的 Android Studio 的工具和补充系统之外，还有一些你可能需要或想要的额外工具，以便为你的开发构建各种额外的资源。这可以包括图像、动画、录音、音乐等等。

有很多商业工具服务于这些目的，您可能已经知道并使用了其中的一些。我将重点介绍一些关键的开源工具，它们在各自领域都是强劲的竞争对手，在某些情况下还是领导者。我是开源的强烈拥护者，这就是为什么我倾向于在可能的情况下使用开源工具。您可能不同意这种观点，但是下面的列表将概述可用的内容，即使您选择商业替代方案。

您应该为您的开发环境考虑的开源工具包括

搅拌机:对于所有 2D 和 3D 动画的顶级工具，你只需要看看搅拌机。它在专业和业余圈子里有大量的追随者，被用于电影和电视等行业，并且对于你可能想到的几乎任何动画开发都有惊人的能力。点击 www.blender.org 了解更多信息。

GIMP (GNU 图像处理程序):一个众所周知的图像编辑和处理工具，GIMP 通常会根据你问的人找到等量的爱与恨。它非常适合许多常见任务，如调整大小、缩放、裁剪、红眼消除、图层开发/展平等。那些不喜欢它的人通常会指出 Adobe Photoshop 是黄金标准的商业产品。这些人没有错——Photoshop 是真正全面和有能力的。但是对于一个开源的替代方案，让 GIMP 试试( www.gimp.org )。

Inkscape:矢量图形可能会成为你的 Android 开发世界中非常大的一部分，特别是如果你冒险进入游戏开发的话。Inkscape 是一个奇妙的开源矢量图形程序，历史悠久。还是有人说各种商业包装更好，他们可能是对的。点击 https://inkscape.org 了解更多关于 Inkscape 的信息。

Audacity:另一个被认为是该领域最好的应用之一，Audacity 是首屈一指的多声道音频编辑套件之一，支持所有流行的操作系统。在 www.audacityteam.org/ 寻找无畏。

LAME:原始音频工具之一(也是嵌入在本章提到的许多其他工具中的工具)，LAME 是一个命令行工具和可嵌入库，它对来自各种源( https://lame.sourceforge.io )的音频执行 MP3 编码。

OpenShot:许多开源视频(和音频)编辑套件之一，OpenShot 有一些很棒的功能，包括基于曲线的关键帧动画，高级时间轴和逐帧功能，以及跨平台支持。更多详情请点击 www.openshot.org 。

Olive:另一个视频编辑工具，拥有狂热的追随者( www.olivevideoeditor.org/ )。

DaVinci Resolve:另一个非常强大的视频编辑工具，目前号称是支持高达 8k 的非常高分辨率视频的少数工具之一。它还对在同一视频项目上工作的多个用户之间的协作提供了强大的支持。点击 www.blackmagicdesign.com/ 了解更多信息。

在本书的第三部分中，当我们在 Android 应用中处理图像、声音、视频和其他资源时，您将会看到这些工具中的一些正在发挥作用。

摘要

正如你从本章所涵盖的主题中所看到的，仔细考虑你的硬件和软件环境可以极大地帮助你成为一名专注的 Android 开发者。还有一个应该涉及的软件主题——Java 和 JDK。这是一个有数百本书撰写的主题，虽然我们没有那么多的篇幅，我们将从第七章的下一页开始，用整整一章来讲述 Java！

七、面向 Android 开发的 Java 简介

在这一章中，我们将探索如何开始使用 Java 开发 Android 应用，特别关注如何处理像 Java 这样庞大的主题，而不被其规模所吓倒。那些已经对 Java 开发有所了解的人可以浏览大部分内容，但是有一些关于 Android 细节的要点，我会推荐给任何读者阅读。

将 Java 学习到专家水平是一项巨大的努力。即使学习到“快乐初学者”的水平，也要比这本书的一个章节，甚至是一整本书本身要多得多。几乎“成千上万”的书籍都是关于 Java 及其许多方面的。我们不会提供一个不完整且最终无用的介绍，而是将重点放在三个关键的准备点上，用本书之外的工具和资源引导您踏上学习 Java 的道路。

首先，我们将从软件角度回顾 Java，包括 Java 开发工具包(JDK)和 Java 运行时环境(JRE)，以及 Android 使用和采用 Java 虚拟机环境(JVM)的特点，包括其支持随处运行软件的承诺和 Java 版本的悠久历史。

其次，我们将深入一个基本的纯 Java 应用，您可以在任何装有 Java 的机器上运行该应用，从基础的一两个部分开始，扩展您对 Java 的理解，以及它如何(和不)转化为 Android 应用。

最后，我们将介绍 Java 中的关键领域或主题，您应该随时学习，并链接到一些最好的免费和商业资源，以便在本章之后继续您的旅程。

Other Development Language Choices For Android

Java 有着悠久的历史，当 Android 推出时，Android 是(平等的)首选开发语言。但它不是开发应用所支持的唯一语言。与 Java 一样，Android 从早期就通过“原生开发工具包”或 NDK 支持 C++ 的“原生”开发形式。2016 年，谷歌冒险将 Kotlin 加入受支持语言的行列，并于去年决定 Kotlin 将成为新的首选语言。就应用使用而言，Java 仍然是 Android 开发中的主导语言，接近 90%。但是许多新的应用混合了 Kotlin 和 Java，或者只选择 Kotlin。你可以在 Apress 'Learn Kotlin for Android Development(spth，ISBN 9781484244661)中了解更多关于 kot Lin for Android 的开发。

Java，Java，无处不在

这个吸引人的标题我有两种意思——Java 本来是一种只写一次，可以在任何地方运行的语言。令人惊讶的是，尽管有很多疑问、阻力甚至法律障碍，它还是成功地实现了这个目标。Java 也无处不在，因为它是编程语言的名称，但也常常是用来实现随处运行承诺的软件的简称。Java 虚拟机(或 JVM ),以及它在计算机上部署的打包方式，通常也被称为 Java。如果这还不算是混淆的话，一旦你沉浸在 Java 中，你会发现你自己和其他从业者也把提供基本功能的核心库称为 Java。

作为一名 Java 开发人员，命名的复杂性是一个需要适应的问题，但是当谈到“随处运行”的能力实际上是如何交付的时候，Java 也有过一段艰难的历史。Java 发行版对 JVM 进行了补充，作为运行时，称为 Java 运行时环境(JRE ),或者作为完整的开发工具，称为 Java 开发工具包，或 JDK。版本如何被处理一直是软件中最扭曲的故事之一，因此发现系统试图同时支持五个并行的主要 Java 版本并不罕见——Java 6、Java 8、Java 9、Java 11 以及最近发布的任何 Java 版本。

多亏了 Google 的行动，Android Studio 在其 2.3 版本中冒险隐式捆绑了一个 JDK，并为您完全管理它，所以您再也不需要自己开发了。然而，在 Android 之外测试代码，以及在非 Android 应用中学习更多关于 Java 的知识，有时会很有用。在这一章的后面，如果你还不熟悉这种方法，我们将演示如何去做，如果你是这一领域的绝对初学者，也可以把它作为学习 Java 语言的跳板。

Java Security

如果不讨论安全性，这个主题就不完整。无论是作为独立安装还是作为 Android Studio 的一部分，Java 及其运行时和 JVM 都有一段非常长、非常麻烦的安全问题历史。我不会深究已经发现并修复的数千个漏洞、错误和利用方式！–在过去的二十年里，但我要说的是。总是修补你的 Java 安装，包括总是保持 Android Studio 最新。永远！

要了解更多影响 Android 的 Java 历史漏洞，请点击 www.beginningandroid.org 阅读更多内容。

安卓的 Java 时间扭曲

当第一次发布时，谷歌选择了当时最新的 Java 版本作为 Android 的基础，即 Java 版本 6，即当时所知的 Java 1.6。随着 Android 未来版本的发布，Java 版本的进展相对缓慢，保持 Android 与 Java 6 兼容有很大的好处。随着时间的推移，发布模式发生了变化，特别是 Java，在 Java 7 和 Java 8 的缓慢发布之后，速度加快了。在撰写本书时，我们正处于 Java 15 阶段，但由于各种技术和非技术原因，Java 兼容性在 Android 与 Java 7 和对 Java 8 的部分支持中“停滞不前”。如果你学习 Java 是为了编写 Android 应用，请记住这一点！

在为 Android 开发时，Java 9 和更高版本的概念和特性根本不可用。这意味着诸如 Java 9 中引入的模块、Java 10 中引入的数据类共享，或者 Java 12 中 switch 语句增强的安全性和实用性都不是您所能支配的。在实践中，这并不会造成很大的障碍，但是如果您对现代 Java 很有经验，并且已经习惯了它所提供的最新特性，那么可能需要一些时间来适应。

使用 JDK 安装程序学习 Java

由于 Android Studio 将 JDK 与它的安装捆绑在一起，除了出色的 Android Studio IDE 体验之外，您还可以使用现成的“纯 Java”环境。要单独使用 JDK，您可以在磁盘上查找 Android Studio 放置 JDK 的目录。你可以直接从 Android Studio 本身找到这个，打开任何项目。选择File ➤ Other Settings ➤ Default Project Structure菜单。你会看到如图 7-1 所示的对话框，显示 JDK 的位置。

图 7-1

Android Studio 显示 JDK 的位置

总结 Android Studio 支持的各种操作系统

• 在 macOS/OSX 上:JDK 在/Applications/Android Studio.app/Contents/jre/jdk/Contents/Home被发现。

• 在 Linux 上:根据您指示 Android Studio 安装程序放置 IDE 的位置，JDK 的位置会有所不同，但是它位于该位置下的./android-studio/jre文件夹中。

• 在 Windows 上:JDK 的位置会根据您指示 Android Studio 安装程序放置 IDE 的位置而变化，但是默认情况下它在C:\Android\Android Studio\jre\bin中。

对于本章中的纯(非 Android) Java 示例，您可以使用命令提示符或 shell 通过"cd"命令导航到该目录。您还可以测试这个目录是否包含在您计算机上的PATH环境变量中——这意味着无论您从哪个目录开始工作，您的操作系统都知道在哪里可以找到 JDK 的关键工具。例如，在 macOS 和 Linux 上的"which javac"命令将返回第一次安装的javac二进制文件的路径，这是 Java 编译器，如果在PATH中指定的目录中找到的话。例如，在我的 MacBook Air 上，我看到以下内容:

$ which javac
/usr/bin/javac

还有什么比这更简单的呢？您可能还记得，在前面关于 Java 无处不在的标题中，在同一台机器上安装多个版本的 Java 是很常见的，这些版本可能是完整的 JDK，为 Java 提供开发工具，或者只是 JRE，它提供运行时 JVM 和一些支持实用程序，但不提供像编译器这样的开发工具。

如果您想绝对确定您使用的是 Android Studio 附带的编译器(javac二进制)和 JVM ( java二进制)，那么在调用这些程序时，请使用它们的完整路径。例如，为了确保我在下面的例子中使用 Android Studio 中的 javac，我将调用它

$ "/Applications/Android Studio.app/Contents/jre/jdk/Contents/Home/bin/javac" somejavafile.java

有很多方法可以询问你默认使用的 Java 安装版本，并出于各种原因在它们之间切换——甚至在 Android Studio 内部。然而，这超出了本书的范围。对于初学者，我警告不要在这方面修改 Android Studio 的设置。

代码中的第一个 Java 概念

传统上，通过编写“Hello World”应用来开始学习编程语言。我们将跳过这一步，转到一个稍微高级一点的例子，向您展示 Java 代码的基本工作原理。清单 7-1 展示了我们的非 Android Java 示例应用 FirstJavaDemo 的代码，您可以在Ch07/FirstJavaDemo.zip中找到它。

import java.io.*;
import java.util.*;

public class FirstJavaDemo {

  public static void main(String[] args) {

    Console console = System.console();
    if (console == null) {
      System.out.println("Console not found");
      System.out.println("Please re-run from a command line, shell, or console window");
      System.exit(0);
    }

    System.out.print("Tell me something about yourself: ");
    String something = console.readLine();

    System.out.println("Interesting!  You said: " + something);
  }
}

Listing 7-1Source code from the FirstJavaDemo.java file

在接下来的章节中，我们将逐步介绍这段代码的各个部分会产生什么样的效果。在稍微大一点的层面上，让我们遍历整个结构，并用简单的英语解释正在发生的事情。这将允许您交叉引用一个外行人的解释，以及特定于 Java 的方面。

第一行是 import 语句，指示我们的程序使用 Java 的库系统(其中捆绑了其他 Java 功能供您使用，而不必自己从头开始构建)。语法看起来有点奇怪，但其核心是我们在指导 Java 引入java.io库和java.util库的所有方面。这些库处理诸如文件和控制台输入和输出以及您经常想要或需要的其他无处不在的特性。

然后我们有一个class声明。类是应用开发的面向对象(OO)设计学派的核心概念，我们将在本章后面更多地讨论它们。重要的是，这是我(或你)选择的一个类定义。我选择了FirstJavaDemo这个名字。Java 关键字"public"意味着，如果需要，其他 Java 程序可以导入我的类并重用它。

类的主体和逻辑的其他子块都用花括号括起来——就是你看到的{和}符号。这些花括号是重要的标点符号(在编程和编译器的说法中是记号)，必须用于分组嵌套的逻辑集——无论是类、它们的方法，还是内部逻辑块(如循环和条件测试)等等。

接下来，我们有强制的main()方法，我们将其定义为具有一个void返回类型，这实质上意味着在退出时，程序不会从变量或其他方法调用中返回任何数据，并将一个名为args的String数组作为(可选)参数。在实践中，这种方法是许多编程语言的长期风格，其中参数(或自变量)可以在程序首次运行时传递给程序，用于开发人员想到的任何目的，例如打开或关闭程序中的选项，或者用关键的启动数据作为种子。

然后，我们基于由System.console()方法提供的Console对象，定义并创建一个名为console(小写)的对象，由于导入了java.util库，该方法本身就是我们可以访问的实用程序之一。这种方法隐藏了FirstJavaDemo程序和 JVM 之间的大量操作系统交互，将你的程序连接到一个控制台——这通常是一个 shell 或命令提示符窗口，或者是更复杂程序的类似风格的一部分，如 Android Studio IDE 中的控制台窗口。

Key Concepts: Data Types and Variables

这个名为“Console”的控制台对象和工作副本或容器的例子介绍了几乎所有编程语言(包括 Java)的两个基本方面。这些概念是变量和数据类型。

变量可以被认为是一个容器或一个尚未确定值的占位符——就像高中数学或代数一样。在 Java 中，变量首先被定义为标识它将包含的信息种类，即它的数据类型。

Java 中的数据类型是用于变量或其他环境的信息或数据种类的规范。数据类型有两种形式:第一种是非常简单的数据类型，称为基元，它以几种形式表示简单的整数或浮点数——int、short、long、float 和 double——以及简单的字符文本，称为 char 和 boolean，它表示 true 或 false 值。

第二种数据类型是更复杂的对象，比如在我们的控制台案例中。您可以将这种更复杂的数据类型视为多个原始数据类型和可用于处理该数据的预定义逻辑的复合集合。这是 Java 和其他面向对象编程语言中类的本质。

有时创建控制台会因为奇怪的原因而失败——权限问题就是一个例子。我们使用 Java 的 If-Then 逻辑来引入一个逻辑测试，用符号==来表示，以确定我们的console是否存在或者是未定义的——用 Java 的说法就是null。如果console没有定义，我们使用我们可以使用的System.out.println()方法，感谢java.io库的引入，写出一些对阅读它的人有意义的有用的字符串文本。然后我们使用System.exit()方法退出程序。

Key Concept: Branching and Looping Structures In Java – If, While, For

清单 7-1 中的代码展示了 Java 中主要的逻辑控制结构之一——If 语句。还有其他几个这样的结构，允许您在代码中基于测试值做出决策，并基于测试值决定合适的逻辑分支或重复操作，直到条件发生变化。除了 If 语句，Java 还提供了 For 循环、While 循环和 Do While 循环。每一个后面的结构都有许多细微差别，我们将在本书的后面探索，但是你可以在 http://en.wikibooks.org/wiki/Java_Programming/ 了解更多。

在更可靠、更常见的场景中，创建console对象一切顺利，然后我们使用System.print()方法在控制台中打印问题的文本，使用System.readln()方法接受您输入的响应，并将其存储在一个名为something的String变量中，我们将该变量定义为保存您输入文本的地方。最后，我们再次使用System.println()和由+操作符提供的一些String连接特性来回应您。

这个简短的描述应该有助于你理解FirstJavaDemo应用是做什么的，但是除了非常粗略的层次之外，并不能真正给你对 Java 语法、结构或规则的深刻感受。我们稍后会进一步加深您的理解。现在，让我们练习编译和运行这个程序。

要编译该程序，打开一个 shell 或命令提示符，如果需要的话，将目录更改为 JDK，如前面针对您的操作系统所述。请注意您将来自Ch07/FirstJavaDemo.zip的FirstJavaDemo.java文件放置在磁盘上的什么位置。然后调用javac二进制文件，给它传递FirstJavaDemo.java的完整路径和文件名，例如，在 macOS 或 Linux 上如下所示:

$ javac <path-to-where-you-unzipped-code>/FirstJavaDemo.java

过一会儿，您应该会看到命令或 shell 提示符回到您的控制中。发生了什么？javac实用程序已经处理了源代码，并生成了 JVM 现在可以理解和运行的代码的中间版本。在您的目录中，您应该会看到一个名为FirstJavaDemo.class的新文件，它是javac命令的输出。

要运行您的代码，使用java命令(小写)并传递给它FirstJavaDemo.class文件的完整路径，但是省略文件名的文件扩展名(.class部分)，例如:

$ java <my-path-to-the-file>/FirstJavaDemo

一旦您回答了屏幕上应该看到的问题提示，输出将如下所示:

$ java FirstJavaDemo
Tell me something about yourself: I program in Java
Interesting!  You said you: I program in Java

你做到了！使用特定于 Java 的工具和一些新学到的代码，您已经创建了一个纯 Java 应用。请继续阅读，了解更多关于 Java 语言的知识，以及如何更深入地理解FirstDemoJava应用中的每个单词、行和古怪的标点符号。

Android 开发的关键 Java 构件

本书剩余部分的所有例子都依赖于一定程度的 Java 知识。在本章的剩余部分，我们将为您提供一个主题主列表，它涵盖了您至少需要遵循的基础知识，但更重要的是，它还将为您提供一个起点，让您从网上、书店、学校和大学等大量免费和商业资源中进一步学习和自学 Java。我们将直接链接到其中的一些链接，这样您的 Java 之旅就不会被打断——我鼓励您在阅读本章时关注其中的一些链接，因为深入研究 Java 主题永远不会太早！

为了最大限度地提高您学习 Java for Android 开发的效率，以下主题是关键:

一般软件开发知识:

1. 代码的结构和布局

2. 面向对象的设计和编程，包括类和对象

3. 类方法和数据成员

特定于 Java 的编码知识:

1. 接口和实现

2. 线程和并发

3. 碎片帐集

4. 异常处理

5. 文件处理

6. 无商标消费品

7. 收集

显然，这不是 Java 的全部，但它是 Java 的一个子集，足以让您立即开始 Android 开发的构建块！

代码结构

回头看一下FirstJavaDemo源代码，就能体会到 Java 代码在最简单的情况下是如何构造的。Java 可以被认为是最基本的构造的洋葱分层，一层一层地构建最深远和最复杂的构造。从最简单到最复杂，我们有

• Token:Java 的最小构造块，token 代表我们已经创建的或系统提供的对象实例的名称，例如我们的FirstJavaDemo代码中的 something String对象，Java 语言中的关键字，如“return,”操作符，括号等标点符号，等等。

• 表达式:一个或多个标记以及类似于+的操作符，或者方法调用，它们构成了一个逻辑。在我们的第一个 JavaDemo 示例中，我们看到一个表达式“有趣！你说:“+ something，是用+运算符连接两个字符串的表达式。

• 语句:由符号和表达式构建的一套完整的逻辑，用分号分隔。这通常与一行代码同义，但实际上它可以跨越任意多行。

• 方法:语句的逻辑分组，形成一组连贯的逻辑，可以通过使用方法名来调用。在我们的FirstJavaDemo代码中，我们为我们的类的 main 方法创建了逻辑，但是我们也引用了其他类的方法，比如用于在控制台读取文本输入的readLine()方法和用于打印回控制台的println()方法。

• 类:一个概念对象的表示，以及用于表示该对象并允许操作该对象及其功能的所有方法和数据成员。类的概念与面向对象设计的概念紧密联系在一起，我们很快就会谈到这一点。

• 包:虽然在我们的例子中没有显示，包是类的集合，通常用于将那些支持特定相关逻辑组的类捆绑在一起，例如，文件处理或图形渲染。

Java 代码还有许多其他的结构方面，但是掌握前面的内容将使您能够根据对基础知识的理解来解释和利用更深奥的结构。

Android and Main

不，那不是十字路口，但可能是。在第一个 JavaDemo 示例中，您将看到我们定义了一个方法，称为 main。Java 的设计规定，Java 程序的几个强制性要求之一是存在一个名为 main 的方法，并且它将是运行程序时 JVM 调用的第一个方法。可以把它想象成 Java 中的一个大标志，上面写着“从这里开始”。

但是看看我们在前面的章节中已经写过的 Android 例子，比如 MyFirstApp 应用。MainActivity.java 文件缺少一个主方法。这是怎么回事？不要害怕。您的应用确实有一个 main 方法，但是它隐藏在 Android Studio 提供的支持框架中。Android 提供了一个活动生命周期，定义了开发人员可以关注的点，处理创建、使用、暂停和处理活动的点，而不是强迫您修改主要方法，然后修改所有可以为用户提供运行应用体验的流程或事件处理工作。该活动生命周期在第十一章中有详细介绍。

如果你看看你已经编写的 Android Java，包括MyFirstApp应用，你可以在实践中看到这种 Java 语言层次的许多方面——在没有意识到的情况下，你已经在你的第一个应用中运用了这些概念。

理解面向对象的设计、类和对象

Java 编程语言从一开始就被设计成包含和表达面向对象设计的概念(有时缩写为“OO”)。在本质上，面向对象设计使用这样一种思想:用对象(或实体)来表达您在应用中创建的概念模型的几乎所有内容，例如“人”或“动物”，然后使用一些强大的设计理念来塑造如何定义、操作、扩展和细化对象。这是一个庞大的主题，但是你可以从一些优秀的在线资料开始，这些资料可以帮助你理解关键的 OO 概念，包括封装、继承、多态等等。

使用类方法和数据成员

采用面向对象方法进行编码的一个重要部分是这样一个概念，即关于对象和对象实例的数据属于这些实体，为了操作和查询这些数据，应该使用生成这些对象的类的设计所提供(和规定)的技术。简而言之，这意味着该类定义并提供给开发人员的方法(或函数)。

对于那些刚刚接触面向对象开发的人来说，这并不像看起来那么困难。它体现了面向对象的原则之一，封装。使用对象所需的一切都整齐地包装(封装)在它的类中。这种方法有无数的好处，你可以在许多面向对象的设计文本中广泛地读到，比如 a press 'Interactive Object-Oriented Programming in Java(Sarcar，ISBN 9781484254035)和无数的在线网页中。也要记住，当你写自己的类时，你有自由选择你想要的类方法。

发展您特定于 Java 的编码知识

正如我已经说过的，学习所有的 Java 是一项巨大的努力。学习面向 Android 的 Java 并不那么令人畏惧，但仍然涵盖了 Java 领域的大量内容。为了让你开始，这里是开始掌握的关键领域，带有一些最好的免费在线资源的链接。虽然我将参考 Java 编程 Wikibook，这是一个免费的在线资源，但许多其他在线资源也同样不错。你也可以从专门针对 Android 的 Java 书籍中受益匪浅，比如 Apress 'Learn Java for Android Development(spth 和 Friesen，ISBN 9781484259429)。

接口和实现

理解 Java 对象如何构建和扩展其他对象，并提供一个派生版本应该做什么的模板，以及如何做的机制。 http://en.wikibooks.org/wiki/Java_Programming/Interfaces见。

线程和并发

特别是在我们的多核 CPU 时代，只要小心，并发和线程提供了同时执行大量工作流的方法。 http://en.wikibooks.org/wiki/Java_Programming/Threads_and_Runnables见。

碎片帐集

Java 是谨慎管理内存等资源方法的早期采用者，这种方法试图将开发人员从跟踪和手动处理资源分配中解放出来——至少可以说这是一项容易出错的任务！参见 https://en.wikibooks.org/wiki/Java_Programming/Java_Overview 的自动内存垃圾收集部分。

异常处理

当事情确实出错时，目标是提供安全、结构化和信息丰富的方法来优雅地处理问题。 http://en.wikibooks.org/wiki/Java_Programming/Exceptions见。

文件处理

虽然我们的 FirstJavaDemo 应用让用户通过键入直接在控制台输入数据，但更常见的是使用文件和管理它们的语义来消费和创建数据。 http://en.wikibooks.org/wiki/Java_Programming/BasicIO见。

无商标消费品

Java 在概念上是一种“强类型”语言，这意味着它提供了防护栏和保护，以确保Strings、integers和其他类型永远不会与不兼容的数据有效载荷一起存在，并且一种类型的数据不会意外地放入另一种类型的变量中。这是一个关键的保护机制，但是在某些情况下会造成不灵活。泛型提供了维护强类型的方法，但是当支持不同类型数据的相同通用逻辑时，可以避免不必要的重复和过多的重复。 http://en.wikibooks.org/wiki/Java_Programming/Generics见。

收集

正如像整数这样的原始数据类型集可以分组到数组中一样，对象也可以分组到方便的集合中。集合是 Java 支持将对象组作为集合进行操作的一种方式(但不是唯一的方式)。 http://en.wikibooks.org/wiki/Java_Programming/Collections见。

摘要

没有哪一章或者整本书能够给你一本完整的 Java 初学者指南，但是在这一章中，我们尝试了退而求其次的方法。现在，您已经了解了 Java 语言、Java 软件产品、Java 对 Android 的意义，以及学习内容的路线图和帮助您掌握 Java 的资源。我强烈建议刚接触 Java 的人，在开始阅读本书的其余部分之前，先探索一下本章中提到的其他资源，甚至更多的商业和免费在线资源。即使是一点点的阅读和实践也会为你的 Android 理解收获巨大的回报。

八、Android 开发中的 XML 简介

本章将讨论两个主题。首先，我们将从初学者的角度来看一看 XML，对于那些从未接触过 XML，也没有深入研究过它的使用模式、特点、优势和问题的人来说。本章的第二部分将涵盖 Android 开发中的三个主要领域，在这三个领域中，您通常会接触到 XML 的读取、编写和编辑:

1. 我们已经介绍过的应用清单

2. 资源定义，特别是字符串等常量

3. 活动规划，这是一个很大的话题，但是可以一步步来

XML 入门

可扩展标记语言，简称 XML，是标准通用标记语言 SGML 的一个老标准的子集。XML 的目标是以一种标准化的结构来传递数据和有关数据的信息——称为元数据——这种结构可以被查询和使用，而无需事先了解数据的含义或该结构存在什么规则。我知道这是一个相当抽象的定义。维基百科提供了另一种定义:

可扩展标记语言(XML)是一种标记语言，它定义了一组规则，用于以人类可读和机器可读的格式对文档进行编码。

——https://en.wikipedia.org/wiki/XML，2020 年 7 月

就定义而言，这也好不到哪里去。一个更实用的定义可能如下:

XML 是一种标记语言，它定义了如何交换数据，并描述了正在交换的数据，以便人类和机器都能理解这些数据及其结构和与其他数据的关系。

—格兰特·艾伦 2020 年 7 月

仍然不完美，但正在接近。遗憾的是，这个评论可以应用于整个 XML，而不仅仅是我简单的描述。也许更好的理解 XML 的方法是深入研究它的结构和工作方式。

关于 XML 的一些要点。严格来说，XML 不是一种编程语言…用 XML 写的东西不“做”任何事情。XML 是一种标记语言，旨在向数据传达含义和结构，以便程序和编程语言可以用这些数据做事情。

当您创建 XML 时，您正在将文本放入一个文档中，该文档的某些方面受 XML 标准和规则的约束，这就是所谓的 XML 文档。无论 XML 文档变得多么复杂或费解，您总是可以后退一步，把它仅仅看作文本——在某些地方有特殊含义、有约定的结构和语法规则的文本，但它仍然是文本。

对于 XML 文档中需要什么样的预定义组件，XML 没有固定的定义。它使用基本的构造块定义了如何在文档中定义自己的组件的规则和语法。XML 及其规则的总体目标是允许一种独立于机器/程序的方式来描述和打包数据，并使描述和结构在 XML 文档本身或相关的 XML 模式中自我描述。

让我们看看关键的 XML 构建块。

XML 版本和编码

在 XML 文档的开头应该有一个特殊的标记，表明它遵循哪个版本的 XML 标准，以及 XML 中的文本使用什么字符编码(ASCII、UTF-8 等)。).默认情况下，在几乎所有的 Android 开发中，该声明将规定 XML 版本 1.0 和 UTF-8 编码。特殊标签采用以下形式，使用特殊的<?xml和?>开始和结束标记:

<?xml version="1.0" encoding="utf-8"?>

这有助于任何读取和使用 XML 文档的程序理解如何解释文本和 XML 结构。

XML 元素

元素是 XML 的基本构建块，是为数据提供含义和结构的“标签”，但它们本身不是数据。XML 元素是嵌套的，因此 XML 文档中最外面的第一个元素称为根元素，它可以包含(嵌套)一个或多个子元素。XML 文档中只有一个根元素。

元素标签包含在<(大于)和>(小于)符号中。对于我定义和使用的每个元素，我将需要一个开始标记和一个同名的匹配结束标记，并在结束标记中的元素名称前添加一个前导的/(反斜杠)。必须使用这种方法使我的 XML 语法正确——用 XML 的行话来说就是“格式良好”。例如，我可能决定创建一个 XML 文档，在一个模仿地址簿的数据结构中保存人们的联系信息，并决定我的根元素将被称为<addressbook>。

我的 XML 文档开始看起来像这样。

<?xml version="1.0" encoding="utf-8"?>
<addressbook>
</addressbook>

这包括版本和编码特殊标记和<addressbook>根元素开始标记，用匹配的</addressbook>结束标记正确结束。目前为止，一切顺利。

我可以包含一个人的子元素和一个人的名和姓的子元素，如下所示:

<?xml version="1.0" encoding="utf-8"?>
<addressbook>
  <person>
    <firstname>Jane</firstname>
    <lastname>Smith</lastname>
  </person>
</addressbook>

目前为止，一切顺利。请记住，我是决定元素名称的人，也是决定它们的用途的人。

Note

元素的结束标记不必总是单独在一个新行上。事实上，XML 的任何部分都不需要换行。但是这样做确实使您的 XML 更易于阅读。人们普遍接受的 XML 标准是，开始标记出现在新的一行，结束标记出现在开始元素标记出现的同一行的末尾，例如前面的<firstname>和</firstname>，当该标记没有子元素时，或者开始和结束元素标记单独出现在一行中，其中嵌套有任何子元素，例如前面的<person>和</person>标记。标签也缩进以表示它们是子元素，但是这也是为了方便读者的约定。

如果这是一个真正的通讯录，我会有不止一个人在里面。但是您可能会注意到，对于阅读这个 XML 的计算机(甚至人类)来说，很难区分哪个人是哪个人。如果我们这样做，任何试图跟踪哪个人的程序都会有问题:

<?xml version="1.0" encoding="utf-8"?>
<addressbook>
  <person>
    <firstname>Jane</firstname>
    <lastname>Smith</lastname>
  </person>
  <person>
    <firstname>John</firstname>
    <lastname>Jones</lastname>
  </person>
</addressbook>

在 XML 中解决这个问题的一个方法是使用属性，它的作用就像元素的参数。

XML 属性

任何 XML 元素都可以有零个或多个相关联的属性。属性不同于元素本身提供的数据，出现在元素名称的< >标记中，紧跟在标签名称之后。属性采用以下形式

attribute_name="value in double quotes"

继续我们的地址簿示例，我们可以通过向<person>元素添加 ID 属性来区分 XML 数据中的不同人，使用数值给每个人一个不同的 ID。结果将如下所示:

<?xml version="1.0" encoding="utf-8"?>
<addressbook>
  <person id="1">
    <firstname>Jane</firstname>
    <lastname>Smith</lastname>
  </person>
  <person id="2">
    <firstname>John</firstname>
    <lastname>Jones</lastname>
  </person>
</addressbook>

请注意，尽管您和我可能认为这里给出的 ID 值是一个整数，甚至已经编写了程序将其视为整数，但是 XML 总是将属性放在双引号中，使它们看起来像是字符串。

如果一个元素有多个属性，它们只是用一个空格隔开。例如，我们可以使用 dateadded 属性跟踪将某人添加到地址簿的日期:

<?xml version="1.0" encoding="utf-8"?>
<addressbook>
  <person id="1" dateadded="2020-01-01">
    <firstname>Jane</firstname>
    <lastname>Smith</lastname>
  </person>
  <person id="2" dateadded="2020-01-31">
    <firstname>John</firstname>
    <lastname>Jones</lastname>
  </person>
</addressbook>

XML 值

XML 文档中封装的实际数据是包含在开始和结束元素标记中的值。在我们正在进行的地址簿示例中，我们的值类似于“Jane”代表一个<firstname>元素，而“Smith”代表一个<lastname>元素。用所有的 XML 语法和元素标记来表达这一点似乎有些多余(一般来说，冗长是对 XML 的一种常见批评)，但是作为一个阅读 XML 的人，它很好地进行了自我描述，并且还提供了关于结构、完整性等方面的保证。

说到完整性，元素本身不包含任何数据是完全可能的，正如本章前面我们的第一个地址簿 XML 文档所显示的那样。通过使用您已经看到的开始和结束标记方法，以及使用只让元素标记名出现一次并带有结尾/(反斜杠)的快速自结束标记方法，有一些选项允许您的元素存在并且不包含任何数据。让我们给我们的<person>结构添加一个<middleinitial>元素，显示两个选项，如下所示:

<?xml version="1.0" encoding="utf-8"?>
<addressbook>
  <person id="1" dateadded="2020-01-01">
    <firstname>Jane</firstname>
    <middleinitial></middleinitial>
    <lastname>Smith</lastname>
  </person>
  <person id="2" dateadded="2020-01-31">
    <firstname>John</firstname>
    <middleinitial/>
    <lastname>Jones</lastname>
  </person>
</addressbook>

对于没有数据的元素，<middleinitial></middleinitial>和<middleinitial/>表单都有效。请注意，不能在自结束标记下嵌套任何子元素。

XML 名称空间

XML 的巨大优势之一是它使使用数据的开发人员和系统更容易交换数据。一旦您习惯了以 XML 格式共享数据，就开始觉得这是您的第二天性。但是你可能会在这种简单的传输和分享中遇到问题。一个特别的问题是，由于您定义了自己的 XML 标记(甚至可能定义了自己的 XML 模式)，您可能会发现其他人开发了自己的模式，并使用了与您的模式相冲突的元素名称。如果您和他们从不共享数据，这没什么大不了的，但是如果您成为一名共享 XML 格式数据的从业者，当您试图混合来自多个来源的数据时，您可能会遇到名称冲突。那你是做什么的？

XML 标准提供了一种由两部分组成的方法来帮助解决这种名称冲突。首先，您可以用标识字符串作为任何元素的前缀，标识字符串是一个标记，指明给定元素被认为是从哪个源派生的。因此，如果我们知道我们将来自我们的<addressbook>的数据与我们自己对<person>的定义和其他人的数据混合在一起，而这些人可能具有完全不同的结构和元素集，我们可以给我们的元素加上前缀来区分它们，例如:

<?xml version="1.0" encoding="utf-8"?>
<my:addressbook>
  <my:person id="1" dateadded="2020-01-01">
    <my:firstname>Jane</my:firstname>
    <my:middleinitial></my:middleinitial>
    <my:lastname>Smith</my:lastname>
  </my:person>
  <my:person id="2" dateadded="2020-01-31">
    <my:firstname>John</my:firstname>
    <my:middleinitial/>
    <my:lastname>Jones</my:lastname>
  </my:person>
</my:addressbook>

这个前缀充当这些元素的名称空间，而另一个 XML 文档中带有 person 混淆版本的项目的名称空间会有不同的前缀，例如:

<?xml version="1.0" encoding="utf-8"?>
<other:list_of_addresses>
  <other:person >
    <other:name>Judy</other:name>
    <other:surname>Walsh</other:surname>
  </other:person>

XML 标准要求我们提供一个 URI 作为名称空间的唯一区分符——基本上，这个属性保证是唯一的，并反映我们为文档定义的 XML 结构。这是在元素的开始标记中用 xmlns 属性指定的，通常您会在 XML 文档的根元素中看到这一点，如下所示:

<?xml version="1.0" encoding="utf-8"?>
<my:addressbook xmlns:my="https://www.beginningandroid.org/XMLnamespaces/addressbook">
  <my:person id="1" dateadded="2020-01-01">
    <my:firstname>Jane</my:firstname>
    <my:middleinitial></my:middleinitial>
    <my:lastname>Smith</my:lastname>
  </my:person>
  <my:person id="2" dateadded="2020-01-31">
    <my:firstname>John</my:firstname>
    <my:middleinitial/>
    <my:lastname>Jones</my:lastname>
  </my:person>
</my:addressbook>

XML 世界的其他部分

随着知识的增长，我们可能会对本章没有涉及的 XML 标准的其他部分感兴趣:

1. CDATA: CDATA 值是特殊的 XML 值，它们被视为一字不差的数据，不会被处理或解析来发现其中是否有进一步嵌套的 XML 标记。这最初可能没有多大意义，但是您会发现它经常被用来传递其他形式的数据标记，或者像 HTML 这样的表示标记，作为 XML 文档中的数据——它防止 XML 解析器和希望执行 XML 标准的程序无意中出错，这些东西看起来可能是 XML，但实际上不是——当然它们也不遵循 XML 规则。

2. XML Path 和 XQuery: XML Path 和 XQuery 提供了遍历 XML 文档的方法，通过导航标签的层次结构、评估属性等来查找数据。默认情况下，这些工具不用于 Android 应用的基本设计和构建，但是如果您构建的 Android 应用本身可以操作基于 XML 的数据，您当然可以使用它们。

3. XSLT 和转换:XSLT 是 XML 样式表转换语言，这是一种编程语言，旨在查询和转换 XML 的结构和数据，创建派生数据作为输出。XSLT 转换的输出通常是另一个 XML 文档，尽管它也可以是不同格式的数据。

有成千上万的网站可以帮助您了解更多关于 XML 的知识，但是现在您已经了解了足够的基础知识，可以深入了解 Android 如何使用 XML，并开始为 Android 应用编写和编辑 XML 文件。

在 Android 应用中使用 XML

正如本章开头提到的，Android 在三个主要领域使用 XML 来帮助构建和运行应用。概括来说，这些是

1. 我们已经介绍过的应用清单

2. 资源定义，特别是字符串等常量

3. 活动规划，这是一个很大的话题，但是可以一步步来

查看 Android 清单 XML 文件

不管您对 XML 的熟悉程度如何——不管您是否已经使用它很多年了，也不管您是否参加了本章前半部分概述的速成班——我们现在都可以详细探讨 Android 清单。清单 8-1 再次引用了 androidmanifest.xml 内容:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="org.beginningandroid.myfirstapp">

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

Listing 8-1The androidmanifest.xml file revisited

在第四章的中，我们强调了这个文件的一些元素和其他部分，例如，使用一个名称空间来唯一标识所有具有"android"名称空间的 Android 资源元素，绑定到唯一的 xmlns 引用xmlns:android=" http://schemas.android.com/apk/res/android "，以及使用作为 Android Manifest XML 文档的根元素。但是我们现在可以回顾一些其他的元素和属性。

Note

如果你还没有发现的话，Google 倾向于在 Android 开发中的所有 XML 使用中广泛利用属性。有时，许多人强调这太过分了，许多重属性的元素可以被重新设计为包含数据值的子元素。这是一个永无止境的理论争论，你现在可以加入了！

在您的清单中通常会有一个<application>元素标签。该标记的突出属性是android:icon和android:roundIcon选项以及android:label和android:theme属性——后一个示例充当一组其他样式和设计 XML 设置的名称，您可以采用这些设置来赋予您的应用特定的外观和感觉。你会注意到它们都使用了"@path/detail"形式。"@"符号是引用项目的res/层次结构中的关键资源的简写——无论是由 mipmap 图像控制的应用图标，还是值层次结构中的strings.xml文件中的字符串值(稍后讨论),等等。

我们已经简要介绍了清单 8-1 中的<activity>元素，并指出这个特定条目如何将您的MainActivity java 活动链接到 Android 应用启动时触发的"MAIN"动作。

您的清单可以并且将会包含更多的<activity>元素，每个元素对应于您为应用创建的一个活动。请记住，对于您可以为您的应用创建多少个活动没有真正的限制，所以您最终可以看到许多这样的元素。

随着本书的进展，我们将继续学习您对 Android 清单及其 XML 细微差别的知识。

使用 XML 进行资源定义

Android 利用 XML 的另一个主要领域是常量或引用值的定义和使用，其中给定的数据在一系列用例中以只读方式使用。有大量的例子可以说明恒定数据如何有助于简化应用的构建，并减少从确保所有活动和可视元素的一致外观到确保关键数据值(如珠穆朗玛峰的高度(8848 米)、应用的名称(“MyFirstApp”)或其他不变的数据值可以在一个地方声明，但在许多其他地方使用。

一些关键的资源定义文件是

1. colors.xml:一个参考文件，用于为各种红绿蓝(RGB)十六进制颜色表示提供对您有意义的有用名称。

2. strings.xml:一个引用文件，用于抽象文本字符串，如简单的单词、短语、句子和段落，以便可以在各种源代码和其他文件中引用它们，而无需将文本复制到许多地方。

3. styles.xml:一个参考文件，用于在自我声明的样式下收集颜色定义和其他样式元素，以便该样式可以在整个应用中用作公共设计主题。

4. dimens.xml:提供不同尺寸和大小设置的抽象表示的参考文件，允许您在一个位置控制密度/大小的变化，而不必在许多不同的文件中编辑许多值。

这些资源文件的定义对于高层次的概念理解来说是很好的，但是对于理解它们是如何使用的来说还有待改进。让我们开始动手混合一些东西，并向这些资源文件中添加新的内容。

改变颜色

最容易修改的 XML 文件是您的colors.xml文件。该文件可以包含任意数量的颜色别名。默认内容如清单 8-2 所示。

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <color name="colorPrimary">#6200EE</color>
    <color name="colorPrimaryDark">#3700B3</color>
    <color name="colorAccent">#03DAC5</color>
</resources>

Listing 8-2The default colors.xml file content

是时候对您的MyFirstApp应用进行更多的修改了。通过用"colorPrimary"的 name 属性改变 color 元素，我们可以在布局引用这个颜色资源定义的地方改变应用的外观。当在整个应用设计中使用一致的颜色选择和调色板时，您可以看到这是如何使开发变得更加容易的。

选择任何你感兴趣的 RGB 颜色表示。就我个人而言，我非常喜欢漂亮的森林绿色，所以我会选择十六进制值#2F8800，这样您的colors.xml定义就会更新，如清单 8-3 所示。

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <color name="colorPrimary">#2F8800</color>
    <color name="colorPrimaryDark">#3700B3</color>
    <color name="colorAccent">#03DAC5</color>
</resources>

Listing 8-3Altering color definitions centrally via colors.xml

保存这些更改，然后再次运行您的MyFirstApp应用。你应该看到颜色变化生效，如图 8-1 所示。

图 8-1

在 MyFirstApp 中更改颜色

将此与您的项目使用 Android 默认设置运行的相同应用进行比较，如第三章图 3-19 所示。在你运行的应用中，颜色的差异应该是显而易见的，即使它们在本书中以黑白形式打印出来看起来没有什么不同。

获得描述性信息

strings.xml档是安卓世界里一个沉睡的巨人。在这里，您可以定义各种各样的常量，这些常量基本上很少改变，或者至少在您的应用上下文中以固定的初始值开始。当你想到常数时，你可以超越我之前给出的幽默例子(为什么把自己限制在以米为单位的珠穆朗玛峰的高度——为什么不是英尺、杆、弗隆或链？！).

更严重的是，您应该随时注意(没有双关的意思)在您的代码中输入文字字符串，并问自己是否将单个条目放入strings.xml文件中会更好。从字面上看，程序员几十年的经验教训都可以归结为一句格言“从你的代码中抽象出文字串——你以后会感谢我的。”

让我们向strings.xml文件添加一个条目，目的是替换您在MyFirstApp应用中看到的屏幕文本。除了定义新的参考值之外，还有更多工作要做，但我们将在下一节讨论。现在，打开strings.xml文件，它看起来应该很像清单 8-4 。

<resources>
    <string name="app_name">MyFirstApp</string>
</resources>

Listing 8-4The default strings.xml file for MyFirstApp

添加一个新行，创建一个属性为 name 的<string>元素条目，等于一个名为welcome_text的文本字符串。<string>元素的值应该是你希望用户在屏幕上看到的任何文本。您的strings.xml文件应该类似于清单 8-5 。

<resources>
    <string name="app_name">MyFirstApp</string>
    <string name="welcome_text">Hello Android, from the strings.xml file!</string>
</resources>

Listing 8-5Adding a new <string> element to strings.xml

记住，这是 XML。name 属性的值可以是您喜欢的任何值—"welcome_text", "look_at_my_great_string", "text1",等等。只要您在将来正确地引用它，您就会获得可扩展标记语言的“可扩展”好处！让我们在下一节看看如何使用这个新字符串。

用 XML 定义活动布局

也许 Android 依赖 XML 的最大和最复杂的领域是视图布局的定义和管理——也就是说，定义和控制屏幕用户界面如何呈现给用户，以及应用如何以编程方式控制它。

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello Android!"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

</androidx.constraintlayout.widget.ConstraintLayout>

Listing 8-6The default activity_main.xml layout file for MyFirstApp

我们默认的MyFirstApp应用是通过新建项目向导生成的，默认情况下，它为您的MainActivity活动选择了默认布局"ConstraintLayout"。这是您的活动可以使用的众多布局类型之一，从父 视图 类派生而来。我们将在接下来的几章中深入研究视图、布局以及它们的排列。现在，让我们开始在你现有的布局上工作。

一个ConstraintLayout被设计来给你非常灵活的控制其他 UI 元素的大小和位置——被称为窗口小部件——出现在它里面。从清单 8-6 中，您可以看到我们只描述了一个小部件，它是一个TextView。我们将在接下来的两章中添加更多的小部件。现在，让我们通过使用小部件文本的strings.xml引用值的能力，而不是硬编码值，使我们的屏幕问候更加灵活。

让我们更新布局 XML，将硬编码的字符串"Hello Android!"替换为对welcome_text常量的引用，该常量是我们在前面的strings.xml文件中定义的。更改android:text属性，使其引用"@string/welcome_text"，这是前面创建的字符串别名的名称。您的布局现在应该看起来如清单 8-7 所示，更改以粗体显示。

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/welcome_text"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

</androidx.constraintlayout.widget.ConstraintLayout>

Listing 8-7Changing TextView text to reference strings.xml constant

Note

有点烦人的是，虽然引用值 XML 文件以复数命名——strings . XML、colors.xml 和 styles . XML——但当我们实际引用它们包含的定义时，我们使用单数引用——string、@color 和@style。Android Studio 会在你输入的时候提示你。

随着我们的布局 XML 被更改为引用我们的 strings.xml welcome_text 值，是时候再次运行您的应用来查看实际效果了，如图 8-2 所示。

图 8-2

MyFirstApp 中新的欢迎文本完全通过 XML 定义控制

瞧啊。您已经用可用的 XML 定义更改了应用中的颜色和欢迎文本。使用 XML 作为定义和控制机制的 Android 应用越来越多，当结合 Java 处理 XML 的能力时，结果可能会令人震惊。但是现在，您已经掌握了继续 Android 之旅所需的 XML 基础知识。

摘要

在这一章中，你已经对 XML 以及 Android 如何利用 XML 进行了快速的介绍。XML 是一个很大的主题，一章无法很好地解释它，我鼓励您在网上和其他书籍中寻找更多的信息。XML 在 Android 开发领域的最大优势之一是既能使用它来控制应用逻辑，又能通过应用逻辑来控制它。我们将在接下来的两章中更深入地探讨这个问题，在那里我们将更深入地了解 Android 布局和小部件的世界！