B0B36PJV Webové stránky předmětu

• Vývojové prostředí – JDK, JVM, kompilace a běh programu, správa paměti, GC, profilování a optimalizace.
• Objekty, třídy a jejich vztahy – princip abstrakce a zapouzdření, modifikátory přístupu. Interface a abstraktní třída. Dědičnost a kompozice, polymorfismus, dynamická vazba.
• Výčtové typy – práce s kolekcemi, vzor iterátor, generické typy.
• Vnitřní a anonymní třídy – imutabilita, vzor singleton. Proměnné a metody třídy vs. instance.
• Mechanismus výjimek – typy a jejich ošetření, vlastní výjimky. Práce se soubory – přístup k souboru, textové vs. binární, proudy, ukládání dat. Sokety – typy soketů, typy spojení, síťová komunikace.
• Paralelismus – vícevláknové aplikace, problém souběhu a zastavení. Tvorba vláken a jejich ukončení, threadpool, synchronizace, volatilita.

Většinu programovacích jazyků je možné rozdělit do dvou kategorií:

• kompilované - program je zkompilovaný do spustitelného souboru, skládá se z nativních procesorových instrukcí, které přímo vykonává procesor a musí být tedy kompilován pro konkrétní architekturu a systém. Mezi tyto jazyky patří například C/C++.
• interpretované - program není zkompilovaný, pro spuštění je nutný jiný program (interpreter), který program při spuštění převádí do nativních procesorových instrukcí, které může počítač vykonávat. Typický interpretovaný jazyk je třeba Python.

Javu je možné zařadit do obou kategorií - program se první zkompiluje do bytecode, který je obecný - není specifický pro danou platformu. Pro tento proces je potřeba JDK (java development kit).

Tento bytecode je možné následně pustit s JRE (java runtime environment- subset JDK), který bytecode za běhu interpretuje.

Proces kompilace a spuštění v Javě:

• Zdrojový kód se píše do souborů s příponou `.java`.
• Překladač `javac` přeloží `.java` do `.class` souboru s bytecode.
• Bytecode spouští JVM pomocí příkazu `java NázevTřídy`.

Java tedy umožňuje program zkompilovat pouze jednou do bytecode a následně spustit na jekékoliv platformě s JRE (i když v praxi to obecně tak jednoduché není - compile once, debug everywhere). Tento přístup vede k rychlosti blížící se kompilovaným jazykům bez nutnosti kompilovat pro každou platformu zvlášť.

JVM (java virtual machine) je obsažen v JRE i JDK a je zodpovědný za překlad bytecode do nativních procesorových instrukcí.

JAR (Java ARchive) je archivní formát pro sdružení více tříd (*.class*) a dalších souborů do jednoho balíčku. Používá se k distribuci a spouštění Java aplikací.

Součástí může být také soubor `MANIFEST.MF`, ve kterém lze určit hlavní třídu programu:

• např. `Main-Class: com.example.Main`
• Umožňuje poté spustit aplikaci jednoduše: `java -jar program.jar`

Malý paměťový prostor, ve kterém se typicky ukládají lokální proměnné (což obsahuje i reference, atd). Funguje na principu last-in first-out. Při zavolání funkce se na stacku alokuje místo pro všechny lokální proměnné dané funkce. Implementováno přes stack-pointer, který ukládá adresu konce stacku.

Pro každé volání metody vzniká tzv. aktivní záznam, který obsahuje:

• návratovou adresu,
• parametry metody,
• lokální proměnné.

Po ukončení metody se tento záznam odstraní.

Velký paměťový prostor, dynamicky alokovaná paměť. Typicky se zde ukládají objekty a větší datové struktury. Alokována pomocí new. O dealokaci se nestará programátor, ale Garbage Collector (GC).

Heap je sdílený mezi všemi vlákny programu. Objekty zde zůstávají tak dlouho, dokud na ně existuje reference – poté je odstraní GC.

Garbage Collector běží na pozadí JVM. Běží ve vlastním vlákně (nebo i více vláknech), takže neblokuje běh samotného programu (asynchronní). Drží si seznam všech referencí na data na heap a jakmile zjistí, že už žádné reference neexistují, tak data uvolní (dealokuje).

Garbage Collector sice nebude nikdy tak efektivní jako korektní manuální dealokace jako např. v C/C++, ale zjednodušuje psaní programu, jeho udržitelnost a značně snižuje riziko memory leaků kvůli špatným manuálním dealokacím.

JDK a z části i JRE implementuje několik nástrojů pro profiling programu, jako třeba vytížení procesoru a jednotlivých vláken, využití paměti, stav GC.

