Úplné zobrazení záznamu

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

Bibliografická citace

.
0 (hodnocen0 x )
EB
EB
ONLINE
1. elektronické vydání
Grada 2008
1 online zdroj (576 stran)
Externí odkaz    Plný text PDF (Bookport) 
   * Návod pro Bookport 


ISBN 978-80-247-7025-3 (online ; pdf)
ISBN 978-80-247-2653-3 (print)
Tato kniha provede čtenáře krok za krokem světem objektového programování a naučí jej doopravdy programovat. Autor řeší dvě základní nectnosti většiny současných učebnic, kterými jsou výklad objektových technologií začínající někde ve středu učebnice a demonstrace látky na triviálních příkladech. Souběžně s objektovými technologiemi se v knize čtenář naučí pracovat v jazyku Java, především v jeho verzi 5.0, ale seznámí se i s novinkami verzí 6.0 a 7.0..
001486533
8 // Myslíme objektově v jazyku Java // Stručný obsah // Poděkování...21 // Předmluva k prvnímu vydání...22 // Úvod...23 // Části: Zapouzdření 33 // 1. Seznamujeme se s nástroji...34 // 2. Třídy a objekty v interaktivním režimu...51 // 3. Vytváříme vlastní třídu...85 // 4. Přidáváme atributy a metody...116 // 5. Dotváříme vlastní třídu...184 // 6. Návrhové vzory...229 // Část 2: Více tváří 243 // 7. Rozhraní...244 // 8. Budete si to přát zabalit?...286 // 9. Co takhle něco zdědit?...307 // 10. Dědit mohou i třídy...324 // 11. Knihovny...389 // 12. Program ve výjimečné situaci...403 // Část 3: Učíme program přemýšlet 419 // 13. Program začíná přemýšlet...420 // 14. Ještě jednu rundu, prosím...453 // 15. Interní datové typy...475 // 16. Kontejnery nejsou jen na odpadky...488 // 17. Statické kontejnery - pole...538 // 18. Závěrečný projekt a kudy dál...558 // Rejstřík...565 // Podrobný obsah // 9 // Podrobný obsah // Poděkování...21 // Předmluva ? prvnímu vydání...22 // Úvod...23 // Komu je kniha určena...23 // Co se naučíte...23 // Styl výuky...24 // Programovací jazyk...25 // Uspořádání...26 // Čeština...26 // Proč je kniha tlustá...27 // Potřebné vybavení...27 // Doporučená konfigurace...27 // Sada JDK (Java Development Kit)...28 // Vývojové prostředí...28 // Konfigurační soubor pro prostředí BlueJ...29 // Doprovodné programy...29 // Doprovodné animace...29
Použité konvence...29 // Odbočka...31 // Části: Zapouzdření 33 // 1. Seznamujeme se s nástroji...34 // 1.1 Trochu historie...34 // První počítače...34 // Co je to program...35 // Program musí být především spolehlivý...35 // 1.2 Objektově orientované programování - OOP...36 // Vývoj metodik programování...36 // Principy OOP...37 // 1.3 Překladače, interprety, platformy...37 // Operační systém a platforma...37 // Programovací jazyky...38 // 1.4 Java a její zvláštnosti...39 // Klíčové vlastnosti Javy...40 // Objektově orientovaná...40 // Jednoduchá...40 // Multiplatformní...40 // Java je jazyk i platforma...40 // Vývojářská sada...41 // 1.5 Vývojové prostředí BlueJ...41 // 1.6 Projekty a BlueJ...42 // Umístění projektů na disku...42 // Windows a substituované disky...43 // Vyhledání a otevření projektu...44 // 18 // Myslíme objektově v jazyku Java // Co prozradí událost java.awt.event.KeyEvent...431 // 13.7 Střelba...433 // Třída Střela...433 // Třída Dělo...434 // 13.8 Statický Konstruktor...435 // Vylepšené dělo...436 // 13.9 Rychlost ošetření klávesnice...439 // 13.10 Vnořené podmíněné příkazy...440 // 13.11 Výběr ze dvou možností...441 // 13.12 Kaskáda možností...443 // 13.13 Přepínač...445 // 13.14 Sestřelování letadel...447 // 13.15 Přepínač nad výčtovým typem...447 // 13.16 Ještě jednou metoda equals(Object)...448 // Překrytí metody equals(Object)...449 // 13.17 Shrnutí
- co jsme se naučili...450 // 14. Ještě jednu rundu, prosím...453 // 14.1 Cykly...453 // 14.2 Jak máme rychlý počítač - cyklus s koncovou podmínkou...454 // 14.3 Jeden test nestačí - cyklus s počáteční podmínkou...455 // 14.4 Cyklus s parametrem...456 // 14.5 Nekonečný cyklus...457 // 14.6 Vnořování cyklů...457 // 14.7 Cyklus s podmínkou uprostřed...458 // Příkaz break s návěštím...460 // 14.8 Cyklus s prázdným tělem...461 // 14.9 Skákající balónek...461 // Zadání...461 // Příprava testu...461 // Předběžné úvahy, definice konstruktorů...462 // Koncepce simulace pádu...463 // Dotažení simulace pádu...464 // Metody přemístiNa(int,int) a spadni()...465 // Balon se odráží...466 // Zmenšování odrazů...466 // 14.10 Jak dělat několik věcí najednou...467 // Vlákna...468 // Spuštění pádu v samostatném vlákně...468 // Čekání na ukončení vlákna...470 // 14.11 Opuštění více bloků současně...471 // 14.12 Shrnutí-co jsme se naučili...473 // 15. Interní datové typy...475 // 15.1 Přehled...475 // Terminologie...475 // Společné charakteristiky...476 // Použití...477 // 15.2 Globální typy - typové členy vnořené a vnitřní...478 // Vnořené datové typy...478 // Adaptér vnořený do svého rozhraní...478 // Vnitřní třídy...480 // Balónek s vnitřní třídou...480 // 15.3 Lokální třídy...482 // Pojmenované lokální třídy...483 // Anonymní třídy...483 // Balónek s anonymní třídou...485
// Podrobný obsah 19 // 15.4 Shrnutí - co jsme se naučili...486 // 16. Kontejnery nejsou jen na odpadky...488 // 16.1 Co je to kontejner...489 // Kolekce (Collection)...489 // Množina (Set)...489 // Seznam (List)...489 // Mapa (Map), Slovník (Dictionary)...490 // 16.2 Koncepce kontejnerů ve standardní knihovně...490 // Další kontejnery...491 // Zásobník (Stack)...491 // Fronta (Queue)...491 // Strom (Tree)...491 // Graf...491 // 16.3 Parametrizované datové typy...491 // Definice parametrizovaných typů...492 // Použití parametrizovaných typů...492 // Jak chápat definice typů a jejich metod...493 // Žolíky...493 // 16.4 Práce s kontejnery ve standardní knihovně...494 // Deklarujte typy co nejobecněji...494 // Rozhraní java.util.Collection<E>...495 // 16.5 Pracujeme s množinami...496 // Rozhraní java.util.Set<E>...496 // Třída java.util.LinkedHashSet<E>...496 // 16.6 Brownův pohyb molekul...496 // 1. Konstrukce molekuly...497 // 2. Náhodné rozmístění molekul...498 // 3. Pohyb molekul a jejich srážky...500 // Pravidelné spuštění úloh pomocí instance třídy java.util.Timer...501 // 4. Animátor...502 // Animátor jako soukromá vnořená třída...503 // 16.7 Návrhový vzor Iterátor (Iterator)...504 // Princip...504 // Použití iterátorů v Jávě...504 // Rozhraní java.util.lterátor<E>...505 // Molekuly s vývěvou...506 // 16.8 Pracujeme se seznamy...509 // Rozhraní java.util.List<E>...509 // Třídy java.util.ArrayList<E> a
java.util.LinkedList<E>...509 // 16.9 Návrhový vzor Pozorovatel...510 // 16.10 Mnohotvar...512 // Základní koncepce a první testy...512 // Dovedení programu ? úspěšnému vykonání testů...515 // Metoda nakresli(Kreslitko)...515 // Metoda pndej(IHýbaci)...516 // Přidání hýbacích vlastností...518 // Metoda setPozice(int,int)...519 // Metoda setRozměr(int,int)...519 // 16.11 Soukromá přepravka...522 // 16.12 Zavedení vrstev - práce se seznamy...527 // Třída java.util.Listlterator<E>...530 // 16.13 Primitivní a obalové datové typy...530 // 16.14 Pracujeme s mapami...531 // Rozhraní java.util.Map<K,H>...531 // Rozhraní java.util.Map.Entry<K,H>...532 // 16.15 Mapy v balíčku rup.česky.tvary...532 // 20 // Myslíme objektově v jazyku Java // Třída Smér8 Třída Barva // 16.16 Hodnotové typy a metoda hashCode() // Hešové tabulky... // Pravidla pro ukládání... // Pravidla pro vyhledávání... // Vytváření hešových tabulek... // Metoda hashCode()... // Ještě jednou hodnotové typy... // 16.17 Shrnutí - co jsme se naučili... // 17. Statické kontejnery - pole... // 17.1 Pole jako kontejner... // Pole odkazů na objekty... // Pole a BlueJ... // Pole hodnot primitivních typů... // Hlídání mezí polí... // Inicializace polí v deklaraci... // Inicializace vytvářeného pole... // Neinicializovaná pole objektových typů // 17.2 Vypsání čísla slovy... // 17.3 Vícerozměrná pole... // Obdélníková pole... // Neobdélníková
pole... // Inicializace vícerozměrného pole... // 17.4 Pascalův trojúhelník... // 17.5 Třídy StringBuilder a StringBuffer... // 17.6 Metoda main(StringQ)... // 17.7 Metody s proměnlivým počtem parametrů // 17.8 Shrnutí - co jsme se naučili... // 18. Závěrečný projekt a kudy dál // 18.1 Závěrečný projekt: Displej... // Zadání... // Analýza... // Displej... // Číslice... // Segment... // Zpět u číslic... // Dotahujeme segmenty... // Dotahujeme číslice... // Dotahujeme displej... // Závěr... // 18.2 Kudy dál... // Rejstřík // .532 // .533 // .534 // .534 // .534 // .534 // .534 // .535 // .535 // .536 // 538 // .538 // .539 // .539 // .541 // .543 // .543 // .545 // .546 // .547 // .548 // .549 // .550 // .550 // .551 // .552 // .553 // .554 // .556 // 558 // .558 // .559 // .559 // .559 // .559 // .560 // .560 // .560 // .561 // .561 // .562 // .562 // 565 // 10 // Myslíme objektově v jazyku Java // 1.7 Diagram tříd...45 // Manipulace s třídami v diagramu...46 // 1.8 Shrnutí - co jsme se naučili...49 // 2. Třídy a objekty v interaktivním režimu...51 // 2.1 Nejprve trocha teorie...51 // Třídy a jejich instance...51 // Zprávy...52 // 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ání...57 // Posíláme instanci zprávu...59 // Vytváříme další instance...59
// Rušení instancí a správa paměti...60 // 2.4 Restartování virtuálního stroje...61 // 2.5 Instance versus odkaz...61 // 2.6 Zprávy žádající o hodnotu...63 // Datové typy...64 // Primitivní datové typy...64 // Objektové datové typy...65 // Vracení hodnot primitivních typů...65 // Vracení hodnot objektových typů...66 // 2.7 Parametry a jejich typy...68 // Vyvolání konstruktoru s parametry...69 // Parametry objektových typů...71 // Posílání zpráv s parametry...73 // 2.8 Metody třídy...73 // 2.9 Výlet do nitra instancí...75 // Atributy instancí...75 // Atributy třídy - statické atributy...77 // 2.10 Přímé zadávání hodnot parametrů objektových typů...79 // Veřejné atributy...79 // Odkazy vrácené po zaslání zprávy...81 // 2.11 Shrnutí - co jsme se naučili...83 // 3. Vytváříme vlastní třídu...85 // 3.1 První vlastní třída...86 // 3.2 Zdrojový kód třídy...87 // Prázdná třída...88 // Bílé znaky a uspořádání programu...89 // 3.3 Soubory projektu...91 // 3.4 Odstranění třídy...92 // 3.5 Implicitní konstruktor...94 // 3.6 Přejmenování třídy...97 // 3.7 Ladění...98 // Syntaktické chyby...99 // Běhové chyby...100 // Logické (sémantické) chyby...103 // 3.8 Konstruktors parametry...103 // Použití skrytého parametru this...105 // 3.9 Přetěžování...107 // 3.10 Testování...108 // TDD - vývoj řízený testy...108 // Zprovoznění nástrojů pro automatizaci testů...109 // Podrobný obsah
// 1 1 // Testovací třída...110 // Přípravek...111 // Úprava obsahu přípravku...112 // 3.11 Shrnutí - co jsme se v kapitole naučili...114 // Zdrojový kód...114 // Ladění...114 // Konstruktory a metody...115 // 4. Přidáváme atributy a metody...116 // 4.1 Deklarace atributů...116 // Modifikátory přístupu...117 // Vylepšujeme třídu Strom...118 // Možné důsledky zveřejnění atributů...119 // 4.2 Definujeme vlastní metodu...120 // Test vytvořených metod...121 // Reakce na chybu v testu...124 // Nejprve testy, pak program?...125 // Někdy jsou věci složitější...127 // Použití metod vracejících hodnotu...128 // Definice metod vracejících hodnotu...129 // Parametry a návratové hodnoty objektových typů...130 // 4.3 Doplnění projektu o třídu odjinud...130 // 4.4 Přístupové metody...131 // Atributy versus vlastnosti...132 // Konvence pro názvy přístupových metod...132 // 4.5 Kvalifikace a klíčové slovo this...133 // Kvalifikace metod...133 // Kvalifikace atributů...134 // 4.6 Atributy a metody třídy (statické atributy a metody)...136 // Atributy třídy...136 // Metody třídy...137 // 4.7 Čtení chybových hlášení...139 // 4.8 Lokální proměnné...140 // 4.9 Konstanty a literály...143 // Konstanty objektových typů...145 // Správná podoba literálů...145 // boolean...146 // int...146 // double...146 // String...147 // null...147 // 4.10 Zapouzdření a skrývání implementace...148 // Rozhraní versus implementace...148
// Signatura * kontrakt...149 // 4.11 Komentáře a dokumentace...150 // Proč psát srozumitelné programy...150 // Tři druhy komentářů...151 // Zakomentování a odkomentování části programu...152 // Pomocné značky pro tvorbu dokumentace...152 // Okomentování třídy Strom...153 // Uspořádání jednotlivých prvků v těle třídy...160 // Prázdná standardní třída...161 // BlueJ a komentářová nápověda...163 // Automaticky generovaná dokumentace...164 // Dokumentace celého projektu...164 // 4.12 Třída Object...168 // Anotace @0verride...169 // 12 // Myslíme objektově v jazyku Java // 4.13 Metoda toStringf)...169 // Sčítání řetězců...169 // Jak definovat metodu toString()...170 // 4.14 Závěrečný příklad - UFO... 171 // Předběžné poznámky...171 // Stručný přehled...171 // Třída Dispečer...172 // Jednodušší varianta...173 // Varianta ovládaná z klávesnice...173 // Třída UFO...174 // Atributy...174 // Konstruktor...174 // Metoda setRychlost(intjnt)...174 // Metody getX(), getYQ, getXRychlost(), getYRychlost(), getXTah(), getYTah()...174 // Metoda nakresli()...175 // Metoda popojecf(int)...175 // Metody vpravo(), vlevo(), vzhúruQ, dolů(), vypniMotory()...175 // Metoda toString()...176 // Třída UFO 4...176 // Třída UFOŤest...176 // 4.15 Vytvoření samostatné aplikace...177 // Prohlížení obsahu JAR-souborů...177 // Třída spouštějící aplikaci...177 // Vytvoření souboru JAR s aplikací...178 // Stěhování
projektu mezi platformami...179 // Problémy s kódováním znaků...180 // 4.16 Shrnutí - co jsme se v kapitole naučili...181 // Zdrojový kód...181 // Atributy a lokální proměnné...181 // Dokumentace...182 // Aplikace...183 // 5. Dotváříme vlastní třídu...184 // 5.1 Jednoduché vstupy a výstupy...184 // Textové řetězce...184 // Rozdíl mezi prázdným řetězcem a null...186 // Čísla...186 // 5.2 Podrobnosti o operátorech...187 // Binární aritmetické operátory +-*/%...188 // Sčítání, odčítání, násobení...188 // Slučování řetězců +...189 // Dělení/...189 // Zbytek po dělení (dělení modulo) %...190 // Unární operátory +-...190 // Kulaté závorky ()...190 // Přiřazovací operátor =...191 // Složené přiřazovací operátory +=, -= *=, /=, %=...191 // Operátor přetypování (typ)...192 // Univerzální přetypování na String...193 // 5.3 Počítáme instance...194 // 5.4 Inkrementační a dekrementační operátory...195 // Způsoby předávání hodnot...198 // Jiný způsob inicializace rodného čísla...199 // 5.5 Standardní výstupy...199 // Standardní chybový výstup...201 // 5.6 V útrobách testovací třídy...202 // Přípravek...204 // Automaticky generované testy...206 // Podrobný obsah // 13 // Vlastní testy...206 // Úklid...207 // Metody assertEquals a assertTrue...207 // Test testů...208 // 5.7 Debugger a práce s ním...210 // Krokování programu...211 // Okno debuggeru...214 // Vlákna...214
Atributy třídy...214 // Atributy instancí...215 // Lokální proměnné...215 // Pořadí volání-zásobník návratových adres...215 // Krokování konstruktoru...216 // Atributy a proměnné objektových typů...216 // Už nezastavuj - ruším zarážky...217 // Předčasný konec programu...217 // Pozastavení běžícího programu...218 // 5.8 Hodnotové a odkazové objektové typy...218 // Odkazové datové typy...219 // Hodnotové typy...219 // Program demonstrující rozdíl...220 // Hodnotové typy podruhé...221 // 5.9 Projekt Zlomky...222 // 5.10 Metoda equals(Object)...223 // Operátor porovnání ==...224 // Operátor logické konjunkce &&...224 // Operátor instanceof...224 // Definice equals(Object) pro Zlomek...225 // 5.11 Shrnutí - co jsme se naučili...225 // 6. Návrhové vzory...229 // 6.1 Knihovní třída (Utility)...230 // 6.2 Přepravka (Messenger)...230 // 6.3 Tovární metoda (Factory method)...233 // 6.4 Jedináček (Singleton)...234 // 6.5 Výčtové typy...237 // 6.6 Návrhový vzor Prázdný objekt (Null Object)...240 // 6.7 Shrnutí - co jsme se naučili...241 // Část 2: Více tváří 243 // 7. Rozhraní...244 // 7.1 Návrhový vzor Prostředník (Mediator)...244 // 7.2 Kreslíme jinak...245 // 7.3 Syntaxe rozhraní...246 // 7.4 Instance rozhraní...247 // 7.5 Nový projekt...248 // Práce s novým plátnem...251 // 7.6 Událostmi řízené programování...253 // 7.7 Implementace rozhraní...253 // Implementace rozhraní v diagramu tříd...254
// Odvolání implementace rozhraní...254 // Implementace rozhraní ve zdrojovém kódu...255 // 7.8 Úprava zdrojového kódu třídy Strom...256 // Třída musí jít přeložit...256 // Testování...259 // 14 // Myslíme objektově v jazyku Java // Opomenuté testy...263 // Efektivita vykreslování...264 // Závěrečné úpravy...264 // Uložení odkazu na správce plátna do atributu třídy...264 // Odstranění statického atributu krok...265 // Úpravy posunových metod...265 // Zefektivnění přesunu...265 // Vnořený blok...266 // 7.9 Implementace několika rozhraní...266 // 7.10 Návrhový vzor Služebník (Servant)...267 // Proč zavádíme rozhraní...268 // Implementace...269 // Aplikace na náš projekt...269 // Závěrečný test...270 // 7.11 Refaktorování...272 // Ukázka...272 // 1. krok: Vytvoření testu...273 // 2. krok: Doplnění prázdných verzí testovaných metod...274 // 3. krok: Definice nových atributů...274 // 4. krok: Kopírování těla konstruktoru do těla metody...275 // 5. krok: Dočasné „odkonstantnéní“ některých atributů...275 // 6. krok: Definice potřebných lokálních proměnných...275 // 7. krok: Odstranění tvorby nových instancí koruny a kmene...276 // 8. krok: Vrácení koruny a kmene mezi konstanty...276 // 9. krok: Vyvolání metody setRozměr(int,int) v konstruktoru...276 // 10. krok: Odstranění zdvojeného kódu z konstruktoru...277 // 11. krok: Doplnění metody setRozměr(Rozměr)...277 // 12. krok:
Doplnění metody setOblast(Oblast)...278 // 7.12 Projekt Výtah...278 // Analýza problému...279 // Okolí...279 // Konstruktory...279 // Potřebné metody...280 // Implementace...281 // Implementovaná rozhraní...281 // Atributy...281 // Postup při návrhu metod...282 // Metoda doPatra(int)...282 // Metoda přijeďK(IPosuvný)...282 // Metoda nástup(IPosuvný)...283 // Metody výstupVpravoQ a výstupVlevoQ...283 // Test převozu pasažéra...283 // Metody odvezVpravo(IPosuvnýjnt) a odvezVlevo(IPosuvný,int)...284 // 7.13 Shrnutí - co jsme se naučili...284 // 8. Budete si to přát zabalit?...286 // 8.1 Velké programy a jejich problémy...286 // 8.2 Balíčky...287 // Podbalíčky...288 // Uspořádání podbalíčků s programy ? dosavadní části knihy...288 // Názvy tříd...289 // 8.3 Balíčky a BlueJ...289 // Příprava stromu balíčků pro BlueJ ve správci souborů...289 // Příprava stromu balíčků v BlueJ...290 // Vytvoření struktury balíčků pro tuto kapitolu...290 // Putování stromem balíčků...291 // Odstraňování balíčků...291 // Zavírání a otevírání projektů...292 // Podrobný obsah // 15 // 8.4 Naplňujeme balíčky...292 // Automatické vložení příkazu package...294 // 8.5 Balíčky a příkaz import...295 // Import celého balíčku...297 // Import a podbalíčky...297 // Balíček java.lang...297 // Změna balíčku...298 // 8.6 Názvy balíčků...298 // 8.7 Příkazový panel...299 // Nevýhody koncepce balíčků v BlueJ...299
// Zobrazení příkazového panelu...299 // Použití příkazového panelu...300 // Opakované používání příkazů...301 // 8.8 Přístupová práva v rámci balíčku...301 // 8.9 Neveřejné třídy...302 // 8.10 Tvorba vlastních aplikací...303 // 8.11 Statický import...303 // 8.12 Shrnutí - co jsme se naučili...304 // 9. Co takhle něco zdědit?...307 // 9.1 Co to je, když rozhraní dědí?...308 // 9.2 Jak to zařídit...308 // Duplicitně deklarovaná implementace...309 // 9.3 Společný potomek několika rozhraní...310 // Třída Oblast a rozhraní IHýbací...312 // 9.4 Návrhový vzor Stav (State)...313 // Projekt Šipky...314 // Shrnutí...317 // 9.5 Návrhový vzor Zástupce (Proxy)...318 // 9.6 Projekt Kabina...320 // Předpřipravené třídy...320 // Třída rup.česky.tvary.Multipřesouvač...320 // Rozhraní rup.česky.tvary.lMultiposuvný...321 // Rozhraní doprava.IZastávka...321 // Třída doprava.Linka...321 // Úloha: třída doprava.Kabina...322 // 9.7 Shrnutí - co jsme se naučili...323 // 10. Dědit mohou i třídy...324 // 10.1 Podtřídy a nadtřídy...324 // Specializace...324 // Zobecnění...325 // Realizace v OOP...325 // Univerzální (pra)rodič Object...326 // 10.2 Experimenty s dědičností...327 // Atributy a bezparametrické konstruktory tříd v projektu...328 // Hierarchie dědičnosti...329 // Podobjekt rodičovské třídy...331 // Explicitní volání konstruktoru předka...333 // Dosažitelnost parametru this...336 // Postup
budování instance...336 // Chráněné atributy - modifikátor přístupu protected...337 // Dědičnost a metody tříd...337 // Metody instancí, jejich dědění a překrývání...338 // Nové metody...339 // Nepřekryté zděděné metody...339 // Překryté zděděné metody...339 // Test chování překrývajících a překrytých metod...340 // 16 // Myslíme objektově v jazyku Java // Porovnání...342 // Podobjekt...343 // Soukromá metoda...343 // Veřejná metoda...343 // Instance vnučka...343 // Vyvolání překryté verze metody...344 // 10.3 Vytváříme dceřinou třídu...345 // Jednoduchá dceřiná třída...346 // Konstruktory potomka...347 // Složitější dceřiná třída...348 // Definice konstruktoru...348 // Metoda kresli(Kreslítko)...349 // Metoda setPozice(intjnt)...350 // Jak přesvědčit objekt, aby se pokaždé choval jinak...352 // Samostatná úloha: Terč...353 // 10.4 Vytváříme rodičovskou třídu...356 // Společný rodič Posuvný...356 // Příprava...356 // Konstantní atributy třídy...357 // Proměnné atributy třídy...357 // Konstantní atributy instancí...358 // Proměnné atributy instancí...358 // Konstruktory...359 // Metody instancí...360 // Třídy jako objekty - class-objekt třídy...361 // Doladění dceřiných tříd...362 // Elipsa, Obdélník, Trojúhelník...362 // Čára...362 // Text...363 // Strom...364 // Dodatečné rozšíření rodičovské třídy...364 // Společný rodič Hýbací...366 // 10.5
Abstraktní metody a třídy...367 // Neimplementovaná metoda implementovaného rozhraní...368 // Zděděná a neimplementovaná abstraktní metoda...368 // Přidání metody zobraz()...369 // Nově deklarovaná abstraktní metoda...369 // Abstraktní třída bez abstraktních metod...370 // 10.6 Nová schopnost - přizpůsobivost...370 // 10.7 Návrhový vzor Stav podruhé...371 // Projekt Šipka...372 // 10.8 Co je na dědičnosti špatné...374 // 10.9 Třída ZpětnáKabina...374 // 10.10 Omezení kladená na konstruktory...376 // 10.11 Konečné třídy...377 // Poznámka o dobrých mravech...378 // 10.12 Konečné metody...379 // 10.13 ZpětnáKabina podruhé...380 // 10.14 Tovární metoda podruhé...381 // Jak něco udělat před spuštěním rodičovského konstruktoru...381 // Využití tovární metody...382 // 10.15 Kdy (ne)použft dědičnost...383 // Potomci, kteří nejsou speciálním případem rodiče...383 // Kdy jsme použili dědičnost místo správného skládání...384 // Potomci, kteří jsou příliš speciální...385 // Kdy dát přednost skládání a kdy dědičnosti...386 // 10.16 Shrnutí - co jsme se naučili...386 // Podrobný obsah // 17 // 11. Knihovny...389 // 11.1 Zbylé primitivní datové typy...389 // long...389 // short...390 // byte...390 // float...391 // char...391 // 11.2 Primitivní a obalové datové typy...392 // 11.3 Třída System...393 // 11.4 Formátovaný výstup...393 // Národní prostředí...394 // Ukázka...395 // 11.5
Základní matematické funkce...395 // 11.6 Pracujeme s náhodou...396 // 11.7 Ukončení aplikace...398 // 11.8 Třída String...399 // 11.9 Definice vlastní knihovny a její začlenění do BlueJ...399 // Vytvoření JAR-souboru s knihovnou...400 // Přidání knihovny do BlueJ...401 // 11.10 Shrnutí-co jsme se naučili...402 // 12. Program ve výjimečné situaci...403 // 12.1 Nejdůležitější výjimky...404 // 12.2 Vyhození výjimky...405 // Výjimky a dostupný kód...406 // 12.3 Co výjimky umí...406 // getMessage()...406 // toStringO...407 // printStacklraceO...407 // printStackTrace( PrintStream )...407 // 12.4 Zachycení vyhozené výjimky...407 // Analýza rekurzivní metody...408 // Několik současně odchytávaných výjimek...409 // Společný úklid...410 // Testování správného vyhození výjimky...411 // 12.5 Hierarchie dědičnosti výjimek...412 // Definice vlastních výjimek...413 // Kontrolované výjimky...414 // Převedení kontrolované výjimky na nekontrolovanou...415 // 12.6 Shrnutí - co jsme se naučili...417 // Část 3: Učíme program přemýšlet 419 // 13. Program začíná přemýšlet...420 // 13.1 Ternární operátor ?:...420 // 13.2 Jednoduchý podmíněný příkaz...421 // Vyhození výjimky...424 // 13.3 Blok příkazů (složený příkaz)...425 // 13.4 Podmínky a jejich skládání...426 // Porovnávací operátory...426 // Logické výrazy...427 // Použití v programu...428 // 13.5 Návrhový vzor Adaptér (Adapter)...429
// 13.6 Ošetření klávesnice...429 // Návrhový vzor Pozorovatel (Posluchač) potřetí...429 // Možné události klávesnice...430

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