Cvičenie strojopis: Programovanie v jazyku Java

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žujú počet syntaktických chýb a umožňujú 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. Súbory v Jave začínajú deklaráciou package, nasleduje import. Chýbajúci bod alebo preklep vedie k chybe "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ú bezpečné počas kompilácie. Systém typov v Jave zahŕňa modifikátory viditeľnosti (public, private), final pre nemennosť a kolekcie so špecifikovanými typmi, ako List<Order>. 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. 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

Poznámka: "checked exceptions" angl.: checked exceptions musia byť ošetrené alebo deklarované počas kompilácie. "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. Spolu umožňujú písať čitateľný, spoľahlivý kód, ktorý často funguje hneď na prvýkrát.