JDK provádí mnoho optimalizací již při kompilaci bytecode, jako např. eliminace nepoužitého kódu, inlining, atd… Následně probíhá i několik optimalizací při interpretaci programu, jako např. cachování kompilace do nativních procesorových instrukcí.

Java nabízí několik nástrojů pro analýzu výkonu:

• `jconsole` – vizualizace běhu JVM (paměť, CPU, vlákna, GC).
• `jvisualvm` – pokročilé grafické rozhraní s možností sledovat heap, GC, threaddump, apod.
• `Java Flight Recorder` – nástroj pro detailní záznam a analýzu výkonu aplikace.
• `javap` – nástroj pro prohlížení bytecode (.class).

Tyto nástroje umožňují najít místa s největším využitím CPU, paměti nebo nejdelším časem běhu.

Objektově orientované programování (OOP) je paradigma, ve kterém modelujeme svět pomocí objektů – entit, které kombinují data a chování. Základními principy OOP jsou: abstrakce, zapouzdření, dědičnost a polymorfismus.

Třída – abstraktní popis objektu, definuje jeho strukturu (atributy) a chování (metody). Objekt – konkrétní instance třídy, která nese data a reaguje na operace definované třídou.

Třída je šablona pro vytváření tříd, objekt je konkrétní instance třídy.

Například:

// class definition
public class Person {
    private String name;
    private int age;
 
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
    public String getName() {
        return name;
    }
 
    public int getAge() {
        return age;
    }
}
 
// object instantiation
Person person = new Person("John", 30);

Abstrakce – organizujeme koncepty do tříd, skrýváme vnitřní implementaci a vystavujeme jen potřebné rozhraní. Zapouzdření – každý objekt chrání svůj stav a komunikuje s okolím přes veřejné metody.

Modifikátory přístupu v Javě:

• `private` – přístup pouze uvnitř třídy.
• `protected` – přístup z třídy, dědiců a stejného balíčku.
• `public` – přístup odkudkoliv.
• výchozí (bez modifikátoru) – přístup v rámci balíčku.

Dědičnost – třídám lze předat chování a atributy z nadřazené třídy (`extends`), vytváří hierarchii typů („is-a“ vztah).

Kompozice – třída obsahuje jiné objekty jako své atributy („has-a“ vztah), vhodná pro sdružování funkcionality.

Příklad rozdílu:

// dědičnost
class Animal { void speak() { System.out.println("..."); } }
class Dog extends Animal { void speak() { System.out.println("Woof"); } }
 
// kompozice
class Engine { void start() { ... } }
class Car {
    private Engine engine = new Engine();
    void start() { engine.start(); }
}

Polymorfismus – schopnost objektu zareagovat různě podle svého konkrétního typu, i když je používán přes obecný typ.

Např. metoda `draw()` může mít jinou implementaci ve třídách `Circle`, `Square`, ale lze je volat skrze rozhraní `Shape`.

Dynamická vazba (late binding) – konkrétní metoda se určuje až v době běhu na základě typu objektu.

Rozdíl:

• *Přetížení (overloading)* – metoda se liší počtem nebo typem parametrů (rozhoduje se v čase překladu).
• *Přepisování (overriding)* – metoda se předefinuje v podtřídě (rozhoduje se v době běhu).

Rozhraní (interface) definuje sadu metod, které třída musí implementovat (`implements`). Třída může implementovat více rozhraní.

Abstraktní třída (`abstract`) může obsahovat jak implementované, tak neimplementované (abstraktní) metody. Třída ji může pouze dědit (`extends`).

Rozdíly:

• Rozhraní – bez stavových atributů, vhodné pro vícenásobnou dědičnost.
• Abstraktní třída – umožňuje sdílení částečné implementace a stavu.

Java neumožňuje vícenásobnou dědičnost tříd, aby se předešlo problémům jako je diamond problem – tedy situace, kdy by podtřída dědila stejnou metodu z více nadtříd a nebylo by jasné, kterou implementaci použít.

Místo toho umožňuje vícenásobnou dědičnost rozhraní:

  interface A { void doA(); }
  interface B { void doB(); }
 
  class C implements A, B {
      public void doA() { System.out.println("A"); }
      public void doB() { System.out.println("B"); }
  }

Single dispatch znamená, že metoda, která se má zavolat, se vybírá podle *dynamického typu objektu*, na kterém je metoda volána:

  class Animal { void speak() { System.out.println("..."); } }
  class Dog extends Animal { void speak() { System.out.println("Woof"); } }
 
  Animal a = new Dog();
  a.speak(); // zavolá se Dog.speak() – podle skutečného typu objektu

