Java pradedantiesiems

Kodėl Java vis dar verta mokytis 2024-aisiais

Kiekvienais metais internete pasirodo bent kelios dešimtys straipsnių su antraštėmis tipo „Ar Java mirusi?” arba „Kokia kalba pakeis Java?”. Ir kiekvienais metais Java ramiai sau gyvuoja, užima aukščiausias pozicijas TIOBE indekse ir toliau maitina milijonus programuotojų visame pasaulyje. Tai nėra atsitiktinumas.

Java buvo sukurta 1995 metais Sun Microsystems, o šiandien ją prižiūri Oracle. Per beveik tris dešimtmečius kalba išgyveno daugybę transformacijų, išlaikė konkurenciją su Python, Kotlin, Go ir daugybe kitų kalbų. Kodėl? Nes Java yra ne tik programavimo kalba – tai ekosistema, infrastruktūra ir milijardų eilučių kodo pagrindas, kuris juda bankų sistemose, Android telefonuose, NASA programinėje įrangoje ir daugybėje kitų vietų.

Jei esi pradedantysis ir galvoji, ar verta investuoti laiką į Java mokymąsi – trumpas atsakymas yra taip. Ilgas atsakymas – tai visas šis straipsnis.

Kaip Java iš tikrųjų veikia – JVM ir „write once, run anywhere”

Vienas iš dalykų, kuris skiria Java nuo daugelio kitų kalbų, yra jos architektūra. Kai rašai kodą C ar C++, kompiliatorius tą kodą paverčia mašinine kalba, kuri yra specifinė konkrečiai operacinei sistemai ir procesoriaus architektūrai. Java veikia kitaip.

Java kodas kompiliuojamas į vadinamąjį bytecode – tai tarsi tarpinė kalba, kurią supranta ne kompiuteris tiesiogiai, o Java Virtual Machine (JVM). JVM yra programa, kuri „skaito” bytecode ir jį vykdo konkrečioje platformoje. Tai reiškia, kad tas pats sukompiliuotas Java programos failas veiks tiek Windows, tiek Linux, tiek macOS – tereikia, kad toje sistemoje būtų įdiegta JVM.

Štai kaip atrodo šis procesas žingsnis po žingsnio:

• Tu parašai kodą .java faile
• Java kompiliatorius (javac) paverčia jį .class failu su bytecode
• JVM interpretuoja arba JIT (Just-In-Time) kompiliuoja bytecode į mašininį kodą
• Programa vykdoma

JIT kompiliacija yra svarbus aspektas – JVM ne tik interpretuoja kodą, bet ir stebi, kurios kodo dalys vykdomos dažniausiai, ir jas optimizuoja realiuoju laiku. Dėl to Java programos, kurios ilgai veikia (pvz., serveriai), laikui bėgant tampa greitesnės, nes JVM „išmoksta” jas optimizuoti.

Praktinis patarimas: pradedant mokytis Java, svarbu suprasti skirtumą tarp JDK (Java Development Kit) ir JRE (Java Runtime Environment). JRE reikia tik programoms paleisti, o JDK – programuoti. Kaip pradedantysis, tau reikia JDK. Šiuo metu rekomenduojama naudoti JDK 21 (LTS versija), kurią galima atsisiųsti iš Adoptium arba Oracle svetainių.

Pirmieji žingsniai: aplinkos paruošimas ir pirmoji programa

Prieš rašant kodą, reikia pasiruošti darbo aplinką. Čia pradedantieji dažnai pasiklysta, nes internete yra daugybė prieštaringų rekomendacijų. Pabandysiu viską supaprastinti.

Ką įdiegti:

1. JDK 21 – atsisiųsk iš adoptium.net. Tai nemokama, atviro kodo versija.
2. IntelliJ IDEA Community Edition – geriausias pasirinkimas pradedantiesiems. Nemokamas, galingas, su puikia Java palaikymo sistema. Eclipse ir NetBeans taip pat egzistuoja, bet IntelliJ šiandien yra industrijoje de facto standartas.

Kai viskas įdiegta, sukurk naują projektą IntelliJ ir parašyk savo pirmąją programą:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Labas, pasauli!");
    }
}

Ši programa atrodo paprasta, bet joje yra daugybė konceptų, kuriuos verta suprasti iš karto:

