Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00128 004797 19012631 na godz. na dobę w sumie
Java dla zupełnie początkujących. Owoce programowania. Wydanie VII - książka
Java dla zupełnie początkujących. Owoce programowania. Wydanie VII - książka
Autor: Liczba stron: 1176
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-283-4829-5 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> java - programowanie
Porównaj ceny (książka, ebook (-35%), audiobook).

Od struktur sterujących po obiekty

Java jest rozbudowanym, elastycznym i wszechstronnym, a przy tym dojrzałym językiem programowania. Pozwala na tworzenie kodu dla prawie wszystkich rodzajów komputerów, również tych sterujących pracą najbardziej wyspecjalizowanych urządzeń. Można go używać do pisania dużych systemów, małych programów, aplikacji mobilnych i aplikacji WWW. Jest znakomitym wyborem dla osób, które postanowiły związać swoją przyszłość zawodową z którąś z wielu gałęzi informatyki. Aby optymalnie wykorzystać potencjał drzemiący w Javie, koniecznie trzeba zadbać o solidne podstawy - zarówno w teorii, jak i w praktyce kodowania.

Oto zaktualizowane i uzupełnione wydanie cenionego podręcznika dla studentów. Książka została pomyślana w taki sposób, aby maksymalnie ułatwić naukę Javy krok po kroku i pozwolić na możliwie szybkie rozpoczęcie samodzielnego kodowania. Znalazło się tu wprowadzenie do wiedzy o sprzęcie, oprogramowaniu, wykonywaniu programów i kompilacji kodu. Dzięki temu nawet zupełnie początkujące osoby zaczną płynnie posługiwać się typami danych, zmiennymi czy instrukcjami sterującymi. Bardzo starannie omówiono takie tematy jak klasy, obiekty i dziedziczenie. Nie zabrakło wprowadzenia do pracy z bazami danych, plikami czy też podstaw budowy graficznego interfejsu użytkownika za pomocą nowej biblioteki JavaFX.

W tej książce między innymi:

Java: zdobądź solidne podstawy i programuj jak mistrz!

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

Darmowy fragment publikacji:

