Slajdy k přednáškám předmětu. KIV/PPA1. Arnoštka Netrvalová

Transkript

1 Slajdy k přednáškám předmětu POČÍTAČE A PROGRAMOVÁNÍ 1 KIV/PPA1 Arnoštka Netrvalová 2016 Slidy jsou určeny studentům předmětu Počítače a programování 1 vyučovaného Katedrou informatiky a výpočetní techniky Fakulty aplikovaných věd Západočeské univerzity v Plzni jako doplněk a podpora přednášek. Jakékoliv jiné využití těchto slidů podléhá souhlasu autorky. Základním studijním materiálem je záznam přednášek z předmětu Počítače a programování vytvořený Pavlem Heroutem, jemuž za možnost využití materiálu tímto děkuji. A. Netrvalová

2 Obsah 1. přednášky: O předmětu Problém algoritmus program Java editace, překlad, spuštění Proměnná název, deklarace, typ Datové typy, typové konverze Operátory, výraz, příkaz, přiřazení Komentáře a dokumentace kódu Základní matematické funkce (Math) Generátor náhodných čísel (Random) Terminálový vstup (Scanner) Grafický nástroj DrawingTool Tato tematika je zpracována v Záznamy přednášek: str. 4-16, 18-31, Strana 2 (celkem 37)

3 O předmětu (podrobně portal.zcu.cz nutno přečíst) 1. Požadavky Absolvování + zisk bodů domácí úlohy (DÚ) písemný test (T) samostatná práce (SP) písemná zkouška (P) Něco se nepovedlo? stanoven min. a max. počet bodů z každé kategorie (DÚ, T, SP, on-line test ONL, P). možnost opravy bonusy (ACM úlohy, vybrané DÚ, SP rozšíření) Výsledná známka (součet bodů za celý semestr) 2. Kritéria hodnocení Kategorie Max. Min. Bonusy navíc Známka Bodů DÚ 18 9 DÚ T 25 7 SP SP 7 5 ACM ONL <50 P Min. 37!!! Strana 3 (celkem 37)

4 3. Etika, opisování a práce na zakázku Poradit není totéž, co opsat! DÚ, - kontrola shodnosti validovaných řešení SP, ACM - obhajoba T, P, ONL - kontrola identity, dozor Kontrola počtu získaných bodů: práce pod dohledem vs. práce ostatní. Definition of Academic Dishonesty Academic dishonesty is any action or attempted action that may result in creating an unfair academic advantage for yourself or an unfair academic advantage or disadvantage for any other member or members of the academic community. University of California, Berkeley Více o etice: portal.zcu.cz Studijní materiály Strana 4 (celkem 37)

5 Problém algoritmus program 1. Problém Definice (Slovník spisovného jazyka českého) Věc k řešení, nerozřešená sporná otázka, otázka k rozhodnutí, nesnadná věc Definice (informatika): Každý problém P je určen uspořádanou trojicí (vst; vyst; fce), kde: vst je množina přípustných vstupů vyst je množina očekávaných výstupů fce: vst vyst přiřazuje přípust. vstupu očekávaný výstup Příklad problému... nalezení cesty do hotelu, postup vaření těstovin, dostat se do autobusu č. 30, vypsání 5x Ahoj, Algoritmus Nejstarší známý algoritmus - starověký Egypt - nalezen v roce 1858 na tzv. Rhindově papyru (asi z r před n. l.): algoritmus násobení dvou přirozených čísel. Název algoritmus odvozen ze jména - Abú Jafar Muhammad Ibu Músa Al Khwarizmí (Chwárizmí, Chovarizmí, Choresmí) - významný perský matematik (cca 800 n.l.), autor díla Algoritmi de numeré Indorum (lat. překl.). Jméno bylo ve středověku latinizované na Al-Gorizmí. Algoritmus = obecný předpis sloužící pro řešení daného problému - posloupnost kroků doplněná jednoznačnými pravidly Strana 5 (celkem 37)

6 Vlastnosti: elementárnost determinovanost konečnost rezultativnost (efektivnost) hromadnost Přístupy k návrhu algoritmu (více viz 9. přednáška): dekompozice a abstrakce problému metodologie shora dolů a zdola nahoru. Prostředky pro zápis algoritmů: vývojový diagram pseudojazyk programovací jazyk Příklad problému, dekompozice a algoritmu Vypsání 5x Ahoj: - opakuj 5x výpis Ahoj - proveď dekompozici výpisu: - zjisti tvar příkazu pro výpis, vlož řetězec "Ahoj", příkaz zapiš 5x (lépe: použij cyklus) 3. Program - zápis algoritmu některým z uvedených prostředků Niklaus Wirth (* Winterthur, Švýcarsko) Vzdělání: University of California, Berkeley, USA (1963), Laval University, Canada (1960), Spolková vysoká technická škola v Curychu (1959) 1984Turingova cena za vývoj programovacích jazyků Algoritmus + datové struktury = program. Strana 6 (celkem 37)