• public class HelloWorld – Java yra objektiškai orientuota kalba, todėl viskas egzistuoja klasių kontekste. Klasės pavadinimas turi sutapti su failo pavadinimu.
• public static void main(String[] args) – tai yra programos įėjimo taškas. JVM ieško būtent šio metodo, kai paleidžia programą. static reiškia, kad metodas priklauso klasei, o ne objektui. void – metodas nieko negrąžina.
• System.out.println() – tai metodas, kuris išveda tekstą į konsolę ir prideda eilutės pabaigos simbolį.

Nepabūk, jei iš karto nesupranti visų šių žodžių. Tai normalu. Tiesiog žinok, kad main metodas yra vieta, nuo kurios prasideda programa, ir judėk toliau.

Kintamieji, tipai ir operatoriai – Java pagrindų pagrindai

Java yra statiškai tipizuota kalba. Tai reiškia, kad kiekvienas kintamasis turi turėti aiškiai apibrėžtą tipą, ir tas tipas negali keistis programos vykdymo metu. Tai skiriasi nuo Python ar JavaScript, kur tipai yra dinamiški.

Pagrindiniai primityvūs tipai Java:

int sveikasSkaicius = 42;           // 32 bitų sveikasis skaičius
long didelisSkaicius = 9999999999L; // 64 bitų sveikasis skaičius
double realusSkaicius = 3.14;       // 64 bitų slankiojo kablelio skaičius
float mazesnisRealus = 3.14f;       // 32 bitų slankiojo kablelio skaičius
boolean tiesa = true;               // loginis tipas
char simbolis = 'A';                // vienas simbolis
byte mažasSkaičius = 127;           // 8 bitų sveikasis skaičius
short vidutinis = 32767;            // 16 bitų sveikasis skaičius

Taip pat yra String – tai ne primityvus tipas, o klasė, bet naudojama labai dažnai:

String tekstas = "Labas, Java!";
String vardas = "Tomas";
System.out.println("Sveiki, " + vardas + "!");

Nuo Java 10 versijos galima naudoti var – tipo išvedimą, kai kompiliatorius pats nusprendžia, koks tipas:

var skaicius = 10;        // kompiliatorius supranta, kad tai int
var tekstas = "Labas";   // kompiliatorius supranta, kad tai String

Praktinis patarimas: var naudok tik tada, kai tipas akivaizdus iš konteksto. Jei rašai var x = metodas() ir nežinai, ką grąžina metodas – geriau parašyk tipą aiškiai. Kodo skaitomumas yra svarbesnis už trumpumą.

Sąlygos ir ciklai veikia panašiai kaip daugelyje kitų kalbų:

// Sąlyga
int amzius = 20;
if (amzius >= 18) {
    System.out.println("Pilnametis");
} else if (amzius >= 14) {
    System.out.println("Paauglys");
} else {
    System.out.println("Vaikas");
}

// For ciklas
for (int i = 0; i < 5; i++) {
    System.out.println("Iteracija: " + i);
}

// While ciklas
int n = 0;
while (n < 3) {
    System.out.println(n);
    n++;
}

Objektinis programavimas – Java širdis ir siela

Jei Java turėtų vieną pagrindinį principą, tai būtų objektinis programavimas (OOP). Viskas Java yra objektas (arba beveik viskas – primityvūs tipai yra išimtis). Suprasti OOP – tai suprasti Java.

OOP remiasi keturiais pagrindiniais principais:

• Inkapsuliacija – duomenų slėpimas ir prieigos kontrolė
• Paveldėjimas – klasės gali perimti kitų klasių savybes
• Polimorfizmas – tas pats metodas gali elgtis skirtingai priklausomai nuo objekto tipo
• Abstrakcija – sudėtingų detalių slėpimas, eksponuojant tik tai, kas svarbu

Pažiūrėkime į paprastą pavyzdį:

public class Automobilis {
    // Laukai (fields) - inkapsuliuoti su private
    private String marke;
    private int metai;
    private double greitis;

    // Konstruktorius
    public Automobilis(String marke, int metai) {
        this.marke = marke;
        this.metai = metai;
        this.greitis = 0;
    }

    // Metodai
    public void greitinti(double kiekis) {
        greitis += kiekis;
        System.out.println(marke + " greitis: " + greitis + " km/h");
    }

    public void stabdyti() {
        greitis = 0;
        System.out.println(marke + " sustojo");
    }

    // Getter metodai
    public String getMarke() {
        return marke;
    }

    public int getMetai() {
        return metai;
    }
}

// Naudojimas
public class Main {
    public static void main(String[] args) {
        Automobilis auto = new Automobilis("Toyota", 2020);
        auto.greitinti(60);
        auto.greitinti(40);
        auto.stabdyti();
    }
}