Tytuł oryginału: Starting Out with Java: From Control Structures through Objects (7th Edition) Tłumaczenie: Tomasz Walczak ISBN: 978-83-283-4829-5 Authorized translation from the English language edition, entitled: STARTING OUT WITH JAVA: FROM CONTROL STRUCTURES THROUGH OBJECTS, Seventh Edition; ISBN 0134802217; by Tony Gaddis; published by Pearson Education, Inc. Copyright © 2019, 2016, 2013 by Pearson Education, Inc., Hoboken, New Jersey 07030. 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 Pearson Education, Inc. Polish language edition published by Helion SA. Copyright © 2019. 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. Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi ich właścicieli. 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. Helion SA ul. Kościuszki 1c, 44-100 Gliwice tel. 32 231 22 19, 32 230 98 63 e-mail: helion@helion.pl WWW: http://helion.pl (księgarnia internetowa, katalog książek) Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/javzp2 Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. Pliki z przykładami omawianymi w książce można znaleźć pod adresem: ftp://ftp.helion.pl/przyklady/javzp2.zip Printed in Poland. • Kup książkę • Poleć książkę • Oceń książkę • Księgarnia internetowa • Lubię to! » Nasza społeczność Spis treści Przedmowa ...................................................................... 21 1.4. ROZDZIAŁ 1. Wprowadzenie do komputerów i Javy .......................... 31 1.1. Wprowadzenie ...................................................................31 Po co programować? ..........................................................31 1.2. Systemy komputerowe: sprzęt i oprogramowanie ................33 1.3. Sprzęt ................................................................................33 Oprogramowanie ...............................................................36 Języki programowania ........................................................37 Czym jest program? ............................................................37 Historia języka Java .............................................................38 Z czego składa się program? ...............................................40 Elementy języka ..................................................................40 Wiersze i instrukcje .............................................................42 Zmienne .............................................................................42 Kompilator i maszyna wirtualna Javy ...................................43 Wersje oprogramowania Java ..............................................45 Kompilowanie i uruchamianie programów w Javie ...............46 Proces programowania .......................................................48 Inżynieria oprogramowania .................................................50 Programowanie obiektowe .................................................51 1.7. Pytania kontrolne i ćwiczenia ...........................................................53 Zadania programistyczne .................................................................57 1.5. 1.6. ROZDZIAŁ 2. Podstawy Javy ................................................................ 59 2.1. Części programu w Javie .....................................................59 2.2. Metody print i println oraz interfejs API Javy ........................65 5 Poleć książkęKup książkę 6 Spis treści 2.3. 2.4. 2.5. 2.6. 2.7. Zmienne i literały ................................................................70 Wyświetlanie wielu elementów za pomocą operatora + ......72 Zachowaj ostrożność przy cudzysłowach .............................73 Jeszcze o literałach ..............................................................73 Identyfikatory .....................................................................74 Nazwy klas .........................................................................76 Proste typy danych ..............................................................76 Całkowitoliczbowe typy danych ..........................................78 Typy zmiennoprzecinkowe ..................................................79 Typ danych boolean ............................................................82 Typ danych char .................................................................82 Inicjowanie zmiennych i przypisywanie do nich wartości ......84 Zmienne w danym momencie przechowują tylko jedną wartość ............................................................85 Operatory arytmetyczne ......................................................86 Dzielenie całkowitoliczbowe ................................................89 Pierwszeństwo operatorów .................................................89 Grupowanie z użyciem nawiasów ........................................91 Klasa Math .........................................................................94 Złożone operatory przypisania .............................................95 Konwersja prostych typów danych na inne takie typy ...........97 Operacja na różnych typach całkowitoliczbowych ................99 Inne wyrażenia matematyczne z różnymi typami ................100 Tworzenie nazwanych stałych za pomocą słowa kluczowego final ..............................................................101 Klasa String ......................................................................103 Obiekty są tworzone na podstawie klas .............................103 Klasa String ......................................................................104 Zmienne typów prostych i zmienne będące instancją klasy ... 104 Tworzenie obiektu typu String ..........................................105 Zasięg ..............................................................................108 2.10. 2.11. Komentarze ......................................................................110 2.12. Styl programowania .........................................................114 2.13. Wczytywanie danych wejściowych z klawiatury ..................116 Wczytywanie znaków .......................................................120 Łączenie wywołań metody nextLine z wywołaniami innych metod klasy Scanner .......................120 2.14. Okna dialogowe ...............................................................123 Wyświetlanie okien dialogowych .......................................124 Wyświetlanie okien dialogowych na dane wejściowe .........124 Przykładowy program .......................................................125 Przekształcanie tekstowych danych wejściowych na liczby .....126 2.8. 2.9. Poleć książkęKup książkę Spis treści 7 2.15. Typowe błędy, których należy unikać .................................129 Pytania kontrolne i ćwiczenia .........................................................131 Zadania programistyczne ...............................................................137 3.1. ROZDZIAŁ 3. Struktury decyzyjne ...................................................... 143 Instrukcja if .......................................................................143 Używanie operatorów relacji do tworzenia warunków .......145 Łączenie wszystkich informacji ..........................................147 Style programowania a instrukcja if ...................................149 Uważaj na średniki ............................................................149 Warunkowe wykonywanie wielu instrukcji .........................150 Flagi .................................................................................150 Porównywanie znaków .....................................................151 Instrukcja if-else ................................................................152 Zagnieżdżone instrukcje if .................................................154 Instrukcja if-else-if .............................................................160 Operatory logiczne ...........................................................165 Pierwszeństwo operatorów logicznych ..............................170 Sprawdzanie przynależności liczb do przedziałów za pomocą operatorów logicznych ....................................171 Porównywanie obiektów typu String .................................172 Ignorowanie wielkości znaków przy porównywaniu łańcuchów .........................................176 Jeszcze o deklarowaniu i zasięgu zmiennych ......................178 Operator warunkowy (opcjonalny) ....................................179 Instrukcja switch ...............................................................180 3.7. 3.8. 3.9. 3.10. Wyświetlanie sformatowanych danych wyjściowych 3.2. 3.3. 3.4. 3.5. 3.6. za pomocą instrukcji System.out.printf i String.format .......189 Składnia specyfikatorów formatowania .............................192 Precyzja ............................................................................193 Określanie minimalnej szerokości pola ...............................194 Opcje ...............................................................................196 Formatowanie argumentów w postaci łańcuchów znaków ...........................................199 Metoda String.format .......................................................200 3.11. Typowe błędy, których należy unikać .................................203 Pytania kontrolne i ćwiczenia .........................................................204 Zadania programistyczne ...............................................................210 Poleć książkęKup książkę 8 Spis treści 4.1. 4.2. 4.3. 4.4. 4.5. ROZDZIAŁ 4. Pętle i pliki ..................................................................... 217 Operatory inkrementacji i dekrementacji ............................217 Różnice między trybami przyrostkowym i przedrostkowym ............................................................219 Pętla while ........................................................................221 Pętla while jest testowana na początku .............................223 Pętle nieskończone ...........................................................224 Nie zapominaj o umieszczaniu bloku instrukcji w nawiasie klamrowym .....................................................225 Styl programowania i pętla while ......................................225 Stosowanie pętli while do sprawdzania poprawności danych wejściowych .........................................................227 Pętla do-while ..................................................................231 Pętla for ...........................................................................233 Pętla for jest pętlą ze sprawdzaniem wstępnym .................237 Unikaj modyfikowania zmiennej sterującej w ciele pętli for ............................................................................237 Inne formy wyrażenia aktualizującego ...............................237 Deklarowanie zmiennej w wyrażeniu inicjującym pętli for ...237 Tworzenie pętli for sterowanych przez użytkownika ..........238 Używanie wielu instrukcji w wyrażeniach inicjującym i aktualizującym ................................................................239 Suma bieżąca i wartość wartownika ..................................242 Stosowanie wartownika ....................................................245 Pętle zagnieżdżone ...........................................................247 4.7. 4.8. Instrukcje break i continue (opcjonalne) .............................254 4.9. Wybieranie rodzaju pętli ...................................................255 4.10. Wprowadzenie do zapisu i odczytu plików ........................255 Stosowanie klasy PrintWriter do zapisu danych w pliku ......256 Dołączanie danych do pliku ...............................................262 Określanie lokalizacji pliku .................................................263 Odczyt danych z pliku .......................................................263 Odczyt wierszy pliku za pomocą metody nextLine ..............264 Dodawanie klauzuli throws do nagłówka metody ..............266 Sprawdzanie, czy plik istnieje ............................................270 4.11. Generowanie liczb losowych za pomocą klasy Random ......273 4.12. Typowe błędy, których należy unikać .................................279 Pytania kontrolne i ćwiczenia .........................................................280 Zadania programistyczne ...............................................................287 4.6. Poleć książkęKup książkę Spis treści 9 5.2. 5.4. ROZDZIAŁ 5. Metody ........................................................................... 295 5.1. Wprowadzenie do metod .................................................295 Metody void i metody zwracające wartość .........................297 Definiowanie metody void ................................................297 Wywoływanie metody .......................................................299 Warstwowe wywołania metod ..........................................302 Używanie komentarzy javadoc do metod ...........................303 Przekazywanie argumentów do metod ..............................304 Zgodność typów danych argumentów i parametrów ..........307 Zasięg parametrów ...........................................................307 Przekazywanie wielu argumentów .....................................307 Argumenty są przekazywane przez wartość .......................309 Przekazywanie metodom referencji do obiektów ...............310 Używanie znacznika @param w komentarzach javadoc .....313 Jeszcze o zmiennych lokalnych ..........................................315 Czas życia zmiennych lokalnych .........................................316 Inicjowanie zmiennych lokalnych za pomocą parametrów ... 316 Zwracanie wartości przez metody .....................................317 Definiowanie metody zwracającej wartość .........................318 Wywoływanie metody zwracającej wartość ........................319 Używanie znacznika @return w komentarzach javadoc .....320 Zwracanie wartości logicznych ..........................................323 Zwracanie referencji do obiektu ........................................324 Rozwiązywanie problemów za pomocą metod ..................325 Wywoływanie metod zgłaszających wyjątki .......................328 5.6. Typowe błędy, których należy unikać .................................329 Pytania kontrolne i ćwiczenia .........................................................330 Zadania programistyczne ...............................................................334 5.3. 5.5. 6.1. ROZDZIAŁ 6. Pierwszy kontakt z klasami .......................................... 343 Obiekty i klasy ...................................................................343 Klasy: to z nich biorą się obiekty .......................................344 Klasy w interfejsie API Javy ................................................345 Zmienne typów prostych a obiekty ....................................347 Pisanie prostej klasy krok po kroku ....................................350 Akcesory i mutatory ..........................................................363 Znaczenie ukrywania danych .............................................363 Unikanie nieaktualnych danych .........................................363 Podawanie specyfikatorów dostępu na diagramach UML ...364 Zapis typów danych i parametrów na diagramach UML .....364 Układ składowych klasy ....................................................365 6.2. Poleć książkęKup książkę 10 Spis treści 6.3. 6.4. 6.5. 6.6. Pola i metody instancji ......................................................366 Konstruktory .....................................................................370 Zapisywanie konstruktorów na diagramach UML ...............372 Niezainicjowane lokalne zmienne referencyjne ...................372 Konstruktor domyślny .......................................................373 Pisanie własnego konstruktora bezargumentowego ...........374 Konstruktor klasy String ....................................................374 Przekazywanie obiektów jako argumentów .......................382 Przeciążanie metod i konstruktorów ..................................393 Klasa BankAccount ...........................................................395 Przeciążone metody zwiększają użyteczność klas ...............400 Zasięg pól instancji ...........................................................400 Przesłanianie .....................................................................401 Pakiety i instrukcje import .................................................402 Szczegółowe i ogólne instrukcje import .............................402 Pakiet java.lang .................................................................403 Inne pakiety z interfejsu API ..............................................403 Projektowanie obiektowe: określanie klas i ich zadań .........403 Określanie klas ..................................................................404 Określanie zadań klas ........................................................408 To dopiero początek .........................................................411 6.10. Typowe błędy, których należy unikać .................................411 Pytania kontrolne i ćwiczenia .........................................................412 Zadania programistyczne ...............................................................417 6.7. 6.8. 6.9. ROZDZIAŁ 7. Tablice i klasa ArrayList ................................................ 427 7.1. Wprowadzenie do tablic ...................................................427 Dostęp do elementów tablicy ............................................429 Zapisywanie i wyświetlanie zawartości tablicy ....................430 Java sprawdza zakres tablicy .............................................433 Uważaj na pomyłki o jeden element ..................................434 Inicjowanie tablicy ............................................................434 Różne sposoby deklarowania tablic ...................................435 Przetwarzanie elementów tablic ........................................437 Długość tablicy .................................................................439 Pętla for dla kolekcji ..........................................................439 Umożliwianie użytkownikom określania wielkości tablicy ...441 Przypisywanie nowych tablic do tablicowych zmiennych referencyjnych .................................................442 Kopiowanie tablic .............................................................443 7.2. Poleć książkęKup książkę Spis treści 11 7.5. 7.6. 7.3. Przekazywanie tablic jako argumentów metod ..................445 7.4. Wybrane przydatne algorytmy i operacje tablicowe ...........448 Sumowanie wartości w tablicy liczb ...................................449 Obliczanie średniej wartości z tablicy liczb .........................449 Wyszukiwanie największej i najmniejszej wartości w tablicy liczb ...................................................................450 Klasa SalesData .................................................................451 Częściowo zapełnione tablice ............................................458 Praca z tablicami i plikami .................................................459 Zwracanie tablic przez metody ..........................................460 Tablice typu String ............................................................461 Wywoływanie metod typu String za pomocą elementów tablicy ...........................................464 Tablice obiektów ..............................................................464 Algorytm wyszukiwania sekwencyjnego ............................467 Tablice dwuwymiarowe ....................................................469 Inicjowanie tablicy dwuwymiarowej ..................................473 Pole length w tablicy dwuwymiarowej ...............................474 Wyświetlanie wszystkich elementów tablicy dwuwymiarowej ...............................................................475 Sumowanie wszystkich elementów tablicy dwuwymiarowej ....................................................476 Sumowanie wartości wierszy tablicy dwuwymiarowej ........477 Sumowanie kolumn tablicy dwuwymiarowej .....................477 Przekazywanie tablic dwuwymiarowych do metod .............478 Tablice z wierszami o różnej długości ................................479 Tablice o co najmniej trzech wymiarach .............................480 7.7. 7.8. 7.9. 7.10. 7.11. Algorytm sortowania przez wybieranie i wyszukiwania binarnego .................................................481 Algorytm sortowania przez wybieranie ..............................481 Algorytm wyszukiwania binarnego ....................................484 7.12. Argumenty podawane w wierszu poleceń i listy argumentów o zmiennej długości .............................486 Argumenty w wierszu poleceń ..........................................487 Listy argumentów o zmiennej długości ..............................488 7.13. Klasa ArrayList ..................................................................490 Tworzenie i używanie obiektów typu ArrayList ...................491 Używanie pętli for dla kolekcji do obiektów typu ArrayList ... 492 Metoda toString klasy ArrayList .........................................493 Usuwanie elementów z obiektu typu ArrayList ...................494 Wstawianie elementu .......................................................495 Zastępowanie elementu ....................................................496 Poleć książkęKup książkę 12 Spis treści Pojemność ........................................................................496 Zapisywanie własnych obiektów w obiektach typu ArrayList ...................................................................497 7.14. Typowe błędy, których należy unikać .................................498 Pytania kontrolne i ćwiczenia .........................................................499 Zadania programistyczne ...............................................................504 8.1. 8.8. 8.9. ROZDZIAŁ 8. Jeszcze o klasach i obiektach ....................................... 513 Statyczne składowe klasy ..................................................513 Krótkie omówienie pól i metod instancji ............................513 Składowe statyczne ..........................................................514 Pola statyczne ...................................................................514 Metody statyczne .............................................................516 Przekazywanie obiektów jako argumentów metod ............519 8.2. 8.3. Zwracanie obiektów przez metody ....................................522 8.4. Metoda toString ...............................................................524 8.5. Pisanie metody equals .......................................................528 8.6. Metody kopiujące obiekty .................................................530 Konstruktory kopiujące .....................................................532 Agregowanie ....................................................................533 Agregacja na diagramach UML .........................................539 Problemy z bezpieczeństwem dotyczące klas agregujących ....................................................................539 Unikaj stosowania referencji null .......................................542 Zmienna referencyjna this .................................................545 Używanie słowa kluczowego this do zapobiegania przesłanianiu ..........................................545 Używanie słowa kluczowego this do wywoływania przeciążonego konstruktora w innym konstruktorze ..........546 Typy wyliczeniowe ............................................................547 Typy wyliczeniowe są wyspecjalizowanymi klasami ............548 Używanie typu wyliczeniowego w instrukcji switch ............553 Przywracanie pamięci ........................................................555 Metoda finalize .................................................................556 8.10. 8.7. 8.11. Koncentracja na projektowaniu obiektowym — współdziałanie klas ......................................................557 Opisywanie współdziałania klas za pomocą kart CRC .........559 8.12. Typowe błędy, których należy unikać .................................561 Pytania kontrolne i ćwiczenia .........................................................561 Zadania programistyczne ...............................................................566 Poleć książkęKup książkę Spis treści 13 ROZDZIAŁ 9. Przetwarzanie tekstu i klasy nakładkowe .................. 573 9.1. Wprowadzenie do klas nakładkowych ...............................573 9.2. 9.3. 9.4. Sprawdzanie i konwersja znaków za pomocą klasy Character .........................................................................574 Zmiana wielkości znaków ..................................................579 Inne metody klasy String ...................................................581 Wyszukiwanie podłańcuchów ...........................................581 Pobieranie podłańcuchów .................................................587 Metody zwracające zmodyfikowany obiekt typu String ......590 Statyczne metody valueOf .................................................592 Klasa StringBuilder ............................................................594 Konstruktory klasy StringBuilder ........................................595 Inne metody klasy StringBuilder .........................................596 Metoda toString ...............................................................599 Rozdzielanie łańcuchów znaków .......................................604 Klasy nakładkowe dla liczbowych typów danych ................608 Statyczne metody toString ................................................608 Metody toBinaryString, toHexString i toOctalString ............608 Stałe MIN_VALUE i MAX_VALUE .......................................609 Automatyczna konwersja na klasę i na typ prosty ..............609 Rozwiązywanie problemów — klasa TestScoreReader ........611 9.7. 9.8. Typowe błędy, których należy unikać .................................614 Pytania kontrolne i ćwiczenia .........................................................615 Zadania programistyczne ...............................................................619 9.5. 9.6. ROZDZIAŁ 10. Dziedziczenie ................................................................. 627 10.1. Czym jest dziedziczenie? ...................................................627 Uogólnianie i specjalizacja .................................................627 Dziedziczenie to relacja „jest czymś” ..................................628 Dziedziczenie na diagramach UML ....................................635 Konstruktor klasy bazowej ................................................635 Dziedziczenie nie działa w drugą stronę .............................637 10.2. Wywoływanie konstruktora klasy bazowej .........................638 Co się dzieje, gdy klasa bazowa nie ma konstruktora domyślnego ani bezargumentowego? ...............................644 Streszczenie zagadnień związanych z konstruktorami w kontekście dziedziczenia ................................................644 Przesłanianie metod klasy bazowej ....................................646 Przeciążanie a przesłanianie ..............................................650 Zapobieganie przesłanianiu metody ..................................653 10.3. Poleć książkęKup książkę 14 Spis treści 10.4. 10.5. Składowe chronione .........................................................653 Dostęp na poziomie pakietu ..............................................658 Łańcuchy dziedziczenia .....................................................659 Hierarchie klas ..................................................................663 10.6. Klasa Object .....................................................................665 10.7. Polimorfizm ......................................................................667 Polimorfizm i wiązanie dynamiczne ...................................668 Relacja „jest czymś” nie działa w drugą stronę ...................670 Operator instanceof ..........................................................670 10.8. Klasy i metody abstrakcyjne ...............................................671 Klasy abstrakcyjne na diagramach UML .............................677 Interfejsy ..........................................................................677 Interfejs jest kontraktem ...................................................679 Pola w interfejsach ............................................................682 Implementowanie wielu interfejsów ..................................683 Interfejsy na diagramach UML ...........................................683 Metody domyślne .............................................................683 Polimorfizm i interfejsy ......................................................685 10.10. Anonimowe klasy wewnętrzne ..........................................690 10.11. Interfejsy funkcyjne i wyrażenia lambda .............................693 10.12. Typowe błędy, których należy unikać .................................697 Pytania kontrolne i ćwiczenia .........................................................698 Zadania programistyczne ...............................................................705 10.9. ROZDZIAŁ 11. Wyjątki i zaawansowane plikowe operacje wejścia-wyjścia ............................................................. 711 11.1. Obsługa wyjątków ............................................................711 Klasy wyjątków .................................................................712 Obsługa wyjątków ............................................................713 Pobieranie domyślnego komunikatu o błędzie ...................717 Polimorficzne referencje do wyjątków ...............................719 Używanie wielu klauzul catch do obsługi wielu wyjątków .... 719 Klauzula finally .................................................................726 Ślad stosu .........................................................................727 Obsługa wielu wyjątków za pomocą jednej klauzuli catch .....729 Co się dzieje, gdy wyjątek nie zostaje przechwycony? ........731 Wyjątki kontrolowane i niekontrolowane ...........................731 Zgłaszanie wyjątków .........................................................733 Tworzenie własnych klas wyjątków ...................................736 Używanie znacznika @exception w komentarzach javadoc ..................................................738 11.2. Poleć książkęKup książkę Spis treści 15 11.3. Zagadnienia zaawansowane: pliki binarne, pliki z dostępem swobodnym i serializowanie obiektów .............739 Pliki binarne ......................................................................739 Pliki o dostępie swobodnym ..............................................745 Serializowanie obiektów ...................................................751 Serializowanie obiektów zagregowanych ...........................754 11.4. Typowe błędy, których należy unikać .................................755 Pytania kontrolne i ćwiczenia .........................................................756 Zadania programistyczne ...............................................................761 ROZDZIAŁ 12. JavaFX: programowanie interfejsu GUI 12.3. 12.5. i podstawowe kontrolki ............................................... 765 12.1. Graficzne interfejsy użytkownika .......................................765 Programy z interfejsem GUI sterowanym zdarzeniami ........766 12.2. Wprowadzenie do biblioteki JavaFX ..................................768 Kontrolki ..........................................................................768 Płótno i sceny ...................................................................769 Klasa Application ..............................................................770 Tworzenie scen .................................................................772 Tworzenie kontrolek .........................................................773 Tworzenie kontenerów .....................................................773 Tworzenie obiektów typu Scene ........................................774 Dodawanie obiektu typu Scene do płótna .........................775 Określanie wielkości sceny ................................................777 Wyrównywanie kontrolek w kontenerze HBox ...................777 12.4. Wyświetlanie grafiki ..........................................................779 Wczytywanie grafiki z internetu ........................................782 Określanie wielkości grafiki ...............................................782 Zachowywanie proporcji obrazu ........................................783 Modyfikowanie obrazu powiązanego z obiektem typu ImageView ...............................................................783 Jeszcze o kontenerach HBox, VBox i GridPane ....................784 Kontener typu HBox .........................................................784 Kontener typu VBox ..........................................................789 Kontener typu GridPane ....................................................791 Używanie wielu kontenerów na jednym ekranie ................797 Przyciski i zdarzenia ..........................................................798 Obsługa zdarzeń ...............................................................800 Pisanie obiektów obsługi zdarzeń ......................................801 Rejestrowanie obiektu obsługi zdarzeń ..............................801 12.7. Wczytywanie danych za pomocą kontrolki typu TextField .... 805 12.6. Poleć książkęKup książkę 16 Spis treści 12.8. Używanie anonimowych klas wewnętrznych i wyrażeń lambda do obsługi zdarzeń ...............................................809 Używanie anonimowych klas wewnętrznych do tworzenia obiektów obsługi zdarzeń .............................809 Używanie wyrażeń lambda do tworzenia obiektów obsługi zdarzeń ................................................................811 12.9. Kontener typu BorderPane ................................................814 12.10. Interfejs ObservableList .....................................................817 12.11. Typowe błędy, których należy unikać .................................819 Pytania kontrolne i ćwiczenia .........................................................819 Zadania programistyczne ...............................................................823 ROZDZIAŁ 13. JavaFX: zaawansowane kontrolki ............................... 829 13.1. Dodawanie stylów aplikacji opartych na bibliotece JavaFX za pomocą arkuszy CSS .....................................................829 Nazwy selektorów typów ..................................................830 Właściwości w stylach .......................................................831 Stosowanie arkuszy stylów do aplikacji opartych na bibliotece JavaFX ...........................................833 Stosowanie stylów do węzła korzenia ................................836 Podawanie kilku selektorów w jednej definicji stylu ............838 Praca z kolorami ...............................................................838 Tworzenie niestandardowej klasy stylu ..............................840 Selektory identyfikatorów ..................................................842 Wewnątrzwierszowe reguły stylów ....................................842 13.2. Kontrolki typu RadioButton ...............................................844 Sprawdzanie w kodzie, czy dana kontrolka typu RadioButton jest zaznaczona .............................................845 Zaznaczanie kontrolki typu RadioButton w kodzie ..............845 Reagowanie na kliknięcie kontrolki typu RadioButton ........850 13.3. Kontrolki typu CheckBox ...................................................853 Sprawdzanie w kodzie, czy kontrolka typu CheckBox jest zaznaczona ................................................................854 Zaznaczanie kontrolki typu CheckBox za pomocą kodu ......854 Reagowanie na kliknięcie kontrolki typu CheckBox ............857 13.4. Kontrolki typu ListView .....................................................858 Pobieranie zaznaczonego elementu ...................................859 Pobieranie indeksu zaznaczonego elementu ......................861 Reagowanie na zaznaczenie elementu za pomocą obiektu obsługi zdarzeń ................................................................862 Dodawanie elementów a ustawianie elementów ...............864 Poleć książkęKup książkę Spis treści 17 Inicjowanie kontrolki typu ListView za pomocą tablicy lub obiektu typu ArrayList .................................................864 Tryby zaznaczania elementów ...........................................866 Pobieranie wielu zaznaczonych elementów .......................867 Używanie elementów z listy typu ObservableList ................869 Przekształcanie listy typu ObservableList na tablicę .............870 Używanie kodu do zaznaczania elementu w kontrolce typu ListView .................................................871 Układ kontrolki typu ListView ............................................871 Tworzenie kontrolek typu ListView z elementami typów innych niż String ...............................................................872 13.5. Kontrolki typu ComboBox .................................................877 Pobieranie zaznaczonego elementu ...................................879 Reagowanie na zaznaczenie elementu w kontrolce typu ComboBox ................................................................880 Kontrolki typu ComboBox umożliwiające modyfikacje ........881 13.6. Kontrolki typu Slider .........................................................882 13.7. Kontrolki typu TextArea .....................................................888 13.8. Menu ...............................................................................890 Przypisywanie klawiszy skrótu do opcji menu .....................897 13.9. Klasa FileChooser ..............................................................899 Wyświetlanie okna dialogowego typu FileChooser .............899 13.10. Używanie danych wyjściowych w konsoli do debugowania aplikacji z interfejsem GUI .................................................901 13.11. Typowe błędy, których należy unikać .................................904 Pytania kontrolne i ćwiczenia .........................................................904 Zadania programistyczne ...............................................................909 ROZDZIAŁ 14. JavaFX: grafika, efekty i multimedia ........................... 913 14.1. Rysowanie kształtów .........................................................913 Układ współrzędnych ekranu ............................................913 Klasa Shape i jej podklasy ..................................................914 Klasa Line .........................................................................915 Zmienianie koloru pędzla ..................................................917 Klasa Circle .......................................................................918 Klasa Rectangle ................................................................921 Klasa Ellipse ......................................................................924 Klasa Arc ..........................................................................928 Klasa Polygon ...................................................................931 Klasa Polyline ....................................................................934 Klasa Text .........................................................................936 Poleć książkęKup książkę 18 Spis treści 14.3. Obracanie węzłów ............................................................938 Skalowanie węzłów ..........................................................940 14.2. Animacje ..........................................................................942 Klasa TranslateTransition ...................................................943 Klasa RotateTransition .......................................................946 Klasa ScaleTransition .........................................................950 Klasa StrokeTransition .......................................................953 Klasa FillTransition .............................................................954 Klasa FadeTransition .........................................................955 Sterowanie animacją .........................................................956 Wybieranie mechanizmu interpolacji .................................958 Efekty ...............................................................................959 Klasa DropShadow ...........................................................960 Klasa InnerShadow ...........................................................961 Klasa ColorAdjust ..............................................................963 Klasy BoxBlur, GaussianBlur i MotionBlur ...........................964 Klasa SepiaTone ................................................................967 Klasa Glow .......................................................................967 Klasa Reflection ................................................................967 Łączenie efektów ..............................................................968 14.4. Odtwarzanie plików dźwiękowych ....................................970 Rejestrowanie obiektu obsługi zdarzenia EndOfMedia .......972 14.5. Odtwarzanie filmów .........................................................975 14.6. Obsługa zdarzeń związanych z klawiszami ........................980 Stosowanie anonimowej klasy wewnętrznej do rejestrowania obiektu obsługi zdarzeń dla sceny ...........981 Używanie wyrażeń lambda do rejestrowania obiektów obsługi zdarzeń dla sceny .................................................981 14.7. Obsługa zdarzeń związanych z myszą ...............................986 14.8. Typowe błędy, których należy unikać .................................991 Pytania kontrolne i ćwiczenia .........................................................992 Zadania programistyczne ...............................................................995 ROZDZIAŁ 15. Rekurencja ..................................................................... 999 15.1. Wprowadzenie do rekurencji .............................................999 15.2. Rozwiązywanie problemów za pomocą rekurencji ...........1002 Rekurencja bezpośrednia i pośrednia ...............................1006 Przykładowe metody rekurencyjne ...................................1006 Sumowanie przedziału elementów tablicy za pomocą rekurencji ......................................................1006 Rysowanie koncentrycznych kół ......................................1008 15.3. Poleć książkęKup książkę Spis treści 19 Ciąg Fibonacciego ...........................................................1010 Znajdowanie największego wspólnego dzielnika ..............1011 15.4. Rekurencyjne wyszukiwanie binarne ................................1012 15.5. Wieże Hanoi ...................................................................1015 15.6. Typowe błędy, których należy unikać ...............................1019 Pytania kontrolne i ćwiczenia .......................................................1020 Zadania programistyczne .............................................................1023 16.2. ROZDZIAŁ 16. Bazy danych ................................................................. 1025 16.1. Wprowadzenie do systemów zarządzania bazami danych ...1025 JDBC ..............................................................................1027 SQL ................................................................................1027 Używanie systemu DBMS ................................................1028 Java DB i Apache Derby ..................................................1028 Tworzenie bazy danych CoffeeDB ...................................1028 Nawiązywanie połączenia z bazą CoffeeDB .....................1029 Łączenie się z bazą chronioną hasłem ..............................1031 Tabele, wiersze i kolumny ...............................................1032 Typy danych kolumn .......................................................1033 Klucze główne ................................................................1034 16.3. Wprowadzenie do instrukcji SQL SELECT .........................1035 Przekazywanie instrukcji SQL-owych do systemu DBMS ....1036 Określanie kryteriów wyszukiwania za pomocą klauzuli WHERE ..............................................1045 Sortowanie wyników zapytania SELECT ...........................1051 Funkcje matematyczne ....................................................1052 16.4. Wstawianie wierszy ........................................................1055 Wstawianie wierszy za pomocą technologii JDBC .............1057 16.5. Aktualizowanie i usuwanie istniejących wierszy ................1058 Aktualizowanie wierszy za pomocą technologii JDBC .......1059 Usuwanie wierszy za pomocą instrukcji DELETE ...............1063 Usuwanie wierszy za pomocą technologii JDBC ...............1063 Tworzenie i usuwanie tabel .............................................1066 Usuwanie tabel za pomocą instrukcji DROP TABLE ...........1069 Tworzenie nowej bazy danych za pomocą technologii JDBC ...1069 16.7. 16.8. Przewijalne zbiory wyników .............................................1071 16.9. Metadane zbioru wyników ..............................................1073 16.10. Dane relacyjne ................................................................1078 Złączanie danych z wielu tabel ........................................1081 System wprowadzania zamówień ....................................1082 16.6. Poleć książkęKup książkę 20 Spis treści 16.11. Zaawansowane zagadnienia ...........................................1092 Transakcje ......................................................................1092 Procedury składowane ....................................................1094 16.12. Typowe błędy, których należy unikać ...............................1094 Pytania kontrolne i ćwiczenia .......................................................1095 Zadania programistyczne .............................................................1100 DODATEK A Odpowiedzi do punktów kontrolnych ....................... 1103 DODATEK B Odpowiedzi na nieparzyste pytania kontrolne ........ 1131 Skorowidz .................................................................... 1159 Poleć książkęKup książkę Podstawy Javy Ł A I Z D Z O R 2 TEMATYKA 2.1. Części programu w Javie 2.2. Metody print i println oraz interfejs 2.8. Tworzenie nazwanych stałych za pomocą słowa kluczowego final API Javy 2.3. Zmienne i literały 2.4. Proste typy danych 2.5. Operatory arytmetyczne 2.6. Złożone operatory przypisania 2.7. Konwersja prostych typów danych na inne takie typy 2.9. Klasa String 2.10. Zasięg 2.11. Komentarze 2.12. Styl programowania 2.13. Wczytywanie danych wejściowych z klawiatury 2.14. Okna dialogowe 2.15. Typowe błędy, których należy unikać 2.1. Części programu w Javie 2.1. Części programu w Javie WYJAŚNIENIE: Program w Javie ma części o określonym przeznaczeniu. Programy w Javie składają się z różnych części. Pierwszy etap w nauce Javy polega na poznaniu tych części. Zaczniemy od prostego przykładu przedstawionego na lis- tingu 2.1. WSKAZÓWKA: Pamiętaj, że numery wierszy na listingach nie są częścią pro- gramów. Te numery pozwalają wskazywać konkretne wiersze programów. W rozdziale 1. wspomniano, że nazwy plików z kodem źródłowym w Javie mają roz- szerzenie .java. Nazwa programu z listingu 2.1 to Simple.java. Za pomocą kompilatora Javy ten program można skompilować, wywołując następujące polecenie: javac Simple.java 59 Poleć książkęKup książkę 60 Rozdział 2. Podstawy Javy Listing 2.1 Plik Simple.java 1 // To prosty program w Javie. 2 3 public class Simple 4 { 5 public static void main(String[] args) 6 { 7 System.out.println( Programowanie to świetna zabawa! ); 8 } 9 } Kompilator utworzy wtedy następny plik, Simple.class, zawierający przekształcony kod bajtowy Javy. Nowy plik można uruchomić za pomocą następującego polecenia: java Simple WSKAZÓWKA: Pamiętaj, że gdy używasz polecenia java, nie powinieneś wpi- sywać rozszerzenia .class. Poniżej pokazano dane wyjściowe z tego programu. Oto co pojawia się na ekranie po uruchomieniu programu: Dane wyjściowe programu Programowanie to świetna zabawa! Przeanalizujmy przedstawiony program wiersz po wierszu. Oto instrukcja z wiersza 1.: // To prosty program w Javie. Oprócz dwóch początkowych ukośników ten wiersz wygląda jak zwykłe zdanie. Sym- bole // oznaczają początek komentarza. Kompilator ignoruje wszystko od podwójnego ukośnika do końca wiersza. To oznacza, że w takim wierszu możesz wpisać cokol- wiek, a kompilator nie będzie zgłaszał zastrzeżeń. Choć komentarze nie są wymagane, są bardzo istotne dla programistów. Większość programów jest dużo bardziej skom- plikowana niż pokazany przykład, a komentarze pomagają objaśniać kod. Wiersz 2. jest pusty. Programiści często dodają w programach puste wiersze, aby poprawić czytelność kodu. Oto wiersz 3.: public class Simple Ten wiersz to nagłówek klasy. Taki nagłówek oznacza początek definicji klasy. Klasy służą między innymi do tworzenia kontenerów na aplikacje. W trakcie lektury tej książki dowiesz się więcej o klasach. Na razie zapamiętaj, że program w Javie musi zawierać przynajmniej jedną definicję klasy. Pokazany wiersz kodu zawiera trzy słowa: public, class i Simple. Przyjrzyjmy się bliżej każdemu z nich.  public to słowo kluczowe Javy. Trzeba je zapisywać małymi literami. Jest to tak zwany specyfikator dostępu, kontrolujący sposób dostępu do klasy. Specyfikator public oznacza nieograniczony dostęp do klasy. Innymi słowy, taka klasa jest „publicznie otwarta”. Poleć książkęKup książkę 2.1. Części programu w Javie 61  class to także słowo kluczowe Javy (również należy je pisać małymi literami). Oznacza ono początek definicji klasy.  Simple to nazwa klasy. Została ona wymyślona przez programistę. Klasę można też nazwać Pizza, Pies lub w dowolny inny sposób, jak sobie tego programista zażyczy. Nazwy definiowane przez programistę można pisać za pomocą liter dowolnej wielkości. W skrócie można stwierdzić, że omawiany wiersz kodu informuje kompilator o tym, iż definiowana jest publicznie dostępna klasa o nazwie Simple. Oto dwie inne rzeczy, jakie należy wiedzieć o klasach:  W pliku możesz utworzyć więcej niż jedną klasę, ale w jednym pliku Javy może  znajdować się tylko jedna klasa publiczna (public class). Jeśli w pliku Javy znajduje się klasa publiczna, jej nazwa musi być identyczna z nazwą pliku (bez rozszerzenia .java). Przykładowo, w programie z listingu 2.1 znajduje się klasa publiczna Simple, dlatego zapisano ją w pliku Simple.java. UWAGA: W Javie wielkość liter ma znaczenie. To oznacza, że wielkie litery są uznawane za zupełnie inne znaki od ich małych odpowiedników. Słowo Public nie jest tym samym co public, a Class różni się od class. Niektóre słowa w pro- gramach w Javie muszą być całe zapisane małymi literami. W innych słowach mogą występować kombinacje małych i wielkich liter. Dalej w tym rozdziale znaj- dziesz listę wszystkich słów kluczowych Javy; trzeba je zapisywać małymi literami. Wiersz 4. zawiera tylko jeden znak: { Jest to lewy (otwierający) nawias klamrowy, powiązany tu z początkiem definicji klasy. Wszystkie instrukcje będące częścią klasy znajdują się w nawiasie klamrowym. Jeśli spojrzysz na ostatni wiersz programu (wiersz 9.), zobaczysz zamykający nawias klam- rowy. Wszystko między tymi dwoma nawiasami jest ciałem klasy Simple. Poniżej jeszcze raz pokazano kod programu. Tym razem ciało definicji klasy jest wyróżnione ciem- niejszym kolorem. // To prosty program w Javie. public class Simple { public static void main(String[] args) { System.out.println( Programowanie to świetna zabawa! ); } } OSTRZEŻENIE! Upewnij się, że każdemu otwierającemu nawiasowi klamrowemu w programie odpowiada zamykający nawias klamrowy. Oto wiersz 5.: public static void main(String[] args) Poleć książkęKup książkę 62 Rozdział 2. Podstawy Javy Ten wiersz to nagłówek metody. Oznacza on początek metody. Metodę można trakto- wać jak nazwaną grupę instrukcji programu. Gdy tworzysz metodę, musisz podać kom- pilatorowi kilka informacji na jej temat. To dlatego przedstawiony wiersz zawiera tyle słów. Na tym etapie ważne jest tylko to, że nazwa metody to main. Reszta słów jest potrzebna do poprawnego zdefiniowania tej metody. Nagłówek metody jest pokaza- ny na rysunku 2.1. Rysunek 2.1. Nagłówek metody main W rozdziale 1. napisano, że niezależny program w Javie działający w komputerze jest nazywany aplikacją. Każda aplikacja w Javie musi zawierać metodę o nazwie main. Ta metoda jest punktem początkowym aplikacji. UWAGA: Na razie wszystkie programy, jakie będziesz pisał, będą obejmowały klasę z metodą main, której nagłówek będzie wyglądał identycznie jak na listingu 2.1. W trakcie lektury tej książki poznasz znaczenie członów public static void i (String[] args). Na razie przyjmij, że uczysz się „przepisu” na programy w Javie. Wiersz 6. zawiera następny otwierający nawias klamrowy: { Ten otwierający nawias klamrowy należy do metody main. Pamiętaj, że nawiasy klam- rowe otaczają instrukcje, a każdemu nawiasowi otwierającemu musi towarzyszyć nawias zamykający. Jeśli przyjrzysz się wierszowi 8., zobaczysz zamykający nawias klam- rowy powiązany z pokazanym tu nawiasem otwierającym. Wszystko między tymi nawiasami to ciało metody main. Oto wiersz 7.: System.out.println( Programowanie to świetna zabawa! ); Można ująć to prosto — ten wiersz wyświetla na ekranie komunikat. Ten komuni- kat, „Programowanie to świetna zabawa!”, jest wyświetlany bez cudzysłowu. W żargo- nie programistycznym grupa znaków ujęta w cudzysłów to literał tekstowy. UWAGA: Jest to jedyny wiersz w tym programie, który powoduje wyświetlenie czegoś na ekranie. Inne wiersze, np. public class Simple i public static void main(String[] args), są niezbędne do utworzenia szkieletu programu, ale nie wyświetlają niczego na ekranie. Pamiętaj, że program to zestaw instrukcji dla kom- putera. Jeśli coś ma zostać wyświetlone na ekranie, trzeba posłużyć się w tym celu instrukcją w języku programowania. Poleć książkęKup książkę 2.1. Części programu w Javie 63 Na końcu wiersza znajduje się średnik. Podobnie jak kropka oznacza koniec zdania, tak średnik oznacza koniec instrukcji w Javie. Jednak nie każdy wiersz kodu kończy się średnikiem. Poniżej krótko opisano, gdzie nie trzeba umieszczać średnika:  Komentarze nie muszą kończyć się średnikiem, ponieważ są ignorowane przez kompilator.  Nagłówki klas i metod nie kończą się średnikiem, ponieważ ich zakończeniem jest blok kodu w nawiasie klamrowym.  Nawiasy klamrowe { i } nie są instrukcjami, dlatego nie należy umieszczać po nich średnika. Może się wydawać, że reguły dodawania średników nie są jasne. Na razie skoncentruj się na poznaniu części programu. Wkrótce zrozumiesz, gdzie należy stosować śred- niki, a gdzie nie są one konieczne. Jak już wspomniano, wiersze 8. i 9. zawierają zamykające nawiasy klamrowe dla metody main i definicji klasy: } } Przed przejściem dalej warto przypomnieć omówione kwestie, w tym niektóre mniej oczywiste reguły.  Java to język, w którym wielkość znaków ma znaczenie. Wielkie litery nie są traktowane w nim tak samo jak ich małe odpowiedniki.  Wszystkie programy w Javie muszą być zapisywane w plikach o rozszerzeniu .java.  Komentarze są ignorowane przez kompilator.  Plik .java może zawierać wiele klas, ale dozwolona jest tylko jedna klasa publiczna (public). Jeśli w pliku .java znajduje się klasa publiczna, musi mieć ona tę samą nazwę co sam plik. Przykładowo, jeśli plik Pizza.java zawiera klasę publiczną, jej nazwa to Pizza.  Każda aplikacja w Javie musi zawierać metodę o nazwie main.  Dla każdego lewego (otwierającego) nawiasu klamrowego musi istnieć nawias prawy (zamykający). Instrukcje kończą się średnikami. Nie dotyczy to komentarzy, nagłówków klas i metod oraz nawiasów klamrowych.  W przykładowym programie znajduje się kilka znaków specjalnych. W tabeli 2.1 znaj- dziesz podsumowanie ich znaczenia. Punkt kontrolny 2.1. Ten program nie skompiluje się, ponieważ wymieszano w nim wiersze: public static void main(String[] args) } // Zwariowany wymieszany program. public class Columbus { Poleć książkęKup książkę 64 Rozdział 2. Podstawy Javy Tabela 2.1. Znaki specjalne Znaki Nazwa Podwójny ukośnik Otwierający i zamykający nawias Otwierający i zamykający nawias klamrowy Obejmują grupę instrukcji, Znaczenie Oznacza początek komentarza. Używane w nagłówkach metod. // () {} Cudzysłów ; Średnik np. zawartość klasy lub metody. Obejmuje łańcuch znaków, np. komunikat wyświetlany na ekranie. Oznacza koniec kompletnej instrukcji języka programowania. System.out.println( W 1492 r. Kolumb wyruszył na błękitny ocean. ); { } Po właściwym uporządkowaniu wierszy program powinien wyświetlać na ekranie tekst: W 1492 r. Kolumb wyruszył na błękitny ocean. Uporządkuj wiersze we właściwej kolejności. Przetestuj program. W tym celu wpisz go w komputerze, skompiluj i uruchom. 2.2. Jak należy nazwać plik z programem z zadania 2.1? 2.3. Uzupełnij poniższy szkielet programu, aby kod wyświetlał na ekranie tekst „Witaj, świecie!”. public class Hello { public static void main(String[] args) { // Wstaw tu kod, aby uzupełnić program. } } 2.4. Zapisz na kartce program, który wyświetli na ekranie Twoje imię. Na początku programu umieść komentarz z dzisiejszą datą. Przetestuj program; w tym celu wpisz go, skompiluj i uruchom. 2.5. Nazwy wszystkich plików z kodem źródłowym w Javie muszą się kończyć: a. średnikiem, b. rozszerzeniem .class, c. rozszerzeniem .java, d. żadna z odpowiedzi nie jest poprawna. 2.6. Każda aplikacja w Javie musi zawierać: a. metodę o nazwie main, b. więcej niż jedną definicję klasy, c. przynajmniej jeden komentarz. Poleć książkęKup książkę 2.2. Metody print i println oraz interfejs API Javy 65 2.2. Metody print i println oraz interfejs API Javy 2.2. Metody print i println oraz interfejs API Javy WYJAŚNIENIE: Metody print i println służą do wyświetlania danych tekstowych. Te metody są częścią interfejsu API Javy. Ten interfejs to zestaw gotowych klas i metod do wykonywania określonych operacji. Z tego podrozdziału dowiesz się, jak pisać programy wyświetlające dane wyjściowe na ekranie. Najprostszy rodzaj danych wyjściowych, jakie program może wyświetlać, to dane w konsoli. Dane wyjściowe w konsoli są zwykłym tekstem. Gdy wyświetlasz dane w konsoli w systemie z graficznym interfejsem użytkownika, np. w systemach Windows i macOS, dane wyjściowe zwykle pojawiają się w oknie podobnym do tego z rysunku 2.2. Rysunek 2.2. Okno konsoli (Microsoft Corporation) Słowo konsola to dawne pojęcie ze świata komputerów. Pochodzi z czasów, gdy ope- rator dużego systemu komputerowego komunikował się z nim, pisząc na terminalu składającym się z prostego ekranu i klawiatury. Ten terminal był nazywany konsolą. Ekran konsoli, wyświetlający sam tekst, był nazywany standardowym urządzeniem wyjścia. Obecnie określenie standardowe urządzenie wyjścia zwykle oznacza urządze- nie wyświetlające dane wyjściowe w konsoli. W Javie generowanie danych wyjściowych, podobnie jak wiele innych zadań, odbywa się z użyciem interfejsu API Javy. Nazwa API to akronim od Application Program- ming Interface. Interfejs API to standardowa biblioteka gotowych klas do wykony- wania określonych operacji. Te klasy i ich metody są dostępne we wszystkich pro- gramach Javy. Metody print i println są częścią tego interfejsu API i umożliwiają wyświetlanie danych wyjściowych w standardowym urządzeniu wyjścia. Poleć książkęKup książkę 66 Rozdział 2. Podstawy Javy W programie z listingu 2.1 (Simple.java) do wyświetlania komunikatu na ekranie używana jest następująca instrukcja: System.out.println( Programowanie to świetna zabawa! ); System to klasa z interfejsu API Javy. Ta klasa zawiera obiekty i metody wykonujące operacje na poziomie systemu. Jednym z obiektów z klasy System jest out. Obiekt out zawiera metody (np. print i println) do wyświetlania danych w konsoli systemowej lub standardowym urządzeniu wyjścia. Hierarchiczne zależności między elementami System, out, print i println pokazano na rysunku 2.3. Rysunek 2.3. Zależności między klasą System, obiektem out a metodami print i println Oto krótkie podsumowanie współdziałania tych elementów:  Klasa System należy do interfejsu API Javy. Obejmuje składowe obiekty i metody służące do wykonywania operacji na poziomie systemu, np. przesyłania danych wyjściowych do konsoli.  Obiekt out to składowa klasy System. Udostępnia metody do przesyłania danych wyjściowych na ekran.  Metody print i println to składowe obiektu out. Odpowiadają za pokazywanie znaków na ekranie. Ta hierarchia wyjaśnia, dlaczego instrukcja wykonania metody println jest tak długa. W sekwencji System.out.println określono, że println to składowa obiektu out, który jest składową klasy System. Wartość wyświetlana na ekranie jest umieszczona w nawiasie. Ta wartość to argu- ment. Przykładowo, następna instrukcja wykonuje metodę println z argumentem Król Artur . Ta instrukcja wyświetla na ekranie tekst „Król Artur” (bez cudzysłowu). System.out.println( Król Artur ); Ważne w metodzie println jest to, że po wyświetleniu komunikatu przenosi ona kur- sor na początek następnego wiersza. Kolejny element wyświetlany na ekranie będzie widoczny właśnie tam. Przyjrzyj się programowi z listingu 2.2. Poleć książkęKup książkę 2.2. Metody print i println oraz interfejs API Javy 67 Listing 2.2 Plik TwoLines.java 1 // To następny prosty program w Javie. 2 3 public class TwoLines 4 { 5 public static void main(String[] args) 6 { 7 System.out.println( Programowanie to świetna zabawa!
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Java dla zupełnie początkujących. Owoce programowania. 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ą: