Proč Java jednotný, univerzální jazyk ( ne však vhodný pro cokoli ) definovaný specifikací: je to především norma, pak i produkty rozsáhlý, otevřený, rozvíjející se, s návaznými technologiemi právně chráněný normotvorný - zavádí užitečné normy a uzance expanzivní, od r. 1995 vykázal nevídaný rozmach velmi efektivní při tvorbě software spolehlivý, robustní, velmi dobře dokumentovaný portabilní, ( Windows / Linux / Solaris ...) bezpečný deterministický - úlohy končí či havarují určitelným způsobem silně objektový – avšak hybridní - obsahuje i primitivní typy síťový Internetový, internacionální a návazný na nativní platformu multithreadový - více vláken (tj.úkolů) běží [jakoby] současně interpretovaný - s adaptací pro platformu ( JIT ) vhodný i pro úvod do objektového programování zdarma C00

Java & IDE Tvůrcem a vlastníkem práv je fa. Sun Microsystems a Oracle, která vydává JavaSE, JavaEE, JavaME a další produkty po verzích - zdarma stáhnutelné z: http://java.oracle.com/ resp. http://www.netbeans.org 1.0 - 1995, 1.1 - delegační model událostí, 1.2 - JFC, 1.3 - API, 1.4 - assert 1.5 - 2004: rozšíření jazyka: for, enum, autoboxing, generika, anotace 1.6 - 2006: rozšíření API, 1.7 - 2011: rozšíření čísla, switch, try, catch, diamond 1.8 - 2014: funkcionální interfejsy, ->, :: , default metody, lambda výrazy jre - Java Runtime Environment ( bez vývojových prostředků ) obsahuje JVM ale nikoli IDE, databázi či aplikační server. S Javou lze pracovat velmi nepohodlně řádkově s programy v jdk1.8**/bin/ javac A.java B.java ... kompilace zdrojů .java na .class java A běh aplikace dané třídy java -jar appletviewer A.html tester apletů javadoc … tvorba dokumentace, tzv. docletů v html či velmi pohodlně a bezpečně ve vyspělých IDE: Netbeans – 8.0 April 2014 Eclipse - IBM, JBuilder - Borland, IntelliJIDEA - JetBrains ... C00

Podpora Javy Sun Microsystems velmi podporuje Javu tím, že vydává: různé softwarové svazky – ke stažení a instalaci lze doporučit: http://java.sun.com/javase/downloads/index.jsp ke každé hlavní verzi dokumentaci ve formě html stránek. Ta obsahuje zejména popis API, který je radno připojit nerozzipovaný IDE. Viz: http://java.sun.com/docs/ http://download.oracle.com/javase/7/docs/ tématické tutoriály: http://java.sun.com/docs/books/tutorial/index.html http://java.sun.com/docs/books/jls - Java specification 3rd edition popisuje i verze >= 1.5 Zakhour, S. et al.: Java 6 výukový kurz, Computer Press, Brno, 2007, s. 534, ISBN 978-80-251-1575-6 http://www.saeedsh.com/resources/Thinking%20in%20Java%204th%20Ed.pdf C00

Dodržujte jmenné konvence Prosté jméno je posloupnost znaků UNICODE: písmen, $ _ číslic jež nezačíná číslicí a není klíčovým slovem. Jména volte mnemotechnická, nejlépe z kódu ASCII a anglická. S podtržítkem a dolarem šetřte : podtržítko se užívá ve víceslovných konstantách, dolar v automatické generaci kódu. Kvalifikované jméno obsahuje uvnitř také tečky. UJmenSloženýchZVíceslovDodržujteVelbloudíKonvenciKvůliČitelnosti. package ( balíček ) - jen malá písmena, číslice a tečka, např.: projekt1 projekt2.util java.util.zip class ( třída ) - a její konstruktory - podstatné jméno začínající velkým písmenem, např.: String FileInputStream BankAccount Rectangle2D.Double - pro vnořené či vnitřní třídy Třídy výjimek / chyb vyznačujte sufixem Exception / Error, např.: MySpecialException CommonStrangeError C00

Dodržujte jmenné konvence interface ( rozhraní ) - přídavné jméno začínající velkým písmenem, ( což se přetěžko hledá a dodržuje ) např.: Comparable Serializable Cloneable Runnable Readable Iterable AutoCloseable Scrollable method ( metoda ) - sloveso začínající malým písmenem, např.: reset( ) getX( ) parseDouble( ) compareTo( ) vrací-li typ boolean, vhodný je prefix is nebo has isLetterOrDigit( ) hasNextElement( ) variable ( proměnná ) – podstatné jméno začínající malým písmenem: j counter totalTax currentFrequency final variable ( konstanta ) a návěští: - jen velká písmena, číslice a podtržítka, např.: PI MAX_VALUE POINT_123 CYCLE3 Bezejmenné jsou: hodnoty, výrazy, příkazy, objekty. C00

Primitivní typy ( 8+1 ) Typ Formát - dle normy IEEE 754 Obalové (wrap) třídy bit Celá čísla - dvojkový komplement se znaménkem byte 8 -128 … 127 Byte short 16 -32768 … 32767 Short int 32 -2147483648 … 2147483647 ( 2.1E+9 = 2.1 miliard ) Integer long 64 -9223372036854775808 … 9223372036854775807 Long ( 9.2E+18 = 9.2 trilionů /EU = 9.2 quintillions /US) char 16 znaky Unicode '\u0000‘ … '\uffff' ~ 0 ... 65535 Character jsou ale v přímém dvojkovém kódu bez znaménka Reálná čísla - s exponentem a mantisou float 32 2-149 … ( 2-2-23 )*2127, +/-0.0F, pos/neg Infinity, NaN Float Float.MIN = +1.4E-45 Float.MAX = 3.4028235E+38 double 64 2-1074… ( 2-2-52 )*21023, +/-0.0, pos/neg Infinity, NaN Double Double.MIN = +4.9E-324 Double.MAX = 1.7976931348623157E+308 boolean ? true false Boolean void pomocný prázdný typ Void C00

Konverze primitivních typů Primitivní typy jsou vzájemně nekompatibilní, ale jejich hodnoty lze převádět. 8 rozšíření ( widening ) znaménkový bit 0 je + 1 je - se rozšiřuje byte zúžení ( narrowing ) přetypování celočíselných hodnot odkrojí horní bity, znaménkem se stane nejvyšší z dolních char 16 16 short 32 int minimální aritmetika 64 omezení do intervalu long / int <MAX_VALUE, MIN_VALUE> long IEEE 754 32 float exp mantissa (+127 ) 64 1 8 23 double exp mantissa IEEE 754 (+1023 ) 1 11 52 C00

Integrální aritmetika int a long 000..0111 7 n/0 či n%0 způsobí ArithmeticException + Sudá čísla končí n nulami a jsou dělitelná 2n. znaménkový bit Lichá čísla končí jedničkou. pro lichá n<0 : n/2 != n>>1 důsledek: -1>> == -1 2 000..0010 1 000..0001 011..1111 MAX_VALUE overflow 000..0000 100..0000 MIN_VALUE -1 111..1111 100..0001 MIN_VALUE+1 -2 111..1110 MAX+1 -> MIN k * MAX -> - k k * MAX -> MAX-k+1 MAX * MAX -> 1 MIN-1 -> MAX MIN * k -> 0 MIN * k -> MIN MIN == - MIN MAX + MIN -> -1 MIN / -1 -> MIN -3 111..1101 pro sudé k pro liché k -7 111..1001 chybné výpočty -8 111..1000 pro sudé k - negace: - n = ~ n + 1 pro liché k ~ inverze: 0 -> 1, 1 -> 0 -> true - samonegace: - n = n - inverze znaménka C00 Hádanky: n&-n, n&=n-1, n^=n&-n,

Numerické literály Obsahuje-li literál jen číslice a případně znaménko ukládá se jako int, se sufixem L jako long. Vyjadřuje jen celá čísla zapsána jako: dekadicky [ + | - ] 10289 [ L ] oktalově [ + | - ] 000567 [ L ] hexadecimálně [ + | - ] 0x012DEF [ L ] binárně [ + | - ] 0b0101 [ L ] Vložit hodnotu do typu byte či short lze jen s přetypováním, např.: byte b = ( byte ) 0xFF; // má hodnotu -1 . int i = b; // Obsahuje-li literál tečku či exponent, ukládá se jako double. Sufix F či D vynutí typ float či double . Např.: 123.0, 0123., .5, +123.45, -00123e2, -123e2, 12300e-2, -123.0F , 0123.f, .5F, +123.45e+3F, 125D, -333f apod. Písmena v literálech mohou být libovolně velká či malá. Mezi číslice lze pro čitelnost vložit podtržítka, např: -10_289, 5.123_789, 0x0123_ABCD, 0b1111_11111__0000_0000 C00

Operátory aritmetik integrální a „reálné“ Pro typy int a long ( byte, short, char se převedou na int ) lze užít: ++ -- inkrementace tj. přičtení 1, dekrementace tj. odečtení 1, + - * sčítání či unární plus, odčítání či negaci, násobení, Přetečení přitom se nijak nehlásí ! / % dělení, modulo tj. zbytek po dělení Jsou-li oba a operandy int, long dojde na integrální dělení a je-li dělitel nula, vyhodí se ArithmeticException ! << >> >>> dva aritmetické posuny a logický posun Posun >> o n bitů je dělení floor( x/2 ) i pro x < 0 & | ^ ~ po bitech: AND OR XOR INVERZE Pro typy float a double : + - * / % Nevyhazuje žádné výjimky, avšak zahrnuje tři speciální hodnoty: NaN - Not a Number, tj. nečíslo nebo neurčitý výraz POSITIVE_INFINITY NEGATIVE_INFINITY S těmito hodnotami lze provádět další operace, avšak již nelze získat opravdové číslo. Krom x != NaN je každé porovnání s NaN vždy false. HW HW HW n HW HW C00

Další operátory = přiřazení += -= *= /= %= <<= >>= >>>= &= ^= |= aktualizace a pak přiřazení Např. pro int i = 0, i += 2 odpovídá i = (int) (i+2) a tedy i += 2.9 je ekvivalentní i += 2. ++ -- in/de –krement je buď prefixní či sufixní, což znamená: ++x == x=x+1, --x == x=x-1, x++ == (x=x+1)-1, x-- == (x=x-1)+1 aktualizace a pak užití užití původní hodnoty a pak aktualizace << >> aritmetické posuny int / long o 0 .. 31 / 63 bitů vlevo / vpravo, >>> logický posun vpravo ( zleva se přidávají nuly ) přičemž hodnota posunu se maskuje 0b1_1111 / 0b11_1111 + zřetězení – je-li alespoň jeden z operandů řetěz instanceof - test referenčního typu vrací hodnotu boolean ( datový typ ) - přetypování HW HW HW C00 ALG

Komparace Výsledkem porovnání je logická hodnota ( true, false ). Porovnání primitivních typů: == != rovno, nerovno, > >= větší než, větší nebo rovno, < <= menší než, menší nebo rovno, <> - tzv. diamond, symbol generické inference ( vnesení ) nikoli != . Ku podivu lze ho psát i jako < > . Test identity referenčních typů je pouhý test referencí: == != nikoli hodnot objektů. Objekty, tj. jejich hodnoty, se porovnají metodami v patřičné třídě, typicky: boolean equals( Object o ) - java.lang.Object int compare( … o1, … o2 ) … dle typu 8 obalových tříd int compareTo( Object o ) - java.lang.Comparable int compare( Object o1, Object o2 ) - java.util.Comparator int compare( Object o1, Object o2, Comparator c ) - java.util.Objects C00

Bitové a logické operátory Bitové a logické unární operátory: sestupně podle priority: ! pro negaci typu boolean ~ pro bitovou inverzi celého čísla Logické binární operátory: Operandy musejí být buď oba celočíselné anebo oba boolean. & pro AND, | pro OR , ^ pro XOR Pro zkrácené vyhodnocení typů boolean: && pro AND, || pro OR Je-li výsledek dán prvním operandem, zbytek výrazu se nevyhodnocuje. Pozor na vedlejší efekty, je-li dalším operandem např. volání metody. Pozor na nizší priority && a || : false && true | true dá false false && true || true dá true ( false && true ) | true dá true HW C00

