prvni commit

pom.xml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>groupId</groupId>
+    <artifactId>Java_Kankys</artifactId>
+    <version>1.0-SNAPSHOT</version>
+
+    <properties>
+        <maven.compiler.source>17</maven.compiler.source>
+        <maven.compiler.target>17</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+    
+</project>

src/main/java/Ruzne/README.md

@@ -0,0 +1,30 @@
+# cviceni.lukan
+První aplikace co se učí každý na programovat začíná klasickým pozdravem Ahoj světe! v mém případe Čus Sporťák!
+
+.................................................
+
+Základní datové typy:
+***Celá čísla: int
+Desetinná čísla: float
+Textový řetězec: String***
+* * *
+* * *
+* * *
+**STRING** je datový typ a má v sobě spousty metod.
+* * *
+* * *
+**Metody:**
+* * *
+**startsWith()**
+
+**endsWith()**
+
+**contains()**
+
+**isEmpty()**
+
+
+* * *
+
+
+

src/main/java/Ruzne/booleanvysvetleni.java

@@ -0,0 +1,23 @@
+package Ruzne;
+
+
+/* Boolean nabývá dvou hodnot: true (pravda) a false (nepravda).
+Budeme ho používat zejména tehdy, až se dostaneme k podmínkám.
+Do proměnné typu boolean lze uložit jak přímo hodnotu true/false, tak i logický výraz.
+Výrazy píšeme do závorek. Vidíme, že výraz nabývá hodnoty true (pravda),
+ protože 15 je opravdu větší než 5. Od výrazů je to jen krok k podmínkám, na ně se podíváme příště.
+ */
+
+
+
+
+public class booleanvysvetleni
+{
+    public static void main(String[] args) {
+
+        boolean b = false;
+        boolean vyraz = (15 > 5);
+        System.out.println(b);
+        System.out.println(vyraz);
+    }
+}

src/main/java/Ruzne/cus_sportak.java

@@ -0,0 +1,9 @@
+package Ruzne;
+
+/* Čus sporťák je nejlehčí a nejzákladnější Java program*/
+
+public class cus_sportak {
+    public static void main(String[] args) {
+        System.out.println("Čus Sporťák");
+    }
+}

src/main/java/Ruzne/easycalc.java

@@ -0,0 +1,23 @@
+package Ruzne;
+
+import java.util.Scanner;
+
+public class easycalc {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in, "UTF-8");
+        System.out.println("Ahoj, vítám tě v EasyCalc");
+        System.out.println("Zadej první číslo a stiskni Enter:");
+        float a = Float.parseFloat(sc.nextLine());
+        System.out.println("Zadej druhé číslo a stiskni Enter");
+        float b = Float.parseFloat(sc.nextLine());
+        float soucet = a + b;
+        float rozdil = a - b;
+        float soucin = a * b;
+        float podil = a / b;
+        System.out.println("Součet: " + soucet);
+        System.out.println("Rozdíl: " + rozdil);
+        System.out.println("Součin: " + soucin);
+        System.out.println("Podíl. " + podil);
+        System.out.println("Díky za použití EasyCalc!");
+    }
+}

src/main/java/Ruzne/error.java

@@ -0,0 +1,16 @@
+package Ruzne;
+
+/* Pro výpis textu chybového charakteru použijeme volání System.err.println().
+   Text je na obrazovce zobrazen červenou barvou
+ */
+public class error {
+    public static void main(String[] args) {
+        System.err.println("Chybové hlášení");
+    }
+
+}
+
+
+
+/* Test GitHub */
+

src/main/java/Ruzne/errorvtipek.java

@@ -0,0 +1,18 @@
+package Ruzne;
+
+import java.util.Scanner;
+
+// Vytvoříme dotaz ať uživatel něco napíše a pak mu to vypíše chybu.
+public class errorvtipek {
+    public static void main(String[] args) {
+        Scanner sc  = new Scanner(System.in, "UTF-8");
+        System.out.println("Ahoj, zadej text prosím:");
+        String vstup;
+        vstup = sc.nextLine();
+        for (;;) {
+            System.err.println("Něco děláš špatně, zkus aplikaci znovu spustit a něco napsat:");
+
+        }
+
+    }
+}

src/main/java/Ruzne/kruh.java

@@ -0,0 +1,42 @@
+package Ruzne;
+
+//Vypočítá obvod a obsah kruhu. Díky Float lze použít desetiná čísla.
+
+
+import java.util.Scanner;
+
+public class kruh {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in, "Windows-1250");
+        System.out.println("Zadej poloměr kruhu (cm):");
+        String s = sc.nextLine();
+        float a = Float.parseFloat(s);
+        float b = Float.parseFloat(s);
+
+        a = (float) (2 * 3.1415 * a); // výpočet obvodu kruhu
+        System.out.println("Obvod zadaného kruhu je:" + " " + a +" "+"cm");
+
+        b = (float) ( 3.1415 * (b*b)); // výpočet obsahu kruhu
+
+        System.out.println("Jeho obsah je "+ b +" "+"cm^2");
+
+
+
+    }
+}
+
+/*
+ *  Můžete ho upravovat a používat jak chcete, musíte však zmínit
+ *  odkaz na http://www.itnetwork.cz
+package cz.itnetwork.kruh;
+        import java.util.Scanner;
+public class Kruh {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in, "Windows-1250");
+        System.out.println("Zadej poloměr kruhu (cm): ");
+        float r = Float.parseFloat(sc.nextLine());
+        float o = 2 * 3.1415F * r;
+        float s = 3.1415F * r * r;
+        System.out.println("Obvod zadaného kruhu je: " + o + " cm");
+        System.out.println("Jeho obsah je " + s + " cm^2");
+ */

src/main/java/Ruzne/metody.java

@@ -0,0 +1,7 @@
+package Ruzne;
+
+public class metody {
+    public static void main(String[] args) {
+
+    }
+}

src/main/java/Ruzne/mocniny.java

@@ -0,0 +1,18 @@
+package Ruzne;
+
+import java.util.Scanner;
+
+public class mocniny {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in, "UTF-8");
+        System.out.println("Zadej číslo k umocnění:");
+        String s = sc.nextLine();
+        int a = Integer.parseInt(s);
+
+        a = a * a;
+        System.out.println("Výsledek:" + " " + a);
+
+
+
+    }
+}

src/main/java/Ruzne/papousek.java