7 Programovací jazyk syntaxe (pravidla) a sémantika (význam) strojově orientované vs. vyšší programovací jazyky Metody implementace: interpretační, kompilační Interpret editace zdrojový kód+vst. data interpret výst.data Kompilátor editace zdrojový kód kompilátor cílový program + vst.data výstupní data Programovací jazyky Algol, Simula, Cobol, Fortran, Basic, Pascal, Delphi, C, C++, C#, LISP, Java, Python, Prolog, ADA, SQL,... Java editace, překlad, spuštění Strana 7 (celkem 37)

8 Nezávislost na platformě bytecode Java Interpret Java Interpret... Java Interpret Windows Linux Solaris Java - historie James Gosling (*1954), Oak (1994) Java, 1995, Sun 2004 JDK 1.5 nové prvky jazyka 2006 JDK 1.6 žádné změny jazyka 2011 JDK 1.7 malé změny (parametr přepínače, formátovaný výstup, ) 2014 JDK 1.8 verze aktuální pro PPA1 (pro úvodní kurz PPA1 - žádné změny) Program v Javě jeden či více zdrojových souborů Jmeno.java překlad do vnitřní formy (bytekód) vznikne soubor Jmeno.class interpretaci provádí program java JVM (Java Virtual Machine) program využívá knihovny (Java Core API - Application Programming Interface) JVM + Java Core API = Java platforma program v Javě = třída(y) Strana 8 (celkem 37)