Ternární výraz je podmíněný - vrátí jednu ze dvou hodnot dle podmínky podmínka ? hodnotaProTrue : hodnotaProFalse První operand musí být typu boolean. Druhý a třetí operand mohou být různých typů. Podmíněný operátor je zprava asociativní, tedy: a ? b : c ? d : e ? f : g odpovídá a ? b : ( c ? d : ( e ? f : g ) ) Příklad užití: int abs( int i ) { return i >= 0 ? i : - i ; } Object o = cond ? 1.23 : "ABC" ; System.out.print( cond ? new Thread( ) : "ABC" ); C00

Priorita a asociativita operátorů 1. ++ -- ++ -- unární operátory prefixní resp. sufixní + - ~ ! (datový typ) unární operátory * / % násobení, dělení, modulo - + binární operátory, + také pro zřetězení << >> >>> posuny aritmetické a posun logický < > <= >= instanceof porovnání primitivních hodnot a typu == != primitivních i referenčních hodnot & AND bitový, logický ^ XOR bitový, logický | OR bitový, logický && AND logický zkrácený || OR logický zkrácený ? ternární operátor primitivní či referenční hodnota = += -= *= /= %= <<= >>= >>>= &= ^= |= s následným přiřazením kde: levá asociativita: a / b * c je ( a / b ) * c pravá asociativita: - ++a je - ( ++ a ), a = b = c je a = (b = c) C00

Složené přiřazovací operátory += -= = /= = <<= >>= >>>= &= ^= |= jsou zkratky zápisu, např. pro int resp. String s lze napsat výraz: i += 2 místo i = i + 2 resp. s += “XYZ” místo s = s + “XYZ” Hodnotou operace přiřazení je hodnota proměnné po provedeném přiřazení a proto je následující příklad chybný: double d; int i = d = 10; // Error: possible loss of precision: double, required int Java 8 zavádí další symboly: -> šipka („arrow token“) typová inference (vnesení, úsudek, vyvození) :: reference metod a konstruktorů C00

Výrazy jen s literály a operátory vyhodnotí již kompilátor. Vyhodnocení výrazu se provádí v zásobníkovém automatu. Např. výraz: x = – 1 + ( 2 << 3 ) * 4 / ( 5 – 6 ) infix forma x 1 – 2 3 << 4 * 5 6 – / + = postfix forma (polish reversal) Zásobník (horizontální): x 1 – x –1 2 3 << x –1 16 4 * x –1 64 5 6 – x –1 64 –1 / x –1 –64 + x –65 = x = –65 –65 uložení do x = 7 pořadí 1 2 3 4 5 6 7 x + 6 1 – / 1 5 reference hodnota bi-operátor un-operátor závorka 1 * 3 – 4 << 4 5 6 2 2 3 syntaktický strom Výrazy jen s literály a operátory vyhodnotí již kompilátor. C00

Vyhodnocení potrhlého výrazu 8*(x*x+x) x*=x+++x+++1<<+1+1 infix forma x = x * ( ( x=x+1 ) –1 + ( x=x+1 ) –1 +1 << +1 +1 ) infix rozepsaně x x x x 1 + = 1 – x x 1 + = + 1 – 1 + 1 + 1 + << * = postfix forma x = 3 x 3 x 3 1 + x 3 x 4 = x = 4 x 3 4 1 – x 3 3 x 4 1 + x 3 3 x 5 = x = 5 x 3 3 5 + x 3 8 1 – x 3 7 1 + x 3 8 1 + x 3 8 1 1 + x 3 8 2 << x 3 32 * x 96 = x = 96 96 = x 96 * x 32 3 << + 2 8 + _ 1 + 1 + _ 1 3 1 = = reference hodnota bi-operátor un-operátor závorka 1 4 5 x + x + 3 4 x 1 x 1 syntaktický strom C00

Použití obalových tříd int iMax = Integer.MAX_VALUE; // zjištění max. hodnoty int k = Integer.parseInt( "123" ); // konverze řetěz - číslo String s = Integer.toHexString( k ); // konverze do hexa Integer i = new Integer( "123" ); // konverze řetěz - číslo int i = Integer.compare( 3, 5 ); // komparace // obdobně pro typy byte, short, long double dMax = Double.MAX_VALUE; // zjištění max. hodnoty double x = Double.parseDouble( "-123.45" ); // konverze řetěz - číslo boolean b = Double.isNaN(x); // test na nečíslo int i = Double.compare( 3.0, 5.0 ); // komparace // obdobně pro typ float char c = Character.toLowerCase( 'Z' ); // převod znaku boolean b = Character.isLetterOrDigit( '@' ); // je to písmeno / číslice? int i = Character.digit( ''f" , 16 ); // hexadec. hodnota znaku Tzv. autoboxing automaticky za/roz-baluje primitivní typy do/z příslušných obalových objektů, např.: Double dd=2.71; double d=dd; C00

Třídy pro matematické operace Pro typy int, long, float a double třída java.lang.Math obsahuje konstanty PI=3.14… a E=2.71… a statické funkce: abs, min, max, sqrt, cbrt, pow, exp, log, ceil, floor, random, sin, sinh, asin, tan, tanh, atan, toDegrees, toRadians, hypot … a další. Od verze 8 pro typy int, long: addExact, subtractExact, negateExact, multiplyExact, increaseExact, decreaseExact, které vyhazují ArithmeticException při přetečení výsledku. java.lang.StrictMath je identická strictfp – dodržuje přesně normu IEEE 754, byť by hardware umožňovalo více. Pro čísla s libovolným rozsahem a přesností: java.math.BigInteger - pro celá čísla java.math.BigDecimal - pro desetinná racionální čísla Výpočty se provádějí pouze metodami - nikoli operátory. C00 ALG

Literály Logický: true a false . Typový: je typu Class a lze tedy přiřadit např.: Class x = int.class, int[ ].class, Point.class, Point[ ][ ].class, Comparable.class, apod. Znakový: 16-ti bitový znak Unicodu v apostrofech např.: ' ' = 0x0020 = 32, '0' = 0x0030 = 48, 'A' = 0x0041 = 65, 'a' = 0x0061 = 97 Též pomocí escape chars: '\'' '\\' '\uCafe' ale: \n či \r\n. Řetězový: posloupnost znaků Unicodu ( i prázdná ) v uvozovkách např.: "Abc123" "Řeřicha" "@" "" "My \uCafe \101 Tea \n " . Je to objekt typu java.lang.String a lze volat metody třídy String. Escape chars (ASCII): \’ \" \\ \r \n \f \t \b \ooo \uhhhh pro: apostrof 0x27 = 39, uvozovku 0x22 = 34, backslash 0x2F = 47, carriage return (CR 0x0D), line feed (LF 0x0A), form feed (FF 0x0C), horiz. tabulator (HT 0x09), backspace (BS 0x08), o - octal, h - hexadec C00

Unicode – viz www.unicode.org kóduje světové symboly na 16-ti bitech (čínské znaky na 21 bitech) takto: stránka_znak v rozsahu: 0x00_00 – 0xFF_FF ( = 0 – 65535 ), 00 – ASCII angličtina, 01 – Latin1 – jazyky románské, germánské, 02 – Latin2 – slovanské, ugrofinské, baltické, 03 – řečtina, 04 – kyrilice, 05 – arménština, hebrejština, 06 - arabština … E0 – F8 ConScript Unicode Registry … F8D0 – F8FF klingonština (plaqaD) ASCII 7: 0x00_00 – 0x00_7F ( = 0-127 ), 00-1F (=0-31) řídící znaky 20 (=32) mezera binárně: 010_0000 … !"#$%&'()*+,-./ 30-39 (=48-57), číslice ‘0’ – ’9’ binárně: 011_0000 - 011_1001 … :;<=>?@ 41-5A (=65-90), písmena ‘A’ – ’Z’ binárně: 100_0001 - 101_1010 … [\]^_` 61-7A (=97-122), písmena ‘a’ – ’z’ binárně: 110_0001 - 111_1010 … -7F {|}~ C00

Klíčová slova a reservované literály literály: logické: false true referenční: null typy: primitivní[8]: boolean byte short int long char float double řídící příkazy: if else for do while break continue switch case default return pro výjimky a chyby: throw try catch finally assert operátory: instanceof new this super strukturální: package import import static class enum interface extends implements modifikátory: přístupu: public protected friend se nepíše private atributů, metod, tříd: final static metod, tříd, interfejsů: abstract static strictfp metod: native void throws default* metod, bloků: synchronized atributů: transient volatile nefunkční: const goto Toto rozdělení neodpovídá zcela přesně specifikaci Javy. * - Java 8 C00

Základní konstrukty (1/3) [ public | protected | private ] [ static ] [ transient ] [ volatile ] // pro atributy [ final ] typ [ [ ] ] id [ = výraz ] , id [ = výraz ] , ... ; // lokální var. s inicializací { příkaz; blok; definice ... ; příkaz; ... ; } // blok if ( podmínka ) příkaz1 [ else příkaz2 ] // podmíněný příkaz podmínka ? výraz1 : výraz2 // ternární výraz pro true : false [ návěští :] // jen před cykly while ( podmínka ) příkaz do příkaz while ( podmínka ) ; for ( [ initList ] ; [ podmínka ] ; [ modifList ] ) příkaz for ( [ final ] typ elem // jen v cyklu : ( Iterable | pole ) ) příkaz typicky kolekce continue [ návěští ]; // jen v těle cyklu – přechod na test podmínky break [ návěští ]; // ukončení příkazu cyklu, switch (v case, default ) return [ výraz ]; // jen v metodě, konstruktoru, inicializátorech C00 - metasymboly ALG

Základní konstrukty (2/3) - switch ( index ) { // typ indexu: char, byte, short či int, enum, // Character, Byte, Short, Integer, String. [ case k1 : [ příkazy ] // k musí být konstantní výrazy různých case k2 : [ příkazy ] // hodnot typu int či enum konstanty case k3 : [ příkazy ] // či typu String - ale ne obalené hodnota ... ] [ default : [ příkazy ] ] // Nezávisle volitelné a kdekoli v pořadí [ case k4 : [ příkazy ] } // typ indexu indukuje typ konstant k - try [ ( zdroj [ ; zdroj ] … ) ] // zdroje musí být AutoCloseable { [ příkazy ] } [ catch ( [ final ] t1 [ I t2 ] … parm ) { [ příkazy ] } // I vertical bar catch ( [ final ] t3 [ I t4 ] … parm ) { [ příkazy ] } // značí alternaci ... ] // t musí být typu Throwable [ finally { [ příkazy ] } ] // nelze vynechat catch i finally C00

Základní konstrukty (3/3) - throw objekt // objekt typu Throwable - synchronized ( výraz ) blok // výraz musí referovat objekt - assert podmínka [ : výraz ] ; // kontrola podmínky - enum jméno { // výčtový typ ABC [ ( atributy ) ] [ { metody } ] , DEF [ ( atributy ) ] [ { metody } ] , GHI [ ( atributy ) ] [ { metody } ] ; ... // další složky } - Class [ <T> ] = T.class // popisný objekt typu třídy C00

Syntaxe metod ( bez generiky ) // modifikátory metod konkrétní, nativní, abstraktní v libovolném pořadí : [ public | protected | private ] [ static ] [ final ] [ synchronized ] [ strictfp ] [ public | protected | private ] [ static ] [ final ] [ synchronized ] native [ public | protected ] abstract ( returnTyp | void ) jménoMetody ( [ [ final ] Typ parm, … [ [ final ] Typ ... varargs ] ] ) //formální parametry [ throws Thw1, Thw2, ... ] // stigma: seznam neřešených nehod // Vynechání varargs při volání se vytvoří patřičné pole nulové délky. { ... } //  tělo konkrétní metody // pro návratový typ void může být tělo i prázdné ; //  jen středník pro abstract i native metody Příklad volání: jmenoMetody( x, y, z1, z2, z3 ); Vrácená hodnota musí být kompatibilní s návratovým typem metody. possible autoboxing C00

Důležité pojmy literál: ( literal ) sebevyjadřující konstantní hodnota proměnná: ( variable ) lokální ( local variable ) definována v metodě, konstruktoru, inicializátoru parametr – lokální proměnná definovaná v hlavičce třídní ( class variable ) static instanční ( class variable ) metoda funkce či procedura vrací hodnotu či nevrací nic ( void ) konkrétní - má tělo { … } event. i prázdné abstraktní - nemá tělo – má jen středník ( abstract ) signatura metody / konstruktoru: jméno a seznam typů parametrů stigma metody: throws seznam Throwable přetížení metody: - shoda jmen leč rozdílné signatury překrytí metody: - shoda signatur v předkovi a potomkovi inicializátor statický: static { … } anebo nestatický: { … } třída ( class ) , výčet ( enum ) interfejs rozhraní ( interface ) C00