@@ -0,0 +1,18 @@
+package Ruzne;
+
+import java.util.Scanner;
+
+public class papousek {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in, "UTF8");
+        System.out.println("Ahoj jsem virtuální papoušek, rád opakuji!");
+        System.out.println("Napiš něco: ");
+        String vstup;
+        vstup = sc.nextLine();
+        String vystup;
+        vystup = vstup + ", " + vstup + "!";
+        System.out.println(vystup);
+
+
+    }
+}

src/main/java/Ruzne/petinasobovac.java

@@ -0,0 +1,15 @@
+package Ruzne;
+
+import java.util.Scanner;
+
+public class petinasobovac {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in, "UTF-8");
+        System.out.println("Zadej číslo k pětinásobení");
+        String s = sc.nextLine();
+        int a = Integer.parseInt(s);
+        a = a * 5;
+        System.out.println(a);
+
+    }
+}

src/main/java/Ruzne/prepisovac.java

@@ -0,0 +1,14 @@
+package Ruzne;
+
+/* funkce replace přepíše text dle potřeby
+ */
+
+
+public class prepisovac {
+    public static void main(String[] args) {
+        String s = "Kočky jsou nejlepší!";
+        s = s.replace("Kočky", "Psi");
+        System.out.println(s);
+    }
+
+}

src/main/java/Ruzne/print.java

@@ -0,0 +1,19 @@
+package Ruzne;
+
+/* Pro výpis textu můžeme použít i volání System.out.print().
+   Od System.out.println() se liší tím, že po výpisu na obrazovku nepřesune kurzor na nový řádek
+ */
+import java.util.Scanner;
+
+public class print {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in, "UTF-8");
+        System.out.print("Zadej číslo:");
+        int vstup ; // vstup nám  říka lze zadat pouze číslo, pro text použijeme STring vstup
+        vstup = sc.nextInt(); // pro zobrazení textu použijeme metodu nextLine
+        System.out.print("Zadané číslo je: " + vstup );
+
+
+    }
+
+}

src/main/java/Ruzne/pyramida.java

@@ -0,0 +1,36 @@
+package Ruzne;
+
+public class pyramida {
+    public static void main(String[] args) {
+
+        int radky = 5;
+
+
+        //řádky = 1,2,3,4,5
+        //mezery = 4,3,2,1
+        //hvězžičky = 1,3,5,9
+        // pyramidu si nejdříve nakreslím na papír 9 okýnek vodorovně 5 svisle
+
+
+        int pocetHvezdicek = 1; //pocatecni hodnota
+        for (int i = 1; i <= radky; i++){// posouvá radky
+
+            for (int j = radky -i; j >=1; j--){ // kresli mezery
+                System.out.print(" ");
+            }
+
+            for (int k =1; k <= pocetHvezdicek; k++){// kresli Xka
+                System.out.print("X");
+            }
+            pocetHvezdicek = pocetHvezdicek + 2; // pocitadlo poctu X
+            System.out.println(); // prehodi dalsi radek
+
+        }
+
+
+
+
+
+
+    }
+}

src/main/java/Ruzne/robot.java

@@ -0,0 +1,17 @@
+package Ruzne;
+
+import java.util.Scanner;
+public class robot {
+    public static void main(String[] args) {
+
+        Scanner sc = new Scanner(System.in, "UTF-8");
+        System.out.println("Ahoj, jsem virtuální robot, rád opakuji!");
+        System.out.println("Napiš něco: ");
+        String vstup;
+        vstup = sc.nextLine();
+        String vystup;
+        vystup = vstup + ", " + vstup + "!";
+        System.out.println(vystup);
+
+    }
+}

src/main/java/Ruzne/vstup.java

@@ -0,0 +1,20 @@
+package Ruzne;
+
+import java.util.Scanner;
+
+public class vstup {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in, "UTF-8");
+        System.out.print("Zadej číslo: ");
+        int vstup ; // vstup nám  říka lze zadat pouze číslo, pro text použijeme STring vstup
+        vstup = sc.nextInt(); // pro zobrazení textu použijeme metodu nextLine
+        sc.nextLine();
+        System.out.print("Zadej text: ");
+        String text;
+        text = sc.nextLine();
+        System.out.println("Zadané číslo je: " + vstup );
+        System.out.println("Zadaný text je: " + text);
+
+
+    }
+}

src/main/java/Ruzne/vypis.java

@@ -0,0 +1,18 @@
+package Ruzne;
+
+public class vypis {
+    public static void main(String[] args) {
+
+        int a; // pro desetinou proměnou použijeme float např:65.2F
+
+        a = 78;
+        System.out.println(a);
+
+    }
+}
+
+/*
+float a;
+a = 69.7F;
+System.out.println(a);
+ */

src/main/java/Ruzne/zdvojnasobovac.java

@@ -0,0 +1,16 @@
+package Ruzne;
+
+import java.util.Scanner;
+
+public class zdvojnasobovac
+{
+    public static void main(String[] args) {
+
+        Scanner sc = new Scanner(System.in, "Windows-1250");
+        System.out.println("Zadejte číslo k zdvojnásobení:");
+        String s = sc.nextLine();
+        int a = Integer.parseInt(s);
+        a = a * 2;
+        System.out.println(a);
+    }
+}  

src/main/java/Ruzne/ztrojnasobovac.java

@@ -0,0 +1,14 @@
+package Ruzne;
+
+import java.util.Scanner;
+
+public class ztrojnasobovac {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in, "UTF-8");
+        System.out.println("Zadejte číslo k ztrojnásobení:");
+        String s = sc.nextLine();
+        int a = Integer.parseInt(s);
+        a = a * 3;
+        System.out.println(a);
+    }
+}

src/main/java/TutorialYouTube/README.md

@@ -0,0 +1,2 @@
+# tutorial
+Odkaz na video dle kterého je tento tutoriál https://www.youtube.com/watch?v=rBQ96up-O5Y&list=PLCC47AEAE0BCC4C0C

src/main/java/TutorialYouTube/tutorial1.java

@@ -0,0 +1,7 @@
+package TutorialYouTube;
+
+public class tutorial1 {
+    public static void main(String[] args) {
+        System.out.println("Čus Sporťák!");
+    }
+}

src/main/java/TutorialYouTube/tutorial2.java