Paveldėjimas leidžia kurti hierarchijas:

public class ElektrinisMobilis extends Automobilis {
    private int baterija; // procentais

    public ElektrinisMobilis(String marke, int metai, int baterija) {
        super(marke, metai); // kviečiame tėvinės klasės konstruktorių
        this.baterija = baterija;
    }

    public void tikrintiBaterija() {
        System.out.println("Baterija: " + baterija + "%");
    }
}

Praktinis patarimas: pradedantieji dažnai klausia, kada naudoti extends (paveldėjimą) ir kada implements (sąsają). Paprastas atsakymas: jei galima sakyti "A yra B" (pvz., "ElektrinisMobilis yra Automobilis"), naudok paveldėjimą. Jei galima sakyti "A moka daryti X" (pvz., "Automobilis moka važiuoti"), naudok sąsają (interface).

Java kolekcijos ir darbas su duomenimis

Realios programos retai dirba su vienu ar dviem kintamaisiais. Dažniausiai reikia saugoti ir apdoroti duomenų rinkinius. Java tam turi galingą Collections Framework.

Pagrindinės kolekcijos:

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;

// ArrayList - dinaminis masyvas
List<String> vardai = new ArrayList<>();
vardai.add("Tomas");
vardai.add("Lina");
vardai.add("Petras");
System.out.println(vardai.get(0)); // Tomas
System.out.println(vardai.size()); // 3

// For-each ciklas su kolekcija
for (String vardas : vardai) {
    System.out.println(vardas);
}

// HashMap - raktas-reikšmė poros
HashMap<String, Integer> amziai = new HashMap<>();
amziai.put("Tomas", 25);
amziai.put("Lina", 30);
System.out.println(amziai.get("Tomas")); // 25

// HashSet - unikalių elementų rinkinys
HashSet<String> unikalusMiestai = new HashSet<>();
unikalusMiestai.add("Vilnius");
unikalusMiestai.add("Kaunas");
unikalusMiestai.add("Vilnius"); // dublikatas - nebus pridėtas
System.out.println(unikalusMiestai.size()); // 2

Nuo Java 8 atsirado Stream API – vienas galingiausių įrankių darbui su kolekcijomis:

import java.util.List;
import java.util.stream.Collectors;

List<Integer> skaiciai = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

// Filtruoti lyginius skaičius ir padauginti iš 2
List<Integer> rezultatas = skaiciai.stream()
    .filter(n -> n % 2 == 0)
    .map(n -> n * 2)
    .collect(Collectors.toList());

System.out.println(rezultatas); // [4, 8, 12, 16, 20]

// Suskaičiuoti sumą
int suma = skaiciai.stream()
    .mapToInt(Integer::intValue)
    .sum();

System.out.println("Suma: " + suma); // 55

Stream API iš pradžių gali atrodyti keistai, bet tai yra funkcinis programavimo stilius, kuris leidžia rašyti labai glaustą ir skaitomą kodą. Verta skirti laiko ir išmokti.

Praktinis patarimas: rinkdamasis kolekciją, vadovaukis šiomis taisyklėmis:

• Reikia saugoti elementus eilės tvarka ir pasiekti pagal indeksą? → ArrayList
• Reikia dažnai dėti ir šalinti elementus iš pradžios/vidurio? → LinkedList
• Reikia raktas-reikšmė struktūros? → HashMap
• Reikia raktas-reikšmė struktūros su surikiavimo tvarka? → TreeMap
• Reikia unikalių elementų? → HashSet

Klaidų valdymas ir išimtys – ką daryti, kai viskas eina ne taip

Programos klysta. Tai neišvengiama. Klausimas yra, kaip su tuo dorotis. Java turi išimčių (exceptions) sistemą, kuri leidžia elegantiškai valdyti klaidas.

Java išimtys skirstomos į dvi kategorijas:

• Checked exceptions – kompiliatorius verčia jas apdoroti (pvz., IOException)
• Unchecked exceptions – vykdymo metu atsirandančios klaidos (pvz., NullPointerException, ArrayIndexOutOfBoundsException)

// Bazinis try-catch blokas
try {
    int[] masyvas = {1, 2, 3};
    System.out.println(masyvas[10]); // klaida - indeksas neegzistuoja
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Klaida: " + e.getMessage());
} finally {
    System.out.println("Šis blokas vykdomas visada");
}

// Darbas su failais - checked exception
import java.io.FileReader;
import java.io.IOException;

