Java: vilket språk är det, dess egenskaper och Android-utveckling

Vad är Java?

Java — ett allmänt programmeringsspråk, skapat av Sun Microsystems 1995. Huvudprincipen — «Write Once, Run Anywhere»: kompilerad Java-bytekod körs på vilken plattform som helst där JVM är installerad. Inom mobilutveckling blev Java det första officiella språket för Android SDK, som släpptes av Google 2008.

Java-arkitekturen baseras på tre komponenter: JDK (Java Development Kit) — utvecklarverktyg, JRE (Java Runtime Environment) — körningsmiljö och JVM (Java Virtual Machine) — virtuell maskin. Android använder sin egen implementation av JVM — Android Runtime (ART), som ersatte Dalvik i version 5.0 (Lollipop). ART exekverar DEX-bytekod, som kompileras från Java-bytekod via verktyget dx/d8.

En nyckelfunktion i Java — automatisk minneshantering via Garbage Collector (GC). Utvecklaren behöver inte explicit frigöra minne — GC spårar oanvända objekt och tar bort dem. I Android ART används Concurrent Mark Sweep (CMS) och Generational GC, optimerade för mobila enheters begränsade resurser. Detta minskar belastningen på utvecklaren men kan orsaka «lagg» vid skräpinsamling i UI-tråden.

Java-versioner och Android API

Android stöder en delmängd av Java API, som utökas med varje ny OS-version. Android 12 (API 31) lade till stöd för Java 11, inklusive lambdas med variabelfångst, modulära JPMS-systemet och HTTP-klienten java.net.http. Android 14 (API 34) introducerade experimentellt stöd för Java 17 via D8/R8-desugaring — vissa funktioner (records, sealed classes) översätts till kompatibel kod för äldre versioner.

Java SDK och Android-utveckling

Android SDK innehåller Java-kompilatorn, verktyget dex (d8), aapt (Asset Packaging Tool), emulator och biblioteken android.* och java.*. Utvecklaren skriver kod i Java, kompilerar den till .class-filer (JVM-bytekod), sedan omvandlar d8 dem till .dex-filer (Dalvik Executable), som paketeras i APK tillsammans med resurser och AndroidManifest.xml.

Gradle — byggsystemet för Android-projekt. Filen build.gradle (Groovy) eller build.gradle.kts (Kotlin DSL) beskriver beroenden, SDK-versioner, produktvarianter (product flavors) och signaturer. Android Gradle Plugin (AGP) version 8.x automatiserar desugaring — översättning av moderna Java-funktioner till bakåtkompatibel kod. Till exempel omvandlas java.time.LocalDate till kod kompatibel med API 21+ utan ändringar i utvecklarens källkod.

// En enkel Android Activity i 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("Hej från Java!");
    }

    // Metod för att hantera knapptryckning
    public void onButtonClick(View view) {
        TextView tv = findViewById(R.id.textView);
        tv.setText("Knapp tryckt");
    }
}

Klassen MainActivity ärver AppCompatActivity — basklassen från AndroidX för bakåtkompatibilitet. Metoden onCreate anropas när Activity skapas, där layouten ställs in via setContentView. findViewById kopplar en Java-variabel till ett element från XML-layouten. Metoden onButtonClick är kopplad till knappen via attributet android:onClick i XML.

Arbeta med Activity och livscykel

Activitys livscykel i Java — en sekvens av callbacks: onCreate → onStart → onResume (aktiv), onPause → onStop → onDestroy (avslutning). Utvecklaren åsidosätter dessa metoder för att hantera resurser. onCreate — initiering, onPause — spara data, onDestroy — frigöra resurser. Android anropar dessa metoder vid skärmrotation, övergång till bakgrunden och mottagning av samtal.

// Activity-livscykel med tillståndshantering
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) {
        // Ladda data efter ID
    }
}

Metoden onSaveInstanceState sparar Activitys tillstånd vid skärmrotation eller växling av uppgifter. Bundle innehåller nyckel-värdepar — enkla typer, Parcelable- eller Serializable-objekt. onRestoreInstanceState återställer sparat tillstånd. Detta mönster är kritiskt för Android eftersom systemet kan förstöra Activity vid minnesbrist och återställa den när användaren återvänder.

Java-syntax: klasser, metoder och typer

Java-syntax — C-liknande, starkt typad, objektorienterad. Varje .java-fil innehåller en publik klass vars namn överensstämmer med filnamnet. Java stöder inte funktioner utanför klasser — allt är metoder. Startpunkten är den statiska metoden public static void main(String[] args) för konsolapplikationer eller Android Activitys livscykelmetoder för mobila enheter.

Datatyper i Java

