Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00031 007587 18991672 na godz. na dobę w sumie
Java dla bystrzaków. Wydanie VII - książka
Java dla bystrzaków. Wydanie VII - książka
Autor: Liczba stron: 472
Wydawca: Septem Język publikacji: polski
ISBN: 978-83-283-5989-5 Data wydania:
Lektor:
Kategoria: ebooki >> przewodniki
Porównaj ceny (książka, ebook, audiobook).

W prostocie tkwi siła

Java jest wszędzie, a rosnący popyt na aplikacje WWW i dla Androida sprawia, że programiści Javy są poszukiwani bardziej niż kiedykolwiek! Ten świetny podręcznik opisuje najważniejsze elementy tego języka, takie jak powłoka JShell. W książce znajdziesz też praktyczne pytania i ćwiczenia, które pomogą Ci rozwinąć umiejętności programowania w Javie. Dzięki prostym instrukcjom obsługiwania klas i metod języka Java, stosowania zmiennych oraz sterowania przepływem programu szybko staniesz się ekspertem programowania w Javie!

W książce:

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

Tytuł oryginału: Java For Dummies, 7th Edition Tłumaczenie: Wojciech Moch ISBN: 978-83-283-5989-5 Original English language edition Copyright © 2017 by John Wiley Sons, Inc., Hoboken, New Jersey. All rights reserved including the right of reproduction in whole or in part in any form. This translation published by arrangement with John Wiley Sons, Inc. Oryginalne angielskie wydanie © 2017 by John Wiley Sons, Inc., Hoboken, New Jersey. Wszelkie prawa, włączając prawo do reprodukcji całości lub części w jakiejkolwiek formie, zarezerwowane. Tłumaczenie opublikowane na mocy porozumienia z John Wiley Sons, Inc. Translation copyright © 2020 by Helion SA Wiley, the Wiley Publishing logo, For Dummies, Dla Bystrzaków, the Dummies Man logo, Dummies.com, Making Everything Easier and related trade dress are trademarks or registered trademarks of John Wiley and Sons, Inc. and/or its affiliates in the United States and/or other countries. Used by permission. Java is a registered trademark of Oracle America, Inc. Android is a registered trademark of Google, Inc. All other trademarks are the property of their respective owners. Wiley, the Wiley Publishing logo, For Dummies, Dla Bystrzaków, the Dummies Man logo, Dummies.com, Making Everything Easier i związana z tym szata graficzna są markami handlowymi John Wiley and Sons, Inc. i/lub firm stowarzyszonych w Stanach Zjednoczonych i/lub innych krajach. Wykorzystywane na podstawie licencji. Java jest zastrzeżonym znakiem towarowym Oracle America, Inc. Android jest zastrzeżonym znakiem towarowym Google, Inc. Wszystkie pozostałe znaki handlowe są własnością ich właścicieli. All rights reserved. No part of this book may be reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording or by any information storage retrieval system, without permission from the Publisher. Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną, fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje naruszenie praw autorskich niniejszej publikacji. Autor oraz Helion SA dołożyli wszelkich starań, by zawarte w tej książce informacje były kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Autor oraz Helion SA nie ponoszą również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce. Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://dlabystrzakow.pl/user/opinie/javby7 Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. Helion SA ul. Kościuszki 1c, 44-100 Gliwice tel. 32 231 22 19, 32 230 98 63 e-mail: dlabystrzakow@dlabystrzakow.pl WWW: http://dlabystrzakow.pl Printed in Poland. • Kup książkę • Poleć książkę • Oceń książkę • Księgarnia internetowa • Lubię to! » Nasza społeczność Spis treści O autorze .........................................................................................15 Podziękowania od autora ..............................................................17 Wprowadzenie ................................................................................19 CZĘŚĆ I: ZACZYNAMY PRACĘ Z JĘZYKIEM JAVA ........................25 ROZDZIAŁ 1: Klasy w C++ ........................................................................27 Co możesz zrobić za pomocą języka Java ..............................................................28 Dlaczego warto używać języka Java ........................................................................29 Informacje historyczne: skąd pochodzi Java .........................................................30 Programowanie obiektowe (OOP) .........................................................................32 Języki obiektowe .................................................................................................32 Obiekty i ich klasy ...............................................................................................34 Co jest takiego dobrego w języku zorientowanym obiektowo? ....................35 Lepsze zrozumienie klas i obiektów .................................................................37 Co dalej? ....................................................................................................................39 ROZDZIAŁ 2: Wszystko o oprogramowaniu .........................................41 Skrócona instrukcja ..................................................................................................42 Co zainstalować na swoim komputerze? ..............................................................44 Czym jest kompilator? ........................................................................................46 Czym jest wirtualna maszyna Javy? ..................................................................48 Tworzenie oprogramowania .............................................................................54 Czym jest zintegrowane środowisko programistyczne? ................................56 Spis treści 5 Poleć książkęKup książkę ROZDZIAŁ 3: Używanie podstawowych elementów .............................59 Mówimy w języku Java .............................................................................................60 Gramatyka i typowe nazwy ...............................................................................60 Słowa w programie w języku Java .....................................................................62 Pierwsze czytanie kodu języka Java ........................................................................63 Poznawanie prostego programu w języku Java ....................................................65 Klasa Javy .............................................................................................................65 Metody języka Java .............................................................................................66 Główna metoda programu ................................................................................68 Jak ostatecznie nakazać komputerowi wykonanie jakiejś pracy? .................69 Nawiasy klamrowe .............................................................................................71 A teraz kilka komentarzy .........................................................................................74 Dodawanie komentarzy do kodu .....................................................................75 Jaką wymówkę ma Barry? ..................................................................................78 Wykorzystywanie komentarzy do eksperymentowania z kodem ................79 CZĘŚĆ II: PISANIE WŁASNYCH PROGRAMÓW W JĘZYKU JAVA ...........................................................................81 ROZDZIAŁ 4: Jak najlepiej wykorzystać zmienne i ich wartości .......83 Zmieniając zmienną .................................................................................................84 Instrukcje przypisania ........................................................................................86 Typy wartości, które mogą przyjmować zmienne ..........................................86 Wyświetlanie tekstu ...........................................................................................90 Liczby bez części dziesiętnych ...........................................................................91 Łączenie deklaracji i inicjowanie zmiennych ...................................................92 Eksperymentowanie z JShell ...................................................................................94 Co się stało ze wszystkimi fajnymi efektami wizualnymi? ...................................96 Atomy — proste typy Javy .......................................................................................97 Typ char ...............................................................................................................98 Typ boolean .......................................................................................................100 Cząsteczki i związki — typy referencyjne .............................................................101 Deklaracja importu ................................................................................................105 Tworzenie nowych wartości przez zastosowanie operatorów .........................107 Inicjalizuj raz, często przypisuj ........................................................................110 Operatory inkrementacji i dekrementacji .....................................................111 Operatory przypisania .....................................................................................115 6 Java dla bystrzaków Poleć książkęKup książkę ROZDZIAŁ 5: Kontrolowanie przepływu programu za pomocą instrukcji podejmowania decyzji .............119 Podejmowanie decyzji (instrukcja if w języku Java) ............................................120 Zgadnij liczbę .....................................................................................................120 Kontrolowanie naciśnięć klawiszy na klawiaturze ........................................121 Tworzenie losowości ........................................................................................124 Instrukcja if ........................................................................................................125 Podwójny znak równości .................................................................................126 Przygotuj się ......................................................................................................126 Wcięcia w instrukcji if .......................................................................................127 Bezelseność w Iflandii ......................................................................................128 Używanie bloków w JShell .....................................................................................130 Tworzenie warunków z porównaniami i operatorami logicznymi ...................131 Porównywanie liczb, porównywanie znaków ................................................131 Porównywanie obiektów .................................................................................132 Importowanie wszystkiego za jednym zamachem .......................................134 Operatory logiczne w języku Java ...................................................................135 Vive les nuls! ......................................................................................................137 (Warunki w nawiasach) ....................................................................................138 Budowanie gniazda ................................................................................................140 Wybór spośród wielu wariantów (instrukcja switch w języku Java) ..................142 Podstawowa instrukcja switch ........................................................................143 Przerwać czy nie przerwać ..............................................................................146 Ciągi znaków w instrukcji switch .....................................................................148 ROZDZIAŁ 6: Sterowanie przepływem programu za pomocą pętli ..............................................................151 Wielokrotne powtarzanie instrukcji (instrukcje while w języku Java) ...............152 Powtarzanie określoną liczbę razy (instrukcja for w języku Java) .....................155 Anatomia instrukcji for ....................................................................................157 Światowa premiera piosenki „Al’s All Wet” ....................................................159 Powtarzaj, aż uzyskasz to, czego chcesz (instrukcje do w języku Java) ............162 Odczyt pojedynczego znaku ............................................................................165 Obsługa plików w Javie ....................................................................................166 Deklaracje zmiennych i bloki ...........................................................................167 Spis treści 7 Poleć książkęKup książkę CZĘŚĆ III: PRACA W SZERSZEJ PERSPEKTYWIE — PROGRAMOWANIE OBIEKTOWE .........................................169 ROZDZIAŁ 7: Myślenie w kategoriach klas i obiektów .....................171 Definiowanie klasy (co to znaczy być kontem) ...................................................172 Deklarowanie zmiennych i tworzenie obiektów ...........................................174 Inicjowanie zmiennej ........................................................................................177 Używanie pól obiektu .......................................................................................177 Jeden program, kilka klas ................................................................................177 Klasy publiczne .................................................................................................178 Definiowanie metody w ramach klasy (wyświetlanie konta) ............................179 Konto, które samo się wyświetla ....................................................................180 Nagłówek metody wyświetlającej ...................................................................182 Wysyłanie wartości do i z metod (obliczanie odsetek) .......................................183 Przekazywanie wartości do metody ...............................................................185 Zwracanie wartości z metody getInterest ......................................................188 Poprawianie wyglądu liczb ....................................................................................189 Ukrywanie szczegółów za pomocą metod dostępu ...........................................194 Dobre programowanie ....................................................................................195 Publiczne życie i prywatne marzenia: uniemożliwianie dostępu do pola ....197 Egzekwowanie reguł za pomocą metod dostępu .........................................199 Własna klasa GUI Barry’ego ..................................................................................200 ROZDZIAŁ 8: Oszczędność czasu i pieniędzy — ponowne użycie istniejącego kodu .........................207 Definiowanie klasy (co oznacza bycie pracownikiem) .......................................208 Ostatnie słowo o pracownikach ......................................................................209 Dobre wykorzystanie klasy ..............................................................................210 Przygotowanie wypłaty ....................................................................................214 Praca z plikami (krótki przegląd) ..........................................................................214 Przechowywanie danych w pliku ....................................................................215 Kopiowanie i wklejanie kodu ...........................................................................216 Czytanie z pliku .................................................................................................217 Kto przeniósł mój plik? .....................................................................................220 Dodawanie nazw katalogów do nazw plików ................................................220 Odczytywanie całego wiersza ..........................................................................221 Zamykanie połączenia z plikiem na dysku .....................................................223 Definiowanie podklas (co to znaczy być pracownikiem zatrudnionym w pełnym lub niepełnym wymiarze godzin) ...........................224 Tworzenie podklasy ..........................................................................................226 Nawyk tworzenia podklas ................................................................................228 8 Java dla bystrzaków Poleć książkęKup książkę Korzystanie z podklas ............................................................................................229 Dopasowywanie typów ....................................................................................231 Druga część programu .....................................................................................231 Zastępowanie istniejących już metod (zmiana sposobu wypłaty dla niektórych pracowników) ................................233 Adnotacja Javy ...................................................................................................235 Używanie metod z klas i podklas ....................................................................236 ROZDZIAŁ 9: Konstruowanie nowych obiektów ...............................239 Definiowanie konstruktorów (co to znaczy być temperaturą) ..........................240 Czym jest temperatura? ...................................................................................241 Co to jest skala temperatury? (Typ wyliczeniowy) ........................................241 Dobrze, czym zatem jest temperatura? .........................................................242 Co możesz zrobić z temperaturą? ..................................................................244 Wywołanie new Temperature(32.0) — studium przypadku ........................246 Niektóre rzeczy nigdy się nie zmieniają .........................................................248 Jeszcze więcej podklas (zróbmy coś z pogodą) ...................................................250 Budowanie lepszych temperatur ....................................................................250 Konstruktory dla podklas ................................................................................252 Wykorzystanie tych wszystkich rzeczy ...........................................................253 Domyślny konstruktor .....................................................................................254 Konstruktor, który robi coś więcej .......................................................................257 Klasy i metody z API Javy ..................................................................................259 Adnotacja SuppressWarnings .........................................................................261 CZĘŚĆ IV: SPRYTNE TECHNIKI JAVY .........................................263 ROZDZIAŁ 10: Wprowadzanie zmiennych i metod tam, gdzie się znajdują............................................................265 Definiowanie klasy (co to znaczy być graczem w baseball) ...............................266 Inny sposób na upiększenie liczb ...................................................................267 Korzystanie z klasy Player ................................................................................268 Jedna klasa, dziewięć obiektów .......................................................................270 Nie wszystko GUI, co się świeci .......................................................................270 Rzucanie wyjątku z metody do metody .........................................................272 Prace statyczne (wyznaczanie średniej dla zespołu) ..........................................274 Dlaczego tu jest tak dużo tego static? ............................................................275 Poznaj statyczne inicjalizowanie .....................................................................276 Wyświetlanie ogólnej średniej dla zespołu ....................................................277 Słowo kluczowe static to zeszłoroczny śnieg ................................................280 Zachowaj ostrożność przy elementach statycznych ....................................280 Spis treści 9 Poleć książkęKup książkę Eksperymenty ze zmiennymi ................................................................................283 Umieszczenie zmiennej na swoim miejscu ...................................................283 Wskazywanie zmiennej, gdzie ma iść .............................................................286 Przekazywanie parametrów .................................................................................290 Przekazywanie przez wartość .........................................................................290 Zwracanie wyniku .............................................................................................292 Przekazywanie wartości przez referencję ......................................................292 Zwracanie obiektu z metody ...........................................................................294 Epilog ..................................................................................................................296 ROZDZIAŁ 11: Używanie tablic do żonglowania wartościami ............297 Ustaw gęsi w jednym rzędzie ................................................................................297 Tworzenie tablicy w dwóch prostych krokach ..............................................300 Przechowywanie wartości ...............................................................................301 Tabulatory i inne znaki specjalne ...................................................................303 Korzystanie z inicjalizatora tablicy ..................................................................303 Przechodzenie przez tablicę z rozszerzoną pętlą for ...................................304 Szukanie .............................................................................................................306 Zapisywanie do pliku ........................................................................................308 Kiedy zamknąć plik ...........................................................................................309 Tablice obiektów ....................................................................................................311 Korzystanie z klasy Room ................................................................................313 Jeszcze inny sposób na upiększenie liczb ......................................................315 Operator warunkowy .......................................................................................316 Argumenty wiersza poleceń ..................................................................................319 Używanie argumentów wiersza poleceń w programie Java ........................320 Sprawdzanie, czy liczba argumentów wiersza poleceń jest właściwa ........322 ROZDZIAŁ 12: Korzystanie z kolekcji i strumieni (gdy tablice nie są wystarczające) ...............................325 Poznawanie ograniczeń tablic ..............................................................................326 Klasy kolekcji na ratunek .......................................................................................327 Korzystanie z klasy ArrayList ...........................................................................327 Korzystanie z typów generycznych .................................................................329 Klasy opakowujące ...........................................................................................332 Sprawdzanie obecności większej ilości danych ............................................334 Korzystanie z iteratora .....................................................................................334 Wiele różnych klas kolekcji ..............................................................................335 Programowanie funkcyjne ....................................................................................337 Rozwiązanie problemu w tradycyjny sposób ................................................340 Strumienie .........................................................................................................342 10 Java dla bystrzaków Poleć książkęKup książkę Wyrażenia lambda ............................................................................................342 Typologia wyrażeń lambda ..............................................................................345 Używanie strumieni i wyrażeń lambda ..........................................................346 Po co się tak męczyć? .......................................................................................351 Referencje metod .............................................................................................353 ROZDZIAŁ 13: Wyglądaj dobrze, gdy sprawy przybierają nieoczekiwany obrót ................................355 Obsługa wyjątków ..................................................................................................356 Parametr w klauzuli catch ...............................................................................360 Typy wyjątków ...................................................................................................361 Kto złapie wyjątek? ...........................................................................................363 Łapanie dwóch lub więcej wyjątków naraz ...................................................368 Nadmierna ostrożność ....................................................................................369 Wykonywanie przydatnych rzeczy ..................................................................370 Dobre wyjątki, nasi przyjaciele ........................................................................371 Obsługa wyjątku lub przekazanie odpowiedzialności .......................................372 Kończenie pracy za pomocą klauzuli finally ........................................................378 Instrukcja try i zasoby ............................................................................................381 ROZDZIAŁ 14: Współdzielenie nazw między częściami programu w Javie ............................385 Modyfikatory dostępu ...........................................................................................386 Klasy, dostęp i programy wieloczęściowe ...........................................................387 Elementy klasy kontra klasy ............................................................................387 Modyfikatory dostępu dla elementów ...........................................................388 Umieszczanie rysunku w ramce .....................................................................391 Struktura katalogów .........................................................................................393 Tworzenie ramki ...............................................................................................393 Wymykając się z oryginalnego kodu ....................................................................396 Domyślny dostęp ..............................................................................................397 Jak wślizgnąć się do pakietu? ...........................................................................400 Dostęp chroniony ...................................................................................................401 Podklasy, które nie są w tym samym pakiecie ..............................................401 Klasy, które nie są podklasami (ale znajdują się w tym samym pakiecie) ....................................................403 Modyfikatory dostępu dla klas Javy .....................................................................406 Klasy publiczne .................................................................................................406 Klasy niepubliczne ............................................................................................407 Spis treści 11 Poleć książkęKup książkę ROZDZIAŁ 15: Fantazyjne typy referencyjne .......................................409 Typy w języku Java ..................................................................................................409 Interfejsy w języku Java ..........................................................................................410 Dwa interfejsy ...................................................................................................411 Implementowanie interfejsów ........................................................................412 Składanie wszystkich elementów razem .......................................................414 Klasy abstrakcyjne ..................................................................................................416 Opieka nad swoim zwierzakiem .....................................................................419 Używanie tych wszystkich klas ........................................................................421 Spokojnie! Nie widzisz podwójnie! .......................................................................423 ROZDZIAŁ 16: Reagowanie na naciśnięcia klawiszy i kliknięcia myszą ...........................................................427 No dalej… Naciśnij ten przycisk ............................................................................428 Zdarzenia i obsługa zdarzeń ...........................................................................430 Wątki wykonania ...............................................................................................431 Słowo kluczowe this .........................................................................................432 Wewnątrz metody actionPerformed ..............................................................433 SerialVersionUID ...............................................................................................434 Reagowanie na rzeczy inne niż kliknięcia przycisków ........................................436 Tworzenie klas wewnętrznych ..............................................................................440 ROZDZIAŁ 17: Używanie baz danych w Javie .......................................445 Tworzenie baz danych i tabel ...............................................................................446 Co się dzieje po uruchomieniu kodu ..............................................................447 Korzystanie z poleceń SQL ..............................................................................447 Podłączanie i rozłączanie .................................................................................449 Umieszczanie danych w tabeli ..............................................................................450 Pobieranie danych .................................................................................................451 Niszczenie danych ..................................................................................................452 12 Java dla bystrzaków Poleć książkęKup książkę CZĘŚĆ V: DEKALOGI ..................................................................455 ROZDZIAŁ 18: 10 sposobów unikania błędów .....................................457 Stosowanie wielkich liter we właściwych miejscach ..........................................457 Przerywanie instrukcji switch ................................................................................458 Porównywanie wartości za pomocą podwójnego znaku równości ..................458 Dodawanie komponentów do GUI .......................................................................459 Tworzenie metod obsługi zdarzeń .......................................................................459 Definiowanie wymaganych konstruktorów ........................................................459 Naprawianie odwołań do niestatycznych elementów .......................................460 Pilnowanie granic tablicy .......................................................................................460 Przewidywanie pustych wskaźników ...................................................................460 Pomóż Javie znaleźć pliki programu ....................................................................461 ROZDZIAŁ 19: Dziesięć stron o Javie .....................................................463 Strona WWW tej książki .........................................................................................463 Najważniejsze strony .............................................................................................464 Wyszukiwanie wiadomości, recenzji i przykładowego kodu .............................464 Masz pytanie techniczne? ......................................................................................464 Skorowidz .......................................................................465 Spis treści 13 Poleć książkęKup książkę 14 Java dla bystrzaków Poleć książkęKup książkę W TYM ROZDZIALE:  Czym jest język Java  Skąd się wywodzi język Java  Dlaczego język Java jest taki niesamowity  Jak zorientować się w programowaniu obiektowym Rozdział 1 Klasy w C++ M ów, co chcesz, o komputerach. Jeśli o mnie chodzi, to uważam, że kom- putery są dobre z dwóch prostych powodów:  Gdy komputery pracują, nie odczuwają oporów, stresu, nudy ani zmęczenia. Komputery są naszymi elektronicznymi niewolnikami. Mój komputer pracuje 24 godziny na dobę, 7 dni w tygodniu, wykonując obliczenia dla Cosmology@Home — rozproszonego projektu obliczeniowego, którego celem jest zbadanie modeli opisujących wszechświat. Czy jest mi przykro z powodu ciężkiej pracy mojego komputera? Czy komputer narzeka? Czy komputer zgłosi mnie do Państwowej Inspekcji Pracy? Nie. Mogę żądać, wydawać rozkazy komputerowi i strzelać z bicza. Czy czuję się (lub powinienem się czuć) choć odrobinę winny? Ani trochę.  Komputery, a nie papier poruszają idee. Jeszcze nie tak dawno temu, chcąc wysłać komuś wiadomość, trzeba było wynająć posłańca. Posłaniec wsiadł na swojego konia i osobiście dostarczył wiadomość. Wiadomość była zapisana na papierze, pergaminie, glinianej tabliczce lub jakimkolwiek innym materialnym nośniku, który był wtedy dostępny. Cały ten proces wydaje się teraz marnotrawstwem czasu, ale to tylko dlatego, że Ty i ja siedzimy wygodnie w erze elektronicznej. Wiadomości są ideami, a fizyczne rzeczy, takie jak atrament, papier i konie, mają niewiele lub nic wspólnego ROZDZIAŁ 1 Wszystko o języku Java 27 Poleć książkęKup książkę z prawdziwymi ideami; są tylko ich tymczasowymi nosicielami (pomimo że ludzie przez kilka stuleci używali ich w ten sposób). Niemniej jednak same idee istnieją bez papieru, bez koni i bez posłańców. Dobrą rzeczą w komputerach jest to, że skutecznie przenoszą idee. Przetwarzają wyłącznie idee, kilka fotonów i trochę energii elektrycznej. Robią to bez żadnych kłopotów i bez żadnego dodatkowego fizycznego bagażu. Kiedy zaczynasz skutecznie radzić sobie z ideami, dzieje się coś bardzo ciekawego. Nagle znikają wszystkie dodatkowe obciążenia. Zamiast używać papieru i atra- mentu, tworzysz liczby i koncepcje. Bez dodatkowych obciążeń możesz znacznie szybciej wykonywać swoje prace, które dodatkowo są o wiele bardziej złożone niż kiedykolwiek wcześniej. Co możesz zrobić za pomocą języka Java Byłoby miło, gdyby cała ta złożoność była dostępna za darmo, ale niestety tak nie jest. Ktoś musi się mocno zastanowić i zdecydować, o co dokładnie poprosić kom- puter. Po tych przemyśleniach ktoś musi napisać zestaw instrukcji, tak aby komputer postępował zgodnie z nimi. Biorąc pod uwagę obecny stan rzeczy, nie możesz napisać tych instrukcji w ję- zyku polskim ani w żadnym innym języku naturalnym. Fantastyka naukowa jest pełna historii o ludziach, którzy mówią proste rzeczy robotom i uzyskują katastro- falne, nieoczekiwane rezultaty. Język polski i inne mu podobne języki z kilku powodów nie nadają się do komunikacji z komputerami:  Polskie zdanie może zostać źle zinterpretowane. „Żuj jedną tabletkę trzy razy dziennie, aż do zakończenia”.  Trudno jest wytworzyć bardzo skomplikowane polecenie w języku polskim. „Połącz kołnierz A z wypukłością B, upewniając się, że tylko zewnętrzna krawędź kołnierza A jest połączona z większym końcem wypukłości B, jednocześnie łącząc środkowe i wewnętrzne krawędzie kołnierza A z przelotką C”.  Zdanie polskie ma dużo dodatkowego bagażu. „Zdanie zawiera niepotrzebne słowa”.  Język polski jest trudny do zinterpretowania. „W ramach niniejszej umowy wydawniczej między Johnem Wiley Sons, Inc. (Wiley) a autorem (Barry Burd) Wiley zapłaci kwotę tysiąca dwustu pięćdziesięciu siedmiu złotych i sześćdziesięciu trzech groszy (1257,63 zł) na rzecz autora za częściowe przesłanie książki Java dla bystrzaków (dzieło)”. 28 CZĘŚĆ I Zaczynamy pracę z językiem Java Poleć książkęKup książkę Aby powiedzieć komputerowi, co ma robić, musisz użyć specjalnego języka składa- jącego się ze zwięzłych, jednoznacznych instrukcji. Specjalny język tego rodzaju nazywany jest językiem programowania komputera. Zestaw instrukcji napisanych w takim języku nazywany jest programem. Gdy potraktujemy je jak wielki zbiór instrukcji, to będziemy mogli nazywać je oprogramowaniem lub kodem. Oto jak wygląda taki kod, gdy jest napisany w języku Java: public class PayBarry { public static void main(String args[]) { double checkAmount = 1257.63; System.out.print( Zapłać za rachunek od ); System.out.print( dr. Barry’ego Burda ); System.out.print( PLN ); System.out.println(checkAmount); } } Dlaczego warto używać języka Java Czas świętować! Masz już w ręce kopię książki Java dla bystrzaków i czytasz 1. rozdział. W tym tempie w krótkim czasie staniesz się ekspertem w dziedzinie języka Java1, więc ciesz się z ewentualnego sukcesu, rzucając się w wir wielkiej zabawy. Aby przygotować się do imprezy, trzeba będzie upiec ciasto. Jestem leniwy, więc użyję gotowej mieszanki do pieczenia ciasta. Zobaczmy… dodaj wodę do mieszanki, a następnie dodaj masło i jajka — hej, zaczekaj! Właśnie spojrzałem na listę skład- ników. Co to jest MSG? A co to jest glikol propylenowy? Te składniki są chyba uży- wane w płynach przeciw zamarzaniu, prawda? Jednak zmienię plany i zrobię ciasto samodzielnie. Oczywiście, jest trochę trud- niej, ale w ten sposób otrzymuję dokładnie to, czego chcę. Programy komputerowe działają w ten sam sposób. Możesz użyć cudzego pro- gramu lub napisać własny. Jeśli korzystasz z cudzego programu, używasz wszyst- kiego, co jest w nim zawarte. Kiedy piszesz własny program, możesz dostosować program specjalnie do swoich potrzeb. Pisanie kodu komputerowego to duży światowy przemysł. Robią to firmy, nieza- leżni specjaliści, robią to hobbyści — robi to wiele różnych ludzi. Typowa duża firma posiada zespoły, działy i departamenty, które piszą dla niej programy. Ale możesz pisać programy dla siebie lub kogoś innego, dla zarobku lub dla zabawy. 1 W kręgach zawodowych obowiązki twórcy oprogramowania są zazwyczaj szersze niż obowiązki samego programisty. Ale w tej książce używam terminów programista i twórca oprogramowania niemalże zamiennie. ROZDZIAŁ 1 Wszystko o języku Java 29 Poleć książkęKup książkę Według ostatnich szacunków liczba wierszy kodu pisanego każdego dnia przez samych programistów w Stanach Zjednoczonych przekracza liczbę cząsteczek metanu na planecie Jowisz.2 Zastanów się, co można zrobić przy użyciu kompu- tera. Mając wystarczająco dużo czasu, możesz napisać własny program realizu- jący wybrane zadanie. (Oczywiście „wystarczająco dużo czasu” może okazać się bardzo długim okresem, ale nie o to chodzi. Wiele ciekawych i przydatnych programów można napisać w ciągu kilku godzin lub nawet minut). Informacje historyczne: skąd pochodzi Java Oto krótka historia nowoczesnego programowania komputerowego:  1954 – 1957 — powstaje język FORTRAN. FORTRAN był pierwszym nowoczesnym językiem programowania komputerowego. Jeżeli chodzi o programowanie naukowe, to FORTRAN jest naprawdę niedościgniony. Z roku na rok FORTRAN stawał się coraz bardziej wiodącym językiem wśród programistów komputerowych na całym świecie.  1959 — Grace Hopper w Remington Rand tworzy język programowania COBOL. Litera B w nazwie języka COBOL oznacza biznes, i to na nim koncentruje się ten język. Podstawową cechą tego języka jest przetwarzanie jednego rekordu za drugim, jednego klienta po drugim lub jednego pracownika po drugim. W ciągu kilku lat od swojego powstania COBOL stał się najczęściej używanym językiem do przetwarzania danych biznesowych.  1972 — Dennis Ritchie z AT T Bell Labs opracowuje język programowania C. Charakter kodu widocznego w przykładach z tej książki pochodzi z języka programowania C. W kodzie napisanym w języku C używa się nawiasów klamrowych, instrukcji if, for i tak dalej. Jeśli chodzi o zakres zastosowań, to możesz użyć języka C, aby rozwiązać te same problemy, które możesz także rozwiązać przy użyciu języka FORTRAN, Java lub dowolnego innego nowoczesnego języka programowania. (Możesz na przykład napisać program kalkulatora naukowego w języku COBOL, ale to byłoby już naprawdę dziwne). Różnica między jednym językiem programowania a innym nie polega zatem na ich możliwościach. Różnica polega na łatwości używania danego języka i poziomie dopasowania go do danego zadania. Tutaj właśnie wyróżnia się język Java. 2 Sam to wymyśliłem. 30 CZĘŚĆ I Zaczynamy pracę z językiem Java Poleć książkęKup książkę  1986 — Bjarne Stroustrup (ponownie w AT T Bell Labs) opracowuje C++. W przeciwieństwie do swojego przodka (języka C) język C++ pozwala na programowanie obiektowe. Ta nowa możliwość stanowi ogromny krok naprzód (zobacz następny podrozdział).  23 maja 1995 — Sun Microsystems wydaje pierwszą oficjalną wersję języka programowania Java. Java ulepsza jeszcze koncepcje zawarte w języku C++. Filozofia języka Java „napisz raz, uruchom gdziekolwiek” sprawia, że język jest idealny do rozpowszechniania kodu w internecie. Ponadto Java jest doskonałym językiem programowania ogólnego przeznaczenia. Dzięki Javie możesz pisać aplikacje okienkowe, tworzyć i przeszukiwać bazy danych, kontrolować urządzenia przenośne i jeszcze o wiele, wiele więcej. W ciągu pięciu krótkich lat język programowania Java miał 2,5 miliona programistów na całym świecie. (Wiem. Mam na dowód pamiątkową koszulkę).  Listopad 2000 — College Board ogłasza, że począwszy od roku 2003, egzaminy Advanced Science z Computer Science będą oparte na Javie. Chcesz wiedzieć, czego ten nudziarz mieszkający na końcu ulicy uczy się w szkole średniej? Zgadłeś — języka Java.  2002 — Microsoft wprowadza nowy język o nazwie C#. Wiele funkcji języka C# pochodzi bezpośrednio z języka Java.  Czerwiec 2004 — Sys-Con Media donosi, że popyt na programistów Javy przewyższa popyt na programistów C++ o 50 (http://java.sys-con.com/node/48507). I to nie wszystko! Zapotrzebowanie na programistów języka Java o 8 przekracza łączne zapotrzebowanie na programistów języka C++ i C#. Programiści Javy są o 190 bardziej pożądani niż programiści języka Visual Basic (VB).  2007 — Google przyjmuje język Java jako podstawowy język do tworzenia aplikacji na urządzeniach mobilnych z Androidem.  Styczeń 2010 — Oracle Corporation kupuje Sun Microsystems, wprowadzając technologię Java do rodziny produktów Oracle.  Czerwiec 2010 — eWeek plasuje Javę na pierwszym miejscu listy „10 najpopularniejszych języków programowania pozwalających utrzymać zatrudnienie” (www.eweek.com/c/a/Application-Development/Top-10- Programming-Languages-to-Keep-You-Employed-719257).  2016 — Java działa na 15 miliardach urządzeń (http://java.com/en/about), a Android Java działa na 87,6 wszystkich telefonów komórkowych na całym świecie (www.idc.com/prodserv/smartphone-os-market- share.jsp). ROZDZIAŁ 1 Wszystko o języku Java 31 Poleć książkęKup książkę Ponadto technologia Java zapewnia interaktywne możliwości wszystkim urządzeniom Blu-ray i jest najpopularniejszym językiem programowania w Indeksie Społeczności Programistycznej (Programming Community Index) TIOBE (www.tiobe.com/index.php/content/paperinfo/tpci), na PYPL: indeks popularności języków programowania (PopularitY of Programming Language Index) (http://sites.google.com/site/pydatalog/pypl/PyPL-PopularitY-of-Programming- Language) oraz na innych indeksach. Jestem pod wrażeniem. Programowanie obiektowe (OOP) Jest trzecia rano. Śnię o egzaminie z historii w szkole średniej, który udało mi się oblać. Nauczyciel krzyczy na mnie: „Masz dwa dni na naukę do sprawdzianu końcowego, ale nie pamiętasz o tym, żeby się uczyć. Zapomnisz o tym i poczu- jesz się winny, winny, winny”. Nagle dzwoni telefon. Obudziłem się wyrwany z głębokiego snu. (Jasne, nie po- dobał mi się sen o egzaminie z historii, ale jeszcze bardziej nie lubię się z nagła obudzić). Po pierwsze upuszczam telefon na podłogę. Po jego niezdarnym pod- niesieniu wydaję zrzędliwe: „Cześć, kto to?”. Głos odpowiada: „Jestem reporterem z »New York Timesa«. Piszę artykuł o Javie i muszę wiedzieć wszystko o tym języku programowania w pięciu lub mniej słowach. Możesz nam przybliżyć ten temat?”. Mój umysł jest zbyt zamglony. Nie mogę myśleć. Mówię więc pierwszą rzecz, która przychodzi mi do głowy, a potem wracam spać. Rano prawie nie pamiętam rozmowy z reporterem. Nie pamiętam nawet, w jaki sposób odpowiedziałem na to pytanie. Czy powiedziałem reporterowi, gdzie może sobie wsadzić ten artykuł o Javie? Zakładam wdzianko i wybiegam na podjazd przed domem. Gdy zabieram poranną gazetę, spoglądam na pierwszą stronę i widzę nagłówek w rozmiarze dwóch cali: Burd nazywa język Java „świetnym językiem obiektowym”. Języki obiektowe Java jest zorientowana obiektowo. Co to znaczy? W przeciwieństwie do języków takich jak FORTRAN, które koncentrują się na wydawaniu komputerowi poleceń „Zrób to, zrób tamto”, języki obiektowe skupiają się na danych. Oczywiście pro- gramy zorientowane obiektowo nadal informują komputer, co ma robić, ale za- czynają jednak od uporządkowania danych, a polecenia pojawiają się później. 32 CZĘŚĆ I Zaczynamy pracę z językiem Java Poleć książkęKup książkę Języki zorientowane obiektowo są lepsze od języków „Zrób to, zrób tamto”, po- nieważ organizują dane w sposób, który pomaga ludziom zrobić z nimi różne rzeczy. Aby zmodyfikować dane, możesz korzystać z tego, co już masz, zamiast wyrzucać wszystko, co zrobiłeś, i zaczynać od nowa za każdym razem, gdy mu- sisz zrobić coś nowego. Chociaż programiści komputerowi są zazwyczaj inteli- gentnymi ludźmi, trochę czasu zajęło im rozgryzienie tego tematu. Pełna lekcja historii znajduje się w ramce „Kręta droga z FORTRAN-a do Javy” (ale nie będę mieć Ci za złe, jeśli jej nie przeczytasz). KRĘTA DROGA Z FORTRAN-A DO JAVY W połowie lat 50. XX wieku zespół ludzi stworzył język programowania o nazwie FORTRAN. Był to dobry język, ale opierał się na idei, że należy wydawać kompute- rowi bezpośrednie, imperatywne polecenia. „Komputer, zrób to. Komputer, zrób tamto”. (Oczywiście komendy w prawdziwym programie FORTRAN były znacznie bardziej precyzyjne niż takie ogólne „zrób to” lub „zrób tamto”). W kolejnych latach zespoły programistów opracowały wiele nowych języków pro- gramowania komputerów, a wiele z tych języków skopiowało znany z FORTRAN-a model „zrób to, zrób tamto”. Jeden z bardziej popularnych języków z tej grupy otrzymał jednoliterową nazwę — C. Oczywiście obóz „zrób to, zrób tamto” miał kilku odszczepieńców. W językach o nazwach SIMULA i Smalltalk programiści przenieśli niezbędne polecenia „zrób to” na drugi plan i skoncentrowali się na opisie danych. W tych językach nie można było bezpośrednio powiedzieć: „Wydrukuj mi listę zale- głych rachunków”, zamiast tego trzeba było zaczynać od stwierdzenia: „Tak wygląda konto. Konto ma swoją nazwę i saldo”. Następnie można było powiedzieć: „A tak można zapytać konto, czy ma ono zaległości”. Nagle dane stały się najważniejsze. Konto było czymś, co miało nazwę, saldo i odpowiedni sposób na przekazanie Ci in- formacji dotyczących zaległych płatności. Języki, które skupiają się przede wszystkim na danych, nazywane są językami pro- gramowania obiektowego. Stanowią one doskonałe narzędzia programistyczne. Oto lista powodów, dlaczego tak jest:  Jeżeli najpierw skupiasz się na danych, to znaczy, że jesteś dobrym programistą komputerowym.  Możesz w kółko rozszerzać i ponownie wykorzystywać opisy danych. Kiedy próbujesz nauczyć stare programy FORTRAN nowych sztuczek, pokazują one, jak bardzo są kruche. Po prostu psują się. W latach 70. XX wieku języki zorientowane obiektowo, takie jak na przykład SIMULA i Smalltalk, wspominane były jedynie w artykułach hobbystycznego magazynu kompu- terowego. Natomiast w międzyczasie języki oparte na starym modelu FORTRAN roz- mnażały się jak króliki. ROZDZIAŁ 1 Wszystko o języku Java 33 Poleć książkęKup książkę Jednak w 1986 roku człowiek o nazwisku Bjarne Stroustrup stworzył język o nazwie C++. Stał się on bardzo popularny, ponieważ zmieszał starą terminologię języka C z ulepszoną strukturą obiektową. Wiele firm odwróciło się od starego stylu programo- wania FORTRAN/C i przyjęło język C++ jako swój standard. Ale język C++ miał pewną wadę. Używając go, można pominąć wszystkie funkcje obiektowe i napisać program przy użyciu starego stylu programowania FORTRAN/C. Podczas pisania programu księgowego w języku C++ możesz wybrać jedną z dróg:  Zacząć od wydawania bezpośrednich poleceń komendami „zrób to”, tworząc matematyczny odpowiednik polecenia: „Wydrukuj listę kont z zaległościami i zrób to szybko”.  Wybrać podejście zorientowane obiektowo i opisać najpierw, jak ma wyglądać konto. Niektórzy mówili, że programowanie w języku C++ oferuje najlepsze z obu światów, ale inni twierdzili, że pierwszy świat (świat FORTRAN i C) nie powinien być częścią nowoczesnego programowania. Gdybyś dał programistom możliwość pisania kodu w dowolny sposób, zbyt często zdecydowaliby się na napisanie go w sposób nie- właściwy. W 1995 roku James Gosling z firmy Sun Microsystems stworzył język o nazwie Java. Tworząc Javę, Gosling zapożyczył wygląd języka C++, ale większość jego starych funkcji „zrób to, zrób tamto” wrzucił do kosza. Następnie dodał funkcje, dzięki któ- rym tworzenie obiektów było znacznie łatwiejsze. W sumie Gosling stworzył język, którego filozofia obiektowa jest przejrzysta i czysta. Kiedy programujesz w Javie, nie masz innego wyboru; musisz pracować z obiektami. I tak właśnie powinno być. Obiekty i ich klasy W języku zorientowanym obiektowo do porządkowania danych używa się obiek- tów oraz klas. Wyobraź sobie, że piszesz program komputerowy przechowujący informacje o do- mach w nowej inwestycji domków własnościowych (wciąż w budowie). Domy różnią się tylko nieznacznie od siebie, każdy z nich ma charakterystyczny kolor elewacji, kolor ścian wewnętrznych oraz styl szafek kuchennych i tak dalej. W Twoim zorientowanym obiektowo programie komputerowym każdy dom jest obiektem. Ale same obiekty to nie wszystko. Chociaż domy różnią się nieco od siebie, wszystkie mają tę samą listę wspólnych cech. Na przykład każdy dom ma cechę zwaną kolorem elewacji, każdy z nich ma też cechę zwaną stylem szafek kuchen- nych. W Twoim programie obiektowym potrzebna jest główna lista zawierająca wszystkie te cechy, które może mieć obiekt domu. Ta główna lista cech nazywa się klasą. 34 CZĘŚĆ I Zaczynamy pracę z językiem Java Poleć książkęKup książkę A to dopiero! Programowanie obiektowe otrzymało błędną nazwę. Powinno być nazywane „programowaniem za pomocą klas i obiektów”. Teraz zauważ, że najpierw użyłem słowa klasa. Dlaczego to zrobiłem? Wbrew pozorom jeszcze nie oszalałem. Pomyśl o tym, jak budowany jest nowo powsta- jący dom. Gdzieś w okolicy w rozklekotanej przyczepie zaparkowanej przy dro- dze znajduje się główna lista cech znanych jako projekt. Projekt architekta przypomina klasę programisty stosującego rozwiązania obiektowe Projekt to lista cech, które będzie miał każdy dom. W projekcie zapisana jest „elewacja”, a rze- czywisty obiekt domu ma szarą elewację. W projekcie znajdziesz element „szafka kuchenna”, a rzeczywisty obiekt domu ma szafki kuchenne w stylu Ludwika XIV. Analogia nie kończy się na listach cech. Istnieje jeszcze jedna ważna paralela między planami a klasami. Rok po utworzeniu projektu możesz użyć go do bu- dowy dziesięciu domów. To samo dotyczy klas i obiektów. Najpierw programista pisze kod opisujący klasę. Po uruchomieniu programu komputer tworzy obiekty na podstawie klasy (projektu). To jest prawdziwy związek między klasami i obiektami. Programista definiuje klasę, a na jej podstawie komputer tworzy poszczególne obiekty. Co jest takiego dobrego w języku zorientowanym obiektowo? Korzystając z opowieści o budowie domu z poprzedniego punktu, wyobraź sobie, że napisałeś już program komputerowy, który śledzi kolejne kroki budowy do- mów na nowym osiedlu. I wtedy ważny szef firmy decyduje o zmodyfikowaniu planu budowy, tak że połowa z domów będzie miała trzy sypialnie, a druga po- łowa będzie wyposażona w cztery. Jeśli używasz starego stylu programowania komputerowego FORTRAN/C, Twoje instrukcje będą wyglądały tak: Wykop ziemię pod fundamenty. Wylej beton na ławy fundamentów. Połóż dwa czworoboki wzdłuż boków ław fundamentów. ... Wyglądałoby to tak, jakby architekt tworzył długą listę instrukcji zamiast nary- sować plan. Aby znaleźć instrukcje dotyczące budowania sypialni, musisz zmo- dyfikować plan budowy, sortując listę kolejnych kroków. Co gorsza, poszczegól- ne instrukcje mogą się znajdować na stronach 234, 394 – 410, 739, 10 i 2. Jeśli budowlaniec musiałby rozszyfrować skomplikowane instrukcje innych ludzi, zada- nie byłoby dziesięć razy trudniejsze. ROZDZIAŁ 1 Wszystko o języku Java 35 Poleć książkęKup książkę Rozpoczęcie prac nad programem od przygotowania klasy jest podobne do roz- poczęcia budowy domu od przygotowania projektu. Jeśli zdecydujesz się budo- wać domy z trzema i czterema sypialniami, możesz zacząć od ogólnego projektu zwanego planem domu, na którym znajdzie się rysunek parteru i piętra, ale nie będzie rozrysowanych na piętrze ścian wewnętrznych. Następnie tworzysz dwa projekty piętra — jeden dla domu z trzema sypialniami, a drugi dla domu z cztere- ma sypialniami. (Nazywasz te nowe plany domem z trzema sypialniami i domem z czterema sypialniami). Twoi koledzy budowlańcy są zdumieni Twoim poczuciem logiki i organizacji, ale mają zastrzeżenia. I zadają pytanie: „Nazwałeś jeden z projektów domem z trzema sypialniami. To się nie zgadza. Ale to jest przecież projekt samego piętra, a nie całego domu?”. Mądrze się uśmiechasz i mówisz: „Zauważcie, że w projekcie domu z trzema sypialniami znajduje się notatka: »informacje na temat dolnych pięter znajdują się w oryginalnym projekcie domu«. W ten sposób projekt domu z trzema sypial- niami staje się kompletnym projektem całego domu. W projekcie domu z czte- rema sypialniami znajdziecie taką samą notatkę. Dzięki tej konfiguracji możemy wykorzystać całą wykonaną wcześniej pracę, aby opracować kompletny projekt domu i zaoszczędzić mnóstwo pieniędzy”. W języku programowania obiektowego klasy domów z trzema i czterema sypial- niami dziedziczą cechy oryginalnej klasy domu. Można również powiedzieć, że klasy domów z trzema i czterema sypialniami rozszerzają pierwotną klasę domów (patrz rysunek 1.1). RYSUNEK 1.1. Terminologia w programowaniu obiektowym Oryginalna klasa domu nazywa się klasą nadrzędną klas domów trzy- i czteropoko- jowych. Podążając tym tropem, można powiedzieć, że klasy domów z trzema i czte- rema sypialniami są podklasami oryginalnej klasy domu. Innymi słowy, oryginalna 36 CZĘŚĆ I Zaczynamy pracę z językiem Java Poleć książkęKup książkę klasa domu nazywa się klasą bazową klas domów trzy- i czteroosobowych. Klasy domów z trzema i czterema sypialniami są klasami potomnymi pierwotnej klasy domu (patrz rysunek 1.1). Nie trzeba dodawać, że Twoi koledzy budowlańcy są zazdrośni. Cały tłum ludzi kręci się wokół Ciebie, aby usłyszeć o Twoich wspaniałych pomysłach. W tym momencie dorzucasz jeszcze jedną rewelację: „Tworząc klasę z podklasami, mo- żemy w przyszłości ponownie wykorzystać nasz projekt. Jeśli ktoś w przyszłości zażyczy sobie projektu domu z pięcioma sypialniami, możemy rozszerzyć nasz oryginalny plan domu, tworząc wersję z pięcioma sypialniami. Nigdy więcej nie będziemy musieli wydawać pieniędzy na oryginalny plan domu”. „Ale co się stanie, jeśli ktoś zechce inny projekt parteru? — pyta kolega z tylnego rzędu. — Będzie trzeba wyrzucić oryginalny plan domu, czy zaczniemy poprawiać gotowy, oryginalny projekt? To będzie sporo kosztować, prawda?” Pewnym tonem odpowiadasz: „Nie musimy nawet dotykać oryginalnego projektu domu. Jeśli ktoś chce jacuzzi w swoim salonie, możemy stworzyć nowy, mały projekt opisujący tylko nowy salon i nazwać go projektem domu z jacuzzi. Ten no- wy projekt może odwoływać się do oryginalnego projektu domu, pobierając z niego informacje o pozostałej części domu (części, która nie znajduje się w salonie)”. W języku programowania obiektowego projekt domu z jacuzzi w salonie nadal rozszerza oryginalny plan domu. Projekt domu z jacuzzi jest nadal podklasą ory- ginalnego planu domu. Nadal obowiązuje tu cała terminologia dotycząca klasy nadrzędnej, klasy bazowej i klasy potomnej. Jedyną nowością jest to, że projekt domu z jacuzzi zastępuje funkcje salonu w oryginalnym projekcie domu. W czasach poprzedzających języki obiektowe świat programowania doświadczył kryzysu w rozwoju oprogramowania. Programiści pisali kod, następnie pojawiały się nowe potrzeby, przez co byli zmuszeni zniszczyć swój kod i zacząć od zera. Ten problem wciąż się powtarzał, ponieważ kod, który pisali programiści, nie mógł być ponownie użyty. Programowanie zorientowane obiektowo zmieniło to wszystko na lepsze (a jak powiedział Burd, Java to „świetny język obiektowy”). Lepsze zrozumienie klas i obiektów Podczas programowania w Javie stale pracujesz z klasami i obiektami. Te dwie idee są naprawdę ważne. To dlatego w tym rozdziale będę prezentował kolejne ana- logie opisujące klasy i obiekty. Zamknij na chwilę oczy i pomyśl, co to znaczy, że coś jest krzesłem… Krzesło ma siedzisko, podparcie pleców i nogi. Każde siedzisko ma kształt, kolor, stopień miękkości i tak dalej. To są właściwości każdego krzesła. To, co o czym teraz piszę, to istota krzesła — opis czegoś, co jest krzesłem. Stosując terminologię obiektową, opisuję tutaj klasę Chair. ROZDZIAŁ 1 Wszystko o języku Java 37 Poleć książkęKup książkę Teraz odłóż na chwilę tę książkę i rozejrzyj się po swoim pokoju. (Jeśli nie sie- dzisz teraz w swoim pokoju, spróbuj sobie go wyobrazić). W pokoju jest kilka krzeseł, a każde krzesło jest obiektem. Każdy z tych obiektów jest przykładem tej eterycznej rzeczy zwanej klasą Chair. Tak to działa — klasa jest opisem istoty krzesła, a każde krzesło jest obiektem. Klasa nie jest jedynie zbiorem elementów. W pewnym sensie jest ona ideą pew- nego rodzaju rzeczy. Kiedy mówię o klasie krzeseł z Twojego pokoju, mówię o tym, że każde z nich ma nogi, siedzisko, kolor i tak dalej. Każde z krzeseł znajdujących się w pokoju może mieć inny kolor, ale to nie ma znaczenia. Kiedy mówisz o klasie rzeczy, skupiasz się na właściwościach, które ma każda z tych rzeczy. Sensowne w tym miejscu jest myślenie o obiekcie jako konkretnym egzemplarzu danej klasy. I rzeczywiście, oficjalna terminologia jest zgodna z tym tokiem my- ślenia. Jeśli napiszesz program w języku Java, w którym to zdefiniujesz klasę Chair, każde rzeczywiste krzesło (krzesło, na którym siedzisz, puste krzesło tuż obok itd.) nazywane będzie instancją klasy Chair. A oto inny sposób myślenia o klasie. Wyobraź sobie tablicę wyświetlającą dane Twoich trzech kont bankowych (patrz tabela 1.1). TABELA 1.1. Tabela kont Numer konta 16-13154-22864-7 Typ konta Konto główne 1011 1234 2122 0000 Kredyt 16-17238-13344-7 Oszczędności Saldo konta 174,87 –471,03 247,38 Możesz myśleć o zbiorze nagłówków kolumn tabeli jak o klasie, a o każdym wierszu tabeli jak o obiekcie. Nagłówki kolumn tabeli opisują klasę Account. Zgodnie z nagłówkami kolumn tabeli każde konto ma numer konta, typ konta i saldo. Definiując to w terminologii programowania zorientowanego obiektowo, każdy obiekt klasy Account (tj. każda instancja klasy Account) ma numer konta, typ konta i saldo konta. Tak więc dolny wiersz tabeli jest obiektem o numerze konta 16-17238-13344-7, ma on typ Oszczędności i saldo 247,38. Po otworzeniu nowego konta mielibyśmy kolejny obiekt, a tabela powiększyłaby się o dodatkowy wiersz. Taki nowy obiekt byłby instancją tej samej klasy Account. 38 CZĘŚĆ I Zaczynamy pracę z językiem Java Poleć książkęKup książkę Co dalej? Ten rozdział wypełniony jest ogólnymi opisami różnych rzeczy. Ogólny opis jest dobry w momencie, gdy dopiero zaczynasz poznawać tę tematykę, ale tak na- prawdę rozumiesz to wszystko po poznaniu dodatkowych szczegółów. Dlatego w następnych kilku rozdziałach będę omawiał te szczegóły. Proszę więc, przewróć tę stronę. Następny rozdział już się nie może doczekać, aż go przeczytasz. ROZDZIAŁ 1 Wszystko o języku Java 39 Poleć książkęKup książkę 40 CZĘŚĆ I Zaczynamy pracę z językiem Java Poleć książkęKup książkę
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Java dla bystrzaków. Wydanie VII
Autor:

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: