目录

1. 第一部分：开发环境配置

   
   （图片来源网络，侵删）
   • 1 安装 Java Development Kit (JDK)
   • 2 安装 Android Studio
   • 3 配置 Android SDK
   • 4 创建第一个项目

2. 第二部分：Android 项目结构与核心配置文件

   • 1 项目结构 (Project Structure)
   • 2 build.gradle - 项目的灵魂
   • 3 AndroidManifest.xml - 应用的“身份证”
   • 4 资源文件 (res/ 目录)

3. 第三部分：核心配置详解

   • 1 依赖管理
   • 2 应用签名
   • 3 构建变体
   • 4 代码混淆

4. 第四部分：现代开发与配置

   • 1 使用 View Binding
   • 2 使用 Hilt 进行依赖注入
   • 3 配置多语言/多地区

第一部分：开发环境配置

这是开始 Android 开发的第一步,确保你的电脑上安装了必要的工具。

1 安装 Java Development Kit (JDK)

Android 应用使用 Java 或 Kotlin 语言编写，因此需要 JDK 来编译代码。

• 版本要求：目前推荐使用 JDK 11 或 JDK 17，Android Studio 通常会自带一个兼容的 JDK,但有时手动安装可以获得更好的控制。
• 下载地址：Oracle JDK 或 OpenJDK
• 安装与配置：
  1. 下载并运行安装程序。
  2. 安装后，需要配置环境变量 JAVA_HOME。
  3. 将 %JAVA_HOME%\bin (Windows) 或 $JAVA_HOME/bin (macOS/Linux) 添加到系统的 PATH 变量中。
  4. 打开终端/命令提示符，输入 java -version 和 javac -version 验证安装是否成功。

2 安装 Android Studio

这是官方的、也是唯一的官方 Android IDE。

• 下载地址：https://developer.android.com/studio
• 安装：根据你的操作系统运行安装程序，按照提示一步步操作即可，它会自动检测已安装的 JDK。

3 配置 Android SDK

SDK (Software Development Kit) 包含了开发 Android 应用所需的 API 库、模拟器、工具等。

1. 打开 Android Studio。
2. 进入 Tools -> SDK Manager。
3. 你可以：
   • SDK Platforms：选择你想支持的 Android API 级别,通常建议选择最新的稳定版和一个较旧的版本以保证兼容性。
   • SDK Tools：确保勾选了以下关键组件：
     • Android SDK Build-Tools：编译工具,必须安装。
     • Android SDK Command-line Tools (latest)：命令行工具。
     • Android Emulator：模拟器。
     • NDK (Side by side)：如果你需要开发 C/C++ 原生库，需要安装 NDK。

4 创建第一个项目

1. 启动 Android Studio，选择 "New Project"。
2. 选择一个模板，"Empty Activity"。
3. 配置项目名称、包名、保存位置、语言（选择 Java）、最低 API 级别等。
4. 点击 "Finish"，Android Studio 会自动为你构建项目并同步 Gradle。

第二部分：Android 项目结构与核心配置文件

创建项目后,理解项目结构和核心文件至关重要。

1 项目结构

Android Studio 提供了两种视图：Android 视图和 Project 视图，对于初学者，Android 视图更友好。

• java/：存放你的 Java 或 Kotlin 源代码文件。
  • com.example.myapp/：你的包名,代码按模块和功能分包存放。
• res/：存放所有非代码资源（字符串、图片、布局等）。
  • drawable/：图片、图标等。
  • layout/：XML 布局文件。
  • mipmap/：应用启动图标。
  • values/：字符串 (strings.xml)、颜色 (colors.xml)、样式 (styles.xml)、尺寸 (dimens.xml) 等配置。
• AndroidManifest.xml：应用的清单文件,必须了解。
• build.gradle：构建脚本,分为模块级和项目级。
• proguard-rules.pro：代码混淆规则文件。

2 build.gradle - 项目的灵魂

这是配置应用依赖、编译选项、SDK 版本的核心文件，有两个主要的 build.gradle 文件。

A. 项目级 build.gradle (Project: MyApp)

// Top-level build file where you can add configuration options common to all sub-projects/modules.
plugins {
    id 'com.android.application' version '7.4.2' apply false // 插件版本
    id 'org.jetbrains.kotlin.android' version '1.8.0' apply false // 如果使用 Kotlin
}
task clean(type: Delete) {
    delete rootProject.buildDir
}

• 作用：配置整个项目通用的设置,比如声明所有模块共用的插件。

B. 模块级 build.gradle (Module: app)