Double dispatch znamená, že metoda je vybrána na základě *dynamických typů dvou objektů*. V Javě se běžně simuluje pomocí návrhového vzoru Visitor:

  interface Visitor {
      void visit(Dog d);
      void visit(Cat c);
  }
 
  interface Animal {
      void accept(Visitor v);
  }
 
  class Dog implements Animal {
      public void accept(Visitor v) { v.visit(this); }
  }
 
  class Cat implements Animal {
      public void accept(Visitor v) { v.visit(this); }
  }

Zde metoda `visit(…)` závisí jak na typu návštěvníka (`Visitor`), tak na konkrétním typu zvířete (`Dog`, `Cat`).

Výčtový typ / enumerate, je typ který může nabývat jenom předem stanovených hodnot. Hodí se například pro uchovávání nějakého stavu, místo arbitrárně zvolených čísel.

Například:

public enum Day {
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    SUNDAY
}
 
Day today = Day.MONDAY;
 
public enum Suit {
    CLUBS(Color.BLACK),
    DIAMONDS(Color.RED),
    HEARTS(Color.BLACK),
    SPADES(Color.RED);
 
    private Color color;
 
    Suit(Color c) {
        this.color = c;
    }
 
    public Color getColor() {
        return color;
    }
 
    public boolean isRed() {
        return color == Color.RED;
    }
}

Třída která je definovaná uvnitř jiné třídy.

class OuterClass {
  int x = 10;
 
  class InnerClass {
    int y = 5;
  }
}

Anonymní třída je třída vnitřní bez názvu, pro kterou je vytvořen pouze jediný objekt.

GeeksforGeeks

// Interface
interface Age {
    int x = 21;
    void getAge();
}
 
class AnonymousDemo {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // A hidden inner class of Age interface is created
        // whose name is not written but an object to it
        // is created.
        Age oj1 = new Age() {
 
            @Override public void getAge()
            {
                // printing  age
                System.out.print("Age is " + x);
            }
        };
 
        oj1.getAge();
    }
}

Výjimka (exception) je neočekávaná událost během běhu programu, kvůli níž nelze pokračovat v běžném průběhu. Typickým příkladem je dělení nulou nebo přístup mimo rozsah pole.

• Vše začíná třídou Throwable.
  • Error – vážné chyby JVM (např. OutOfMemoryError), většinou je *nechytáme.
  • Exception – vše, co smysluplně ošetřujeme.

• Checked – kompilátor hlídá; musíš je buď zachytit pomocí catch, nebo předat dál klíčovým slovem throws (např. FileNotFoundException).
• Unchecked – všechny výjimky odvozené od RuntimeException a také Error; kompilátor jejich ošetření nevynucuje (např. NullPointerException).

try {
    // rizikový kód
} catch (IOException | SQLException ex) {  // multi-catch od Java 7
    log(ex);
    throw ex;         // volitelné předání dál
} finally {
    cleanup();        // provede se vždy
}

• try-with-resources (Java 7+) – vše, co implementuje AutoCloseable, se zavře automaticky:

try (BufferedReader br = Files.newBufferedReader(Path.of("data.txt"))) {
    return br.readLine();
}

public class DataFormatException extends Exception {           // checked
    public DataFormatException() {}
    public DataFormatException(String msg)       { super(msg); }
    public DataFormatException(String msg, Throwable cause) {
        super(msg, cause);
    }
}

• Kdy se hodí? Když stávající výjimky nedostačují a potřebuješ popsat specifickou situaci.
• Rozhodni se, zda má být checked (nutí volající k ošetření) nebo unchecked (dědí z RuntimeException).

• Vyhazuj co nejkonkrétnější výjimky, ať je volající může smysluplně řešit.
• Nezachytávej zbytečně obecné Exception/Throwable – skrýváš tím chyby.
• Vždy uvolňuj prostředky (soubor, socket…) v finally nebo ještě lépe v try-with-resources.
• Přidávej smysluplné chybové zprávy, aby bylo z logu jasné *proč* se výjimka stala.

• File – abstraktní reprezentace cesty; umí zjišťovat existenci, práva, velikost a vytvářet adresáře/základní soubory.
• InputStream / OutputStream – bajtové proudy (binární data).
  • Dekorátory: Buffered* (buffer), Data* (primitiva), Object* (serializace), GZIP* (komprese)…
• Reader / Writer – znakové proudy (text, kódování).
  • Typicky BufferedReader, InputStreamReader (převod bajt→znak), FileWriter atd.
• RandomAccessFile – čtení/zápis s libovolným posuvem uvnitř souboru.
• Rozhraní Closeable / Flushable / Serializable – sjednocují zavírání, flush a serializaci.