@@ -0,0 +1,25 @@
+package TutorialYouTube;
+
+public class tutorial2 {
+    public static void main(String[] args) {
+        // int (datový tip) , celeCislo (proměnná) , = (operátor) , 200 (hodnota, je přiřazená do proměnné )
+        int celeCislo = 200;    // datový tip int pro celé číslo
+        float desetineCislo = 5.3f;  // datový tip float desetiné číslo
+        double vetstiVerzeFloat = 4.45; // datový tip double, větší verze float
+        boolean pravdaNepravda = false; // datový tip boolean pravda nepravda
+        byte maleCislo = 127;     // datový tip krátké číslo (bájt) v rozmezí -128 až 127
+
+        // u promnenné nastavit nutno datový tip jinak vypíše chybu
+        int promenna;
+        System.out.println("Čus Sporťák!");
+        promenna = 20;
+        System.out.println(promenna);
+        promenna = 50;
+        System.out.println(promenna);
+        System.out.println(Integer.MAX_VALUE);  // vypíše maximální a minimální hodnoty
+        System.out.println(Byte.MIN_VALUE);
+    }
+}
+
+
+

src/main/java/TutorialYouTube/tutorial3.java

@@ -0,0 +1,21 @@
+package TutorialYouTube;
+// zde probereme základy z matematiky , Matematické operace
+public class tutorial3 {
+    public static void main(String[] args) {
+        float celeCislo = 15;
+        float celeCislo2 = 10;
+        float vyraz = celeCislo * celeCislo2 + celeCislo;
+
+        System.out.println(celeCislo + celeCislo2);
+        System.out.println(celeCislo - celeCislo2);
+        System.out.println(celeCislo * celeCislo2);
+        System.out.println(celeCislo / celeCislo2);  // při dělení používát float, int nezobrazí destiná čísla!!
+        System.out.println(vyraz);
+
+        int celeCislo3 = 15;
+        int celeCislo4 = 10;
+        System.out.println(celeCislo3 % celeCislo4); // operátor modulo, zobrazí rozdíl
+    }
+
+}
+

src/main/java/TutorialYouTube/tutorial4.java

@@ -0,0 +1,24 @@
+package TutorialYouTube;
+// větvení, příkaz if podobná funkce jako boolean
+
+public class tutorial4 {
+    public static void main(String[] args) {
+        int promenna1 = 20;
+        int promenna2 = 15;
+        // porovná dve cisla pokud se rovnají == vypíše System...hlášku pokud se nerovnají nic nevypíše
+        // použít můžeme != a to že se nerovnají
+
+        if(promenna1 == promenna2) {
+            System.out.println("Proměnné se rovnají");
+
+        } else { // pomocí else ošetříme podmínku a vypíšeme že se promenné nerovnají, můžeme použít i níže opačně
+            System.out.println("Proměnné se nerovnají :-)");
+        }
+
+        if(promenna1 != promenna2) {
+            System.out.println("Proměnné se nerovnají");
+        }
+    }
+
+}
+

src/main/java/TutorialYouTube/tutorial5.java

@@ -0,0 +1,31 @@
+package TutorialYouTube;
+
+// Podmínkové operátory
+// && operátor end (musí být obě pravdivé)
+// || operátor or (nebo, musí být aspoň jeden výraz pravdivý)
+
+public class tutorial5 {
+    public static void main(String[] args) {
+        int promenna1 = 20;
+        int promenna2 = 15;
+
+        if(promenna1 == promenna2 && promenna1 == 20 ) { // zde se musejí rovnat obě proměnné
+            System.out.println("Proměnné se rovnají");
+        } else {
+            System.out.println("Proměnné se nerovnají");
+        }
+
+        if(promenna1 == promenna2 || promenna1 == 20)
+            System.out.println("Proměná or || aspoň jedna proměná se rovná");
+
+        // negace , otočí true na folse a opačně
+        if(!(promenna1 == promenna2)) {
+            System.out.println("Proměnné se Rovnají");
+        } else {
+            System.out.println("Proměnné se Nerovnají");
+        }
+
+
+
+    }
+}

src/main/java/TutorialYouTube/tutorial6.java

@@ -0,0 +1,33 @@
+package TutorialYouTube;
+
+// Cykuls While a For
+public class tutorial6 {
+    public static void main(String[] args) {
+
+      /*  // while pokud podmínka bude true tak se bude něco dít stále do kola
+        int pocitadlo = 0;
+        while(pocitadlo < 20) {
+            System.out.println("Číslo: " + pocitadlo); // zde + neznamená že chci sčítat, ale spojuji
+            pocitadlo = pocitadlo + 1; // přičte se přikaždém průchodu 1 až do 20.
+
+        } */
+
+
+        // while pokud podmínka bude true tak se bude něco dít stále do kola
+        /*  int pocitadlo = 0;
+         while(pocitadlo < 20) {
+             System.out.println("Číslo (příklad dva): " + pocitadlo); // zde + neznamená že chci sčítat, ale spojuji
+             pocitadlo++; // ++ unární operátor
+            } */
+
+
+        // for provede to samá co výše
+        int pocitadlo = 0;
+        for(int a = 0; a < 20; a++) {
+            System.out.println("Číslo (funkce for): " + a);
+        }
+
+
+    }
+
+}

src/main/java/TutorialYouTube/tutorial7.java

@@ -0,0 +1,35 @@
+package TutorialYouTube;
+
+
+// příklad switch používá se místo if pokud potřebujeme porovnat více hodnot z jednou proměnnou
+
+public class tutorial7 {
+    public static void main(String[] args) {
+
+        //int celeCislo = 10;
+
+    /*if(celeCislo == 5)
+        System.out.println("Promenná je rovna 5");
+    else if(celeCislo == 8)
+        System.out.println("Proměnná je rovna 8");
+    else if(celeCislo == 10)
+        System.out.println("Proměnná je rovna 10"); */
+
+        // switch - proměná musí být datový primitvní tip: byte, int, if, char, string atd. Nefungují zde třídy z objektového programovaní
+        // case - (kejs) značí porovnávaní
+        // break - (brejk) bez breake by se provedli všechny case
+        // v tomto příkladě už musíme použít { } (více řádků)
+        int celeCislo = 8;
+        switch(celeCislo) {
+            case 5:
+                System.out.println("Proměnná je Rovna 5"); break;
+            case 8:
+                System.out.println("Proměnná je Rovna 8"); break;
+            case 10:
+                System.out.println("Proměnná je Rovna 10"); break;
+        }
+        //System.exit(0); // kdyby psal chybu program , tím ukončime metodu main
+
+    }
+}
+

src/main/java/TutorialYouTube/tutorial8.java

@@ -0,0 +1,4 @@
+package TutorialYouTube;
+
+public class tutorial8 {
+}

src/main/java/TutorialYouTube/tutorial9.java

