Java: qué es este lenguaje, sus características y desarrollo Android

¿Qué es Java?

Java es un lenguaje de programación de propósito general creado por Sun Microsystems en 1995. El principio principal es "Write Once, Run Anywhere": el bytecode de Java compilado se ejecuta en cualquier plataforma que tenga instalada la máquina virtual JVM. En el contexto del desarrollo móvil, Java se convirtió en el primer lenguaje oficial del Android SDK, lanzado por Google en 2008.

La arquitectura de Java se basa en tres componentes: JDK (Java Development Kit) — conjunto de herramientas para el desarrollador, JRE (Java Runtime Environment) — entorno de ejecución y JVM (Java Virtual Machine) — máquina virtual. Android utiliza su propia implementación de JVM — Android Runtime (ART), que reemplazó a Dalvik en la versión 5.0 (Lollipop). ART ejecuta bytecode DEX, que se compila a partir del bytecode de Java mediante la utilidad dx/d8.

Una característica clave de Java es la gestión automática de memoria a través del Garbage Collector (GC). El desarrollador no necesita liberar memoria explícitamente — el GC rastrea los objetos no utilizados y los elimina. En Android ART se utilizan Concurrent Mark Sweep (CMS) y Generational GC, optimizados para recursos limitados de dispositivos móviles. Esto reduce la carga del desarrollador, pero puede causar "lag" durante la recolección de basura en el hilo de la UI.

Versiones de Java y API de Android

Android admite un subconjunto de la API de Java que se expande con cada nueva versión del SO. Android 12 (API 31) añadió soporte para Java 11, incluyendo lambdas con captura de variables, el sistema de módulos JPMS y el cliente HTTP java.net.http. Android 14 (API 34) introdujo soporte experimental para Java 17 mediante desugaring D8/R8 — algunas características (records, sealed classes) se traducen a código compatible para versiones antiguas.

Java SDK y desarrollo Android

El Android SDK incluye el compilador de Java, la utilidad dex (d8), aapt (Asset Packaging Tool), el emulador y las librerías android.* y java.*. El desarrollador escribe código en Java, lo compila en archivos .class (bytecode JVM), luego d8 los convierte en archivos .dex (Dalvik Executable), que se empaquetan en APK junto con los recursos y AndroidManifest.xml.

Gradle es el sistema de compilación de proyectos Android. El archivo build.gradle (Groovy) o build.gradle.kts (Kotlin DSL) describe dependencias, versiones de SDK, flavors y firmas. Android Gradle Plugin (AGP) versión 8.x automatiza el desugar — la traducción de características modernas de Java a código compatible hacia atrás. Por ejemplo, java.time.LocalDate se convierte en código compatible con API 21+ sin cambios en el código fuente del desarrollador.

// Activity simple de Android en Java
package com.example.myapp;

import android.os.Bundle;
import android.widget.TextView;
import androidx.appcompat.app.AppCompatActivity;

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        TextView tv = findViewById(R.id.textView);
        tv.setText("Hello from Java!");
    }

    // Método para manejar el clic del botón
    public void onButtonClick(View view) {
        TextView tv = findViewById(R.id.textView);
        tv.setText("Button clicked");
    }
}

La clase MainActivity extiende AppCompatActivity — una clase base de AndroidX para compatibilidad hacia atrás. El método onCreate se llama al crear la Activity, en él se establece el layout mediante setContentView. findViewById vincula una variable Java con un elemento del layout XML. El método onButtonClick está vinculado al botón mediante el atributo android:onClick en XML.

Trabajo con Activity y ciclo de vida

El ciclo de vida de Activity en Java es una secuencia de callbacks: onCreate → onStart → onResume (activo), onPause → onStop → onDestroy (finalización). El desarrollador sobrescribe estos métodos para gestionar recursos. onCreate — inicialización, onPause — guardar datos, onDestroy — liberar recursos. Android llama a estos métodos al rotar la pantalla, entrar en segundo plano y recibir una llamada.

// Ciclo de vida de Activity con gestión de estado
public class DetailActivity extends AppCompatActivity {
    private String itemId;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_detail);

        itemId = getIntent().getStringExtra("ITEM_ID");
        loadData(itemId);
    }

    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        outState.putString("item_id", itemId);
    }

    @Override
    protected void onRestoreInstanceState(Bundle savedInstanceState) {
        super.onRestoreInstanceState(savedInstanceState);
        itemId = savedInstanceState.getString("item_id");
        loadData(itemId);
    }

    private void loadData(String id) {
        // Cargar datos por identificador
    }
}

El método onSaveInstanceState guarda el estado de la Activity al rotar la pantalla o cambiar de tarea. Bundle contiene pares clave-valor — tipos simples, objetos Parcelable o Serializable. onRestoreInstanceState restaura el estado guardado. Este patrón es crítico para Android, ya que el sistema puede destruir la Activity cuando falta memoria y restaurarla cuando el usuario vuelve.

Sintaxis de Java: clases, métodos y tipos

La sintaxis de Java es similar a C, fuertemente tipada, orientada a objetos. Cada archivo .java contiene una clase public cuyo nombre coincide con el nombre del archivo. Java no admite funciones fuera de las clases — todo es un método. El punto de entrada es el método estático public static void main(String[] args) para aplicaciones de consola o los métodos del ciclo de vida de Android Activity para móviles.

Tipos de datos de Java

