Comprehensive Guide to Running Standard Java Projects in Android Studio

Versatility of Android Studio

While primarily designed for Android application development, Android Studio, built on the IntelliJ IDEA platform, possesses the capability to run standard Java projects. Many developers seek to manage both Android apps and related Java utility code within the same development environment, a need particularly evident when generating preprocessed data or sharing business logic.

Steps to Create a Java Module

To add a Java module to an Android project, begin by opening an existing Android project or creating a new one. Navigate to File > New Module and select the Java Library option. In the configuration window, fill in the package name and other necessary details, after which the system automatically generates the corresponding directory structure and Gradle configuration files.

The newly created Java module includes a standard Java project structure: the src/main/java directory for source code and the build.gradle file for build parameter configuration. This modular design allows developers to maintain different types of code within the same project while ensuring clear code organization.

Configuring Run Parameters

Running a Java project requires proper configuration of application parameters. Click the dropdown menu next to the run button and select the Edit Configurations... option. In the configuration window, add a new Application configuration via the plus sign in the top-left corner.

Key configuration items include:

• Main class: Specify the class containing the main method
• Classpath: Ensure correct pointing to the Java module's compiled output
• Working directory: Set an appropriate runtime environment

Common Issues and Solutions

During configuration, you may encounter the Error: Could not find or load main class... issue. This is typically caused by incorrect classpath configuration. The solution is to re-enter the main class name in the configuration window, even if the field is already populated. Click Apply and Ok, then attempt to run again.

Another common issue is JDK version compatibility. According to Android official documentation, different versions of the Android Gradle Plugin have specific JDK requirements. For instance, Android Gradle Plugin 8.x requires JDK 17; using an earlier JDK version will result in build errors.

Kotlin Integration Support

Android Studio also supports integrating Kotlin code into Java projects. First, add the Kotlin Gradle plugin dependency in the project-level build.gradle file:

buildscript {
    ext.kotlin_version = '1.2.51'
    repositories {
        google()
        jcenter()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:3.1.3'
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
    }
}

Then, apply the Kotlin plugin and add relevant dependencies in the module-level build.gradle:

apply plugin: 'java-library'
apply plugin: 'kotlin'

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
    runtimeClasspath files(compileKotlin.destinationDir)
}

For the main function in Kotlin, use specific syntax:

object Main {
    @JvmStatic
    fun main(args: Array<String>) {
        // Perform specific operations
    }
}

JDK Configuration and Toolchain Management

Android Studio uses JetBrains Runtime (JBR) as the default JDK, an optimized JDK version specifically designed for IDE usage scenarios. To ensure build consistency, it is recommended to explicitly specify the Java toolchain version in Gradle settings.

Configure the toolchain in the module's build.gradle file:

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(17)
    }
}

This configuration ensures the use of the same JDK version across different build environments, avoiding build issues caused by environmental differences.

Practical Application Scenarios

A typical application scenario involves Android apps relying on preprocessed files. For example, an app may require configuration files or data files generated by Java code. Placing this Java code in the same project as the Android app ensures code version consistency and simplifies the build process.

This integrated development model is particularly suitable for projects requiring frequent updates to preprocessing logic, allowing developers to complete all related development tasks within the same IDE without switching between different development environments.

Best Practices for Build Configuration

To ensure project maintainability and build stability, it is advisable to follow these best practices:

• Explicitly specify sourceCompatibility and targetCompatibility versions
• Unify Java toolchain configuration across all modules
• Regularly update Gradle plugin and dependency library versions
• Standardize JDK configuration in team development environments