How to create an Android application in Java from scratch

Development of mobile apps for the Android operating system remains one of the most popular areas in the IT industry. Despite Kotlin's growing popularity, the language Java still powers millions of existing projects and is a fundamental tool for understanding the platform's architecture. Creating your first project may seem like a complex process that requires deep knowledge, but with the right approach, this task becomes quite doable even for a beginner.

You don’t have to be a professional programmer to start your journey. Modern development tools, such as Android Studio, significantly simplify routine operations, allowing you to focus on the logic of the product. In this article, we will look at the key steps: from installing the necessary software to publishing the finished APK file.

It is important to understand that the Google ecosystem is constantly being updated. IDEs and minimum API requirements may change over time.

⚠️ Warning: Always check Google's official developer docs before getting started, as some environment setup steps may differ slightly from those described here.

Let's get started preparing your workbench.

Development environment preparation and installation SDK

The first and most critical step is to install the integrated development environment. For working with Java code on Android, the de facto standard is Android Studio. This is a powerful IDE built on IntelliJ IDEA, which includes all the necessary tools: an emulator, a code editor, a profiler and a package manager.

After downloading the installer from the official website, run it and follow the installation wizard instructions. During the process, you will be asked to select components to install. Be sure to make sure that the item Android SDK (Software Development Kit) is checked. It is this set of libraries that allows you to compile code for different versions of the operating system.

Installation may take some time as the system loads the latest versions of platforms and build tools.

⚠️ Attention: Make sure that your C drive (or selected system partition) has at least 10-15 GB of free space, otherwise the component download process may complete error.

After installation is complete, launch the environment and wait until the files are indexed.

When the environment is ready, you need to create a new project. Click the New Project button in the welcome window. You will be asked to select a template. Empty Activityis the best place to start, as it provides the minimum required set of files without the extra code that is often found in other templates.

Project structure and Gradle configuration

After creating the project, you will see a complex folder structure on the left. This is often intimidating for beginners, but only a few key elements are important to get started. The main code of your application will be located in the directory app/src/main/java. This is where packages containing classes in the Java language are located.

Application resources, such as images, interface strings, and screen layout files, are stored in the folder res. The file deserves special attention build.gradle (Module: app). This configuration file manages project dependencies and compiler versions.

Inside the block android you will find a parameter compileSdk. It determines which version of Android your application will compile against. Also important is the parameter minSdk, which specifies the minimum version of the system on which the app can run.

What is the difference between compileSdk and minSdk?

compileSdk is the version whose functions you can use in code. minSdk is the oldest version of Android on which your application is guaranteed to run for users.

Do not set minSdk too high if you want to reach a large audience, but not too low so as not to limit yourself in using modern APIs.

To connect third-party libraries, use the block dependencies. Here you can add popular tools, for example, for working with the network or databases.

After changing the file build.gradle be sure to click the button Sync Nowfor the environment to apply the new settings.

Interface design in XML

External The appearance of Android applications is described using the XML markup language. Layout files are located in the folder res/layout. The main activity file is usually named activity_main.xml. When you open it, you will see a visual editor where you can drag elements onto the screen, or a text code editor.

Each interface element is a View. The most common of them are: TextView for displaying text, Button for buttons and EditText for input fields. All of them should be nested in containers called Layouts. The most flexible and modern container is ConstraintLayout.

In a ConstraintLayout, the position of each element is set relative to the screen boundaries or other elements. This allows you to create adaptive interfaces that look good on devices with different diagonals.

An example of a simple layout with a button and text looks like this:

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

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

Pay attention to the attribute android:id. It gives the element a unique name through which we can access it from Java code. Without an identifier, it is impossible to programmatically control an element.

Writing logic in Java

Now let's move on to the most interesting part - programming the behavior of the application. Open the file MainActivity.java in the folder java/com.example.yourapp. This class is the entry point to the application. The method onCreate is called by the system immediately after the activity is launched.

Inside onCreate bundle Java objects with XML markup. For this, the method findViewByIdis used. It finds the interface element by its ID, which we specified earlier.

Why does findViewById return Object?