@@ -0,0 +1,22 @@
+package TutorialYouTube;
+// Vstup od uživatele
+// Zde použijeme scanner
+import java.util.Scanner;
+
+public class tutorial9 {
+    public static void main(String[] args) {
+        Scanner in = new Scanner(System.in);
+        String retezec;
+        System.out.println("Zadejte řetězec");
+        retezec = in.nextLine(); // přiřadí do proměnné hodnotu kterou uživatel napíše
+        System.out.println("Uživatel zadal: " + retezec);
+
+
+
+
+    }
+
+}
+
+
+

src/main/java/algo/HelloWorld.java

@@ -0,0 +1,16 @@
+package javaProZacatecniky.algo;
+/**
+ * Toto je základní aplikace HalloWorld!
+ * @author kankys
+ */
+public class HelloWorld {/**
+ * Toto je vstupní bod teto aplikace
+ * @param args the command line arguments
+ */
+public static void main(String[] args) {
+    System.out.println("HelloWorld!"); // řetězce vždy se dávají do dvojitých uvozovek
+}
+}
+// A takto vypadá řádkový komentáře
+// Může jich být více pod sebou
+

src/main/java/algo/OperatorC.java

@@ -0,0 +1,22 @@
+package javaProZacatecniky.algo;
+
+public class OperatorC {
+    public static void main(String[] args) {
+        int a = 5;
+        a = a + 3;
+        System.out.println(a);
+
+        int a2 = 5;
+        a2 += 3; // alternativni zapis predchoziho (a2 = a2 + 3)
+        System.out.println(a2);
+
+        a2 /= 4; // deleni (a2 = a2 / 4;)
+        System.out.println(a2);
+
+        a2 -= 1; // odcitani (a2 = a2 = 1;)
+        System.out.println(a2);
+
+        a2 *= 3; // násobení (a2 = a2 * 3;)
+        System.out.println(a2);
+    }
+}

src/main/java/algo/README.md