Java divide los tipos en primitivos (int, double, boolean, char, byte, short, long, float) y tipos de referencia (clases, interfaces, arrays, enum). Los primitivos se almacenan en la pila y se pasan por valor. Los objetos están en el heap, se pasan por referencia. El autoboxing convierte automáticamente un primitivo en un objeto wrapper (Integer, Double, Boolean), pero crea objetos adicionales — en Android esto es crítico para el rendimiento de la UI.

// Ejemplos de tipos de datos y estructuras de Java
public class DataTypes {
    // Primitivos
    int count = 42;
    double price = 19.99;
    boolean isActive = true;
    char grade = 'A';

    // Tipos de referencia
    String name = "Android";
    Integer boxed = 100; // autoboxing
    List<String> items = new ArrayList<>();

    // Método con Genéricos
    public <T> T getFirst(List<T> list) {
        return list.isEmpty() ? null : list.get(0);
    }

    // Enum para conjunto fijo de valores
    public enum Status {
        PENDING, LOADING, SUCCESS, ERROR
    }
}

Los genéricos List<T> proporcionan seguridad de tipos para las colecciones. El método getFirst devuelve un elemento de cualquier tipo — el tipo específico se determina en el punto de llamada. Enum Status se compila en una clase con un conjunto fijo de constantes, cada instancia es un singleton. En Android, enum se usa con menos frecuencia debido al consumo de memoria: ProGuard/R8 optimiza enum en constantes int cuando es posible.

Java vs Kotlin: comparación en Android

La comparación entre Java y Kotlin para el desarrollo Android ha sido uno de los temas principales desde 2019, cuando Google declaró a Kotlin como el lenguaje prioritario. Kotlin es totalmente compatible con Java — ambos se compilan a bytecode JVM, pueden llamarse entre sí y usar las mismas librerías. Sin embargo, los enfoques para escribir código difieren drásticamente.

Código boilerplate

Kotlin elimina la verbosidad de Java: data class reemplaza 50+ líneas de una clase Java con getters, setters, equals, hashCode, toString y copy. La seguridad de nulos está integrada en el sistema de tipos de Kotlin — NullPointerException es prácticamente imposible. Las funciones de extensión permiten añadir métodos a clases existentes sin herencia. Smart Casts convierten tipos automáticamente después de una comprobación.

Rendimiento

En cuanto al rendimiento, Java y Kotlin son idénticos — ambos se compilan a bytecode JVM, que Android ART ejecuta de la misma manera. La diferencia está en el tamaño del APK: Kotlin añade ~200-400 KB por la librería kotlin-stdlib. Los proyectos Java tienen un tamaño de APK menor debido a la ausencia de runtime adicional, pero al usar Java Stream API y Optional, el tamaño del APK puede aumentar debido al desugaring.

Herramientas del desarrollador Java para Android

Las herramientas del desarrollador Java para Android incluyen Android Studio, Gradle, el perfilador y el emulador. Android Studio es el IDE oficial, basado en IntelliJ IDEA Community, que incluye un editor con autocompletado de Java, analizador de código (lint), refactorización y un editor visual de layouts (Layout Editor).

Herramientas principales

Android Gradle Plugin (AGP) versión 8.x gestiona la compilación: compilación de Java en clases, desugaring, minificación ProGuard/R8, empaquetado en APK/AAB. R8 es un desugaring y ofuscador actualizado que reemplaza a ProGuard. Las variantes de compilación (debug/release + product flavors) se configuran mediante build.gradle. Gradle Daemon acelera las compilaciones posteriores mediante el almacenamiento en caché.

// build.gradle (app) — configuración del módulo Java
android {
    compileSdk 34
    defaultConfig {
        applicationId "com.example.myapp"
        minSdk 21
        targetSdk 34
        versionCode 1
        versionName "1.0"
    }
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_17
        targetCompatibility JavaVersion.VERSION_17
    }
}

dependencies {
    implementation 'androidx.core:core-ktx:1.12.0'
    implementation 'androidx.appcompat:appcompat:1.6.1'
    implementation 'com.google.android.material:material:1.11.0'
    testImplementation 'junit:junit:4.13.2'
}

El bloque compileOptions especifica la versión de Java para la compilación — Java 17 está disponible con AGP 8.x. El SDK mínimo (minSdk) determina la versión mínima de Android en la que funciona la aplicación. Target SDK es la versión con la que se probó la aplicación. La diferencia entre compileSdk y targetSdk: compileSdk es la API para compilación, targetSdk es el comportamiento en tiempo de ejecución.

Limitaciones de Java en el desarrollo móvil

Las limitaciones de Java en Android llevaron a la transición de Google a Kotlin. NullPointerException es la excepción más común en aplicaciones Java para Android, ya que el sistema de tipos no distingue entre referencias nullable y non-null. Google recomienda las anotaciones @Nullable y @NonNull del paquete androidx.annotation, pero el compilador no las verifica — solo lo hace lint.

La ausencia de corrutinas es otra limitación: las operaciones asíncronas en Java requieren callbacks, AsyncTask (obsoleto desde API 30), ExecutorService o RxJava. Esto lleva a callback hell y fugas de memoria al rotar la pantalla. Las corrutinas de Kotlin con Structured Concurrency resuelven este problema a nivel de lenguaje: una corrutina se cancela al destruirse la Activity sin gestión manual.

El código boilerplate en Java es una fuente de errores al escribir manualmente equals/hashCode, implementaciones Parcelable y ViewHolder para RecyclerView. Las librerías Android KTX y Jetpack Compose están orientadas a Kotlin. Las nuevas APIs de Android (Room, Navigation, Compose) publican ejemplos en Kotlin por defecto, aunque existen versiones en Java.