Tahák - Základní konstrukce jazyka Java
Proměnné a datové typy
Primitivní datové typy
Typ |
Velikost |
Rozsah |
Výchozí hodnota |
Příklad |
byte |
8 bitů |
-128 až 127 |
0 |
byte b = 100; |
short |
16 bitů |
-32,768 až 32,767 |
0 |
short s = 1000; |
int |
32 bitů |
-231 až 231-1 |
0 |
int i = 100000; |
long |
64 bitů |
-263 až 263-1 |
0L |
long l = 100000L; |
float |
32 bitů |
±3.4e±38 |
0.0f |
float f = 3.14f; |
double |
64 bitů |
±1.7e±308 |
0.0d |
double d = 3.14; |
char |
16 bitů |
0 až 65,535 |
'\u0000' |
char c = 'A'; |
boolean |
1 bit |
true/false |
false |
boolean flag = true; |
Referenční datové typy
- String - textové řetězce
- Array - pole
- Objekty - instance tříd
- Výchozí hodnota: null
// Deklarace a inicializace proměnných
int cislo = 10;
double desetinne = 3.14;
char pismeno = 'A';
boolean pravda = true;
String text = "Ahoj světe!";
// Konstanty (final)
final double PI = 3.14159;
final int MAX_POCET = 100;
Parsování (převody mezi typy)
Automatické převody (implicitní)
- byte → short → int → long → float → double
- char → int
- K menšímu typu se musí explicitně převádět
Explicitní převody (casting)
// Zúžení (může způsobit ztrátu dat)
double d = 3.14;
int i = (int) d; // i = 3 (ztráta desetinné části)
// Rozšíření (bezpečné)
int x = 100;
double y = x; // y = 100.0
// Parsování řetězců
String text = "123";
int cislo = Integer.parseInt(text); // cislo = 123
double dbl = Double.parseDouble("3.14"); // dbl = 3.14
boolean bool = Boolean.parseBoolean("true"); // bool = true
// Převod na řetězec
int num = 456;
String str = String.valueOf(num); // str = "456"
String str2 = Integer.toString(456); // str2 = "456"
Podmínky
if-else
int vek = 18;
if (vek < 18) {
System.out.println("Neplnoletý");
} else if (vek >= 18 && vek < 65) {
System.out.println("Dospělý");
} else {
System.out.println("Důchodce");
}
switch-case
int den = 3;
String nazevDne;
switch (den) {
case 1:
nazevDne = "Pondělí";
break;
case 2:
nazevDne = "Úterý";
break;
case 3:
nazevDne = "Středa";
break;
default:
nazevDne = "Neznámý den";
}
// Ternární operátor
int vek = 20;
String status = (vek >= 18) ? "Dospělý" : "Neplnoletý";
Operátory
Typ operátoru |
Operátory |
Příklad |
Aritmetické |
+ - * / % ++ -- |
a + b, i++ |
Relační |
== != < > <= >= |
a == b, x > y |
Logické |
&& || ! |
a && b, !flag |
Přiřazovací |
= += -= *= /= %= |
a += 5 (ekvivalent a = a + 5) |
Bitové |
& | ^ ~ << >> >>> |
a & b, x << 2 |
// Příklady operátorů
int a = 10, b = 3;
// Aritmetické
int soucet = a + b; // 13
int podil = a / b; // 3 (celočíselné dělení)
int zbytek = a % b; // 1
// Relační
boolean rovnost = (a == b); // false
boolean vetsi = (a > b); // true
// Logické
boolean podminka = (a > 5) && (b < 10); // true
// Přiřazovací
a += 5; // ekvivalent a = a + 5, výsledek a = 15
Cykly
for cyklus
// Klasický for
for (int i = 0; i < 5; i++) {
System.out.println(i);
}
// Výsledek: 0 1 2 3 4
foreach cyklus
int[] cisla = {1, 2, 3, 4, 5};
for (int cislo : cisla) {
System.out.println(cislo);
}
// Výsledek: 1 2 3 4 5
while cyklus
int i = 0;
while (i < 5) {
System.out.println(i);
i++;
}
do-while cyklus
int i = 0;
do {
System.out.println(i);
i++;
} while (i < 5);
// Řízení cyklů
for (int i = 0; i < 10; i++) {
if (i == 3) {
continue; // přeskočí aktuální iteraci
}
if (i == 7) {
break; // ukončí celý cyklus
}
System.out.println(i);
}
// Výsledek: 0 1 2 4 5 6
Pole a metody pro práci s polem
Deklarace a inicializace pole
// Různé způsoby deklarace pole
int[] cisla1 = new int[5]; // pole 5 nul
int[] cisla2 = {1, 2, 3, 4, 5}; // pole s hodnotami
int[] cisla3 = new int[]{1, 2, 3}; // alternativní syntaxe
// Dvourozměrné pole
int[][] matice = new int[3][3];
int[][] matice2 = {{1,2,3}, {4,5,6}};
Základní metody pro práci s poli
int[] cisla = {5, 2, 8, 1, 9};
// Délka pole
int delka = cisla.length; // 5
// Přístup k elementům
int prvek = cisla[0]; // 5 (první prvek)
cisla[0] = 10; // změna hodnoty
// Procházení pole
for (int i = 0; i < cisla.length; i++) {
System.out.println(cisla[i]);
}
// Třídění
Arrays.sort(cisla); // {1, 2, 5, 8, 9}
// Vyhledávání
int index = Arrays.binarySearch(cisla, 5); // vrátí index
// Kopírování
int[] kopie = Arrays.copyOf(cisla, cisla.length);
// Porovnání polí
boolean stejne = Arrays.equals(cisla, kopie);
Metody pro práci s řetězci (String)
String text = " Hello World! ";
// Základní operace
int delka = text.length(); // 14
String velka = text.toUpperCase(); // " HELLO WORLD! "
String mala = text.toLowerCase(); // " hello world! "
String bezMezer = text.trim(); // "Hello World!"
// Porovnávání
boolean rovna = text.equals("Ahoj"); // false
boolean rovnaIgnoreCase = text.equalsIgnoreCase("hello");
// Vyhledávání
int index = text.indexOf("World"); // 7
boolean obsahuje = text.contains("Hello"); // true
boolean zaciná = text.startsWith(" Hello"); // true
boolean konci = text.endsWith("! "); // true
// Podřetězce
String cast = text.substring(1, 6); // "Hello"
String nahrazeny = text.replace("World", "Java");
// Rozdělení a spojení
String[] slova = text.split(" ");
String spojeny = String.join("-", "A", "B", "C"); // "A-B-C"
// Převod na pole znaků
char[] znaky = text.toCharArray();
// Formátování
String formatovany = String.format("Číslo: %d, Text: %s", 10, "Ahoj");
Matematické funkce (Math třída)
// Základní matematické operace
double a = 4.7, b = 2.3;
// Zaokrouhlování
double zaokrouhlene = Math.round(a); // 5.0
double floor = Math.floor(a); // 4.0 (dolů)
double ceil = Math.ceil(a); // 5.0 (nahoru)
// Mocniny a odmocniny
double mocnina = Math.pow(2, 3); // 8.0
double odmocnina = Math.sqrt(16); // 4.0
double kubicka = Math.cbrt(27); // 3.0
// Goniometrické funkce
double sin = Math.sin(Math.PI / 2); // 1.0
double cos = Math.cos(0); // 1.0
double tan = Math.tan(Math.PI / 4); // 1.0
// Logaritmy
double log = Math.log(10); // přirozený log
double log10 = Math.log10(100); // log base 10
// Absolutní hodnota
double abs = Math.abs(-5.5); // 5.5
// Minima a maxima
double max = Math.max(a, b); // 4.7
double min = Math.min(a, b); // 2.3
// Náhodné číslo
double nahodne = Math.random(); // 0.0 - 1.0
int nahodneInt = (int)(Math.random() * 100); // 0-99
Tipy pro kvíz:
• Pamatujte, že Java je case-sensitive (velká/malá písmena)
• Indexy pole začínají od 0, ne od 1
• String je immutable - metody vrací nový String
• Dělení celých čísel vrací celé číslo (ztráta desetinné části)
• == porovnává reference u objektů, equals() porovnává obsah