@@ -0,0 +1,191 @@
+**Java (1,2) - Úvod**
+
+**První program** 
+
+Po nainstalování Netbeans IDE jej pustíme. Z nabídky File vybereme New Project a zvolíme Java/Java Application. 
+Projekt pojmenujeme jako HelloWorld, dále nic neměníme a stiskneme tlačítko Finish.
+Nyní bychom měli před sebou mít připravenou základní kostru aplikace.
+V tento okamžik si nebudeme vysvětlovat všechna kouzelná slova, která před sebou máme a spokojíme se s ujištěním, že to takto má být (vše bude vysvětleno podrobně v dalších dílech). 
+V tomto díle si alespoň ukážeme, co to jsou komentáře.
+
+**Komentáře**
+
+Komentáře jsou texty, které nejsou javovským kompilátorem zpracovávány, 
+slouží pouze k orientaci programátora, vysvětlujícím pasážím a v neposlední řadě ke generování dokumentace.
+Java má dva typy komentářů řádkové a blokové, ty řádkové začínají znaky // a končí koncem řádku. 
+V programu takový komentář můžete vidět na řádce 18. 
+Druhým typem jsou blokové komentáře, které začínají znaky /* a končí znaky */. 
+Vše uvnitř těchto dvojic znaků není kompilátorem zpracováváno. 
+Speciálním případem blokového komentáře je komentář začínající trojicí znaků /**, to je dokumentační komentář, ze kterého se pomocí nástroje JavaDoc vytvoří dokumentace k programu (všimněte si direktiv pro tento nástroj např. @author). 
+Blokové komentáře můžeme umístit kamkoliv místo bílého znaku (tj. nesmíme je umístit doprostřed slova). 
+
+**Výpis textu**
+
+Pro samotný výpis řetězce Hello world použijeme volání System.out.println(), které umístíme do vstupního bodu aplikace - metody main. 
+Jako parametr tomuto volání předáme (vložíme do závorek) výše zmíněný řetězec (v Javě jsou řetězce vždy umístěny do horních uvozovek).
+Pro spuštění aplikace a zobrazení výsledku zvolíme v menu Run položku Run Main Project. Nyní by se měl v záložce Output zobrazit výstup programu.
+
+**Java (3) - Proměnné**
+
+**Proměnné**
+
+Proměnná je pojmenovaná část paměti, kterou používáme k uložení informace. 
+Vezmeme-li si jako příklad zaměstnance nějaké firmy, tak proměnná popisující jeho plat může mít hodnotu 25000, 
+heslo k jeho uživatelskému účtu bude nenavidimPraci a příznak jeho pohlaví jeMuz bude nastaven na hodnotu PRAVDA.
+
+**Typ proměnné**
+
+V Javě vždy při deklaraci proměnné určíme její typ. 
+Tento typ později již nemůžeme nijak změnit (v rámci bloku, kde je proměnná platná).
+Pokud například prohlásíme o proměnné x, že je typu celé číslo, tak se do ní nesmíme později snažit umístit řetězec.
+Toto není nijak překvapivé pro začátečníka, případně pro člověka se zkušenostmi s jiným silně typovaným jazykem. 
+Ale pro uživatele například PHP to může být šok (PHP je dynamicky typované – typ proměnných se mění automaticky v závislosti na datech).
+
+Silná typovost se proto může zdát být slabinou a zbytečným šikanováním programátora, 
+ale ve skutečnosti velmi usnadňuje práci (vývojové prostředí může lépe radit a pomáhat) a zabraňuje značnému množství chyb z nepozornosti.
+
+**Jména proměnných**
+
+Jména proměnných v Javě mohou být libovolně dlouhá, ale musí začínat písmenem, symbolem podtržítka (_) nebo dolaru ($) a nesmí být klíčovým slovem jazyka (např. název datového typu). 
+V názvu smíme používat libovolné znaky, protože Java pro zdrojové kódy používá Unicode, ale mějme na paměti, že kód mohou číst i jiní lidé jiných národů. 
+Jak by nám asi bylo příjemné, kdybychom měli půlku kódu v japonských znacích (které ani nemáme na klávesnici).
+
+Konvence pro názvy proměnných říká, že pokud se nejedná o konstanty, tak by měly by být psány camelCasem – první písmeno názvu vždy malým písmenem, 
+pokud název obsahuje více slov, tak první písmeno každého nového slova vždy velké (cisarovyNoveSaty). 
+
+Upozornění na závěr: Java je case-sensitive. Proměnné pes a Pes jsou různé.
+
+**Primitivní datové typy**
+
+**Celočíselné datové typy**
+
+Pro ukládání celých čísel Java obsahuje čtyři datové typy byte, short, int, long. 
+Tyto typy se liší pouze v rozsahu hodnot, které mohou používat. 
+Všechny obsahují jak kladná, tak záporná čísla (a nelze to ovlivnit).
+
+Důležitou poznámkou je, že všechny celočíselné literály (tj. hodnoty přímo vepsané ve zdrojovém kódu) jsou implicitně typu int.
+Pokud proto chteme vložit do proměnné typu long hodnotu, která je vyšší než maximální rozsah typu int, tak musíme na konec literálu přidt znak l nebo L.
+
+Typ	Rozsah	Paměť
+byte	-128 až 127	1 bajt (8 bitů)
+short	-32768 až 32767	2 bajty (16 bitů)
+int	-2147483648 až 2147483647	4 bajty (32 bitů)
+long	-9223372036854775808 až 9223372036854775807	8 bajtů (64 bitů)
+
+**Datové typy reálných čísel**
+
+Pro reálná čísla existují typy float a double (viz tabulka). 
+Protože tyto typy musí mít velký rozsah (od obrovských čísel po velmi malé zlomky), používá se pro jejich reprezentaci plovoucí desetinné čárky. 
+To znamená, že jsou čísla zapsána tak, aby jejich první platná číslice byla přímo za desetinnou čárkou (tzv. mantisa) a za tímto zápisem následuje číslo reprezentující exponent základu soustavy, 
+kterým když přenásobíme mantisu, tak dostaneme uložené číslo. 
+Takto to vypadá velmi složitě, ale z příkladů (v desítkové soustavě) je jasně patrné, jak to funguje.
+
+Na tomto matematickém cvičení je důležité jedno poselství – typy float a double nejsou přesné,
+protože obsahují určitý fixní počet míst pro zápis mantisy a exponentu.
+
+Typ	Rozsah	Přesnost	Paměť
+float	-3.4e38 až 3.4e38	cca. 7 míst	4 bajty (32 bitů)
+double	-1.7e308 až 1.7e308	cca. 17 míst	8 bajtů (64 bitů)
+
+Poslední poznámkou pro reálná čísla je, že pro literály je implicitním typem double, proto pokud chceme říci kompilátoru, 
+že je daný literál typu float, tak na konec literálu připojíme znak f nebo F.
+
+**Datový typ znak**
+
+Pro ukládání jednotlivých znaků v Javě slouží typ char, 
+který zabírá v paměti 2 bajty místa. 
+Pro vložení hodnoty znaku do proměnné lze použít buď celočíselného literálu, apostrofů ('A') nebo Unicode sekvence ('\\u0041').
+
+Poznámka: Mezi použitím apostrofů a uvozovek je v Javě rozdíl. Zatímco 'A' znamená znak A, "A" znamená řetězec, který obsahuje jeden znak A.
+
+**Logické hodnoty**
+
+Pro reprezentaci logických hodnot (pravda/nepravda) slouží typ boolean. Boolean může obsahovat buď hodnotu true – pravda nebo false – nepravda.
+
+**Deklarace a inicializace proměnných**
+
+Pro vytvoření proměnné (deklaraci) a dosazení hodnoty do proměnné (inicializaci) se dá použít několik různých zápisů. 
+Všechny zápisy jsou správné, některé jsou však správnější (viz komentáře). 
+Následující kód obsahuje deklarace a inicializace všech datových typů, které jsme si dnes ukázali.
+
+Jak si asi všimnete, tak je za každým příkazem středník, to je v Javě povinnost. Povinností ovšem není mít na řádce pouze jeden příkaz, 
+to je obecná kultura.
+
+**Java (4) - Základní operace**
+
+**Platnost proměnných**
+
+Každá proměnná je platná (a nesmí být opětovně deklarována) v rámci bloku. 
+Blok je taková část kódu, která je uvnitř jednoho páru složených závorek. V
+případě vnořených bloků proměnná platí i ve všech vnitřních blocích. Ovšem v okamžiku, kdy opustíme blok, kde byla proměnná deklarována, 
+ji již nesmíme použít (protože neexistuje).
+
+V následujícím příkladu budeme používat pro bloky pouze osamocené znaky složených závorek. 
+Toto je v Javě poměrně neobvyklé, protože se bloky téměř vždy vážou k cyklům, podmínkám, definicím metod a tříd, ale tato problematika nás teprve čeká.
+
+**Přetypování**
+
+V určitých situacích potřebujeme změnit typ proměnné, což může nastat tehdy, 
+chceme-li volat operaci, která přijímá celá čísla (int), ale naše proměnná je typu double. 
+Některé konverze typu proběhnou automaticky (stačí přiřadit hodnotu do nového typu), u jiných o ně musíme explicitně zažádat. 
+Do první skupiny patří ty změny, u nichž zaručeně nedojde k žádné ztrátě dat (byte → int, int je schopen pojmout více dat než byte), 
+do té druhé ty změny, kde je ztráta dat možná (double → int, double má jak větší rozsah, tak obsahuje desetinné pozice).
+
+V případě explicitní konverze o tuto změnu zažádáme tím, že před proměnnou napíšeme do závorek typ, který si přejeme.
+
+Pokud si seřadíme jednotlivé typy do řady:
+byte-> short-> int-> long-> float-> double
+tak konverze proběhne vždy automaticky tehdy, je-li výchozí typ nalevo od cílového, v opačném případě musíme o konverzi zažádat (všimněte si, že typ boolean nelze přetypovat).
+
+**Operace**
+
+**Operace přiřazení**
+
+Operace přiřazení do proměnné (operátor =) pro nás není nic nového, už ji totiž nějakou dobu používáme.
+
+**Aritmetické operátory**
+
+Pro aritmetické výpočty můžeme použít operátory +, -, *, /. 
+Všechny tyto operátory mají očekávatelnou prioritu (tj. nejprve násobíme a dělíme, teprve až poté sčítáme a odčítáme) a lze při jejich použití využít uzávorkování.
+
+Je důležité vědět, že pokud má některý operand typ double, tak je i druhý operand před provedením operace převeden na double, obdobně na float a long.
+
+Velmi oblíbeným chytákem aritmetických operací je následující kód:(viz operatorA)
+-> Jak je možné, že je výsledek 0.0 a ne 0.5? Je třeba si uvědomit pořadí, ve kterém dochází k vyhodnocení. 
+Nejprve jsou sečteny dvě celá čísla, výsledek je celé číslo 2. Nyní dojde k dělení dvou celých čísel 2/4, což je ovšem celočíselně 0. 
+Teprve v tento okamžik dojde k automatickému přetypování na double. Pokud tomuto chování chceme zabránit, 
+tak musíme explicitně libovolný operand přetypovat na double a automatická konverze se dle předchozí poučky postará o zbytek práce.
+-> operatorB
+->Implicitní typ<-
+Protože je při celočíselných výpočtech vždy implicitně používán typ int, tak je zapotřebí výsledek před přiřazením do kratší proměnné (short, byte) vždy přetypovat.
+
+**Operatory op=**
+
+Velmi často se v programování dosatneme do situace, kdy je zapotřebí nad danou proměnnou vykonat aritmetickou operaci a výsledek opět uložit do původní proměnné. 
+V kódu tím dochází k lehké redundanci. Z tohoto důvodu existují pro zkrácení zápisu operátory op= (kde op nahrazujeme +, -, *, /).
+(operatorC.java)
+
+**Inkrementace a dekrementace**
+
+Pro zvyšování (inkrementace) a snižování (dekrementace) hodnoty proměnné o 1 existuje zvláštní konstrukt (++ a -- zapsané buď před nebo za název proměnné). 
+Tímto se jednak ušetří místo, ale hlavně je možné tuto operaci použít uvnitř jiného aritmeticného výrazu.
+
+Pokud zapíšeme znaménka před proměnnou hovoříme o preinkrementaci (predekrementaci) – při vyhodnocování výrazu se nejprve provede změna hodnoty proměnné a až posléze se vyhodnotí výraz. 
+Při opačném zápisu (promenna++) – postinrekementaci (postdekrementaci) – se nejprve vyhodnotí výraz a až posléze dojde k přiřazení nové hodnoty.
+(inkrementace.java)
+
+**Operátor modulo**
+
+Pro práci s celými čísly existuje také operátor modulo (zbytek po celočíselném dělení). Každé celé číslo lze vyjádřit jako:
+a = b . k + c
+kde c je zbytek po vydělení čísla a číslem b.
+
+
+
+
+
+
+
+
+
+

src/main/java/algo/inkrementace.java

@@ -0,0 +1,18 @@
+package javaProZacatecniky.algo;
+
+public class inkrementace {
+    public static void main(String[] argrs) {
+        int i = 1;
+        i++; //i = 2
+        ++i; //i = 3
+        i--; //i = 2
+        --i; //i = 1
+
+        int c = i++ * 3; // c = 3, i = 2 (nejprve c = i *3; pote i = i + 1)
+        int d = --i * 3; // d = 3, i = 1 (nejprve i = i - 1, pote d = i * 3)
+
+        System.out.println(c);
+        System.out.println(d);
+
+    }
+}

src/main/java/algo/operatorA.java

@@ -0,0 +1,10 @@
+package javaProZacatecniky.algo;
+
+public class operatorA {
+    public static void main(String[] args) {
+        int a = 1;
+        int b = 1;
+        double c = (a + b)/4;
+        System.out.println(c);
+    }
+}

src/main/java/algo/operatorB.java

@@ -0,0 +1,10 @@
+package javaProZacatecniky.algo;
+
+public class operatorB {
+    public static void main(String[] args) {
+        int a = 1;
+        int b = 1;
+        double c =((double) a + b)/4;
+        System.out.println(c);
+    }
+}

src/main/java/algo/platnostPromennych.java

@@ -0,0 +1,43 @@
+
+/**
+ 02.
+ * Priklad na bloky
+ 03.
+ *
+ 04.
+ * V dalsich prikladech budeme pouze vymenovat obsah bloku metody, vse ostatni
+ 05.
+ * zustane stejne. Pokud byste si chteli tyto priklady zkusit, tak mejte na
+ 06.
+ * pameti, ze tento kod musite umistit do souboru 'Main.java' do vychoziho adresare
+ 07.
+ * (v netbeans oznaceno jako 'Source Packages'). Kod pak spustite klikem praveho
+ 08.
+ * tlacitka do kodu a volby 'Run File', pripadne analogicke volby v levem menu
+ 09.
+ * (stromu struktury projektu).
+ 10.
+ *
+ 11.
+ * Duvody techto konstrukci budou vysvetleny v dalsich dilech
+ 12.
+ *
+ 13.
+ * @author Pavel Micka
+14.
+ */
+package javaProZacatecniky.algo;
+
+public class platnostPromennych { // blok tridy
+    public static void main(String[] args) { //blok dany metodou
+        int a = 5;
+        System.out.println(a); // 5
+        { // vnitrni blok
+            System.out.println(a);
+            // promenna je i ve vnitrnim bloku platna
+            int b = 10;
+            System.out.println(b); //10
+        } // konec vnitrniho bloku
+        System.out.println(a); // zde b by uz byla chyba, zde promenna jiz neexistuje
+    } // konec bloku metody
+} //konec bloku tridy