这是最常用的配置文件,包含了应用的大部分构建信息。

plugins {
    id 'com.android.application'
}
android {
    namespace 'com.example.myapp' // 应用包名，Android 8.0+ 必需
    compileSdk 34 // 编译时使用的最高 API 级别
    defaultConfig {
        applicationId "com.example.myapp" // 应用在应用商店的唯一 ID
        minSdk 24     // 最低支持的 API 级别
        targetSdk 34   // 针对 API 级别进行优化和测试
        versionCode 1  // 版本号，用于系统判断新旧
        versionName "1.0" // 版本名称，用户可见
    }
    buildTypes {
        release {
            minifyEnabled true // 是否启用代码混淆
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_11
        targetCompatibility JavaVersion.VERSION_11
    }
}
dependencies {
    // 依赖库
    implementation 'androidx.appcompat:appcompat:1.6.1'
    implementation 'com.google.android.material:material:1.10.0'
    implementation 'androidx.constraintlayout:constraintlayout:2.1.4'
}

• android { ... }：Android 专有配置块。
  • compileSdk：编译代码时使用的 SDK 版本。
  • defaultConfig：默认配置。
    • applicationId：应用 ID。
    • minSdk：最低兼容版本。
    • targetSdk：目标版本,确保应用在新系统上行为正确。
  • buildTypes：构建类型，如 debug (调试) 和 release (发布)。
• dependencies { ... }：依赖管理块。
  • implementation：表示该依赖只在当前模块编译时有效，不会传递给其他依赖它的模块,这是最常用的依赖方式。

3 AndroidManifest.xml - 应用的“身份证”

这个文件声明了应用的基本信息、组件、权限等。

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools">
    <!-- 声明应用需要的权限 -->
    <uses-permission android:name="android.permission.INTERNET" />
    <application
        android:allowBackup="true"
        android:dataExtractionRules="@xml/data_extraction_rules"
        android:fullBackupContent="@xml/backup_rules"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.MyApplication"
        tools:targetApi="31">
        <!-- 声明主 Activity，这是应用的入口点 -->
        <activity
            android:name=".MainActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

• <uses-permission>：请求系统权限，如网络访问、相机访问等。
• <application>：应用容器。
  • android:icon, android:label：应用图标和名称。
  • <activity>：声明一个 Activity（屏幕）。
    • android:name：Activity 的类名。
    • <intent-filter>：定义 Activity 能响应的 Intent。LAUNCHER 类别表示这是桌面图标启动的 Activity。

4 资源文件 (res/ 目录)

资源文件使得你的应用可以支持多语言、不同屏幕尺寸，并且将 UI 和代码分离。

• res/values/strings.xml：存放所有文本字符串。

  <resources>
      <string name="app_name">My Application</string>
      <string name="hello_world">Hello World!</string>
  </resources>

• res/layout/activity_main.xml：定义 Activity 的 UI 布局。
• res/drawable/ic_launcher.xml：定义应用图标。
• 访问资源：在 Java/Kotlin 代码中，使用 R 类：getResources().getString(R.string.app_name)，在 XML 中，使用 ：android:text="@string/app_name"。

第三部分：核心配置详解

1 依赖管理

除了在 build.gradle 中添加 implementation 依赖,你还需要知道如何管理这些依赖的版本。

• 版本目录：在项目级 build.gradle 中，可以使用 dependencyResolutionManagement 来统一管理所有依赖的版本,避免冲突。

  // 项目级 build.gradle
  plugins {
      // ...
  }
  // 新增版本目录
  dependencyResolutionManagement {
      repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
      repositories {
          google()
          mavenCentral()
      }
  }
  // ...

• 版本号：在模块级 build.gradle 的 dependencies 块前定义版本号,方便统一修改。

  // 模块级 build.gradle
  android {
      // ...
  }
  // 定义版本
  def nav_version = "2.5.3"
  dependencies {
      // 使用版本号
      implementation "androidx.navigation:navigation-fragment-ktx:$nav_version"
      implementation "androidx.navigation:navigation-ui-ktx:$nav_version"
  }

2 应用签名

发布应用到 Google Play 或其他渠道，必须对 APK 进行签名。

• 创建签名密钥：

  1. 在 Android Studio 中，进入 Build -> Generate Signed Bundle / APK。
  2. 选择 APK 或 App Bundle。
  3. 选择 "Create new..." 创建一个新的密钥库。
  4. 填写密钥库信息（存储位置、密码、密钥别名、密钥密码等）。

• 配置 build.gradle：可以将签名信息配置到 build.gradle 中,方便自动化构建。

  android {
      // ...
      signingConfigs {
          release {
              storeFile file('your_key_store.jks') // 密钥库文件路径
              storePassword 'your_store_password'
              keyAlias 'your_key_alias'
              keyPassword 'your_key_password'
          }
      }
      buildTypes {
          release {
              signingConfig signingConfigs.release // 将签名配置应用到 release 构建类型
              // ...
          }
      }
  }

• 安全提示：切勿将密钥密码等敏感信息硬编码在代码中，应使用 local.properties 文件和 gradle.properties 文件来管理，并将 local.properties 添加到 .gitignore 中。

3 构建变体

通过配置 build.gradle，可以同时构建多个不同版本的应用,例如免费版和付费版。

• productFlavors：定义不同的产品风味。

  android {
      // ...
      flavorDimensions "version"
      productFlavors {
          free {
              dimension "version"
              applicationIdSuffix ".free"
              versionNameSuffix "-free"
          }
          paid {
              dimension "version"
              applicationIdSuffix ".paid"
              versionNameSuffix "-paid"
          }
      }
  }

• 源代码集：可以为不同的 flavor 创建独立的源代码和资源目录，src/free/java/ 和 src/paid/res/。

4 代码混淆

在发布 release 版本时，为了防止代码被反编译和窃取,需要进行代码混淆。

• 启用：在 build.gradle 的 release 构建类型中设置 minifyEnabled true。
• 规则文件：proguard-rules.pro 文件用于指定哪些类或方法需要保留，不进行混淆，所有继承自 View 的类通常需要保留。

第四部分：现代开发与配置

1 使用 View Binding

View Binding 是一种比 findViewById 更安全、更方便的方式来访问布局中的视图。

1. 启用：在模块级 build.gradle 的 android 块中添加：

   android {
       // ...
       buildFeatures {
           viewBinding true
       }
   }

2. 使用：在 Activity 或 Fragment 中，系统会自动生成一个绑定类（ActivityMainBinding）。

   // MainActivity.java
   public class MainActivity extends AppCompatActivity {
       private ActivityMainBinding binding; // 声明绑定类
       @Override
       protected void onCreate(Bundle savedInstanceState) {
           super.onCreate(savedInstanceState);
           // 使用 binding 设置布局，而不是 setContentView
           binding = ActivityMainBinding.inflate(getLayoutInflater());
           setContentView(binding.getRoot());
           // 通过 binding 访问视图，无需强制类型转换
           binding.button.setText("Hello View Binding!");
           binding.button.setOnClickListener(v -> {
               Toast.makeText(this, "Button Clicked", Toast.LENGTH_SHORT).show();
           });
       }
   }

2 使用 Hilt 进行依赖注入

依赖注入可以降低代码耦合度，提高可测试性和可维护性，Hilt 是 Google 推荐的 Android 依赖注入库。

1. 添加依赖：在模块级 build.gradle 中添加 Hilt 依赖。
2. 配置 Application 类：创建一个继承自 HiltAndroidApp 的 Application 类，并在 AndroidManifest.xml 中声明它。
3. 创建依赖：使用 @Inject 注解在构造函数中标记需要注入的依赖。
4. 提供依赖：使用 @Module 和 @Provides 或 @Binds 创建一个模块来提供依赖。
5. 注入依赖：在需要的地方（如 Activity、Fragment），使用 @AndroidEntryPoint 注解，并通过 @Inject 获取依赖。

这是一个复杂的主题，但配置是现代 Android 开发的标准实践。

3 配置多语言/多地区

1. 创建资源文件夹：在 res/ 目录下创建 values-[语言代码]-[地区代码] 文件夹，values-zh (中文简体), values-en (英文), values-zh-rTW (中文繁体)。
2. 复制 strings.xml：将默认的 strings.xml 复制到这些新文件夹中。
3. ：在各个语言的 strings.xml 中，只翻译 <string> 标签的 name 相同的值。
4. 系统自动选择：Android 系统会根据用户的手机语言设置，自动加载对应的 strings.xml 文件。

配置一个 Java Android 项目是一个系统性的工作，从环境安装到代码构建,每一步都有其配置要点。

• 基础：掌握 JDK, Android Studio, SDK 的安装。
• 核心：深入理解 build.gradle 和 AndroidManifest.xml 的作用。
• 实践：熟练使用 资源文件 和 依赖管理。
• 进阶：拥抱 View Binding、依赖注入 等现代开发实践。

这份指南为你提供了一个全面的框架，随着你经验的增长,你会对这些配置有更深的理解和应用。