Merge branch 'origin/master' into master

KIV PPA1/15. Výjimky.md

@@ -48,7 +48,7 @@
 
 - Všechny tyto výjimky jsou odvozeny (přímo nebo přes delší hierarchii) od ```RuntimeException```
 - Není nutné se o ně v programu postarat, protože mohou nastat kdekoliv
-	- Příkladem je přístup do neexistujícího prvku pole (```ArrayIndexOutOfBoundException```), volání metody nad referenční proměnnou, která je ```null``` (```NullPointerException```),dělení nulou (```ArithmeticException```) a mnoho dalších
+	- Příkladem je přístup do neexistujícího prvku pole (```ArrayIndexOutOfBoundException```), volání metody nad referenční proměnnou, která je ```null``` (```NullPointerException```), dělení nulou (```ArithmeticException```) a mnoho dalších
 	- Program lze přeložit – **překladač nás nenutí, abychom je ošetřili** pomocí speciální části zdrojového kódu
 	- Považujeme-li to za vhodné, můžeme je ošetřit (stejným způsobem jako kontrolované výjimky)
 		- Typicky je to v místech, kde je zvýšená pravděpodobnost problému (např. vstupy od uživatele)
@@ -99,7 +99,8 @@
 		- Blok ```finally``` následuje za blokem catch
 		- Obsahuje část kódu, která se provede vždy – ať už k výjimce dojde, nebo ne (i když dojde k jiné výjimce, která není odchycena)
 		- Nepoužívá se příliš často
-- Možné ošetření výjimky – pouze vypsání chyby a ukončení programu Primitivní, ale často rozumný způsob
+- Možné ošetření výjimky – pouze vypsání chyby a ukončení programu
+	- Primitivní, ale často rozumný způsob
 	- Hodí se v případech, kdy vznik výjimky znamená, že program dál stejně nemůže smysluplně pokračovat
 	- Umožní program přeložit (pokud ošetřujeme kontrolovanou výjimku)
 	- V případě, že je výjimka vyhozena, se o ní z chybového výpisu dozvíme
@@ -190,7 +191,7 @@
 - Propagování výše se provede v bloku ```catch``` příkazem ```throw```
 	- Výjimky jsou zachyceny blokem ```catch```, ve kterém se provede ošetření (zde není žádné potřeba) a výjimka se následně předá výše
 	- Uzavření souboru (pokud je otevřen) se provede v bloku ```finally``` (chceme ho zavřít v každém případě, ať už výjimka vznikla nebo ne) 
-- Pokud potřebujeme v ošetření výjimky provést pouze uzavření souboru (a ne jinou akci), je možné (a lepší) použít konstrukci ```try```-withrerources
+- Pokud potřebujeme v ošetření výjimky provést pouze uzavření souboru (a ne jinou akci), je možné (a lepší) použít konstrukci ```try```-with-resources
 	- Bloky ```catch``` ani ```finally``` se vůbec neuvedou, ale k uzavření souboru dojde
 	- Kvůli chybějícímu bloku ```catch``` se výjimka ani nezachytí a není tedy ani nutné znovu ji vyhazovat příkazem ```throw```
 

KIV PPA1/18. Zobrazení dat v počítači.md

@@ -25,7 +25,6 @@
 - Desetinná část
 	- Desetinnou část násobíme 2, píšeme si číslici vlevo od desetinné čárky (v celé části)
 	- Číslice přečtené popředu dají desetinnou část binárního čísla
-- Příklad převodu čísla 69,6875 na jeho reprezentaci v binární soustavě je na
 
 #### Převod z desítkové do dvojkové soustavy („intuitivní“) 
 

KIV PPA1/6. Třídy a instance.md

@@ -152,7 +152,6 @@
 		- Uvnitř třídy není název třídy nutný
 		- Konstanty mají obvykle přístupové právo ```public```
 		- Konstantě třídy lze přiřadit hodnota pouze přímo v deklaraci, není možné ji inicializovat později
-		- Použití statické konstanty třídy je vidět např. na Obr. 13.2
 
 - Použití proměnných třídy
 	- Málo časté

KIV PPA1/8. Pole.md

@@ -198,10 +198,6 @@ typ nebo třída)
 	- V okamžiku, kdy se dostaneme na „vnitřní“ pole, můžeme zjistit jeho délku
 		- To se velmi často využívá
 		- Funguje dobře při procházení vícerozměrného pole, i pokud je pole „zubaté“
-- Příklady přístupu k prvkům pole a k „vnitřním“ polím kvůli jejich délce je na
-	- Deklarace a vytvoření pole ```jednotkovaMatice```
-- Kompletní příklad na použití dvojrozměrných polí k násobení matic (v kombinaci s objekty)
-	- Použitá třída ```Matice```
 
 ### Pole v paměti
 

KIV PPA1/Příprava na zkoušku/Sort.java

@@ -0,0 +1,75 @@
+import java.util.Arrays;
+
+public class Sort {
+
+	public static void main(String[] args) {
+
+		int[] array = {2, 9, 1, 4, 7, 6, 8, 5, 3};
+
+		int[] selectionSortArray = Arrays.copyOf(array, array.length);
+		selectionSort(selectionSortArray);
+		displayArray(selectionSortArray);
+
+		int[] insertSortArray = Arrays.copyOf(array, array.length);
+		insertSort(insertSortArray);
+		displayArray(insertSortArray);
+
+		int[] bubbleSortArray = Arrays.copyOf(array, array.length);
+		bubbleSort(bubbleSortArray);
+		displayArray(bubbleSortArray);
+
+	}
+
+	public static void bubbleSort(int[] array) {
+		for(int i=1; i<array.length; i++) {
+			boolean swapped = false;
+			for(int j=array.length-1; j >= i; j--) {
+				if(array[j-1] > array[j]) {
+					int currentNumber = array[j];
+					array[j] = array[j-1];
+					array[j-1] = currentNumber;
+					swapped = true;
+				}
+			}
+			if(!swapped) {
+				break;
+			}
+		}
+	}
+
+	public static void insertSort(int[] array) {
+		for(int i=1; i<array.length; i++) {
+			int currentNumber = array[i];
+			int j = i-1;
+			while(j >= 0 && array[j] > currentNumber) {
+				array[j+1] = array[j];
+				j--;
+			}
+			array[j+1] = currentNumber;
+		}
+	}
+
+	public static void selectionSort(int[] array) {
+		for(int i=0; i<array.length; i++) {
+			int iMin = i;
+			for(int j=i+1; j<array.length; j++) {
+				if(array[iMin] > array[j]) {
+					iMin = j;
+				}
+			}
+			if(iMin != i) {
+				int currentNumber = array[i];
+				array[i] = array[iMin];
+				array[iMin] = currentNumber;
+			}
+		}
+	}
+
+	public static void displayArray(int[] array) {
+		for (int i : array) {
+			System.out.print(i);
+		}
+		System.out.println();
+	}
+
+}