src/main/java/algo/pretypovani.java

@@ -0,0 +1,17 @@
+package javaProZacatecniky.algo;
+
+public class pretypovani {
+    public static void main(String[] args) {
+        byte b = 5;
+        int i = b; // automatická konverze, int má větší rozsah
+
+        long l = 150000L;
+        i = (int) l; // hrozi preteceni, musime sami o zmenu zadat
+
+        double d =1.5;
+        i = (int) d; // hrozi ztrata presnosti, o zmenu musime zazadat
+        System.out.println(i); //vypise 1
+
+        d = i; // v poradku, double ma vetsi rozsah nez integer
+    }
+}

src/main/java/algo/promenne.java

@@ -0,0 +1,73 @@
+package javaProZacatecniky.algo;
+
+public class promenne {
+    public static void main(String[] args) {
+        System.out.println("Zde je cvičení na proměnné");
+
+        /**
+         * Deklarace a inicializace
+         */
+        int i1; //pouze deklarace
+        i1 = 1500; //inicializace
+
+        int i2 = 1500; //deklarace s inicializaci - dopuruceny postup
+        int i3, i4, i5; //deklarace vice promennych - neni doporuceno
+        int i6 = 7, i7 = 15, i8 = 17; // toto také neni doporučeno
+
+
+        /**
+         * Celá čísla
+         */
+
+        byte b = 100; // byte
+
+        short s = -30000; // short - záporné číslo
+        short s2 = 30000; // short - kladné číslo
+
+        int i = 10000;
+
+        long l = 100;
+        long l2 = 150000000000l; // long - příliš velké číslo
+        long l3 = 150000000000L; // long - varianta L
+
+        /**
+         * Realna cisla
+         */
+
+        double d = 100.5;
+        double d2 = 0.5;
+        double d3 =  .5; // O.5
+        double d4 = 5E-1; // 0.5
+        double d5 = 0.5e0; // 0.5
+
+        float f = 100.5f;
+        float f2 = 100.5F;
+
+        /**
+         * Znaky
+         */
+
+        char ch = 'A';
+        char ch2 = 65; // A (ASCII hodnota)
+
+        /**
+         * Logické hodnoty
+         */
+
+        boolean bool = true;
+        boolean bool2 = false;
+
+
+
+        /**
+         * Příklady vypisu
+         */
+        System.out.println(i1);
+        System.out.println(i2);
+        System.out.println(s);
+        System.out.println(l2);
+        System.out.println(d4);
+        System.out.println(ch2);
+        System.out.println(bool2);
+    }
+}

