Java je silne typovaný, objektovo orientovaný programovací jazyk, ktorý vyžaduje presnosť a konzistentnosť. Na rozdiel od JavaScriptu, ktorý je viac permisívny, alebo Pythonu, kde štruktúru určuje odsadenie, Java sa spolieha na prísnu syntax: balíky, triedy, importy, modifikátory viditeľnosti, generics a kontrolované výnimky angl.: checked exceptions. Preto je písanie všetkými desiatimi v Jave nielen spôsobom, ako písať rýchlejšie, ale nevyhnutnou zručnosťou. Pomáha predchádzať chybám pri dlhých identifikátoroch, správne uzatvárať vnorené generics a presne umiestňovať zložené zátvorky a bodkočiarky. Cvičenie písania všetkými desiatimi a rýchleho písania v Jave znižuje riziko preklepov a umožňuje sústrediť sa viac na logiku a návrh kódu.

Idiomatická Java a konvencie

Poznámka: "idiomatická Java" angl.: idiomatic Java označuje štýl, ktorý komunita považuje za prirodzený a správny. V Pythone sa používa pojem "pythonic", zatiaľ čo v Jave sú to konvencie: názvy balíkov písané malými písmenami oddelenými bodkami (com.example.billing), triedy a rozhrania v UpperCamelCase, metódy a polia v lowerCamelCase a konštanty v UPPER_SNAKE_CASE. Bloky kódu sú vždy uzavreté v zložených zátvorkách, aj keď obsahujú len jeden riadok. Verejné API sa obvykle dokumentujú pomocou Javadoc (/** ... */). Písanie všetkými desiatimi v Jave pomáha tieto konvencie dodržiavať plynulo a bez chýb.

Balíky, importy a úplne kvalifikované názvy

Úplne kvalifikovaný názov angl.: fully qualified name obsahuje celé meno triedy vrátane balíka. Ak súbor patrí do pomenovaného balíka, deklarácia package predchádza príkazom import. Bez deklarácie balíka patrí súbor do nepomenovaného balíka. Chýbajúca bodka alebo preklep môže spôsobiť syntaktickú chybu alebo chybu pri rozpoznávaní názvu, napríklad "cannot find symbol". Rýchle písanie v Jave uľahčuje písanie dlhých názvov a písanie všetkými desiatimi znižuje riziko chýb.

package com.example.payments.service;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.util.List;

public class InvoiceService {
    // ...
}

Typy, modifikátory a generics

Poznámka: "generics" angl.: generics umožňujú vytvárať generické dátové štruktúry a metódy, ktoré sú typovo bezpečné pri kompilácii. Modifikátory public a private určujú prístup k prvkom kódu. Pri premenných final zabraňuje novému priradeniu, ale nezaručuje nemennosť objektu. V generických typoch, ako je List<Order>, treba správne spárovať < a >. Vnorené zápisy môžu byť zložité: Map<String, List<Integer>>. Písanie všetkými desiatimi v Jave robí tieto vzory prirodzenejšími, rýchle písanie uľahčuje opravy.

import java.util.*;

public class Repository<T> {
    private final Map<String, T> store = new HashMap<>();

    public void save(String id, T value) { store.put(id, value); }
    public Optional<T> find(String id) { return Optional.ofNullable(store.get(id)); }
}

Konštruktory, overloading a records

Poznámka: "overloading" angl.: overloading znamená definovanie viacerých metód s rovnakým názvom, ale odlišnými parametrami. "record" angl.: record je stručný zápis pre nemenné typy s automaticky generovanými metódami. Polia zložiek recordu sú final, ale objekty, na ktoré odkazujú, môžu zostať meniteľné. Konštruktory určujú pravidlá inicializácie. Písanie všetkými desiatimi v Jave uľahčuje správne používanie zátvoriek a čiarkok, rýchle písanie zrýchľuje proces.

// Trieda s konštruktorom
public class Mail {
    private final String to;
    private final String subject;
    private final String body;

    public Mail(String to, String subject, String body) {
        this.to = to;
        this.subject = subject;
        this.body = body;
    }
}

// Record pre nemenný typ
public record Message(String to, String subject, String body) { }

Checked exceptions a try-with-resources

Pri kontrolovaných výnimkách (angl.: checked exceptions) kompilátor overuje, či ich kód zachytáva alebo deklaruje pomocou throws. Samotné výnimky vznikajú počas behu programu. "try-with-resources" angl.: try-with-resources automaticky zatvára zdroje. Syntax vyžaduje presné použitie zátvoriek a blokov. Písanie všetkými desiatimi v Jave tento vzor uľahčuje.

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class Loader {
    public static String firstLine(String path) throws IOException {
        try (BufferedReader br = new BufferedReader(new FileReader(path))) {
            return br.readLine();
        }
    }
}

Metódy, overloading a varargs

Poznámka: pretože Java nepodporuje predvolené parametre, používa sa overloading angl.: overloading. "varargs" angl.: varargs umožňujú odovzdať variabilný počet argumentov pomocou .... Tieto zápisy obsahujú veľa symbolov. Písanie všetkými desiatimi v Jave znižuje chyby, rýchle písanie udržiava plynulosť.

public class Logger {
    public void log(String level, String msg) { System.out.println(level + ": " + msg); }
    public void log(String msg) { log("INFO", msg); }
    public void logf(String fmt, Object... args) { System.out.println(fmt.formatted(args)); }
}