9 Vývojové prostředky JDK (Java Development Kit) + příkazová řádka SciTe Eclipse Instalace Javy dle návodů na portálu (vše ke stažení) nejprve instalace Javy pak Scite a Eclipse Další informace: Jak na první program v Javě? Zásady: program (zdrojový soubor) vytváříme v textovém editoru (Scite, NotePad, WordPad, PSPad), Eclipse název třídy začíná velkým písmenem, ve více slovném názvu začíná každé slovo velkým písmem, nepoužívá se podtržítko ani pomlčka, v názvu nesmí být mezera, třída tvoří blok {... více viz Konvence v Javě (str. 12) ukládaný zdrojový soubor musí mít název shodný s názvem třídy a to včetně malých a velkých písmen uložení zdrojového souboru s příponou *.java překlad: javac Pozdrav.java spuštění: java Pozdrav Strana 9 (celkem 37)

10 Příklad: Vytvořte program, který vypíše jednou slovo Ahoj. public class Pozdrav { public static void main(string[] args) { System.out.println("Ahoj"); Poznámka (bude vysvětlováno i později): modifikátor public přístupové právo k třídě, metodě, atributu Metoda public static void main(string[] args) je veřejná statická metoda, jejíž hlavička musí být zapsána shodně s výše uvedeným příkladem! Metoda main() nevrací žádnou hodnotu, její návratový typ je vždy(!) void (tj. prázdný ). Parametrem metody (metoda má název s počátečním malým písmenem, vyjadřující děj) je pole řetězců pojmenované args (může být i jinak) představující argumenty (možnost zadání vstupních dat z příkazové řádky, např. jméno souboru). Příkaz System.out.println("Ahoj"); je voláním metody pro výpis na obrazovku, metoda pracuje se standardním výstupem (out), patří do třídy System, která je připojena automaticky (není třeba import). Výraz "Ahoj" představuje řetězec, což je text uzavřený v řetězových závorkách, "" (toto je prázdný řetězec). Strana 10 (celkem 37)

11 Java a čeština public class PozdravČesky { public static void main(string[] args) { System.out.println("Ahoj světe!"); System.out.println("Žluťoučký kůň příšerně úpěl ďábelské ódy."); Java češtinu umí, češtinu ale nepoužívejte v programech ani v komentářích při ověřování DÚ na validátoru ZČU! Poznámka (jen pro začátečníky): A. Základní operace s obsahem paměťových míst 1. Uložení hodnoty - původní obsah buňky je přepsán, původní hodnota není dostupná. 2. Výběr hodnoty - obsah buňky je zachován, tj. výběr lze opakovat. 3. Přiřazení hodnoty buňky jiné buňce (operace 3), dochází ke kopírování obsahu do jedné či více buněk, přičemž se jejich původní obsah definitivně ztrácí. 4. Uložení hodnoty výsledku operace s obsahy dvou či více buněk (operace 4). Obsah výchozích buněk se nemění, obsah buňky, do které se uloží výsledek této operace, získává novou hodnotu. S obsahem výchozích buněk je možno dále pracovat. 5. Uložení výsledku operace s obsahy dvou či více buněk (operace 5) zpět do jedné z výchozích buněk. Podobně jako ve výše uvedených případech obsah této buňky získává novou hodnotu (např. inkrementace - zvětšení hodnoty o 1). Každé paměťové místo má svou vymezenou pozici je označeno adresou. Paměťovému místu je přidělována mnemotechnická zkratka shodná se jménem proměnné. Strana 11 (celkem 37)

12 paměťové místo, buňka, na adrese operace 3 uložení z x 1 x 2 a b sum c výběr operace 5 operace 4 B. Číselné soustavy a převody Příklad: desítková soustava Zápis celého čísla v soustavě o základu Z N a Zápis desetinné části 10 m 1 m m 1 Z am 2Z... a1z a0z 1 2 N a Z a Z... a 1 2 kde: Z základ, m počet řádových míst, a i koeficient n počet desetinných míst m Kapacita soustavy K Z Největší hodnota soustavy N Z m 1 Významné soustavy Základ Soustava Hodnoty 10 desítková (dekadická) 0,1,2,3,4,5,6,7,8,9 2 dvojková (binární), 0,1 8 osmičková (oktalová) 0,1,2,3,4,5,6,7 16 šestnáctková (hexadecimální) 0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F MAX nz n 0 Strana 12 (celkem 37)

13 Šestnáctková soustava: (A) 16 =(10) 10 (D) 16 =(13) 10 (B) 16 =(11) 10 (E) 16 =(14) 10 (C) 16 =(12) 10 (F) 16 =(15) 10 Převody převádíme odděleně část: celou (x c ) desetinnou (x d ) Příklad: převod dekadického čísla 25,625 = x (2) do dvojkové soustavy (k=2) x c x c /k x c mod k x d x d *k ,625 1, ,250 0, ,5 1, ,625 (10) = 11001,101 (2) Převody mezi soustavami o Z = 2 N (2) = 31 (8) (2) = 19 (16) Proměnná - název, deklarace, typ Proměnná = symbolicky pojmenovaný datový objekt v operační paměti Identifikátor název (jméno) proměnné, konstanty, metody, třídy... Pravidla pro zápis identifikátoru - neomezená délka - začíná písmenem, podtržítkem _ či dolarem $ - nesmí obsahovat operátory - nelze použít rezervovaná slova (tzv. klíčová slova jazyka) Strana 13 (celkem 37)

14 Konvence v Javě nutno dodržovat ( srozumitelnost kódu ) třídy začínají velkým písmenem (další slovo velkým) metody a proměnné začínají malým písmenem konstanty všechna písmena velká, podtržítka balíky pouze malá písmena Deklarace stanovení symbolického jména a datového typu inicializace (stanovení počáteční hodnoty) pojmenovaná konstanta (hodnota se nemění, final) Proměnné musí být při deklaraci přiřazen datový typ a před použitím hodnota (inicializace). Datové typy, konverze Datový typ = množina hodnot + množina operací primitivní datový typ číslo/znak/logická hodnota Poznámka1: primitivní datové typy (vždy malými písmeny) a jejich tzv. obalovací třídy (první písmeno velké): např. byte versus Byte Poznámka2: s datovými typy úzce souvisí problematika kódování (kódy pro celá čísla, reálná čísla, znaky, logické hodnoty) - bude předneseno na konci semestru! Číselné datové typy Číselné typy celá čísla Typ Rozsah byte short int long Strana 14 (celkem 37)

15 Číselné typy reálná čísla Typ Rozsah double 4.9E E308 float 1.4E E38 Konstanty tzv. literály Standardní číselné konstanty Double.POSITIVE_INFINITY (+ ) Double.NEGATIVE_INFINITY(- ) Double.NaN (Not a Number) Integer.MAX_VALUE (největší hodnota celočíselná) Byte.MIN_VALUE (nejmenší hodnota typu byte: -128) Double.MAX_VALUE (největší hodnota reálná), atd. Celočíselné konstanty zápis (od Java 1.7) implicitně typu int, jinak zadat typ: např. 1234L (1234l), 077L - long desítkové (posloupnost číslic, z nichž první nesmí být nula): např.: 5,128, 0, -6 osmičkové (číslice 0 následovaná číslicemi 0 až 7): např. 0123, 0, 07 šestnáctkové (číslice 0 následovaná znakem x či X a posloupnost 0 až 9, A až F či a až f): např. 0x56, 0x0, 0XCD, 0Xa dvojkové (číslice 0 následovaná znakem b či B a číslicemi 0 či 1): např. 0b1001, 0B101 (Java 1.7) Strana 15 (celkem 37)

16 Reálné konstanty zápis (mohou začínat a i končit desetinnou tečkou, obsahovat znaménka, exponenty, atd. ) jsou implicitně typu double: např. 1.,.2, 5e6, 0.0, -7E2, jinak zadat typ: např. 3.14F (3.14f), 1.F, 1e-4f - float Poznámka: od Java 1.7 podtržítko v numerických literálech (tzn. pouze mezi číslicemi) - oddělení číslic do skupin pro přehlednost: např. 1234_5678, 0b0010_0101, 0xFF_EC_DE_5E, 0_52 pozor ALE: _52 je identifikátor! Znakové typy a konstanty deklarace char - znaková konstanta je uzavřena v apostrofech, může být reprezentována: jedním znakem: např. 'A', '1', '%' posloupností '\uxxxx', kde XXXX reprezentují číslice šestnáctkové: např. '\u00e1' ~ 'á' escape sekvence: např. '\t ' ~ '\u0009' (tabulátor), '\\ ' ~ '\u005c' (zpětné lomítko - backslash) (více v Záznamy přednášek str. 28) Řetězcové konstanty String (řetězec) je v Javě třída, proto zatím budeme řetězce užívat pouze pro výstup, např. "tento retezec" a "tento" + "retezec" (pozor na typ uvozovek!) Logický typ a konstanty deklarace boolean hodnoty jsou dvě: true (logická 1), false (logická 0) Strana 16 (celkem 37)

17 Základní logické funkce && logický součin, logický součet,! negace A B A && B A B!A false false false false true false true false true true true false false true false true true true true false Poznámka datový typ výčet (Záznamy str. 66)* pro zájemce Konverze datových typů proměnné lze přiřadit jen hodnotu stejného typu - jinak přetypování: implicitní (automaticky) explicitní (nutno napsat), jen pro danou operaci, typ proměnné se trvale nezmění! Typy konverzí: identická - konverze na shodný typ rozšiřující - provádějí se implicitně a není nutné uvádět operátor přetypování zužující - při nich může dojít ke ztrátě informace a musí se provádět operátorem přetypování - jeho syntaxe je: (typ) operand převod základního datového typu na řetězec a naopak (viz přednáška: třída String). zakázaná konverze - obvykle nemá smysl (např. přetypování na void). Strana 17 (celkem 37)

18 Příklady konverzí číselných typů: double r, p; r = 3; // implicitni - rozsireni typu int i = 1; p = i; // implicitni p = (double) i; // lepe explicitne, je to umysl i = (int) r; // explicitni ztrata rozsahu i = (int) p + r; // chybne!!! i = (int) (p + r); // spravne Operátory, výraz, příkaz, přiřazení Operátory provádí operace s operandy (proměnné, konstanty,...) Typy operátorů: aritmetické relační logické bitové (např. >>,, &)* - použití je nad rámec PPA1 přiřazení Priority operátorů ++, -- *, /, % +, - <, <=, >, >= ==,!= && inkrementace (zvětšení obsahu o 1), dekrementace násobení, dělení (celočís., reálné), operace modulo sčítání, odčítání menší, menší či rovno, větší, větší či rovno je rovno, není rovno logický součin (AND) logický součet (OR) =, +=, -=, *=, /=, %= přirazení s operací (před rovnítkem) s operandem (vlevo) a opětné přiřazení do operandu (vlevo) Priority operací možno upravit použitím závorek! Strana 18 (celkem 37)

19 Výraz - předepisuje postup při výpočtu hodnoty určitého typu - skládá se z operandů (proměnné, konstanty, volání metod,...) a operátorů (+,-,*,/,...) Vyhodnocení výrazu: zleva doprava dle priorit Příkaz - jednotka vykonávání kódu, ukončení znakem ; Druhy příkazů: o o o o o prázdný (neprovádí nic, nejjednodušší) deklarativní (deklarace proměnné a její inicializace) výrazový (nejčastější- např. přiřazení, inkrementace, volání metody např. výpis hodnot proměnných) toku programu (určuje pořadí vykonávání příkazů) složený příkaz - blok Příkaz přiřazení nastaví hodnotu proměnné vlevo = (není to rovnice!) vypočtenou hodnotu můžeme přiřadit (vložit) do proměnné pouze stejného typu Příkaz přiřazení: proměnná = výraz; Blok - sekvence příkazů a deklarací lokálních proměnných (pravidla používání později) uzavřených do složených závorek {. Použití tam, kde je možno použít příkaz. Blok může být i prázdný, pak se chová stejně jako prázdný příkaz. Příkazy v bloku jsou vykonávány od prvního příkazu k poslednímu, pokud není ukončen předčasně. Strana 19 (celkem 37)

20 Příklad: Výměna obsahu dvou proměnných (jak jinak?) int a = 3; int b = 5; int pom =a; a = b; b = pom a = 3 b = 5 pom = 3 a = 5 b = 3 Příklad: Blok (lokální proměnná v bloku) int i = 1; { // vnitrni blok int i = 3; // i - lokalni promenna // konec bloku System.out.println("i = " + i); i = 1 Operace modulo % - zbytek po celočíselném dělení např.: 13 % 5 = 3 Příklad: Kolik plných plat lze naplnit daným počtem vajec a kolik vajec zbude? public class Vejce { public static void main(string [] args ){ int pocetvajec = 80; int velikostplata = 12; int pocetplat = pocetvajec/velikostplata; int zbytek = pocetvajec % velikostplata; System.out.println("Pocet plat = " + pocetplat); System.out.println("Zbyde " + zbytek + " vajec."); Pocet plat = 6 Zbyde 8 vajec. Strana 20 (celkem 37)

21 Příklad: Příkazy public class Prikazy { public static void main(string []args){ double suma = * 3.5; System.out.println("suma = " + suma); double delenec = 3; double delitel = 2; // ilustrace fce operatoru deleni // zakomentovat predchozi a odkomentovat nasledujici radek // int delitel = 2; double podil = delenec/ /*(double)*/ delitel; // po odkomentovani "(double)" bude deleni opet realne! System.out.println("podil = " + podil); int a = 1; int b = 3; int aminusbnadruhou = a*a - 2*a*b + b*b; System.out.println("(a-b)*(a-b) = " + aminusbnadruhou); double realne = Math.pow(a - b, 3) / (a + b); //reálné dělení System.out.println("realne = " + realne); int c = 4; int d = 5; double prumer = (a + b + c + d)/4.; //reálné dělení double median = (b + c)/2.0; System.out.println("prumer = " + prumer); System.out.println("median = " + median); suma = 8.0 podil = 1.5 (a-b)*(a-b) = 4 realne = -2.0 prumer = 3.25 median = 3.5 Strana 21 (celkem 37)

22 Příklad: Inkrementace (zvětšení hodnoty proměnné o 1) public class Inkrementace { public static void main(string [] args ){ int i = 1; System.out.println("i = " + i); i = i + 1; System.out.println("i = " + i); i += 1; System.out.println("i = " + i); i++; System.out.println("i = " + i); ++i; System.out.println("i = " + i); int sum = 0; //pozor na poradi operaci! i = 1; System.out.println("i = " + i + " sum = " + sum); sum = sum + i++; // zde System.out.println("i = " + i + " sum = " + sum); i = 1; sum = 0; System.out.println("i = " + i + " sum = " + sum); sum = sum + ++i; //zde System.out.println("i = " + i + " sum = " + sum); Důležitá poznámka k problematice dělení v Javě /... celočíselné vs. reálné i = 1 i = 2 i = 3 i = 4 i = 5 i = 1 sum = 0 i = 2 sum = 1 i = 1 sum = 0 i = 2 sum = 2 Oba operandy celočíselné celočíselné dělení, jinak reálné dělení, možnost přetypování! Strana 22 (celkem 37)

23 Komentáře a dokumentace - snazší orientace ve zdrojovém kódu Typy komentářů řádkový (do konce řádku) // text blokový (více řádek) /* text */ dokumentační /** dokumentace */ Co dokumentovat? nestandardní názvy proměnných nestandardní programové konstrukce metody třídy Vygenerování dokumentace (z příkazové řádky) program javadoc příkaz javadoc d mujdokument Jmeno.java založí adresář mujdokument s html soubory spustit Index.html Jméno autora (v dokumentaci a příkaz: javadoc author d mujdokument Jmeno.java Příkaz pro dokumentování více souborů: javadoc author d mujdokument *.java A pokud není užit modifikátor public: javadoc author private d mujdokument *.java Strana 23 (celkem 37)

24 Příklad dokumentace - pro již uvedený program Ahoj.java import java.io.*; // import netreba, jen pro ukazku - kam dokumentaci umistit /** *Vypis pozdravu Ahoj! netrvalo */ public class Ahoj { /** * Metoda main() - spousteni programu args pole retezcu argumentu - nevyuzito */ public static void main(string[] args) { /* prikaz volani metody println () vypise text Ahoj! */ // toto byl blokovy komentar System.out.println("Ahoj!"); // vypis Ahoj! Vygenerování dokumentace příkazová řádka - generuje se do adresáře s názvem doc volbou -d: javadoc d doc Ahoj.java - vygeneruje se i se jménem autora: javadoc author d doc Ahoj.java Strana 24 (celkem 37)

25 Zobrazení dokumentace k programu: Strana 25 (celkem 37)

26 Poznámka: Vývojové prostředí Eclipse generování automaticky (volbou z menu), nutno nastavit cestu k javadoc.exe. Strana 26 (celkem 37)

27 Základní matematické funkce Standardní funkce (Třída Math) - viz Java Core API mocnina druhá odmocnina goniometrické funkce logaritmus exponenciální fce Konstanty - π, e Příklady použití konstant a standard. funkcí: double pi = Math.PI; // double e = Math.E; // Math.exp(1); int a =3, b = 4; double prepona = Math.sqrt(Math.pow(a,2)+b*b); // 5 double v = Math.pow(Math.sin(1),2)+Math.pow(Math.cos(1),2); // 1 double logaritmusdes = Math.log10(100); // 2 double logaritmuspriroz = Math.log(Math.E); // 1 double nahodnecislox = Math.random(); // 0.0 X 1.0 Příklad: Minimum ze tří čísel // minimum ze 3 cisel int a = 1, b = 2, c = 3 ; int min = Math.min (Math.min (a, b),c); System.out.println("min = " + min); min = 1 Strana 27 (celkem 37)

28 Příklad: Vzdálenost dvou bodů v rovině v 2 x x y y2 int x1 = 0, y1 = 0; int x2 = 1, y2 = 1; double v = Math.sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2)); System.out.println("v = " + v); v = 1,41... /* lepe: int rx = x1 - x2; int ry = y1 - y2; v = Math.sqrt(rX*rX + ry*ry); // v = Math.sqrt(Math.pow(rX,2) + Math.pow(rY,2)); */ Příklad: Výpočet plochy kruhu s pomocí Math public class VypocetPlochyMath { public static void main(string [] args) { int polomer = 1; double plocha = Math.pow(polomer,2)*Math.PI; System.out.println("P("+polomer+")="+plocha); // vypocet dalsi plochy polomer = 2; plocha = Math.pow(polomer,2)*Math.PI; System.out.println("P("+polomer+")="+plocha); P(1)= P(2)= Strana 28 (celkem 37)

29 Příklad: Přehled často používaných metod třídy Math public class StandardniFce { // dalsi fce - viz dokumentace Javy public static void main(string[] arg){ int a = 2, b = 3; int d = a - b; System.out.println("d = " + d); System.out.println("a = " + a + ": a^2 = " + a * a); System.out.println(("a = " + a + ": a^7 = " + Math.pow (a,7)); System.out.println("vysledek a^7 jako cele cislo = " + (int) Math.pow (a,7)); System.out.println("mensi ze dvou cisel (" + a + "," + b + ") = " + Math.min (a,b) ); int c = 4; System.out.println("odmocnina z " + c + " = " + Math.sqrt(c)); System.out.println("treti odmocnina z 27 = " + Math.cbrt (27)); double p = , r = ; System.out.println("cela cast " + p + " = " + Math.round(p)); System.out.println("nejmensi cele cislo vetsi nez p = " + (int)math.ceil (p)); System.out.println("nejmensi cele cislo mensi nez p = " + (int)math.floor (p)); System.out.println("cele cislo = " + (int)math.rint (p)); System.out.println("cele cislo = " + (int)math.rint (123.5)); System.out.println("desetinna cast = " + (p-math.round(p))); System.out.println("abs.hodnota z " + r + " = " + Math.abs(r)); System.out.println("realne nahodne cislo = " + Math.random()); int m = 10, n = 1; System.out.println("cele nahodne cislo c = " + (int) (Math.random()*m + n)); System.out.println("pi = " + Math.PI); System.out.println("oriznute pi = " + (double)(int)(math.pi *100)/100); // lépe pouzit formatovany vystup d = -1 a = 2: a^2 = 4 a = 2: a^7 = vysledek a^7 jako cele cislo = 128 mensi ze dvou cisel (2,3) = 2 odmocnina z 4 = 2.0 treti odmocnina z 27 = 3.0 cela cast = 123 nejmensi cele cislo vetsi nez p = 124 nejmensi cele cislo mensi nez p = 123 cele cislo = 123 cele cislo = 124 desetinna cast = abs.hodnota z = realne nahodne cislo = cele nahodne cislo c = 10 pi = oriznute pi = 3.14 Strana 29 (celkem 37)

30 Generátor náhodných čísel (pseudo)náhodná čísla (celá, reálná): třída Random nutný import balíčku java.util inicializace = vytvoření objektu import java.util.*; public class NahodnaCisla { static private Random r = new Random(); // inicializace // static privaterandom r = new Random(1); // stale stejna posloupnost public static void main (String[]args) { // Random r = new Random(); // tez funkcni, ale lepe takto double realne = r.nextdouble(); // nema parametr int rozsah = 10; // tj. 0,1,2,3,4,5,6,7,8,9 int cele = r.nextint(rozsah); // muze mit parametr System.out.println("" + realne + " : " + cele); long velkecele = r.nextlong(); System.out.println("" + velkecele); // nema parametr : Poznámka: r je proměnná - reference třídy Random nextint() - metoda vrací náhodné celé číslo typu int nextint(celecislo) vrací náhodné celé číslo v rozsahu 0, celecislo-1 nextdouble() je metoda třídy Random vracející náhodné reálné číslo 0.0, 1.0 Náhodné číslo (třída Math) už známe Math.random() reálné číslo z intervalu (0.0, 1.0 Strana 30 (celkem 37)

31 Terminálový vstup (z klávesnice) od JDK jednoduché řešení - třída Scanner, použitelné i pro soubory (bude uvedeno později), postupujeme obdobně jako u třídy Random - import balíčku java.util - inicializace, vytvoření objektu (new) - nutno řešit lokalizaci (. vs., v reálném čísle) - používá metody: nextint(), nextdouble(), next(), nextline() Příklad: Načti dvě čísla (reálné, celé) a spočti jejich průměr. import java.util.*; public class VstupScanner { private static Scanner sc = new Scanner(System.in); public static void main(string [] args) { //Scanner sc = new Scanner(System.in); sc.uselocale(locale.us); // lokalizace! System.out.print("Zadej 1. cislo realne: "); double cislo1 = sc.nextdouble(); System.out.println("Zadano bylo: " + cislo1); System.out.print("Zadej 2. cislo cele: "); int cislo2 = sc.nextint(); System.out.println("Zadano bylo: " + cislo2); double prumer = (cislo1 + cislo2)/2; System.out.println("Prumer = " + prumer); Zadej 1. cislo realne: 12.3 Zadano bylo: 12.3 Zadej 2. cislo cele: 12 Zadano bylo: 12 Prumer = Strana 31 (celkem 37)

32 Příklad (problém vyprázdnění vstupu) import java.util.*; public class VyprazdneniVstupu { private static Scanner sc = new Scanner(System.in); public static void main(string [] args) { sc.uselocale(locale.us); System.out.print("Zadej cele cislo: "); int cislo = sc.nextint(); System.out.println("Zadano bylo: " + cislo); System.out.print("Zadej realne cislo: "); double realne = sc.nextdouble(); System.out.println("Zadano bylo: " + realne); sc.nextline(); //zakomentovanim vznikne chyba // docteni radky <cr> a <lf> - vyprazdneni vstupu System.out.print("Zadej vetu: "); String veta = sc.nextline(); System.out.println("Zadano bylo: " + veta); System.out.print("Zadej znak: "); char znak = sc.next().charat(0); System.out.println("Zadano bylo: " + znak); System.out.print("Zadej slovo: "); String slovo = sc.next(); System.out.println("Zadano bylo: " + slovo); Strana 32 (celkem 37)

33 Výstup programu: Bez zakomentování Zadej cele cislo: 12 Zadano bylo: 12 Zadej realne cislo: 12.2 Zadano bylo: 12.2 Zadej vetu: Jak se mas? Zadano bylo: Jak se mas? Zadej znak: w Zadano bylo: w Zadej slovo: lepidlo Zadano bylo: lepidlo Se zakomentováním Zadej cele cislo: 12 Zadano bylo: 12 Zadej realne cislo: 12.2 Zadano bylo: 12.2 Zadej vetu: Zadano bylo: Zadej znak: w Zadano bylo: w Zadej slovo: lepidlo Zadano bylo: lepidlo Upozornění: Metody nextint(), nextdouble() a next() jsou tzv. žravé přečtou a zlikvidují všechny bílé znaky (mezera, znaky konce řádky, tabulátor) před prvním nebílým znakem, čtení skončí na prvním bílém znaku, tento znak však zůstává (tj. není požrán ) ve vyrovnávací paměti (buffer) Řešení - před použitím metody nextline() vyprázdnit vstup příkazem sc.nextline() Pozor ale: metoda nextline() není žravá, ale zato zlikviduje znaky konce řádky, proto se za ní nesmí použít příkaz sc.nextline()! Vyprázdnění vstupu bývá častou chybou! Strana 33 (celkem 37)

34 Správné použití třídy Scanner public class PouzitiScanneru{ static private Scanner sc = new Scanner(System.in); public static void main (String [] args) { int a = sc.nextint(); Takto budeme Scanner používat při vícenásobném volání (např. v main (), v cyklu, či v jiné metodě) více bude vysvětleno později. Poznámka: Vstup s využitím argumentů (tj. parametrů příkazové řádky) public class VstupArgumenty { // cisla zadana jako parametry na prikazove radce public static void main(string[] args) { int a = Integer.parseInt(args[0]); //1. argument // metoda Integer.parseInt () - prevod retezce na cele cislo System.out.print(" a = " + a); int b = Integer.parseInt(args[1]); //2. argument System.out.print(" b = " + b); int suma = a + b; System.out.println("suma = " + suma); Metoda parseint()převádí řetězec na celé číslo (bude vysvětleno až se třídou String), později kód ještě doplníme o test existence argumentů (parametrů). Strana 34 (celkem 37)

35 Grafický nástroj DrawingTool 1 vytvořen pro PPA2 pouze pro kreslení fraktálů (cílem nebylo, a ani teď není, vytvořit kreslicí utilitu!) umí nakreslit čáru z bodu do bodu počátek grafického souřadného systému 0,0 je v levém horním rohu (pracuje se s pixely) soubor DrawingTool.java musí být uložen ve stejném adresáři s naší aplikací (DrawingTool je v podstatě samostatná třída, kterou náš program používá) aplikace musí mít na 1. řádku příkaz: import.java.awt.*; Příklad použití na cvičení Soubor DrawingTool.java a aplikace Kreslení.java překlad: javac *.java // *.java -prelozi se obe tridy spuštění: java Kresleni Úloha: Nakreslete úhlopříčku vedoucí z levého horního do pravého dolního rohu černou barvou na bílém pozadí v okně s rozměry 300x Ing. Roman Tesař (příklady studenti doktorského studia na KIV), pro předmět PPA2. Strana 35 (celkem 37)

36 import java.awt.*; public class Kresleni { public static void main(string[] args) { /* nejprve inicializace objektu: sirka = 300, vyska = 200, barva pozadi = bila DrawingTool je typ, dt je reference na objekt DrawingTool, Color je trida balicku java.awt pro kresleni, WHITE je konstanta tridy Color */ DrawingTool dt = new DrawingTool(300, 200, Color.WHITE, true); /* nastaveni barvy cary na cernou: setcolor() je metoda tridy DrawingTool, BLACK je konstanta */ dt.setcolor(color.black); /* nakresleni uhlopricky z leveho horniho rohu [0, 0] do praveho dolniho rohu [300-1, 200-1] */ dt.line(0, 0, 299, 199); // metoda tridy DrawingTool kresli caru Výstup: Strana 36 (celkem 37)

37 Příklad: Výpočet přepony, obvodu a obsahu pravoúhlého trojúhelníka, jsou-li dány odvěsny. import java.util.* ; /** * Vypocet prepony, obvodu a obsahu pravouhleho trojuhelnika, * jsou-li dany odvesny netrvalo */ public class PravouhlyTrojuhelnik { private static Scanner sc = new Scanner (System.in); /** * Metoda main() - spousteni programu args pole retezcu argumentu - nevyuzito */ public static void main(string[] args) { sc.uselocale(locale.us); System.out.print("Nacti odvesnu a = "); double a = sc.nextdouble(); System.out.print("Nacti odvesnu b = "); double b = sc.nextdouble(); double c = Math.sqrt(Math.pow(a,2) + Math.pow(b,2)) // rychleji: Math.sqrt(a*a + b*b); double obvod = a + b + c; double obsah = a*b/2; System.out.println(Trojuhelnik: "); System.out.println("a, b, c: " + a + ", " + b + ", " + c); System.out.println("O = " + obvod ); System.out.println("P = " + obsah ); Nacti odvesnu a = 3 Nacti odvesnu b = 4 Trojuhelnik: a, b, c: 3.0, 4.0, 5.0 O = 12.0 P = 6.0 Strana 37 (celkem 37)