src/main/java/java_pdf/cv01.java

@@ -0,0 +1,15 @@
+package java_pdf;
+
+public class cv01 {
+    public static void main(String[] args) {
+        // Výstup na obrazovku.
+        System.out.println("Čus sporťák!"); // textový řetězec
+        System.out.println("A"); // jeden znak
+        System.out.println(124); // celé číslo
+        System.out.println(3.14159); //desetinné číslo
+        System.out.println(); // nový řádek
+        System.out.printf("%.2f" ,3.14158); // desetinné číslo zaokrouhleno na dvě místa
+        System.out.println(); // vloží volný řádek
+        System.out.println("Výsledek: " + 50 + " [cm]"); // text a číslo
+    }
+}

src/main/java/java_pdf/cv02.java

@@ -0,0 +1,66 @@
+package java_pdf;
+
+// Cvičení 02 - Proměnné a výpočty
+
+public class cv02 {
+    public static void main(String[] args) {
+        // Textové proměnné.
+        String Txt; // deklarace bez zápisu hodnot
+        String Txt1 = "Vložený text."; // deklarace se zápisem hodnot
+        Txt = "Dodatečně vložený text."; //přiřazení textu do proměnné
+        String TxtVysledek = Txt + Txt1; // řetězení textu
+        System.out.println("Výsledný text: "+TxtVysledek);
+
+        //Celočíselné proměnné.
+        byte C1 = 20;  //-128 až 127
+        short C2 = 1523; //-32768 až 32767
+        int C3 = 528;  //-2147483648 až 2147483647
+        long C4;   // -9223372036854775808 až 9223372036854775807
+        C4 =(C3 + C2 - C1)*5; // matematické operace
+        // Číselnou proměnou C4 není nutno při výstupu na obrazovku převádět na text.
+        System.out.println("Výsedek:" + C4);
+        // Celočíselné dělení, které vrací zbytek po dělení
+        System.out.println("Zbytek po dělení čísel 40/6 . . ."+ 40%6);
+        C1++;  // k hodnotě v C1 připočteme hodnotu 1
+        System.out.println("Inkrrmentace čísla C1++ " + C1);
+        C1--; // od hodnoty v C1 odečteme hodnotu 1
+        System.out.println("Dekrementace čísla C1-- " + C1); // nevím proč, ale nefunguje to
+
+        //Desetinné proměnné
+        float D1;
+        double D2;
+        D1 = 258 / 3;
+        System.out.println("Výsledek 258 / 3 = " + D1);
+        D2 = 0.587 / 0.00003;
+        System.out.println("Výsledek 0.587 / 0.00003 = "+ D2);
+
+        // Logické proměnné
+        boolean B1 = true;  //pravda
+        boolean B2 = false; //nepravda
+        System.out.println("Výsledek B1: " + B1);
+        System.out.println("Výsledek B2. " + B2);
+
+        //Znakové proměnné
+        char Z1 = 'A'; // znakovou proměnnou vložíme do jednoduchých uvozovek
+        System.out.println("Zobraz Z1 jako znak:" + Z1);
+        int ZZ1 = Z1;
+        System.out.println("Zobraz Z1 jako číslo z ascii tabulky:" + ZZ1);
+        char Z2 = 'J';
+        int ZZ2 = Z1 + Z2;
+        System.out.println("Výsledek součtu znaků Z1 + Z2: "+ ZZ2+
+                " Což je součet ascii čísel A=65 + J=74");
+        String ZZ3 = String.valueOf(Z1) + String.valueOf(Z2);
+        System.out.println("Zobraz zřetězení Z1 + Z2: " + ZZ3);
+
+
+
+
+
+
+
+
+
+
+    }
+
+}

src/main/java/java_pdf/cv03.java

@@ -0,0 +1,27 @@
+package java_pdf;
+
+
+/* Cvičení 03 - Výpočet obvodu a obsahu kružnice. Bez zadání hodnoty v konzoli.
+
+ */
+public class cv03 {
+    public static void main(String[] args) {
+        // Zadání vstupních hodnot
+        int polomer = 15; //poloměr kružnice
+        // Výpočet
+        double obvod = 2 * Math.PI * polomer; // Math.Pi... vrátí 3.14149...
+        //Math.pow(x,y) y-tá mocnina čísla x
+        double obsah = Math.PI * Math.pow(polomer, 2);
+        // Zobrazení výsledků
+        System.out.println("Obvod : " + obvod);
+        System.out.println("Obsah : " + obsah);
+        // Zobrazení výsledků  - zaokrouhleno na 2 desetinná místa
+        System.out.printf("Obvod : %.2f" , obvod);
+        System.out.println(); // nový řádek
+        System.out.printf("Obsah . %.2f" , obsah );
+        System.out.println(); //nový řádek
+
+
+
+    }
+    }

src/main/java/java_pdf/cv04.java

@@ -0,0 +1,24 @@
+package java_pdf;
+
+/*
+ * Výpočet ověsny troujúhelníka pomocí Pythagorovy věty
+ */
+
+
+public class cv04 {
+    public static void main(String[] args) {
+        // Zadání vstupních hodnot - přepony trouhelníka
+        double a = 20;
+        double b = 30;
+        //Výpočet
+        double v1 = Math.pow(a, 2);  // druhá mocnina přepony a
+        double v2 = Math.pow(b, 2);  // druhá mocnina přepony b
+        double c1 = v1 + v2;
+        double c = Math.sqrt(c1);      // výpočet druhé odmocniny
+
+        // Zobrazení výsledků
+        System.out.println("Přepona A : " + a);
+        System.out.println("Přepona B :" + b);
+        System.out.println("Odvěsna : " + c);
+    }
+}