Riadiace štruktúry a moderný switch

Poznámka: "switch expressions" angl.: switch expressions používajú šípky (->) a môžu vracať hodnoty. Skracujú kód, ale vyžadujú presnosť. Písanie všetkými desiatimi v Jave zjednodušuje ich písanie.

public class Classifier {
    public static String label(int score) {
        return switch (score / 10) {
            case 10, 9 -> "A";
            case 8 -> "B";
            case 7 -> "C";
            case 6 -> "D";
            default -> "F";
        };
    }
}

Lambdy, method references a streams

Poznámka: "lambda" angl.: lambda je anonymná funkcia, napríklad (x) -> x + 1. "method reference" angl.: method reference má tvar Typ::metóda. "streams" angl.: streams umožňujú reťaziť operácie. Obsahujú veľa symbolov, preto je písanie všetkými desiatimi v Jave užitočné pre presnosť a rýchle písanie pre rýchlosť.

import java.util.List;

class Discounts {
    public static void main(String[] args) {
        List<Integer> prices = List.of(100, 200, 350, 400);
        int total = prices.stream()
                .map(p -> (int)(p * 0.9))
                .filter(p -> p >= 150)
                .reduce(0, Integer::sum);
        System.out.println(total);
    }
}

Rovnosť, poradie a contracts

Poznámka: "contracts" angl.: contracts sú pravidlá pre metódy ako equals, hashCode, toString a compareTo. Vyžadujú opakovanie a presnosť. Písanie všetkými desiatimi v Jave pomáha konzistencii a rýchle písanie zrýchľuje písanie.

public final class Point implements Comparable<Point> {
    private final int x, y;
    public Point(int x, int y) { this.x = x; this.y = y; }
    @Override public int compareTo(Point o) {
        int cx = Integer.compare(this.x, o.x);
        return (cx != 0) ? cx : Integer.compare(this.y, o.y);
    }
}

Reťazce, text blocks a formátovanie

Poznámka: "text blocks" angl.: text blocks sú viacriadkové reťazce uzavreté v """. Formátovanie sa vykonáva pomocou String#formatted alebo String.format. Písanie všetkými desiatimi v Jave uľahčuje správne používanie úvodzoviek a špeciálnych znakov.

class Reporter {
    public static void main(String[] args) {
        String report = """
                Orders Report
                -------------
                Total: %d
                """.formatted(42);
        System.out.println(report);
    }
}

Pattern matching s instanceof

Poznámka: "pattern matching" angl.: pattern matching umožňuje deklarovať premenné priamo v teste instanceof. To znižuje boilerplate, ale vyžaduje presnosť. Písanie všetkými desiatimi v Jave tento zápis zjednodušuje.

static int len(Object o) {
    if (o instanceof String s) { return s.length(); }
    if (o instanceof java.util.List<?> list) { return list.size(); }
    return -1;
}

Moduly a viditeľnosť

Poznámka: "Java Platform Module System" angl.: JPMS používa súbor module-info.java. Modifikátory viditeľnosti (public, protected, package-private, private) sú zásadné. Písanie všetkými desiatimi v Jave pomáha ich používať konzistentne.

module com.example.billing {
    exports com.example.billing.api;
    requires java.sql;
}

Súbežnosť a concurrency

Poznámka: "concurrency" angl.: concurrency zahŕňa vlákna, vlákna v pooloch a CompletableFuture. Syntax využíva množstvo symbolov (<>, ->, ::). Písanie všetkými desiatimi v Jave znižuje chyby a rýchle písanie udržiava produktivitu.

import java.util.concurrent.CompletableFuture;

class AsyncDemo {
    public static void main(String[] args) {
        CompletableFuture<String> f =
            CompletableFuture.supplyAsync(() -> "data")
                             .thenApply(String::toUpperCase)
                             .exceptionally(ex -> "fallback");
        System.out.println(f.join());
    }
}

Anotácie v Jave

Poznámka: "annotations" angl.: annotations sú metadáta označené @. Aj bez frameworkov sú bežné @Override, @Deprecated a @SuppressWarnings. Písanie všetkými desiatimi v Jave uľahčuje ich rýchle a presné zadanie.

public class User {
    private final String name;
    public User(String name) { this.name = java.util.Objects.requireNonNull(name); }

    @Override
    public String toString() { return "User{name='" + name + "'}"; }
}

Cvičenie na klávesnici a význam

Syntax Javy obsahuje množstvo symbolov: zložené zátvorky pre bloky, okrúhle zátvorky pre volania, ostré zátvorky pre generics, šípky a :: pre funkcionálne prvky, čiarky pre parametre a bodkočiarky na ukončenie inštrukcií. Písanie všetkými desiatimi v Jave tieto vzory automatizuje a rýchle písanie udržiava rytmus aj vo veľkých projektoch.

Zhrnutie

Java sa vyznačuje explicitnými typmi, disciplinovanou štruktúrou a jasnými konvenciami. Jej syntax vyžaduje pozornosť: generics, výnimky, riadiace štruktúry a funkcionálne prvky. Písanie všetkými desiatimi v Jave redukuje chyby, rýchle písanie v Jave zvyšuje produktivitu. Tieto zručnosti uľahčujú presné zadávanie kódu v Jave. Správnosť programu treba tiež overiť kompiláciou a testovaním.