Java delar in typer i primitiver (int, double, boolean, char, byte, short, long, float) och referenstyper (klasser, gränssnitt, arrayer, enum). Primitiver lagras på stacken och skickas efter värde. Objekt — på heapen, skickas efter referens. Autoboxning (autoboxing) konverterar automatiskt en primitiv till ett wrapper-objekt (Integer, Double, Boolean) men skapar extra objekt — i Android är detta kritiskt för UI-prestanda.

// Exempel på Java-datatyper och strukturer
public class DataTypes {
    // Primitiver
    int count = 42;
    double price = 19.99;
    boolean isActive = true;
    char grade = 'A';

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

    // Metod med Generics
    public <T> T getFirst(List<T> list) {
        return list.isEmpty() ? null : list.get(0);
    }

    // Enum för fast uppsättning värden
    public enum Status {
        PENDING, LOADING, SUCCESS, ERROR
    }
}

Generics List<T> säkerställer typ säkerhet för samlingar. Metoden getFirst returnerar ett element av vilken typ som helst — den konkreta typen bestäms vid anropsplatsen. Enum Status kompileras till en klass med en fast uppsättning konstanter, varje instans är en singleton. I Android används enum mer sällan på grund av minnesförbrukning: ProGuard/R8 optimerar enum till int-konstanter där det är möjligt.

Java vs Kotlin: jämförelse i Android

Jämförelse mellan Java och Kotlin för Android-utveckling — ett av huvudämnena sedan 2019, när Google förklarade Kotlin som prioriterat språk. Kotlin är helt kompatibelt med Java — båda kompileras till JVM-bytekod, kan anropa varandra och använda samma bibliotek. Men sätten att skriva kod skiljer sig fundamentalt.

Standardkod

Kotlin eliminerar Javas mångordighet: data class ersätter 50+ rader Java-klass med getters, setters, equals, hashCode, toString och copy. Null safety är inbyggt i Kotlins typsystem — NullPointerException är praktiskt taget omöjligt. Extension-funktioner gör det möjligt att lägga till metoder till befintliga klasser utan arv. Smart Casts konverterar automatiskt typer efter kontroll.

Prestanda

Prestandamässigt är Java och Kotlin identiska — båda kompileras till JVM-bytekod som Android ART exekverar på samma sätt. Skillnaden i APK-storlek: Kotlin lägger till ~200-400 KB för kotlin-stdlib-biblioteket. Java-projekt har mindre APK-storlek på grund av avsaknaden av extra runtime, men vid användning av Java Stream API och Optional kan APK-storleken öka på grund av desugaring.

Java-utvecklarens verktyg för Android

Java-utvecklarens verktyg för Android inkluderar Android Studio, Gradle, profilerare och emulator. Android Studio — den officiella IDE:n baserad på IntelliJ IDEA Community, innehåller editor med Java-autokomplettering, kodanalysator (lint), refaktorering och visuell layouteditor (Layout Editor).

Huvudverktyg

Android Gradle Plugin (AGP) version 8.x hanterar bygget: kompilering av Java till klasser, desugaring, minifiering ProGuard/R8, paketering till APK/AAB. R8 — förbättrad desugaring och obfuskerare som ersätter ProGuard. Byggvarianter (debug/release + product flavors) konfigureras via build.gradle. Gradle Daemon snabbar upp efterföljande byggen genom cachning.

// build.gradle (app) — konfiguration av Java-modul
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'
}

Blocket compileOptions anger Java-version för kompilering — Java 17 är tillgänglig från AGP 8.x. Minsta SDK (minSdk) anger den lägsta Android-version som appen fungerar på. Target SDK — den version som appen testats för. Skillnaden mellan compileSdk och targetSdk: compileSdk — API för kompilering, targetSdk — runtime-beteende.

Begränsningar för Java i mobilutveckling

Begränsningar för Java i Android blev anledningen till Googles övergång till Kotlin. NullPointerException — det vanligaste undantaget i Java-Android-appar, eftersom typsystemet inte skiljer mellan nullable och non-null-referenser. Google rekommenderar @Nullable- och @NonNull-annotationer från paketet androidx.annotation, men kompilatorn kontrollerar dem inte — endast lint gör detta.

Avsaknaden av coroutines — ytterligare en begränsning: asynkrona operationer i Java kräver callbacks, AsyncTask (föråldrad sedan API 30), ExecutorService eller RxJava. Detta leder till callback hell och minnesläckor vid skärmrotation. Kotlin-coroutines med Structured Concurrency löser detta problem på språknivå: coroutinen avbryts när Activity förstörs utan manuell hantering.

Standardkod i Java — en källa till fel vid manuell skrivning av equals/hashCode, Parcelable-implementationer och ViewHolder för RecyclerView. Android KTX-bibliotek och Jetpack Compose är inriktade på Kotlin. Nya Android API:er (Room, Navigation, Compose) publicerar exempel i Kotlin som standard, även om Java-versioner finns.