src/main/java/java_pdf/cv05.java

@@ -0,0 +1,43 @@
+package java_pdf;
+
+// Cvičení 05 - Výpočet geometrických funkcí a přetypování proměnné
+
+public class cv05 {
+
+    /**
+     * @param args
+     */
+    public static void  main(String[] args) {
+        // Zadání vstupních hodnot
+        double uhel = 30;   //ůhel ve stupních
+
+        // Výpočet Sin.
+        // metoda Math.sin vyžaduje jako vstup úhel
+        double v1 = Math.sin(Math.toRadians(uhel));
+        float v11 = (float) Math.sin(Math.toRadians(uhel));
+        double v111 = (float) Math.sin(Math.toRadians(uhel));
+        /*
+         * Výpočet úhlu dává odchylku při ukládání vypočtené
+         * hodnoty jako double. Řešení je přetypování vypočtené
+         * hodnoty na typ float.
+         */
+        // zobrazení výsledku sin
+        System.out.println("Double : Sin("+uhel+")=" + v1);
+        System.out.println("Float : Sin("+uhel+")=" + v11);
+        System.out.println("Double(Float) : Sin("+uhel+")=" + v111);
+
+        // Výpočet Cos, Tan.
+        double v2 = (float) Math.cos(Math.toRadians(uhel));
+        double v3 = (float) Math.tan(Math.toRadians(uhel));
+        // zobrazení výsledků cos, tan
+        System.out.println("cos("+uhel+")=" + v2);
+        System.out.println("tan("+uhel+")=" + v3);
+
+
+
+
+
+    }
+
+
+}

src/main/java/java_pdf/cv06.java

@@ -0,0 +1,30 @@
+package java_pdf;
+
+// Cvičení 06 - Generování náhodného čísla, zaokrouhlení čísla
+
+public class cv06 {
+    public static void main(String[] args) {
+        // zobrazení náhodného čísla v rozmezí od 0 do 1
+        System.out.println("Náhodné číslo: " + Math.random());
+        // zobrazení celého náhodného čísla v rozmezí od 1 do 10
+        /* Vygenerované náhodné číslo vynásobíme číslem 10 a připčteme k němu
+         * číslo 1, aby výsledek byl od 1 ne od 0. Aby vzniklo celé číslo,
+         * musíme provést přetypování na integer. */
+        System.out.println("Náhodné číslo: " +((int) (Math.random()*10)+1) );
+
+
+        // zaokrouhlení na celá čísla
+        double cislo = 23.5996433;
+        System.out.println("Zadané číslo: "+cislo);
+        // parametr je desetinné číslo, zaokrouhluje se na celé číslo
+        // (od 0.5 nahoru, jinak dolů)
+        System.out.println("Zaokrouhleno round: "+Math.round(cislo)); // za 23...... zkus změnit hodnotu nad a pod 5
+        // číslo je vždy zaokrouhleno nahoru
+        System.out.println("Zaokrouhleno ceil: "+Math.ceil(cislo));
+        // číslo je vždy zaokrouhleno dolu
+        System.out.println("Zaokrouhleno floor: "+Math.floor(cislo));
+
+
+
+    }
+}

src/main/java/java_pdf/cv07.java

@@ -0,0 +1,42 @@
+package java_pdf;
+// Cvičení 07 - Matematické funkce metody Math.
+public class cv07 {
+    public static void main(String[] args) {
+
+        // Ludolfovo číslo Pí
+        System.out.println();
+        System.out.printf("Ludolfovo číslo : " + Math.PI +
+                " Na tři desetinná místa: %.3f",Math.PI);
+
+        // Eulerovo číslo
+        System.out.println();System.out.println(); // dvakrát println zbůsobí větší mezeru pod sebou o jeden řádek víc
+        System.out.printf("Eulerovo číslo: " + Math.E +
+                " Na dvě desetinná místa: %.2f",Math.E);
+
+        // Větší nebo menší číslo
+        System.out.println();System.out.println();
+        int C1 = 10, C2 = 100;
+        System.out.println("Větší číslo:"+ Math.max(C2, C1));
+        System.out.println("Menší číslo:"+ Math.min(C2, C1));
+
+        // Zaokrouhlení čísla
+        System.out.println();System.out.println();
+        double C3 = 10.5894;
+        System.out.println("Zaokrouhlení čísla: "+C3+" Zaokrouhleno: " + Math.round(C3));
+
+        // Absolutní hodnota
+        System.out.println();System.out.println();
+        int C4 = -256;
+        System.out.printf("Číslo C4=%d absolutní hodnota čísla C4=%d ",
+                C4,Math.abs(C4));
+
+        // N-tá mocnina čísla
+        System.out.println();System.out.println();
+        //Dvě na třetí
+        System.out.printf("Dvě na třetí: %.0f",Math.pow(2,3));
+        System.out.println();
+
+
+
+    }
+}

src/main/java/java_pdf/cv13.java

@@ -0,0 +1,27 @@
+package java_pdf;
+
+/*
+ * Cvičení 13 - Předčasné ukončení programu.
+ */
+
+import java.util.Scanner;
+
+public class cv13 {
+    public static void main(String[] args) {
+        // aktivace instance scanner
+        Scanner scc = new Scanner (System.in); // čísla
+
+        // zadání kladného čísla
+        System.out.print("Zadej kladné číslo nebo nulu: ");
+        int cislo = scc.nextInt();
+
+        if (cislo<0) {         // kontrola vstupní hodnoty
+            System.out.println("Zadané číslo je záporné. Zadal jsi: "+cislo);
+            System.err.println("Program byl ukončen předčasně.");
+            System.exit(0); // předčasné ukončení programu
+
+        }
+        System.out.println("Zadal jsi kladné číslo nebo nulu. Zadané číslo: "+cislo);
+    }
+
+}

src/main/java/java_pdf/cv16.java

@@ -0,0 +1,20 @@
+package java_pdf;
+
+// Cvičení 16 - Příkaz cyklu For ... cyklus s pevným počtem opakování
+
+import java.util.Scanner;
+
+public class cv16 {
+    public static void main(String[] args) {
+
+        // Aktivace instance scanner
+        Scanner sc = new Scanner(System.in);  // čísla
+
+        // Zadání počtu opakování cyklu
+        System.out.print("Zadej počet opakování cyklu: ");
+        int pocet = sc.nextInt();
+
+
+
+    }
+}