The method returns the base type View, so it must be explicitly cast to a specific type (for example, Button or TextView) using casting in parentheses.

An example of getting a reference to button:

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

After receiving a reference to an element, we can assign event listeners to it. The most common scenario is a reaction to a button press. To do this, use the method setOnClickListener, into which an anonymous class or lambda expression is passed.

myButton.setOnClickListener(new View.OnClickListener {
@Override
public void onClick(View v) {
// Code that will be executed when clicked
Toast.makeText(MainActivity.this,"Button pressed!", Toast.LENGTH_SHORT).show;
}
});

The example above uses the class Toast. This is a pop-up notification that appears for a short time and disappears automatically. This is a convenient way to debug or inform the user without creating complex dialog boxes.

Working with the activity lifecycle

Applications on Android do not work linearly like apps on a PC. They are managed by the system, which can kill the process at any time to free up memory. Understanding the Lifecycle is critical to creating stable apps.

Activity goes through several states: creation, start, resume, pause, stop, and destruction. For each state there is a corresponding callback method that you can override in your class.

Method	State description	When called
onCreate	Creation	When the activity is first launched. This is where initialization occurs.
onStart	Start	When the activity becomes visible to the user, but not yet interactive.
onResume	Resume	When the activity comes into focus and the user can interact with it.
onPause	Pause	Partial overlap of another activity (for example, a pop-up window).
onStop	Stop	The activity is completely hidden from the user's field of view.

It is in the methods onPause or onStop it is recommended to save important data, since after it the system can be killed by a process.

⚠️ Attention: Never perform long operations (downloading from the network, complex calculations) in the method onCreate or onResume, otherwise the interface will freeze until loading is complete.

Proper distribution of logic across these methods ensures that your application will not crash when the screen is rotated or minimized.

Debugging and running on an emulator

Before showing the application to users, it needs to be tested. Android Studio comes with a built-in emulator that simulates a real device. You can create a virtual phone via Device Managerby selecting the desired model and version of Android.

To launch the application, click the green button Run (triangle) on the toolbar. If the emulator is not yet running, the system will prompt you to select a device. After compilation, the project will be installed on the virtual machine, and you will see the result of your work.

If the application does not work as expected, use the tool Logcat. This is a console that displays system logs in real time. Errors in the code (for example, NullPointerException) will be displayed here in red, indicating the line where the failure occurred.

You can also connect real devices via a USB cable. To do this, you need to activate the mode on your phone USB Debugging in the "For Developers" menu.

Testing on real hardware is always preferable, since the emulator may not reproduce some features of the camera or sensors.

Building the release version and publishing

When testing is completed and bugs are fixed, the assembly stage begins release version. By default, Android Studio builds a debug version, which is signed with an automatic key and is not optimized for size.

To create a file for publication, go to menu Build → Generate Signed Bundle / APK. You will need to create a new signing key (Keystore). Never lose your keystore file and its password: without them, you will not be able to update your application on Google Play in the future.

This is a Google security rule that cannot be circumvented.

In the build wizard, select format APK (for direct installation) or Android App Bundle (.aab) (recommended for Google Play Store). The AAB format allows the store to automatically optimize the size of the application for a specific user device, cutting off unnecessary resources.

After successful assembly, the finished file will appear in the folder app/release . Now you can upload it to the Google Play developer console, fill out a description, add screenshots and send it for moderation. The verification process usually takes from several hours to several days.

Is it possible to create an application in Java without knowledge of Kotlin?

Yes, absolutely. Java is a full-fledged language for Android development. However, learning the basics of Kotlin in the future will expand your capabilities, since many new Google libraries are written primarily for it.

How long does it take to create a simple application?

A simple application with one screen and basic logic can be created in one evening (2-4 hours). More complex projects with database and network queries require from several days to weeks of work.

Do you need a powerful computer for development?

It is advisable to have at least 8 GB of RAM (preferably 16 GB) and an SSD drive. The Android emulator consumes a lot of resources, and on weak machines the work will be slow and uncomfortable.

Is it free to publish applications on Google Play?

Registering a developer account in Google Play Console costs $25. This is a one-time payment, after which you can publish an unlimited number of applications for free.