Úplné zobrazení záznamu

Toto je statický export z katalogu ze dne 23.04.2019. Zobrazit aktuální podobu v katalogu.

Bibliografická citace

.
0 (hodnocen0 x )
(2) Půjčeno:4x 
BK
1. vyd.
Praha : Grada, 2004
601 s. : il.

ISBN 80-247-0941-4 (brož.)
Knihovna programátora
Myslíme v-
Obsahuje rejstřík
Java (jazyk) - učebnice
Programování objektově orientované - Java (jazyk) - příručky
000065245
Stručný obsah // Poděkování...18 // Předmluva...19 // Úvod...20 // Části: Zapouzdření 27 // 1. Seznamujeme se s nástroji...28 // 2. Pracujeme s třídami a objekty...50 // 3. Vytváříme vlastní třídu...90 // 4. Dotváříme vlastní třídu...192 // 5. Návrhové vzory...244 // Část 2: Více tváří___259 // 6. Rozhraní...260 // 7. Budete si to přát zabalit?...310 // 8. Co takhle něco zdědit?...335 // 9. Dědit mohou i třídy...354 // 10. Knihovny...430 // Část 3: Učíme program přemýšlet 449 // 11. Program začíná přemýšlet...450 // 12. Ještě jednu rundu, prosím...494 // 13. Kontejnery nejsou jen na odpadky...515 // 14. Statické kontejnery - pole...563 // 15. Závěrečný projekt a kudy dál...587 // Rejstřík...594 // Podrobný obsah // Poděkování...18 // Předmluva...19 // Úvod...20 // Potřebné vybavení...23 // Použité konvence...24 // Odbočka...26 // Části: Zapouzdření 27 // 1. Seznamujeme se s nástroji...28 // 1.1 Trochu historie...28 // První počítače...28 // Co je to program...30 // Program musí být především spolehlivý...30 // 1.2 Objektově orientované programováni - OOP...31 // Vývoj metodik programování...31 // Principy OOP...32 // 1.3 Překladače, interprety, platformy...33 // Operační systém a platforma...33 // Programovací jazyky...34 // 1.4 Java a jeji zvláštnosti...36 // Klíčové vlastnosti Javy...36 // Objektově orientovaná...36 // Jednoduchá...36 // Multiplatformni...37 // Java
je jazyk i platforma...37 // Vývojářská sada...38 // 1.5 Vývojové prostředí BlueJ...38 // 1.6 Projekty a BlueJ...39 // Windows a substituované disky...40 // Umístění projektů na disku...41 // Vyhledání a otevření projektu...42 // 1.7 Diagram tříd...43 // Manipulace s třídami v diagramu...44 // 1.8 Shrnutí-co jsme se naučili...48 // 2. Pracujeme s třídami a objekty...50 // 2.1 Nejprve trocha teorie...50 // Třídy a jejich instance...50 // Zprávy...51 // Metody...52 // 2.2 Analogie...53 // 2.3 Třídy a jejich instance...53 // Vytváříme svou první instanci...53 // Pravidla pro tvorbu identifikátorů v jazyce Java...56 // Vytváříme svou první instanci - pokračováni...57 // Posíláme instanci zprávu...59 // Vytváříme další instance...60 // Rušení instancí a správa paměti...61 // 2.4 Restartování virtuálního stroje...62 // 2.5 Instance versus odkaz...62 // 2.6 Zprávy žádající o hodnotu...64 // Datové typy...65 // Primitivní datové typy...65 // Objektové datové typy...66 // Vracení hodnot primitivních typů...67 // Vraceni hodnot objektových typů...68 // 2.7 Parametry a jejich typy...71 // Vyvolání konstruktoru s parametry...71 // Parametry objektových typů...74 // Posílání zpráv s parametry...75 // 2.8 Metody třídy...76 // 2.9 Výlet do nitra instancí...78 // Atributy instancí...79 // Atributy třídy - statické atributy...81 // 2.10 Přímé zadávání hodnot parametrů objektových typů...84 // Veřejné
atributy...84 // Odkazy vrácené po zaslání zprávy...85 // 2.11 Shrnutí-co jsme se naučili...87 // Vytváříme vlastní třídu...90 // 3.1 První vlastní třída...91 // 3.2 Zdrojový kód třídy...94 // Prázdná třída...95 // Bílé znaky a uspořádání programu...96 // Implicitní konstruktor...97 // 3.3 Odstranění třídy...98 // 3.4 Bezparametrický konstruktor...98 // 3.5 Přejmenování třídy...102 // 3.6 Ladění...103 // Syntaktické chyby...104 // Běhové chyby...106 // Logické (sémantické) chyby...107 // 3.7 Konstruktor s parametry...108 // Konstruktor this...110 // 3.8 Přetěžování...113 // 3.9 Testování...114 // TDD - vývoj řízený testy...114 // Zprovoznění nástrojů pro automatizaci testů...115 // Testovací třída...116 // Přípravek...117 // Úprava obsahu přípravku...118 // 3.10 Deklarace atributů...120 // Modifikátory přístupu...121 // Vylepšujeme Strom...122 // Možné důsledky zveřejnění atributů...123 // 3.11 Definujeme vlastní metodu...124 // Test vytvořených metod...126 // Reakce na chybu v testu...129 // Nejprve testy, pak program?...130 // Někdy jsou věci složitější...132 // Použití metod vracejících hodnotu...134 // Definice metod vracejících hodnotu...135 // Parametry a návratové hodnoty objektových typů...136 // 3.12 Doplnění projektu o třídu odjinud...137 // 3.13 Přístupové metody...137 // Atributy versus vlastnosti...139 // Konvence pro názvy přístupových metod...139
3.14 Kvalifikace a klíčové slovo this...140 // Kvalifikace metod...140 // Kvalifikace atributů...142 // 3.15 Atributy a metody třídy (statické atributy a metody)...144 // Atributy třídy...144 // Metody třídy...145 // 3.16 Lokální proměnné...147 // 3.17 Konstanty a literály...150 // Konstanty objektových typů...153 // Správná podoba literálů...153 // boolean...154 // int...154 // double...154 // String...155 // null...156 // 3.18 Zapouzdření...156 // Rozhraní versus implementace...156 // Kontrakt...158 // 3.19 Komentáře a dokumentace...159 // Proč psát srozumitelné programy...159 // Tři druhy komentářů...160 // Uspořádáni jednotlivých prvků v těle třídy...168 // Zakomentování a odkomentování části programu...169 // BlueJ a komentářová nápověda...170 // Automaticky generovaná dokumentace...171 // Dokumentace celého projektu...173 // Pomocné značky pro tvorbu dokumentace...174 // 3.20 Závěrečný příklad - UFO...176 // Třída Dispečer...177 // Jednodušší varianta...178 // Varianta ovládaná z klávesnice...178 // Třída UFO...179 // Atributy...179 // Konstruktor...180 // Metoda setRychlost(int.int)...180 // Metody getX(), getYQ, getXRychlost(), getYRychlostf), getXTah(), getYTah()...180 // Metoda nakresli()...180 // Metoda popojeď(int)...180 // Metody vpravof), vlevo(), vzhůru(), dolů(), vypniMotoryf)...181 // Třída UFO_3a...182 // Třída UFOTest...182 // 3.21 Vytvoření samostatné aplikace...183 // Třída
spouštějící aplikaci...183 // Prohlížení obsahu JAR souborů...184 // Vytvoření souboru JAR s aplikaci...184 // 3.22 Shrnutí-co jsme se naučili...186 // Zdrojový kód...186 // Ladění...187 // Konstruktory a metody...188 // Atributy a lokální proměnné...189 // Dokumentace...190 // Aplikace...191 // Dotváříme vlastní třídu...192 // 4.1 Jednoduché vstupy a výstupy...192 // Textové řetězce...193 // Rozdíl mezi prázdným řetězcem a null...195 // Čísla...195 // 4.2 Knihovny statických metod...197 // 4.3 Podrobnosti o operátorech...197 // Binární aritmetické operátory + - * / %...198 // Sčítání, odčítáni, násobení...198 // Slučování řetězců +...199 // Dělení/...199 // Zbytek po děleni (dělení modulo) %...200 // Unární operátory + -...201 // Kulaté závorky ()... 201 // Přiřazovací operátor =...201 // Složené přiřazovací operátory +=, —, *=, /=, %=...202 // Operátor přetypování (typ)...203 // Univerzální přetypování na String...204 // 4.4 Počítáme instance...205 // 4.5 Inkrementační a dekrementační operátory...206 // Způsoby předávání hodnot...209 // Jiný způsob inicializace rodného čísla...210 // 4.6 Standardní výstupy...211 // Standardní chybový výstup...213 // 4.7 Metoda toStringO...214 // 4.8 Prázdná standardní třída...215 // 4.9 V útrobách testovací třídy...218 // Přípravek...220 // Automaticky generované testy...222 // Vlastní testy...223 // Úklid...224
Metody assertEquals a assertTrue...224 // Test testů...225 // 4.10 Debugger a práce s ním...227 // Krokováni programu...228 // Okno debuggeru...231 // Vlákna...232 // Pořadí volání...232 // Atributy třídy...233 // Atributy instanci...233 // Lokální proměnné...233 // Atributy a proměnné objektových typů...234 // Už nezastavuj - rušim zarážky...235 // Předčasný konec programu...236 // Pozastavení běžícího programu...236 // Krokování konstruktorů...237 // 4.11 Hodnotové a referenční typy...237 // Hodnotové typy...237 // Referenční datové typy...238 // Program demonstrující rozdíl...238 // 4.12 Projekt Zlomky...240 // 4.13 Shrnutí-co jsme se naučili...241 // 5. Návrhové vzory...244 // 5.1 Přepravka (Messenger)...245 // 5.2 Tovární metoda (Factory method)...249 // 5.3 Jedináček (Singleton)...250 // 5.4 Výčtové typy...253 // 5.5 Shrnuti-co jsme se naučili...257 // Část 2: Více tváří 259 // 6. Rozhraní...260 // 6.1 Kreslíme jinak...261 // 6.2 Syntaxe rozhraní...262 // 6.3 Instance rozhraní...264 // 6.4 Nový projekt...265 // Práce s novým plátnem...268 // Událostmi řízené programování...270 // 6.5 Implementace rozhraní...270 // Implementace rozhraní v diagramu tříd...271 // Odvoláni implementace rozhraní...272 // Implementace rozhraní ve zdrojovém kódu...272 // 6.6 Úprava zdrojového kódu třídy Strom...273 // Třída musí jít přeložit...274 // Testování...277 // Opomenuté testy...281 // Závěrečné
úpravy...282 // Uložení odkazu na Plátno do atributu třídy...282 // Odstranění statického atributu krok...282 // Úpravy posunových metod...283 // Zefektivněni přesunu...283 // Efektivita vykreslování...284 // 6.7 Implementace několika rozhraní...285 // 6.8 Návrhový vzor Služebník (Servant)...286 // Proč rozhraní...287 // Implementace...287 // Aplikace na náš projekt...288 // Závěrečný test...290 // 6.9 Refaktorování...291 // Ukázka...293 // 1. krok: Vytvoření testu...293 // 2. krok: Doplnění prázdných verzí testovaných metod...294 // 3. krok: Definice nových atributů...294 // 4. krok: Kopírování těla konstruktoru do těla metody...295 // 5. krok: Dočasné „odkonstantnění“ některých atributů...296 // 6. krok: Definice potřebných lokálních proměnných...296 // 7. krok: Odstraněni tvorby nových instancí koruny a kmene...297 // 8. krok: Vrácení koruny a kmene mezi konstanty...297 // 9. krok: Vyvoláni metody setRozměr(int.int) v konstruktoru...297 // 10. krok: Odstraněni zdvojeného kódu z konstruktoru...298 // 11. krok: Doplnění metody setRozměr(Rozměr)...299 // 12. krok: Doplnění metody setOblast(Oblast)...299 // 6.10 Projekt Výtah...300 // Analýza problému...300 // Okolí...301 // Konstruktory...301 // Potřebné metody...302 // Implementace...302 // Implementovaná rozhraní...303 // Atributy...303 // Postup při návrhu metod...304 // Metoda doPatra(int)...304 // Metoda přijecf K( I Posuvný)...305
// Metoda nástup(IPosuvný)...305 // Metody výstupVpravoO a výstupVlevo()...306 // Test převozu pasažéra...306 // Metody odvezVpravo(IPosuvný.int) a odvezVlevo(IPosuvný,int)...307 // 6.11 Shrnutí - co jsme se naučili...307 // Budete si to přát zabalit?...310 // 7.1 Velké programy a jejich problémy...310 // 7.2 Balíčky...311 // Podbalíčky...312 // Uspořádání podbaličků s programy k dosavadní části knihy...313 // Názvy tříd...314 // 7.3 Balíčky a BlueJ...314 // Příprava stromu balíčků pro BlueJ ve správci souborů...315 // Příprava stromu balíčků v BlueJ...315 // Vytvoření struktury balíčků pro tuto kapitolu...316 // Putováni stromem balíčků...316 // Odstraňováni balíčků...317 // Zavírání a otevírání projektů...’...318 // 7.4 Naplňujeme balíčky...318 // Automatické vloženi příkazu package...320 // 7.5 Balíčky a příkaz import...321 // Import celého balíčku...323 // Import a podbalíčky...324 // Baliček java.lang...324 // Změna balíčku...324 // 7.6 Názvy balíčků...325 // 7.7 Příkazový panel...325 // Nevýhody koncepce balíčků v BlueJ...325 // Zobrazení příkazového panelu...326 // Použití příkazového panelu...327 // Opakované používáni příkazů...328 // 7.8 Přístupová práva v rámci balíčku...329 // 7.9 Neveřejné třídy...330 // 7.10 Tvorba vlastních aplikací...331 // 7.11 Statický import...332 // 7.12 Shrnutí-co jsme se naučili...332 // 8. Co takhle něco zdědit?...335
// 8.1 Co to je, když rozhraní dědí?...336 // 8.2 Jak to zařídit...337 // Duplicitně deklarovaná implementace...339 // 8.3 Společný potomek několika rozhraní...339 // 8.4 Návrhový vzor Stav (State)...341 // Projekt Šipky...342 // Shrnuti...346 // 8.5 Návrhový vzor Zástupce (Proxy)...347 // 8.6 Projekt Kabina...349 // Předpřipravené třídy...349 // Třída rup.česky. tvary. Multipřesouvač...349 // Rozhraní rup.česky.tvary.lMultiposuvný...350 // Rozhraní doprava.lZastávka...350 // Třída doprava.Linka...351 // Úloha: třída doprava.Kabina...352 // 8.7 Shrnutí-co jsme se naučili...352 // 9. Dědit mohou i třídy...354 // 9.1 Podtřídy a nadtřídy...355 // Specializace...355 // Zobecněni...355 // Realizace v OOP...356 // Univerzálni (pra)rodič...357 // 9.2 Experimenty s dědičností...358 // Univerzální rodič Object...359 // Atributy a bezparametrické konstruktory tříd v projektu...360 // Hierarchie dědičnosti...361 // Podobjekt rodičovské třídy...363 // Explicitní volání konstruktoru předka...367 // Chráněné atributy - modifikátor přístupu protected...370 // Dědičnost a metody třid...370 // Metody instanci, jejich děděni a překrývání...372 // Nové metody...372 // Nepřekryté zděděné metody...372 // Překryté zděděné metody...372 // Test chováni překrývajících a překrytých metod...374 // Porovnání...376 // Podobjekt...376 // Soukromá metoda...377 // Veřejná metoda...377 // Instance vnučka...377
// Vyvolání překryté verze metody...377 // 9.3 Vytváříme dceřinou třídu...379 // Jednoduchá dceřiná třída...379 // Konstruktory potomka...382 // Složitější dceřiná třída...382 // Definice konstruktoru...383 // Metoda kresli(Kreslítko)...384 // Metoda setPozice(int.int)...384 // Jak přesvědčit objekt, aby se pokaždé choval jinak...387 // Samostatná úloha: Terč...389 // 9.4 Vytváříme rodičovskou třídu...392 // Společný rodič Posuvný...392 // Příprava...392 // Konstantní atributy třídy...393 // Proměnné atributy třídy...394 // Konstantní atributy instancí...394 // Proměnné atributy instancí...394 // Konstruktory...396 // Metody instancí...396 // Doladění dceřiných tříd...397 // Elipsa, Obdélník, Trojúhelník...398 // Čára...399 // Text...399 // Strom...399 // Dodatečné rozšíření rodičovské třídy...400 // Společný rodič Hýbací...402 // 9.5 Abstraktní metody a třídy...403 // Neimplementovaná metoda implementovaného rozhraní...404 // Zděděná a neimplementovaná abstraktní metoda...405 // Přidání metody nakreslit)...406 // Nově deklarovaná abstraktní metoda...406 // Abstraktní třída bez abstraktních metod...407 // 9.6 Nová schopnost - přizpůsobivost...408 // 9.7 Návrhový vzor Stav podruhé...409 // Projekt Šipka...409 // 9.8 Co je na dědičnosti špatné...411 // 9.9 ZpětnáKabina...412 // 9.10 Omezení kladená na konstruktory...414 // Poznámka o dobrých mravech...416
9.11 Konečné třídy...417 // 9.12 Konečné metody...418 // 9.13 ZpětnáKabina podruhé...419 // 9.14 Tovární metoda podruhé...420 // Jak něco udělat před spuštěním rodičovského konstruktoru...420 // Využití tovární metody...421 // 9.15 Kdy (ne)použít dědičnost...423 // Potomci, kteří nejsou speciálním případem rodiče...423 // Kdy jsme použili dědičnost místo správného skládání...424 // Potomci, kteří jsou příliš speciální...425 // Kdy dát přednost skládání a kdy dědičnosti...426 // 9.16 Shrnutí-co jsme se naučili...427 // 10. Knihovny...430 // 10.1 Datové typy char a long...431 // long...431 // char...431 // 10.2 Primitivní a obalové datové typy...433 // 10.3 Knihovní třída jako návrhový vzor...434 // 10.4 Třída System...434 // 10.5 Formátovaný výstup...435 // Národní prostředí...437 // Ukázka...437 // 10.6 Základní matematické funkce...433 // 10.7 Pracujeme s náhodou...439 // 10.8 Ukončení aplikace...441 // 10.9 Třída String...442 // 10.10 Definice vlastní knihovny a její začlenění do BlueJ...443 // Vytvoření JAR souboru s knihovnou...444 // Přidání knihovny do BlueJ...444 // 10.11 Shrnutí - co jsme se naučili...446 // Část 3: Učíme program přemýšlet 449 // 11. Program začíná přemýšlet...450 // 11.1 Ternární operátor ?:...4SI // 11.2 Jednoduchý podmíněný příkaz...451 // Třídy jako objekty...454 // 11.3 Blok příkazů (složený příkaz)...455 // 11.4 Program
ve výjimečné situaci...457 // Nejdůležitějši výjimky...458 // Vyhozeni výjimky...459 // Výjimky a dostupný kód...460 // Užitečné metody výjimek...461 // Vytvoření objektu výjimky...462 // Metoda printStackT race()...462 // Metoda printStackTrace( PrintStream)...462 // Metody getMessage() a toString()...462 // Vyhození výjimky...463 // 11.5 Podmínky a jejich skládání...463 // Porovnávací operátory...463 // Logické výrazy...464 // Použití v programu...465 // 11.6 Návrhový vzor Adaptér (Adapter)...466 // 11.7 Ošetření klávesnice...466 // Možné události klávesnice...467 // Co prozradí událost java.avvt.event.KeyEvent...468 // 11.8 Střelba...470 // Střela...471 // Dělo...472 // 11.9 Statický konstruktor...473 // Vylepšené dělo...475 // 11.10 Rychlost ošetření klávesnice...478 // 11.11 Vnořené podmíněné příkazy...478 // 11.12 Výběr ze dvou možností...480 // 11.13 Kaskáda možností...482 // 11.14 Přepínač...484 // 11.15 Sestřelování letadel...487 // 11.16 Přepínač nad výčtovým typem...487 // 11.17 Operátor instanceof...488 // 11.18 Metoda equals()...489 // Překrytí metody equals(Object)...490 // 11.19 Shrnutí - co jsme se naučili...491 // 13.8 // Mnohotvar // .539 // Základní koncepce a první testy Dovedeni programu k úspěšnému vykonání testů 540 543 // Konstruktory 543 // Metoda nakresli(Kreslítko) 544 // Metoda pndej(IHýbaci) 544 // Přidání hýbacích vlastnosti 546 // Metoda setPozice(int,int)
547 // Metoda setRozmě r( i n t, i n t) 548 // 13.9 Soukromá přepravka 550 // 13 10 Zavedení vrstev - práce se seznamy 556 // Třída java.util.Listlterator<E> 559 // 1311 Primitivní a obalové datové typy 560 // 13.12 Shrnutí-co jsme se naučili 561 // Statické kontejnery - pole 563 // 14.1 Pole jako kontejner 564 // Pole odkazů na objekty 564 // Pole a BlueJ 565 // Pole hodnot primitivních typů 567 // Hlídání mezi polí 570 // Inicializace poli v deklaraci 570 // Inicializace vytvářeného pole 572 // Neinicializovaná pole objektových typů 573 // 14.2 Vypsání čísla slovy 574 // 14.3 Vícerozměrná pole 576 // Obdélníková pole 576 // Neobdélníková pole 578 // Inicializace vícerozměrného pole 578 // 14.4 Pascalův trojúhelník 579 // 14.5 Třídy StringBuilder a StringBuffer 580 // 14.6 Metoda main(String[]) 581 // 14.7 Metody s proměnlivým počtem parametrů 582 // 14.8 Shrnutí-co jsme se naučili 584 // Závěrečný projekt a kudy dál 587 // 15.1 Závěrečný projekt: Displej 587 // 587 // Analýza 588 // Displej 589 // Číslice 589 // Segment 589 // Zpět u číslic 590 // Dotahujeme segmenty 590 // Dotahujeme číslice 591 // Dotahujeme displej 592 // Závěr 592 // 15.2 Kudy dál 592 // íejstřík...594

Zvolte formát: Standardní formát Katalogizační záznam Zkrácený záznam S textovými návěštími S kódy polí MARC