While Kotlin has become Google's preferred language for Android development, Java remains a powerful, well-supported choice for building robust mobile applications. With its vast ecosystem, extensive libraries, and mature tooling, Java continues to be an excellent platform for Android development. This article explores the fundamentals, best practices, and modern approaches to Android development using Java.

Why Choose Java for Android Development?

Advantages:

• Mature Ecosystem: Decades of libraries, frameworks, and community knowledge
• Strong Typing: Compile-time safety reduces runtime errors
• Cross-Platform Skills: Java knowledge transfers to backend, desktop, and other domains
• Stability: Well-tested language with predictable behavior
• Enterprise Ready: Ideal for large-scale applications and teams

Considerations:

• Verbose Syntax: More code compared to Kotlin for similar functionality
• Null Safety: Requires careful handling (unlike Kotlin's built-in null safety)
• Modern Features: Some newer language features arrive later than in Kotlin

Android Development Setup with Java

Required Tools:

1. Android Studio - The official IDE
2. Java Development Kit (JDK) 8 or later
3. Android SDK - Platform tools and libraries

Project Structure:

app/ ├── src/ │ ├── main/ │ │ ├── java/com/example/app/ # Java source code │ │ ├── res/ # Resources (layouts, strings, drawables) │ │ └── AndroidManifest.xml # App configuration │ └── test/ # Unit tests ├── build.gradle # Module-level build configuration └── ...

Core Android Components with Java

1. Activities - The UI Controllers

public class MainActivity extends AppCompatActivity { private TextView welcomeText; private Button clickButton; private int clickCount = 0; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); // Initialize views welcomeText = findViewById(R.id.welcome_text); clickButton = findViewById(R.id.click_button); // Set up button click listener clickButton.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { clickCount++; welcomeText.setText("Button clicked " + clickCount + " times"); // Start a new activity Intent intent = new Intent(MainActivity.this, DetailActivity.class); intent.putExtra("CLICK_COUNT", clickCount); startActivity(intent); } }); } }

2. Fragments - Reusable UI Components

public class UserProfileFragment extends Fragment { private UserViewModel userViewModel; @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { // Inflate the layout for this fragment View view = inflater.inflate(R.layout.fragment_user_profile, container, false); TextView userName = view.findViewById(R.id.user_name); ImageView userAvatar = view.findViewById(R.id.user_avatar); // Receive arguments Bundle args = getArguments(); if (args != null) { String name = args.getString("user_name"); userName.setText(name); } return view; } }

3. Services - Background Operations

public class DownloadService extends Service { @Override public int onStartCommand(Intent intent, int flags, int startId) { // Perform background work new Thread(new Runnable() { @Override public void run() { downloadFile(); stopSelf(); // Stop service when work is complete } }).start(); return START_NOT_STICKY; } @Nullable @Override public IBinder onBind(Intent intent) { return null; } private void downloadFile() { // Implementation for file download } }

Layouts and UI Design with XML

activity_main.xml:

<?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="match_parent" android:layout_height="match_parent" android:orientation="vertical" android:padding="16dp"> <TextView android:id="@+id/welcome_text" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Welcome to Android with Java!" android:textSize="24sp" android:layout_gravity="center_horizontal" /> <Button android:id="@+id/click_button" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_gravity="center_horizontal" android:layout_marginTop="16dp" android:text="Click Me!" /> <androidx.recyclerview.widget.RecyclerView android:id="@+id/recycler_view" android:layout_width="match_parent" android:layout_height="0dp" android:layout_weight="1" android:layout_marginTop="16dp" /> </LinearLayout>

RecyclerView with Java - Displaying Lists

1. Adapter Class:

public class UserAdapter extends RecyclerView.Adapter<UserAdapter.UserViewHolder> { private List<User> userList; private OnItemClickListener listener; public interface OnItemClickListener { void onItemClick(User user); } public UserAdapter(List<User> userList, OnItemClickListener listener) { this.userList = userList; this.listener = listener; } @NonNull @Override public UserViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) { View view = LayoutInflater.from(parent.getContext()) .inflate(R.layout.item_user, parent, false); return new UserViewHolder(view); } @Override public void onBindViewHolder(@NonNull UserViewHolder holder, int position) { User user = userList.get(position); holder.bind(user, listener); } @Override public int getItemCount() { return userList.size(); } // ViewHolder class static class UserViewHolder extends RecyclerView.ViewHolder { private TextView userName; private TextView userEmail; public UserViewHolder(@NonNull View itemView) { super(itemView); userName = itemView.findViewById(R.id.user_name); userEmail = itemView.findViewById(R.id.user_email); } public void bind(final User user, final OnItemClickListener listener) { userName.setText(user.getName()); userEmail.setText(user.getEmail()); itemView.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { listener.onItemClick(user); } }); } } }

2. Usage in Activity:

public class UserListActivity extends AppCompatActivity { private RecyclerView recyclerView; private UserAdapter adapter; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_user_list); recyclerView = findViewById(R.id.recycler_view); recyclerView.setLayoutManager(new LinearLayoutManager(this)); List<User> users = getUserList(); // Your data source adapter = new UserAdapter(users, new UserAdapter.OnItemClickListener() { @Override public void onItemClick(User user) { // Handle item click showUserDetails(user); } }); recyclerView.setAdapter(adapter); } private void showUserDetails(User user) { Intent intent = new Intent(this, UserDetailActivity.class); intent.putExtra("USER_ID", user.getId()); startActivity(intent); } }

Networking with Retrofit and Java

1. API Interface:

public interface ApiService { @GET("users") Call<List<User>> getUsers(); @GET("users/{id}") Call<User> getUserById(@Path("id") int userId); @POST("users") Call<User> createUser(@Body User user); }

2. Network Operations:

public class UserRepository { private ApiService apiService; public UserRepository() { Retrofit retrofit = new Retrofit.Builder() .baseUrl("https://api.example.com/") .addConverterFactory(GsonConverterFactory.create()) .build(); apiService = retrofit.create(ApiService.class); } public void fetchUsers(final UserCallback callback) { apiService.getUsers().enqueue(new Callback<List<User>>() { @Override - public void onResponse(Call<List<User>> call, Response<List<User>> response) { if (response.isSuccessful()) { callback.onSuccess(response.body()); } else { callback.onError("Failed to fetch users"); } } @Override public void onFailure(Call<List<User>> call, Throwable t) { callback.onError(t.getMessage()); } }); } public interface UserCallback { void onSuccess(List<User> users); void onError(String error); } }

Data Persistence with Room Database

1. Entity Class:

@Entity(tableName = "users") public class User { @PrimaryKey private int id; @ColumnInfo(name = "name") private String name; @ColumnInfo(name = "email") private String email; // Constructors, getters, and setters public User(int id, String name, String email) { this.id = id; this.name = name; this.email = email; } // Getters public int getId() { return id; } public String getName() { return name; } public String getEmail() { return email; } }

2. DAO Interface:

@Dao public interface UserDao { @Query("SELECT * FROM users") List<User> getAllUsers(); @Query("SELECT * FROM users WHERE id = :userId") User getUserById(int userId); @Insert void insertUser(User user); @Update void updateUser(User user); @Delete void deleteUser(User user); }

3. Database Class:

@Database(entities = {User.class}, version = 1) public abstract class AppDatabase extends RoomDatabase { public abstract UserDao userDao(); private static volatile AppDatabase INSTANCE; public static AppDatabase getInstance(Context context) { if (INSTANCE == null) { synchronized (AppDatabase.class) { if (INSTANCE == null) { INSTANCE = Room.databaseBuilder( context.getApplicationContext(), AppDatabase.class, "app_database" ).build(); } } } return INSTANCE; } }

Modern Architecture: MVVM with LiveData

1. ViewModel:

public class UserViewModel extends ViewModel { private MutableLiveData<List<User>> users = new MutableLiveData<>(); private MutableLiveData<String> error = new MutableLiveData<>(); private UserRepository userRepository; public UserViewModel() { userRepository = new UserRepository(); loadUsers(); } public LiveData<List<User>> getUsers() { return users; } public LiveData<String> getError() { return error; } private void loadUsers() { userRepository.fetchUsers(new UserRepository.UserCallback() { @Override public void onSuccess(List<User> userList) { users.postValue(userList); } @Override public void onError(String errorMessage) { error.postValue(errorMessage); } }); } }

2. Activity using ViewModel:

public class UserActivity extends AppCompatActivity { private UserViewModel userViewModel; private UserAdapter adapter; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_user); userViewModel = new ViewModelProvider(this).get(UserViewModel.class); setupRecyclerView(); setupObservers(); } private void setupObservers() { userViewModel.getUsers().observe(this, new Observer<List<User>>() { @Override public void onChanged(List<User> users) { adapter.setUserList(users); } }); userViewModel.getError().observe(this, new Observer<String>() { @Override public void onChanged(String error) { Toast.makeText(UserActivity.this, error, Toast.LENGTH_SHORT).show(); } }); } }

Dependency Injection with Dagger/Hilt

Basic Hilt Setup:

@HiltAndroidApp public class MyApplication extends Application { // Application class } @Module @InstallIn(SingletonComponent.class) public class AppModule { @Provides @Singleton public ApiService provideApiService() { return new Retrofit.Builder() .baseUrl("https://api.example.com/") .addConverterFactory(GsonConverterFactory.create()) .build() .create(ApiService.class); } } @AndroidEntryPoint public class MainActivity extends AppCompatActivity { @Inject ApiService apiService; // Activity code... }

Best Practices for Java Android Development

1. Use AndroidX Libraries: Always use the latest AndroidX packages
2. Handle Configuration Changes: Use ViewModel to survive configuration changes
3. Background Processing: Use WorkManager for guaranteed background work
4. Memory Management: Avoid memory leaks with weak references
5. ProGuard/R8: Enable code shrinking and obfuscation for release builds

build.gradle (Module):

android { compileSdkVersion 33 defaultConfig { applicationId "com.example.myapp" minSdkVersion 21 targetSdkVersion 33 versionCode 1 versionName "1.0" javaCompileOptions { annotationProcessorOptions { arguments += ["room.schemaLocation": "$projectDir/schemas".toString()] } } } buildTypes { release { minifyEnabled true proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro' } } compileOptions { sourceCompatibility JavaVersion.VERSION_1_8 targetCompatibility JavaVersion.VERSION_1_8 } } dependencies { implementation 'androidx.appcompat:appcompat:1.6.1' implementation 'com.google.android.material:material:1.8.0' implementation 'androidx.constraintlayout:constraintlayout:2.1.4' implementation 'androidx.lifecycle:lifecycle-viewmodel:2.6.2' implementation 'androidx.room:room-runtime:2.5.2' annotationProcessor 'androidx.room:room-compiler:2.5.2' implementation 'com.squareup.retrofit2:retrofit:2.9.0' implementation 'com.squareup.retrofit2:converter-gson:2.9.0' }

Conclusion

Java remains a solid choice for Android development, offering:

• Proven Reliability: Battle-tested in millions of applications
• Rich Ecosystem: Vast collection of libraries and tools
• Strong Community: Extensive documentation and support
• Career Flexibility: Skills transfer beyond mobile development

While Kotlin offers modern language features, Java provides stability, performance, and access to a massive ecosystem. By following modern architecture patterns like MVVM, using Jetpack components, and implementing best practices, you can build high-quality, maintainable Android applications with Java that stand the test of time.

Whether you're maintaining legacy codebases or starting new projects, Java continues to be a valuable skill in the Android development landscape.