try (InputStream  in  = new FileInputStream("logo.png");
     OutputStream out = new FileOutputStream("copy.png")) {
 
    byte[] buf = new byte[8192];
    int n;
    while ((n = in.read(buf)) != -1) {
        out.write(buf, 0, n);
    }
}   // oba proudy se zavřou automaticky (try-with-resources)

Nejčastější (a dodnes plně dostačující) kombinací je dvojice ``FileReader`` + ``BufferedReader``:

try (BufferedReader br =
         new BufferedReader(new FileReader("soubor.txt"))) {
 
    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }
} // try-with-resources zajistí zavření souboru

• ``FileReader`` čte znaky (automaticky použije defaultní kódování platformy, nebo explicitně zadej např. ``StandardCharsets.UTF_8``). :contentReference[oaicite:0]{index=0}
• ``BufferedReader`` obalí čtení do větších bloků → méně systémových volání, vyšší výkon. :contentReference[oaicite:1]{index=1}
• Konstrukce try-with-resources (Java 7+) zavře reader i v případě výjimky. :contentReference[oaicite:2]{index=2}

• Text → Reader/Writer, nutné správné kódování (UTF-8 od JDK 18 default).
• Binární → InputStream/OutputStream; rychlejší, ale nečitelné pro člověka.

try (ObjectOutputStream oos =
         new ObjectOutputStream(new FileOutputStream("state.bin"))) {
    oos.writeObject(gameState);
}

• Třída musí implementovat Serializable.
• Pozor na kompatibilitu verzí tříd (pole serialVersionUID).

• Vždy používej try-with-resources – žádné zapomenuté close().
• Bufruj I/O (Buffered*) kvůli výkonu.
• Nezachytávej holou Exception; loguj a přeposílej konkrétní typy.
• Při sériové práci se soubory preferuj nové NIO API (java.nio.file.Path) – ošetří limity File a umí asynchronní I/O, ale porozumění java.io je nutný základ.

• TCP – potvrzuje doručení a pořadí, detekuje ztráty; pomalejší, ale jistý.
• UDP – žádné záruky, ale nízká latence; sám si případně řešíš potvrzení či opakování paketů.

// === Server ===
try (ServerSocket srv = new ServerSocket(9000)) {
    while (true) {
        try (Socket s = srv.accept();
             BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream()));
             PrintWriter    out = new PrintWriter(s.getOutputStream(), true)) {
 
            String line = in.readLine();
            out.println("Echo: " + line);
        }
    }
}
 
// === Klient ===
try (Socket s = new Socket("localhost", 9000);
     BufferedReader in  = new BufferedReader(new InputStreamReader(s.getInputStream()));
     PrintWriter    out = new PrintWriter(s.getOutputStream(), true)) {
 
    out.println("Ahoj světe");
    System.out.println(in.readLine());
}

• Porty a backlog: při new ServerSocket(port, backlog) nastavíš frontu nepřijatých spojení.
• Nastav setSoTimeout() → ochrana proti zablokování čtení.
• Na mnoho paralelních spojení použij java.nio.channels + selektory (non-blocking I/O).
• Pro šifrovaný přenos sáhni po SSLSocket / SSLServerSocket nebo moderním klientovi java.net.http.
• Vždy uzavírej soket v try-with-resources nebo finally.

Nutné dodržet pravidla synchronizace, aby se zabránilo deadlocku.

Objekty jsou odvozené od třídy Thread, tělo nezávislého výpočtu definujeme v metodě run().

public class Worker extends Thread {
    private final int numberOfJobs;
 
    public Worker(int id, int jobs) {
        super("Worker " + id);
        myID = id;
        numberOfJobs = jobs;
        stop = false;
        System.out.println("Worker id: " + id + " has been created threadID:" + getId());
    }
 
    public void run() {
        doWork();
    }
}
 
Worker thread = new Worker(1, 10);
thread.start(); //new thread is created
System.out.println("Program continues here");

Pokud nelze použít dědění od Thread implementujeme rozhraní Runnable:

public class WorkerRunnable implements Runnable {
    private final int id;
    private final int numberOfJobs;
 
    public WorkerRunnable(int id, int jobs) {
        this.id = id;
        numberOfJobs = jobs;
    }
 
    public String getName() {
        return "WorkerRunnable " + id;
    }
 
    @Override
    public void run() { ... }
}
 
WorkerRunnable worker = new WorkerRunnable(1, 10);
Thread thread = new Thread(worker, worker.getName());
thread.start();
 
public void run() {
    Thread thread = Thread.currentThread();
 
    for (int i = 0; i < numberOfJobs; ++i) {
        System.out.println("Thread name: " + thread.getName());
    }
}