Java: o que é esta linguagem, suas características e desenvolvimento Android

O que é Java?

Java é uma linguagem de programação de propósito geral criada pela Sun Microsystems em 1995. O princípio principal é "Write Once, Run Anywhere": o bytecode Java compilado é executado em qualquer plataforma que tenha a máquina virtual JVM instalada. No contexto do desenvolvimento móvel, Java se tornou a primeira linguagem oficial do Android SDK, lançado pelo Google em 2008.

A arquitetura Java é baseada em três componentes: JDK (Java Development Kit) — conjunto de ferramentas do desenvolvedor, JRE (Java Runtime Environment) — ambiente de execução e JVM (Java Virtual Machine) — máquina virtual. O Android usa sua própria implementação da JVM — Android Runtime (ART), que substituiu o Dalvik na versão 5.0 (Lollipop). O ART executa bytecode DEX, que é compilado a partir do bytecode Java através do utilitário dx/d8.

Uma característica fundamental do Java é o gerenciamento automático de memória através do Garbage Collector (GC). O desenvolvedor não precisa liberar memória explicitamente — o GC rastreia objetos não utilizados e os remove. No Android ART, são usados Concurrent Mark Sweep (CMS) e Generational GC, otimizados para recursos limitados de dispositivos móveis. Isso reduz a carga do desenvolvedor, mas pode causar "lags" durante a coleta de lixo na thread da UI.

Versões Java e Android API

O Android suporta um subconjunto da Java API que se expande a cada nova versão do SO. O Android 12 (API 31) adicionou suporte ao Java 11, incluindo lambdas com captura de variáveis, sistema de módulos JPMS e cliente HTTP java.net.http. O Android 14 (API 34) introduziu suporte experimental ao Java 17 através de desugaring D8/R8 — alguns recursos (records, sealed classes) são traduzidos em código compatível para versões antigas.

Java SDK e desenvolvimento Android

O Android SDK inclui o compilador Java, utilitário dex (d8), aapt (Asset Packaging Tool), emulador e bibliotecas android.* e java.*. O desenvolvedor escreve código em Java, compila em arquivos .class (bytecode JVM), então o d8 os converte em arquivos .dex (Dalvik Executable), que são empacotados em APK junto com recursos e AndroidManifest.xml.

Gradle é o sistema de build de projetos Android. O arquivo build.gradle (Groovy) ou build.gradle.kts (Kotlin DSL) descreve dependências, versões do SDK, flavors e assinaturas. O Android Gradle Plugin (AGP) versão 8.x automatiza o desugar — tradução de recursos modernos do Java em código compatível com versões anteriores. Por exemplo, java.time.LocalDate é convertido em código compatível com API 21+ sem alterações no código fonte do desenvolvedor.

// Activity Android simples em 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 lidar com clique do botão
    public void onButtonClick(View view) {
        TextView tv = findViewById(R.id.textView);
        tv.setText("Button clicked");
    }
}

A classe MainActivity estende AppCompatActivity — uma classe base do AndroidX para compatibilidade com versões anteriores. O método onCreate é chamado ao criar a Activity; nele o layout é definido via setContentView. findViewById vincula uma variável Java a um elemento do layout XML. O método onButtonClick está vinculado ao botão através do atributo android:onClick no XML.

Trabalhando com Activity e ciclo de vida

O ciclo de vida da Activity em Java é uma sequência de callbacks: onCreate → onStart → onResume (ativo), onPause → onStop → onDestroy (finalização). O desenvolvedor sobrescreve esses métodos para gerenciar recursos. onCreate — inicialização, onPause — salvar dados, onDestroy — liberar recursos. O Android chama esses métodos ao girar a tela, entrar em segundo plano e receber uma chamada.

// Ciclo de vida da Activity com gerenciamento 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) {
        // Carregar dados por identificador
    }
}

O método onSaveInstanceState salva o estado da Activity ao girar a tela ou alternar tarefas. Bundle contém pares chave-valor — tipos simples, objetos Parcelable ou Serializable. onRestoreInstanceState restaura o estado salvo. Este padrão é crítico para o Android, pois o sistema pode destruir a Activity quando a memória está baixa e restaurá-la quando o usuário retornar.

Sintaxe Java: classes, métodos e tipos

A sintaxe Java é semelhante a C, fortemente tipada, orientada a objetos. Cada arquivo .java contém uma classe pública cujo nome coincide com o nome do arquivo. Java não suporta funções fora de classes — tudo é um método. O ponto de entrada é o método estático public static void main(String[] args) para aplicações de console ou métodos do ciclo de vida da Activity Android para dispositivos móveis.

Tipos de dados Java

Java divide os tipos em primitivos (int, double, boolean, char, byte, short, long, float) e tipos de referência (classes, interfaces, arrays, enum). Os primitivos são armazenados na pilha e passados por valor. Objetos estão no heap, passados por referência. Autoboxing converte automaticamente um primitivo em um objeto wrapper (Integer, Double, Boolean), mas cria objetos extras — no Android isso é crítico para o desempenho da UI.

// Exemplos de tipos de dados e estruturas Java
public class DataTypes {
    // Primitivos
    int count = 42;
    double price = 19.99;
    boolean isActive = true;
    char grade = 'A';

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

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

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

Genéricos List<T> fornecem segurança de tipos para coleções. O método getFirst retorna um elemento de qualquer tipo — o tipo específico é determinado no ponto de chamada. Enum Status compila em uma classe com um conjunto fixo de constantes, cada instância é um singleton. No Android, enum é usado com menos frequência devido ao consumo de memória: ProGuard/R8 otimiza enum em constantes int quando possível.

Java vs Kotlin: comparação no Android

A comparação entre Java e Kotlin para desenvolvimento Android tem sido um dos principais tópicos desde 2019, quando o Google declarou Kotlin como a linguagem prioritária. Kotlin é totalmente compatível com Java — ambos compilam para bytecode JVM, podem chamar um ao outro e usar as mesmas bibliotecas. No entanto, as abordagens para escrever código diferem drasticamente.

Código boilerplate

Kotlin elimina a verbosidade do Java: data class substitui 50+ linhas de uma classe Java com getters, setters, equals, hashCode, toString e copy. A segurança de nulos está embutida no sistema de tipos do Kotlin — NullPointerException é praticamente impossível. Funções de extensão permitem adicionar métodos a classes existentes sem herança. Smart Casts convertem tipos automaticamente após uma verificação.

Desempenho

Em termos de desempenho, Java e Kotlin são idênticos — ambos compilam para bytecode JVM, que o Android ART executa da mesma forma. A diferença está no tamanho do APK: Kotlin adiciona ~200-400 KB pela biblioteca kotlin-stdlib. Projetos Java têm um tamanho de APK menor devido à ausência de runtime adicional, mas ao usar Java Stream API e Optional, o tamanho do APK pode aumentar devido ao desugaring.

Ferramentas do desenvolvedor Java para Android

As ferramentas do desenvolvedor Java para Android incluem Android Studio, Gradle, profiler e emulador. Android Studio é o IDE oficial, baseado no IntelliJ IDEA Community, que inclui editor com autocompletar Java, analisador de código (lint), refatoração e um editor visual de layouts (Layout Editor).

Principais ferramentas

Android Gradle Plugin (AGP) versão 8.x gerencia o build: compilação Java em classes, desugaring, minificação ProGuard/R8, empacotamento em APK/AAB. R8 é um desugaring e ofuscador atualizado que substitui o ProGuard. As variantes de build (debug/release + product flavors) são configuradas via build.gradle. Gradle Daemon acelera builds subsequentes através de cache.

// build.gradle (app) — configuração do 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'
}

O bloco compileOptions especifica a versão Java para compilação — Java 17 está disponível com AGP 8.x. O SDK mínimo (minSdk) determina a versão mínima do Android na qual a aplicação funciona. Target SDK é a versão com a qual a aplicação foi testada. A diferença entre compileSdk e targetSdk: compileSdk é a API para compilação, targetSdk é o comportamento em tempo de execução.

Limitações do Java no desenvolvimento móvel

As limitações do Java no Android levaram à transição do Google para Kotlin. NullPointerException é a exceção mais comum em aplicações Java para Android, pois o sistema de tipos não distingue entre referências nullable e non-null. O Google recomenda as anotações @Nullable e @NonNull do pacote androidx.annotation, mas o compilador não as verifica — apenas o lint faz isso.

A ausência de corrotinas é outra limitação: operações assíncronas em Java exigem callbacks, AsyncTask (obsoleto desde API 30), ExecutorService ou RxJava. Isso leva a callback hell e vazamentos de memória ao girar a tela. As corrotinas do Kotlin com Structured Concurrency resolvem este problema no nível da linguagem: uma corrotina é cancelada quando a Activity é destruída sem gerenciamento manual.

Código boilerplate em Java é uma fonte de erros ao escrever manualmente equals/hashCode, implementações Parcelable e ViewHolder para RecyclerView. As bibliotecas Android KTX e Jetpack Compose são orientadas ao Kotlin. Novas APIs do Android (Room, Navigation, Compose) publicam exemplos em Kotlin por padrão, embora versões em Java existam.