try {
    FileReader reader = new FileReader("failas.txt");
    // darbas su failu...
    reader.close();
} catch (IOException e) {
    System.out.println("Failo klaida: " + e.getMessage());
}

// Savo išimties kūrimas
public class NeteisinguAmziausIsimtis extends RuntimeException {
    public NeteisinguAmziausIsimtis(String zinute) {
        super(zinute);
    }
}

// Naudojimas
public void nustatytAmziu(int amzius) {
    if (amzius < 0 || amzius > 150) {
        throw new NeteisinguAmziausIsimtis("Neteisingas amžius: " + amzius);
    }
    // ...
}

Praktinis patarimas: viena dažniausių klaidų pradedantiesiems – gaudyti visas išimtis su catch (Exception e) ir nieko nedaryti arba tik spausdinti klaidos žinutę. Tai vadinama "klaidos nuryjimas" ir yra bloga praktika. Jei gaudi išimtį, turi žinoti, ką su ja darysi. Jei nežinai – leisk jai kilti aukštyn.

Taip pat svarbu žinoti apie try-with-resources – modernų būdą dirbti su resursais, kurie turi būti uždaryti:

// Modernūs Java – automatinis uždarymas
try (FileReader reader = new FileReader("failas.txt")) {
    // darbas su failu
    // reader bus automatiškai uždarytas, net jei įvyks klaida
} catch (IOException e) {
    System.out.println("Klaida: " + e.getMessage());
}

Kur eiti toliau – kelias nuo "Hello World" iki realių projektų

Gerai, išmokai pagrindus. Parašei keletą programų, supranti klases, kolekcijas, išimtis. Kas toliau? Čia daugelis pradedančiųjų pasimeta, nes Java ekosistema yra milžiniška ir gali būti sunku suprasti, kur judėti.

Štai konkretus mokymosi kelias, kurį rekomenduočiau:

1 etapas – Java pagrindai (1-3 mėnesiai): Tai, ką aprašiau šiame straipsnyje. Klasės, OOP, kolekcijos, išimtys. Taip pat verta išmokti generics (šablonai), lambda išraiškas ir Stream API. Šaltiniai: "Head First Java" knyga, Codecademy Java kursas, Oracle oficiali dokumentacija.

2 etapas – Praktika (2-4 mėnesiai): Rašyk projektus. Ne "Hello World", o realius. Idėjos: skaičiuotuvas su GUI (naudok JavaFX), studentų registro sistema su failų saugojimu, paprastas tekstinis žaidimas. Kiekvieną projektą dėk į GitHub – tai bus tavo portfolio.

3 etapas – Spring Framework (3-6 mėnesiai): Jei nori dirbti backend programuotoju, Spring Boot yra būtinas. Tai populiariausias Java web framework, kuriuo sukurta dauguma Java web aplikacijų. Pradėk nuo spring.io/guides – ten yra puikių pamokų.

4 etapas – Duomenų bazės ir REST API: Išmok SQL pagrindus, suprask, kaip Java jungiasi prie duomenų bazių (JDBC, JPA/Hibernate), ir sukurk savo pirmą REST API su Spring Boot.

Keletas konkrečių resursų:

• Knygos: "Effective Java" (Joshua Bloch) – privaloma bet kuriam Java programuotojui, bet geriau skaityti turint šiek tiek patirties
• Online platformos: Baeldung.com – geriausias Java straipsnių šaltinis internete; HackerRank ir LeetCode – algoritmų praktikai
• YouTube: "Amigoscode" kanalas – puikūs Java ir Spring Boot kursai

Vienas svarbus dalykas, kurį noriu pabrėžti: mokykis rašydamas kodą, ne skaitydamas apie jį. Galima perskaityti dešimt knygų apie plaukimą ir vis tiek neplaukti. Java išmokstama tik praktikuojantis. Kiekvieną konceptą, kurį perskaitysi, iš karto išbandyk – parašyk kodą, pakeisk jį, sulaužyk ir suprask, kodėl sulaužei.

Java kelias nėra trumpas, bet jis yra vertas. Kalba, kuri išgyveno tris dešimtmečius technologijų revoliucijų, niekur nedings artimiausiu metu. O gebėjimas programuoti Java atvers duris į bankų sistemas, Android kūrimą, enterprise programinę įrangą ir daugybę kitų sričių, kur programuotojai vis dar labai reikalingi ir gerai apmokomi. Pradėk nuo pagrindų, būk kantrus, ir po metų ar dvejų pažvelgsi atgal ir nustebsi, kiek toli nuėjai.