Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00286 004554 14271866 na godz. na dobę w sumie
Objective-C. Vademecum profesjonalisty. Wydanie III - książka
Objective-C. Vademecum profesjonalisty. Wydanie III - książka
Autor: Liczba stron: 496
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-3667-9 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> c - programowanie
Porównaj ceny (książka, ebook (-25%), audiobook).

Praktyczny podręcznik tworzenia aplikacji na systemy iOS i Mac OS X!

Tak jak iPhone, iPad czy iPod Touch błyskawicznie stały się obiektem pożądania milionów ludzi na całym świecie, tak samo szybko rynek upomniał się o specjalistów od tworzenia aplikacji na te innowacyjne urządzenia. Mimo że od 2007 roku, gdy Apple opublikowało zaktualizowaną wersję języka Objective-C, oznaczoną jako 2.0, minęło już trochę czasu, programistów znających ten język wciąż jest niewielu, a zapotrzebowanie na programy dla systemów iOS i Mac OS X stale rośnie. Warto zatem opanować ten potężny język, zarazem prosty i oferujący ogromne perspektywy zawodowe. Zwłaszcza że można go wykorzystać także na wielu innych platformach z kompilatorem gcc, a więc między innymi w systemach Unix, Linux i Windows.

Oto książka stworzona z myślą o programistach stawiających pierwsze kroki w języku Objective-C. Do wykorzystania zawartej tu wiedzy nie jest potrzebna znajomość języka C ani żadnego innego obiektowego języka programowania. Podstawą do nauki są dziesiątki ciekawych przykładów i ćwiczeń, ilustrujących użycie poszczególnych cech i ułatwiających zrozumienie poznawanych zagadnień. Książkę podzielono na trzy części. Pierwsza zawiera podstawowe wiadomości na temat języka Objective-C 2.0, a w drugiej znajdziesz opis klas dostępnych w bibliotece Foundation. Część trzecia poświęcona została niezwykle ważnym bibliotekom Cocoa i Cocoa Touch. Na końcu książki zamieszczono kurs pisania programów dla systemu iOS przy użyciu Software Development Kit iOS oraz biblioteki UIKit. Poznaj Objective-C i czerp z tego korzyści!

Zacznij pisać własne, funkcjonalne programy na iPhone...a, iPada oraz iPoda Touch!


Stephen G. Kochan jest autorem lub współautorem kilku uznanych książek na temat języka C, między innymi Programming in C, Programming in ANSI C i Topics in C Programming, a także kilku publikacji dotyczących Uniksa, np. Exploring the Unix System i Unix Shell Programming. Pisze programy dla komputerów Macintosh od samego początku ich istnienia, a więc od roku 1984, kiedy pojawił się pierwszy Mac. Napisał książkę Programming C for the Mac wydaną w serii Apple Press Library, a także książkę Beginning AppleScript.

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

Darmowy fragment publikacji:

Tytuł oryginału: Programming in Objective-C, Third Edition Tłumaczenie: Łukasz Piwko ISBN: 978-83-246-3667-9 Authorized translation from the English language edition, entitled: Programming in Objective-C, Third Edition, ISBN 0321711394, by Stephen G. Kochan, published by Pearson Education, Inc, publishing as Addison Wesley, Copyright © 2011 by Pearson Education, Inc. 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 S.A. Copyright © 2012. Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniej¬szej publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficz¬ną, 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 Wydawnictwo HELION 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 Wydawnictwo HELION nie ponoszą również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce. Wydawnictwo HELION 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?gimpbi Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. 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 ............................................................................................... 11 O korektorach merytorycznych .......................................................... 12 Rozdziaę 1. Wprowadzenie ...................................................................................... 13 ZawartoĞü ksiąĪki ................................................................................................................14 Struktura ksiąĪki ..................................................................................................................15 Pomoc ..................................................................................................................................17 PodziĊkowania ....................................................................................................................17 Jõzyk Objective-C 2.0 .......................................................19 CzõĴã I Rozdziaę 2. Programowanie w jõzyku Objective-C .............................................. 21 Kompilacja i uruchamianie programów ..............................................................................21 Kompilacja programów przy uĪyciu Xcode ..................................................................22 Kompilacja programów przy uĪyciu terminala .............................................................28 ObjaĞnienie kodu pierwszego programu ..............................................................................30 WyĞwietlanie wartoĞci zmiennych ......................................................................................34 Podsumowanie ....................................................................................................................36 Rozdziaę 3. Klasy, obiekty i metody ........................................................................ 39 Czym tak wáaĞciwie jest obiekt ...........................................................................................39 Egzemplarze i metody .........................................................................................................40 Klasa w jĊzyku Objective-C do dziaáaĔ na uáamkach ..........................................................42 Sekcja @interface ................................................................................................................45 Wybór nazw ..................................................................................................................45 Zmienne egzemplarza ...................................................................................................47 Metody klas i egzemplarzy ............................................................................................47 Sekcja @implementation .....................................................................................................49 Sekcja programu ..................................................................................................................50 Zasady dostĊpu do zmiennych egzemplarzy i hermetyzacja danych ...................................56 Podsumowanie ....................................................................................................................59 Rozdziaę 4. Typy danych i wyraŏenia ..................................................................... 61 Typy danych i staáe ..............................................................................................................61 Typ int ...........................................................................................................................61 Typ float ........................................................................................................................62 Typ char ........................................................................................................................62 Kwalifikatory: long, long long, short, unsigned oraz signed .........................................63 Typ id ............................................................................................................................64 6 Objective-C. Vademecum profesjonalisty WyraĪenia arytmetyczne .....................................................................................................65 KolejnoĞü wykonywania dziaáaĔ ...................................................................................65 Arytmetyka liczb caákowitych i jednoargumentowy operator minus ............................68 Operator dzielenia modulo ............................................................................................70 Konwersja miĊdzy typami caákowitymi i zmiennoprzecinkowymi ...............................71 Operator rzutowania typów ...........................................................................................72 Operatory przypisania .........................................................................................................73 Klasa kalkulatora .................................................................................................................74 Rozdziaę 5. Põtle ....................................................................................................... 79 PĊtla for ...............................................................................................................................80 Odbieranie danych z klawiatury ....................................................................................86 ZagnieĪdĪanie pĊtli for ..................................................................................................88 Warianty pĊtli for ..........................................................................................................90 Instrukcja while ...................................................................................................................91 Instrukcja do ........................................................................................................................95 Instrukcja break ...................................................................................................................96 Instrukcja continue ..............................................................................................................97 Podsumowanie ....................................................................................................................97 Rozdziaę 6. Podejmowanie decyzji ......................................................................... 99 Instrukcja if .........................................................................................................................99 Instrukcja if-else ..........................................................................................................103 ZáoĪone testy relacyjne ................................................................................................106 ZagnieĪdĪanie instrukcji if ..........................................................................................108 Konstrukcja else if .......................................................................................................110 Instrukcja switch ................................................................................................................118 Zmienne logiczne ..............................................................................................................121 Operator warunkowy .........................................................................................................126 Rozdziaę 7. Klasy raz jeszcze ................................................................................. 129 Pisanie interfejsu i implementacji w osobnych plikach .....................................................129 Automatyczne tworzenie metod dostĊpowych ..................................................................134 DostĊp do wáaĞciwoĞci za pomocą operatora kropki .........................................................135 Metody przyjmujące po kilka argumentów .......................................................................136 Metody bez nazw argumentów ....................................................................................138 Dziaáania na uáamkach ................................................................................................138 Zmienne lokalne ................................................................................................................141 Argumenty metod ........................................................................................................142 Sáowo kluczowe static .................................................................................................142 Sáowo kluczowe self ..........................................................................................................145 Alokacja i zwracanie obiektów przez metody ...................................................................146 Rozszerzanie definicji klasy i pliku interfejsowego ....................................................151 Rozdziaę 8. Dziedziczenie ...................................................................................... 153 Początek wszystkiego ........................................................................................................153 Wybieranie metody do wywoáania ..............................................................................157 Rozszerzanie klas poprzez dziedziczenie — dodawanie nowych metod ...........................157 Klasa reprezentująca punkt i alokacja pamiĊci ............................................................161 Dyrektywa @class .......................................................................................................162 Klasy jako wáaĞciciele swoich obiektów .....................................................................166 Przesáanianie metod ...........................................................................................................169 Wybór metody .............................................................................................................171 Przesáanianie metody dealloc i sáowa kluczowego super ............................................173 Rozszerzanie poprzez dziedziczenie — dodawanie zmiennych egzemplarzowych ...........175 Klasy abstrakcyjne ............................................................................................................177 Spis treħci 7 Rozdziaę 9. Polimorfizm oraz typowanie i wiázanie dynamiczne ...................... 181 Polimorfizm — ta sama nazwa, róĪne klasy ......................................................................181 Wiązanie dynamiczne i typ id ...........................................................................................184 Sprawdzanie typów ...........................................................................................................186 Typ id i typowanie statyczne .............................................................................................187 Argumenty i typy zwrotne a typowanie dynamiczne ..................................................188 Pytanie o klasy ..................................................................................................................189 Obsáuga wyjątków za pomocą instrukcji @try ..................................................................193 Rozdziaę 10. Zmienne i typy danych — techniki zaawansowane ....................... 197 Inicjowanie obiektów ........................................................................................................197 Zakres dostĊpnoĞci zmiennych — rozszerzenie wiadomoĞci ............................................200 Dyrektywy do kontroli zakresu dostĊpnoĞci zmiennych .............................................200 Zmienne zewnĊtrzne ...................................................................................................201 Zmienne statyczne .......................................................................................................203 Wyliczenia .........................................................................................................................206 Instrukcja typedef ..............................................................................................................209 Konwersja typów ...............................................................................................................210 Reguáy konwersji ........................................................................................................210 Operatory bitowe ...............................................................................................................211 Operator bitowego I ....................................................................................................213 Operator bitowego LUB ..............................................................................................214 Bitowy operator LUB wykluczającego .......................................................................214 Operator uzupeánienia jedynkowego ...........................................................................215 Operator przesuniĊcia w lewo .....................................................................................216 Operator przesuniĊcia w prawo ...................................................................................217 Rozdziaę 11. Kategorie i protokoęy .......................................................................... 219 Kategorie ...........................................................................................................................219 Kilka uwag na temat kategorii .....................................................................................223 Protokoáy i delegacja .........................................................................................................224 Delegacja .....................................................................................................................227 Protokoáy nieformalne .................................................................................................228 Obiekty záoĪone .................................................................................................................229 Rozdziaę 12. Preprocesor ......................................................................................... 233 Instrukcja #define ..............................................................................................................233 Inne zaawansowane definicje typów ...........................................................................235 Instrukcja #import .............................................................................................................239 Kompilacja warunkowa .....................................................................................................241 Instrukcje #ifdef, #endif, #else oraz #ifndef ................................................................241 Instrukcje #if i #elif .....................................................................................................243 Instrukcja #undef .........................................................................................................244 Rozdziaę 13. Dziedzictwo jõzyka C ......................................................................... 245 Tablice ...............................................................................................................................245 Inicjowanie elementów tablic ......................................................................................248 Tablice znaków ...........................................................................................................249 Tablice wielowymiarowe ............................................................................................250 Funkcje ..............................................................................................................................251 Argumenty i zmienne lokalne .....................................................................................253 WartoĞü zwrotna funkcji .............................................................................................255 Funkcje, metody i tablice ............................................................................................258 8 Objective-C. Vademecum profesjonalisty Bloki ..................................................................................................................................259 Struktury ............................................................................................................................263 Inicjowanie struktur ....................................................................................................266 Struktury wewnątrz struktur ........................................................................................267 Struktury — uzupeánienie wiadomoĞci .......................................................................268 Nie zapomnij o programowaniu obiektowym! ............................................................271 WskaĨniki ..........................................................................................................................271 WskaĨniki i struktury ..................................................................................................275 WskaĨniki, metody i funkcje .......................................................................................277 WskaĨniki i tablice ......................................................................................................278 Dziaáania na wskaĨnikach ...........................................................................................288 WskaĨniki i adresy w pamiĊci .....................................................................................290 Unie ...................................................................................................................................290 To nie są obiekty! ..............................................................................................................292 RóĪnoĞci ............................................................................................................................293 Literaáy záoĪone ...........................................................................................................293 Instrukcja goto .............................................................................................................293 Instrukcja pusta ...........................................................................................................294 Operator przecinek ......................................................................................................294 Operator sizeof ............................................................................................................295 Argumenty wiersza poleceĔ ........................................................................................296 Jak to dziaáa .......................................................................................................................298 Fakt 1. Zmienne egzemplarzowe są przechowywane w strukturach ...............................298 Fakt 2. Zmienna obiektowa jest tak naprawdĊ wskaĨnikiem ...........................................299 Fakt 3. Metody i funkcje oraz wyraĪenia wysyáające komunikaty i wywoáania funkcji ....299 Fakt 4. Typ id to ogólny typ wskaĨnikowy .......................................................................299 CzõĴã II Biblioteka Foundation ......................................................303 Rozdziaę 14. Wprowadzenie do biblioteki Foundation .......................................... 305 Dokumentacja biblioteki Foundation .................................................................................305 Rozdziaę 15. Liczby, ęaěcuchy i kolekcje ............................................................... 309 Obiekty liczbowe ...............................................................................................................309 Krótka dygresja na temat puli automatycznej .............................................................311 Obiekty áaĔcuchowe ..........................................................................................................314 Funkcja NSLog — rozszerzenie wiadomoĞci ..............................................................315 Metoda description ......................................................................................................315 Obiekty zmienne i niezmienne ....................................................................................316 àaĔcuchy zmienne ......................................................................................................322 Gdzie podziewają siĊ te wszystkie obiekty? ................................................................326 Obiekty tablicowe ..............................................................................................................328 Budowa ksiąĪki adresowej ..........................................................................................331 Sortowanie tablic .........................................................................................................348 Sáowniki ............................................................................................................................355 Enumeracja sáownika ..................................................................................................356 Zbiory ................................................................................................................................358 Klasa NSIndexSet .......................................................................................................362 Rozdziaę 16. Praca z plikami .................................................................................... 367 Praca z plikami i katalogami — klasa NSFileManager .....................................................368 Klasa NSData ..............................................................................................................372 Praca z katalogami ......................................................................................................374 Sprawdzanie zawartoĞci katalogów .............................................................................376 Spis treħci 9 Praca ze ĞcieĪkami — plik NSPathUtilities.h ....................................................................378 NajczĊĞciej uĪywane metody do pracy ze ĞcieĪkami do plików ..................................380 Kopiowanie plików i uĪywanie klasy NSProcessInfo .................................................382 Podstawowe operacje na plikach — klasa NSFileHandle .................................................386 Klasa NSURL ....................................................................................................................390 Klasa NSBundle ................................................................................................................391 Rozdziaę 17. Zarzádzanie pamiõciá ....................................................................... 395 Pula automatyczna .............................................................................................................395 Liczenie referencji .............................................................................................................396 Liczenie referencji a áaĔcuchy .....................................................................................399 Zmienne egzemplarzowe .............................................................................................401 Przykáad automatycznego zwalniania ................................................................................407 Podsumowanie zasad zarządzania pamiĊcią ......................................................................409 PĊtla zdarzeĔ a alokacja pamiĊci .......................................................................................409 Znajdowanie wycieków pamiĊci .......................................................................................411 Usuwanie nieuĪytków .......................................................................................................411 Rozdziaę 18. Kopiowanie obiektów ......................................................................... 415 Metody copy i mutableCopy .............................................................................................416 Kopiowanie páytkie i gáĊbokie ...........................................................................................418 Implementacja protokoáu NSCopying ...........................................................................420 Kopiowanie obiektów w metodach ustawiających i sprawdzających ................................423 Rozdziaę 19. Archiwizacja ........................................................................................ 427 Listy wáaĞciwoĞci w formacie XML ..................................................................................427 Archiwizacja przy uĪyciu klasy NSKeyedArchiver ..........................................................429 Pisanie metod kodujących i dekodujących ........................................................................431 Tworzenie archiwów przy uĪyciu klasy NSData ...............................................................438 Kopiowanie obiektów przy uĪyciu archiwizatora ..............................................................441 CzõĴã III Cocoa, Cocoa Touch i SDK dla systemu iOS ................443 Rozdziaę 20. Wprowadzenie do Cocoa i Cocoa Touch ........................................ 445 Warstwy bibliotek .............................................................................................................445 Cocoa Touch .....................................................................................................................446 Rozdziaę 21. Pisanie programów dla systemu iOS ................................................. 449 Pakiet SDK dla systemu iOS .............................................................................................449 Pierwszy program dla systemu iOS ...................................................................................449 Tworzenie nowego projektu programu dla iPhone’a ...................................................451 Wpisywanie kodu ........................................................................................................454 Projektowanie interfejsu ..............................................................................................457 Kalkulator uáamków ..........................................................................................................463 Tworzenie projektu Fraction_Calculator .....................................................................464 Definicja kontrolera widoku ........................................................................................467 Klasa Fraction .............................................................................................................471 Klasa Calculator z obsáugą uáamków ..........................................................................474 Projekt interfejsu uĪytkownika ....................................................................................476 Podsumowanie ..................................................................................................................476 Dodatki .................................................................................................479 Dodatek A Sęowniczek ........................................................................................... 481 Skorowidz ............................................................................................. 489 Rozdziaä 3. Klasy, obiekty i metody W tym rozdziale poznasz podstawowe pojĊcia programowania obiektowego oraz na- uczysz siĊ podstaw programowania w jĊzyku Objective-C przy uĪyciu klas. Konieczne bĊdzie przyswojenie terminologii, ale nie bĊdzie to nic strasznego. ObjaĞnienia termi- nów specjalistycznych są ograniczone do niezbĊdnego minimum, aby nie przytáoczyü CiĊ nadmiarem informacji. JeĞli potrzebujesz dokáadniejszych definicji, zajrzyj do do- datku A, zawierającego sáowniczek pojĊü. Czym tak węaĴciwie jest obiekt Obiekt to jakaĞ rzecz. Programowanie obiektowe polega w pewnym sensie na posiada- niu zbioru takich rzeczy i wykonywaniu na nich róĪnych operacji. Jest to caákiem od- mienne podejĞcie niĪ w jĊzyku C, który jest jĊzykiem proceduralnym. W jĊzyku C naj- pierw trzeba siĊ zastanowiü, co siĊ chce zrobiü, a dopiero potem martwi siĊ o obiekty, czyli odwrotnie niĪ w programowaniu obiektowym. Przestudiujemy przykáad z Īycia codziennego. Przyjmijmy, Īe masz samochód, który oczywiĞcie jest jakimĞ obiektem naleĪącym do Ciebie. Ten samochód nie jest jakimĞ tam ogólnie pojazdem, lecz jest konkretnej marki i zostaá gdzieĞ wyprodukowany, na przykáad w Detroit, w Japonii albo jeszcze gdzieĞ indziej. Ma on teĪ numer VIN, którym moĪna siĊ posáugiwaü do jego identyfikacji. W terminologii obiektowej samochód, który posiadasz, nazywa siĊ egzemplarzem samochodu. Idąc tym tropem, samochód to klasa, z której utworzono ten egzemplarz. Zatem kiedy produkowany jest nowy samochód, nastĊpuje utworzenie kolejnego eg- zemplarza klasy samochód. KaĪdy taki egzemplarz nazywa siĊ obiektem. Samochód moĪe byü srebrny, mieü czarną tapicerkĊ, skáadany dach itd. Dodatkowo moĪna z nim zrobiü róĪne rzeczy, na przykáad prowadziü go, tankowaü, myü (oby), naprawiaü itd. Wszystko to przedstawiono w tabeli 3.1. Wszystkie czynnoĞci wymienione w tabeli 3.1 moĪna wykonaü z Twoim samochodem, jak równieĪ z kaĪdym innym. Na przykáad Twoja siostra równieĪ prowadzi swój samo- chód, myje go, tankuje itd. 40 Czúħè I ‹ Júzyk Objective-C 2.0 Tabela 3.1. Dziaäania na obiektach Obiekt [Twój samochód] Dziaáania na nim Prowadzenie Tankowanie Mycie Naprawianie Egzemplarze i metody Konkretnym wystąpieniem klasy jest egzemplarz, a dziaáania, jakie moĪna na nim wy- konywaü, nazywają siĊ metodami. Niektóre metody moĪna wykonywaü na rzecz wy- branych egzemplarzy klasy, a inne takĪe na rzecz samej klasy. Na przykáad mycie sa- mochodu dotyczy konkretnego egzemplarza (w istocie wszystkie czynnoĞci wymienione w tabeli 3.1 to metody egzemplarzowe). Natomiast metoda sprawdzająca, ile typów sa- mochodów dany producent produkuje, miaáaby zastosowanie do klasy, a wiĊc byáaby metodą klasową. PrzypuĞümy, Īe mamy dwa samochody, które zeszáy z linii produkcyjnej i są identyczne: oba mają takie same obicie wnĊtrza, ten sam kolor itd. Początkowo moĪe i są takie sa- me, ale kaĪdy z nich ma innego wáaĞciciela, dziĊki czemu zmieniają siĊ jego wáaĞciwo- Ğci, czyli cechy. Na przykáad jeden samochód moĪe mieü zadrapanie na báotniku, a drugi wiĊcej przejechanych kilometrów. KaĪdy egzemplarz, czyli obiekt, zawiera informacje nie tylko o swoim stanie początkowym, lecz równieĪ o bieĪących cechach, które mogą siĊ dynamicznie zmieniaü. Kiedy jeĨdzisz samochodem, z baku ubywa paliwa, na aucie gromadzi siĊ brud i zuĪywają siĊ opony. Zastosowanie metody do obiektu moĪe spowodowaü zmianĊ jego stanu. JeĞli zastosuje siĊ metodĊ „napeánij bak”, to po jej zakoĔczeniu bak samochodu bĊdzie peány. Zatem metoda ta zmieni stan baku samochodu. NajwaĪniejsze jest to, Īe obiekty to konkretne reprezentacje klas. KaĪdy obiekt zawiera pewne informacje (dane), które są jego prywatną wáasnoĞcią. Do sprawdzania i zmie- niania tych danych sáuĪą metody. W jĊzyku Objective-C do wywoáywania metod na rzecz klas i egzemplarzy sáuĪy poniĪsza skáadnia: [ KlasaLubEgzemplarz metoda ]; Otwiera siĊ nawias kwadratowy, wpisuje nazwĊ klasy lub egzemplarza klasy, przy- najmniej jedną spacjĊ oraz nazwĊ metody, która ma byü wywoáana. Na koniec zamyka siĊ nawias i stawia koĔczący instrukcjĊ Ğrednik. Wydanie instrukcji wykonania przez klasĊ lub obiekt jakiejĞ czynnoĞci nazywa siĊ wysáaniem do klasy lub obiektu komunikatu. Odbiorca komunikatu to adresat. W związku z tym przedstawioną powyĪej skáadniĊ moĪna takĪe wyraziü w nastĊpujący sposób: [ adresat komunikat ] ; Rozdziađ 3. ‹ Klasy, obiekty i metody 41 Wrócimy do poprzedniej listy i napiszemy wszystko przy uĪyciu tej nowej skáadni. Zanim jednak to zrobimy, musimy udaü siĊ do fabryki po nowy samochód. SáuĪy do tego nastĊpująca instrukcja: yourCar = [Car new]; Tworzenie nowego samochodu Wysáano komunikat new do klasy Car (adresata komunikatu), aby poprosiü ją o wydanie nowego samochodu. W odpowiedzi zostaje utworzony nowy obiekt (reprezentujący nasz samochód), który zostaje zapisany w zmiennej yourCar. Od tej pory za pomocą zmiennej yourCar moĪna odwoáywaü siĊ do naszego nowego samochodu, który otrzy- maliĞmy z fabryki. PoniewaĪ aby dostaü samochód, udaliĞmy siĊ do fabryki, new nazywana jest metodą fabryczną albo klasową. Pozostaáe czynnoĞci, które bĊdziesz wykonywaü na swoim samochodzie, bĊdą metodami egzemplarzowymi, poniewaĪ bĊdą dotyczyü Twojego eg- zemplarza samochodu. Oto kilka przykáadowych komunikatów, które moĪna by napisaü dla samochodu: [yourCar prep]; Przygotowanie do pierwszego uĪycia [yourCar drive]; Prowadzenie samochodu [yourCar wash]; Mycie samochodu [yourCar getGas]; Zatankowanie samochodu, jeĞli jest to konieczne [yourCar service]; Naprawa samochodu [yourCar topDown]; Czy samochód jest kabrioletem [yourCar topUp]; currentMileage = [yourCar odometer]; Ostatni wiersz zawiera przykáadową metodĊ egzemplarzową zwracającą informacjĊ — zapewne przebieg zgodnie ze wskazaniem licznika. Informacja ta w tym przypadku jest przechowywana w zmiennej o nazwie currentMileage. Oto przykáad wywoáania metody pobierającej argument okreĞlający konkretną wartoĞü, która w kaĪdym wywoáaniu moĪe byü inna: [yourCar setSpeed: 55]; Ustawienie prĊdkoĞci na 55 mph Twoja siostra Sue moĪe uĪyü tych samych metod na rzecz swojego samochodu: [suesCar drive]; [suesCar wash]; [suesCar getGas]; MoĪliwoĞü stosowania tych samych metod do róĪnych obiektów jest jednym z funda- mentów programowania obiektowego i dlatego póĨniej jeszcze do tego wrócimy. Najprawdopodobniej w swoich programach nie spotkasz siĊ jednak z obiektami samo- chodów. BĊdą to raczej rzeczy ze Ğwiata komputerów, a wiĊc okna, prostokąty, frag- menty tekstu albo kalkulatory czy listy odtwarzania muzyki. Metody w tych wszystkich przypadkach mogą byü podobne do przedstawionych powyĪej metod dla samochodów, na przykáad: 42 Czúħè I ‹ Júzyk Objective-C 2.0 [myWindow erase]; CzyĞci okno theArea = [myRect area]; Oblicza pole powierzchni prostokąta [userText spellCheck]; Sprawdza pisowniĊ tekstu [deskCalculator clearEntry]; Usuwa ostatni wpis [favoritePlaylist showSongs]; WyĞwietla piosenki z listy ulubionych [phoneNumber dial]; Wybiera podany numer telefonu [myTable reloadData]; WyĞwietla zaktualizowane dane w tabeli n = [aTouch tapCount]; WyĞwietla, ile razy stukniĊto w wyĞwietlacz Klasa w jõzyku Objective-C do dziaęaě na uęamkach Czas zbudowaü prawdziwą klasĊ i nauczyü siĊ pracowaü z egzemplarzami. PoniewaĪ najpierw przedstawiĊ samą procedurĊ, przykáadowe programy mogą wyda- waü siĊ maáo praktyczne. Do bardziej praktycznych rzeczy dojdziemy nieco póĨniej. ZaáóĪmy, Īe chcesz napisaü program do wykonywania dziaáaĔ na uáamkach — dziele- nia, mnoĪenia, odejmowania itp. KtoĞ, kto nie potrafi tworzyü klas, mógáby napisaü program podobny do przedstawionego na listingu 3.1: Listing 3.1. // Prosty program do wykonywania dziaáaĔ na uáamkach #import Foundation/Foundation.h int main (int argc, char *argv[]) { NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; int numerator = 1; int denominator = 3; NSLog (@ Uđamek wynosi i/ i , numerator, denominator); [pool drain]; return 0; } Listing 3.1 — wynik Uđamek wynosi 1/3 W programie przedstawionym na listingu 3.1 uáamki są reprezentowane przy uĪyciu licz- nika i mianownika. Znajdujące siĊ za instrukcją tworzącą pulĊ automatyczną dwie in- strukcje definiują zmienne caákowitoliczbowe numerator oraz denominator i przypisują im wartoĞci początkowe 1 oraz 3. Kod tych deklaracji moĪna by równieĪ zapisaü tak: int numerator, denominator; numerator = 1; denominator = 3; Rozdziađ 3. ‹ Klasy, obiekty i metody 43 Uáamek 1/3 zostaá zaprezentowany poprzez zapisanie wartoĞci 1 w zmiennej numerator i 3 w zmiennej denominator. Gdyby w programie trzeba byáo zapisaü duĪą liczbĊ uáam- ków, ta metoda byáaby bardzo uciąĪliwa. KaĪdorazowo, gdy chcielibyĞmy odwoáaü siĊ do jakiegoĞ uáamka, trzeba by byáo odwoáaü siĊ zarówno do jego licznika, jak i mia- nownika. RównieĪ wykonywanie dziaáaĔ byáoby doĞü nieporadne. Znacznie lepiej by byáo, gdyby moĪna byáo definiowaü uáamki jako pojedyncze obiekty i odwoáywaü siĊ do ich liczników i mianowników za pomocą jednej nazwy, na przykáad myFraction. MoĪna to zrealizowaü w jĊzyku Objective-C, ale potrzebna jest do tego klasa. Program pokazany na listingu 3.2 robi to samo co program z listingu 3.1, ale przy uĪy- ciu nowej klasy o nazwie Fraction. PoniĪej znajduje siĊ jego kod Ĩródáowy, a dalej szczegóáowy opis jego dziaáania. Listing 3.2. // Program do wykonywania dziaáaĔ na uáamkach — wersja z uĪyciem klasy #import Foundation/Foundation.h //---- Sekcja @interface ---- @interface Fraction: NSObject { int numerator; int denominator; } -(void) print; -(void) setNumerator: (int) n; -(void) setDenominator: (int) d; @end //---- Sekcja @implementation ---- @implementation Fraction -(void) print { NSLog (@ i/ i , numerator, denominator); } -(void) setNumerator: (int) n { numerator = n; } -(void) setDenominator: (int) d { denominator = d; } @end 44 Czúħè I ‹ Júzyk Objective-C 2.0 //---- Sekcja programu ---- int main (int argc, char *argv[]) { NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; Fraction *myFraction; // Tworzenie egzemplarza klasy Fraction myFraction = [Fraction alloc]; myFraction = [myFraction init]; // Ustawienie uáamka na 1/3 [myFraction setNumerator: 1]; [myFraction setDenominator: 3]; // WyĞwietlenie uáamka przy uĪyciu metody print NSLog (@ Wartoħè mojego uđamka wynosi: ); [myFraction print]; [myFraction release]; [pool drain]; return 0; } Listing 3.2 — wynik Wartoħè mojego uđamka wynosi: 1/3 Zgodnie z komentarzami zamieszczonymi w kodzie Ĩródáowym program jest podzielony na trzy logiczne czĊĞci: „ sekcjĊ @interface, „ sekcjĊ @implementation, „ sekcjĊ programu. W sekcji @interface znajduje siĊ opis klasy oraz jej danych i metod. Natomiast w sekcji @implementation zamieszczono kod implementacji tych metod. W sekcji programu znajduje siĊ kod Ĩródáowy wykonujący zadanie, do którego program zostaá stworzony. KaĪdy program w jĊzyku Objective-C ma wszystkie te sekcje, chociaĪ nie zawsze trzeba je wpisywaü wáasnorĊcznie. Jak siĊ niebawem przekonasz, zazwyczaj są one zapisywane w osobnych plikach. Na razie jednak wszystko bĊdziemy trzymaü w jed- nym pliku. Rozdziađ 3. ‹ Klasy, obiekty i metody 45 Sekcja @interface Aby zdefiniowaü klasĊ, naleĪy wykonaü kilka czynnoĞci. Przede wszystkim trzeba poinformowaü kompilator, skąd ona pochodzi, tzn. wyznaczyü jej klasĊ macierzystą. Po drugie, naleĪy okreĞliü, jakiego typu dane bĊdą przechowywane w obiektach tej klasy, a wiĊc opisaü dane, które bĊdą przechowywane w skáadowych klasy. Skáadowe te na- zywają siĊ zmiennymi egzemplarza. Na koniec trzeba jeszcze zdefiniowaü typy operacji, czyli metody, których bĊdzie moĪna uĪywaü do pracy z obiektami tej klasy. Wszystko to robi siĊ w specjalnej sekcji programu o nazwie @interface. Jej ogólna postaü jest na- stĊpująca: @interface NazwaNowejKlasy: NazwaKlasyMacierzystej { deklaracjeSkđadowych; } deklaracjeMetod; @end Tradycyjnie nazwy klas zaczyna siĊ wielką literą, mimo iĪ nie ma takiego formalnego wymogu. DziĊki temu programista czytający kod Ĩródáowy bez trudu odróĪnia nazwy klas od innych rodzajów zmiennych — wystarczy, Īe spojrzy na pierwszą literĊ nazwy. Zrobimy teraz krótką dygresjĊ od gáównego tematu i zastanowimy siĊ nad wyborem nazw w jĊzyku Objective-C. Wybór nazw W rozdziale 2. zostaáo uĪytych kilka zmiennych do przechowywania liczb caákowitych. Na przykáad w programie przedstawionym na listingu 2.4 uĪyto zmiennej o nazwie sum do przechowywania wyniku dodawania liczb 50 i 25. W jĊzyku Objective-C w zmiennych moĪna zapisywaü takĪe inne typy danych, pod wa- runkiem Īe przed uĪyciem w programie odpowiednio siĊ te zmienne zadeklaruje. MoĪ- na przechowywaü liczby zmiennoprzecinkowe, znaki, a nawet obiekty (a mówiąc do- káadniej — referencje do obiektów). Reguáy tworzenia nazw są bardzo proste: nazwa musi zaczynaü siĊ od litery lub znaku podkreĞlenia (_), po których moĪe wystąpiü dowolna kombinacja wielkich i maáych li- ter, znaków podkreĞlenia i cyfr. Wszystkie poniĪsze nazwy są poprawne: „ sum, „ pieceFlag, „ i, „ myLocation, „ numberOfMoves, „ sysFlag, „ ChessBoard. 46 Czúħè I ‹ Júzyk Objective-C 2.0 Natomiast poniĪsze nazwy są niepoprawne, poniewaĪ są niezgodne z przedstawionymi wyĪej zasadami: „ sum$value — znaku $ nie moĪna uĪywaü w nazwach. „ piece flag — w nazwach nie moĪe byü spacji. „ 3Spencer — nazwy nie mogą siĊ zaczynaü od cyfr. „ int — to sáowo zarezerwowane. Sáowa int nie moĪna uĪyü jako nazwy, poniewaĪ ma ono dla kompilatora specjalne znacze- nie. Jest to tzw. nazwa zarezerwowana lub sáowo zarezerwowane. W jĊzyku Objective-C jest wiĊcej takich sáów i Īadnego z nich nie moĪna uĪyü do nazwania czegokolwiek. NaleĪy równieĪ pamiĊtaü, Īe w jĊzyku Objective-C rozróĪniane są wielkie i maáe litery. W związku z tym nazwy sum, Sum i SUM dotyczą innych zmiennych. PrzypomnĊ, Īe tra- dycyjnie nazwy klas zaczyna siĊ wielką literą. Natomiast nazwy zmiennych egzempla- rza, obiektów oraz metod zaczyna siĊ maáą. Aby tekst byá bardziej czytelny, kaĪde ko- lejne sáowo w nazwie zaczyna siĊ wielką literą, jak w poniĪszych przykáadach: „ AddressBook — to moĪe byü nazwa klasy. „ currentEntry — to moĪe byü nazwa obiektu. „ current_entry — niektórzy wolą oddzielaü wyrazy znakami podkreĞlenia. „ addNewEntry — to moĪe byü nazwa metody. Dam Ci jedną radĊ dotyczącą wybierania nazw: nie spiesz siĊ. Wybieraj takie nazwy, które odpowiadają przeznaczeniu nazywanych elementów. Dobre nazwy — tak jak ko- mentarze — mogą znacznie zwiĊkszyü czytelnoĞü kodu programu i na pewno je doce- nisz podczas usuwania báĊdów i pisania dokumentacji. Tak naprawdĊ pisanie doku- mentacji bĊdzie wówczas o wiele áatwiejsze, poniewaĪ wielu czĊĞci kodu nie trzeba bĊdzie nawet objaĞniaü. PoniĪej jeszcze raz przedstawiam kod sekcji @interface z listingu 3.2. //---- Sekcja @interface ---- @interface Fraction: NSObject { int numerator; int denominator; } -(void) print; -(void) setNumerator: (int) n; -(void) setDenominator: (int) d; @end Utworzona tu klasa nazywa siĊ Fraction, a jej klasą macierzystą jest klasa o nazwie NSObject (temat klas macierzystych jest rozwiniĊty w rozdziale 8.). Definicja klasy NSObject znajduje siĊ w pliku NSObject.h, który jest automatycznie doáączany do kaĪ- dego programu, do którego zaimportowany jest nagáówek Foundation.h. Rozdziađ 3. ‹ Klasy, obiekty i metody 47 Zmienne egzemplarza W sekcji deklaracjeSkđadowych mieszczą siĊ deklaracje typów danych, jakie bĊdą prze- chowywane w klasie Fraction, oraz ich nazwy. Jak widaü, sekcja ta jest zamkniĊta w na- wiasie klamrowym. Z definicji klasy Fraction wynika, Īe jej obiekt bĊdzie zawieraá dwie skáadowe caákowitoliczbowe o nazwach numerator i denominator: int numerator; int denominator; Skáadowe, których definicje znajdują siĊ w tej sekcji, nazywają siĊ zmiennymi egzem- plarza. Jak siĊ niebawem przekonasz, wraz z kaĪdym nowym obiektem tworzony jest nowy zestaw zmiennych egzemplarza. JeĞli zatem zostaáyby utworzone dwa obiekty o nazwach fracA i fracB, to kaĪdy z nich miaáby wáasną parĊ tych zmiennych, tzn. zarówno obiekt fracA, jak i fracB miaáyby wáasne liczniki (numerator) i mianowniki (denominator). System jĊzyka Objective-C pilnuje tego automatycznie, co jest jedną z wielkich zalet korzystania z obiektów. Metody klas i egzemplarzy Aby móc coĞ robiü z klasą, trzeba zdefiniowaü jej metody. Przede wszystkim trzeba mieü moĪliwoĞü ustawiania wartoĞci uáamka. Jako Īe nie bĊdzie bezpoĞredniego dostĊpu do wewnĊtrznej reprezentacji licznika i mianownika (innymi sáowy, nie bĊdzie bezpo- Ğredniego dostĊpu do zmiennych egzemplarza), trzeba napisaü metody, które umoĪliwią zmianĊ tych wartoĞci. Dodatkowo napiszemy teĪ metodĊ o nazwie print do drukowania wartoĞci uáamków. W pliku interfejsu deklaracja tej metody jest nastĊpująca: -(void) print; Znajdujący siĊ na pierwszym miejscu áącznik informuje kompilator Objective-C, Īe jest to metoda egzemplarza. Zamiast niego moĪe teĪ byü znak + oznaczający metodĊ klasy. Metoda klasy to taka, która wykonuje jakieĞ czynnoĞci na samej klasie, a wiĊc na przy- káad tworzy nowy egzemplarz tej klasy. Metoda egzemplarza dziaáa na konkretnym egzemplarzu klasy, na przykáad ustawia lub pobiera jakąĞ jego wartoĞü, wyĞwietla ją itd. Odwoáując siĊ do analogii z samochodem, po odebraniu samochodu z fabryki moĪna napeániü jego bak paliwem. CzynnoĞü ta jest wykonywana na konkretnym egzemplarzu samochodu, a wiĊc jest odpowiednikiem metody egzemplarza. WartoĴci zwrotne Deklarując metodĊ, trzeba poinformowaü kompilator, czy bĊdzie ona zwracaáa jakąĞ wartoĞü, a jeĞli tak, to jakiego typu. DefinicjĊ typu zwrotnego wpisuje siĊ w nawiasie za áącznikiem lub znakiem plusa na początku definicji metody. Zatem metoda o nazwie currentAge, której deklaracjĊ widaü poniĪej, zwraca wartoĞü caákowitoliczbową: -(int) currentAge; 48 Czúħè I ‹ Júzyk Objective-C 2.0 Natomiast poniĪsza metoda zwraca liczbĊ o podwójnej precyzji (wiĊcej o tym typie da- nych dowiesz siĊ w rozdziale 4.). –(double) retrieveDoubleValue; Do zwracania wartoĞci przez metodĊ w jĊzyku Objective-C sáuĪy instrukcja return, a sposób jej uĪycia jest podobny do zwrotu wartoĞci z funkcji main, z którym mieliĞmy do czynienia wczeĞniej. JeĞli metoda nie zwraca Īadnej wartoĞci, zaznacza siĊ to sáowem void: –(void) print; PowyĪsza instrukcja to deklaracja metody egzemplarza o nazwie print, która nie zwra- ca Īadnej wartoĞci. Na koĔcu takiej metody nie trzeba wpisywaü instrukcji return, ale moĪna ją podaü bez Īadnej wartoĞci: return; Argumenty metod Oprócz omówionej metody w sekcji @interface na listingu 3.2 znajdują siĊ deklaracje jeszcze dwóch innych metod: –(void) setNumerator: (int) n; –(void) setDenominator: (int) d; ĩadna z nich nie zwraca wartoĞci. Obie pobierają argument w postaci liczby caákowitej, o czym Ğwiadczy sáowo int w nawiasie przed nazwą argumentu. Metoda setNumerator ma argument o nazwie n. NazwĊ argumentu wybiera siĊ dowolnie i jest ona uĪywana przez metodĊ do odwoáywania siĊ do niego. Zatem z deklaracji metody setNumerator wyni- ka, Īe przyjmuje ona jeden argument wywoáania, o nazwie n, oraz Īe nie zwraca Īadnej wartoĞci. Podobnie jest z metodą setDenominator, z tym Īe jej argument nazywa siĊ d. Przyjrzyj siĊ uwaĪnie skáadni deklaracji tych metod. Po nazwie kaĪdej z nich znajduje siĊ dwukropek, który oznacza, Īe wymagają one argumentu. Dalej w nawiasie znajduje siĊ deklaracja typu argumentu, co jest podobne do deklaracji typu zwrotnego. Na koĔcu jest symboliczna nazwa argumentu sáuĪąca do jego identyfikacji wewnątrz metody. CaáoĞü koĔczy Ğrednik. Na rysunku 3.1 przedstawiono tĊ skáadniĊ w sposób schematyczny. Rysunek 3.1. Deklaracja metody JeĞli metoda przyjmuje argument, naleĪy do jej nazwy doáączaü dwukropek takĪe w od- woáaniach do niej. Zatem poprawnie naleĪaáoby napisaü setNumerator: i setDenominator:, aby odwoáaü siĊ do tych pobierających po jednym argumencie metod. Natomiast odwoáanie do metody print nie ma dwukropka, co oznacza, Īe nie przyjmuje ona Īadnego argumentu. W rozdziale 7. dowiesz siĊ, jak siĊ tworzy metody pobierające wiĊcej argumentów. Rozdziađ 3. ‹ Klasy, obiekty i metody 49 Sekcja @implementation W sekcji @implementation wpisuje siĊ rzeczywisty kod implementacji metod zadekla- rowanych w sekcji @interface. JeĞli chodzi o terminologiĊ, mówi siĊ, Īe w sekcji @interface metody siĊ deklaruje, a w sekcji @implementation siĊ je definiuje, tzn. pisze siĊ ich rzeczywisty kod. Ogólna skáadnia sekcji @implementation jest nastĊpująca: @implementation NazwaNowejKlasy definicjeMetod; @end W miejsce parametru NazwaNowejKlasy naleĪy wpisaü tĊ samą nazwĊ co w sekcji @interface. Podobnie jak poprzednio, za nazwą moĪna wpisaü dwukropek i nazwĊ klasy macierzystej: @implementation Fraction: NSObject Nie jest to jednak obowiązkowe i zazwyczaj siĊ tego nie robi. W czĊĞci definicjeMetod wpisuje siĊ kod wszystkich metod zadeklarowanych w sek- cji @interface. Podobnie jak poprzednio, definicja kaĪdej metody zaczyna siĊ od okreĞlnika jej typu (klasy lub egzemplarza), po którym znajduje siĊ typ zwrotny oraz argumenty i ich typy. Jednak dalej zamiast Ğrednika naleĪy wpisaü kod metody w na- wiasie klamrowym. Spójrz na sekcjĊ @implementation z listingu 3.2: //---- Sekcja @implementation ---- @implementation Fraction -(void) print { NSLog (@ i/ i , numerator, denominator); } -(void) setNumerator: (int) n { numerator = n; } -(void) setDenominator: (int) d { denominator = d; } @end Metoda print do wyĞwietlania wartoĞci zmiennych egzemplarza numerator i denomina- tor uĪywa funkcji NSLog. Ale do którego licznika i mianownika ta metoda siĊ odnosi? Do zmiennych, które są wáasnoĞcią obiektu bĊdącego adresatem komunikatu. To bardzo waĪne i wkrótce jeszcze do tego wrócimy. 50 Czúħè I ‹ Júzyk Objective-C 2.0 Metoda setNumerator: zapisuje argument, któremu nadaliĞmy nazwĊ n, w zmiennej eg- zemplarza numerator. Natomiast metoda setDenominator: zapisuje wartoĞü argumentu d w zmiennej denominator. Sekcja programu W sekcji programu znajduje siĊ kod Ĩródáowy rozwiązujący konkretny problem. W ra- zie potrzeby moĪe on byü podzielony na wiele plików. PrzypomnĊ, Īe gdzieĞ musi siĊ znajdowaü procedura o nazwie main, poniewaĪ od niej zawsze zaczyna siĊ wykonywa- nie programu. Przypomnijmy sobie jeszcze raz sekcjĊ programu z listingu 3.2: //---- Sekcja programu ---- int main (int argc, char *argv[]) { NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; Fraction *myFraction; // Tworzenie egzemplarza klasy Fraction myFraction = [Fraction alloc]; myFraction = [myFraction init]; // Ustawienie uáamka na 1/3 [myFraction setNumerator: 1]; [myFraction setDenominator: 3]; // WyĞwietlenie uáamka przy uĪyciu metody print NSLog (@ Wartoħè mojego uđamka wynosi: ); [myFraction print]; [myFraction release]; [pool drain]; return 0; } Wewnątrz funkcji main zdefiniowana jest zmienna o nazwie myFraction: Fraction *myFraction; PowyĪszy wiersz kodu oznacza, Īe myFraction jest obiektem typu Fraction. Innymi sáowy, w myFraction bĊdą przechowywane wartoĞci z klasy Fraction. Rola gwiazdki znajdującej siĊ przed nazwą zmiennej zostaáa objaĞniona trochĊ dalej. Mając obiekt do przechowywania uáamka, trzeba go utworzyü, tak jak idzie siĊ do fa- bryki, aby záoĪyli nam samochód. SáuĪy do tego poniĪszy wiersz kodu: myFraction = [Fraction alloc]; Rozdziađ 3. ‹ Klasy, obiekty i metody 51 Sáowo alloc to skrót od angielskiego sáowa allocate, czyli alokowaü albo przydzielaü. SáuĪy ono do rezerwowania w pamiĊci miejsca dla nowego uáamka. PoniĪsze wyraĪenie wysyáa komunikat do nowo utworzonej klasy Fraction: [Fraction alloc] Wywoáujemy na rzecz klasy Fraction metodĊ alloc, której nigdzie nie zdefiniowaliĞmy. Skąd wiĊc siĊ ona wziĊáa? Zostaáa odziedziczona po klasie macierzystej, ale szczegóáowo dziedziczenie jest opisane dopiero w rozdziale 8. Po wysáaniu komunikatu alloc do klasy w odpowiedzi otrzymuje siĊ jej nowy egzem- plarz. W programie przedstawionym na listingu 3.2 zwrócona wartoĞü zostaáa zapisana w zmiennej o nazwie myFraction. Metoda alloc ustawia wartoĞci wszystkich zmien- nych egzemplarza na zero, przez co moĪe on nie byü od razu gotowy do uĪytku. Dlatego po alokacji obiekt trzeba zainicjowaü. W programie z listingu 3.2 zrobiono to w nastĊpnym wierszu kodu: myFraction = [myFraction init]; Tu znowu uĪywana jest metoda, której nie zdefiniowaliĞmy. Jest to metoda init, która sáuĪy do inicjacji egzemplarzy klas. Zwróü uwagĊ, Īe komunikat init zostaá wysáany do myFraction, co znaczy, Īe zainicjowany ma zostaü konkretny egzemplarz, a nie klasa. Postaraj siĊ jak najlepiej zrozumieü tĊ róĪnicĊ, zanim przejdziesz do czytania dalszego tekstu. Metoda init zwraca wartoĞü, którą jest zainicjowany obiekt. Zostaáa ona zapisana w zmiennej typu Fraction o nazwie myFraction. Te dwa wiersze kodu sáuĪące do alokacji nowego egzemplarza klasy i jego inicjacji są w jĊzyku Objective-C tak czĊsto uĪywane, Īe najczĊĞciej áączy siĊ je w jeden: myFraction = [[Fraction alloc] init]; Najpierw wykonywane jest wyraĪenie wewnĊtrzne: [Fraction alloc] Jak juĪ wiesz, jego wynikiem jest alokowany obiekt klasy Fraction. Zamiast zapisywaü rezultat alokacji w zmiennej, jak to byáo robione wczeĞniej, od razu zastosowano do niego metodĊ init. Powtórzmy wiĊc: najpierw alokujemy nowy uáamek, a potem go inicjujemy. NastĊpnie wynik inicjacji przypisujemy do zmiennej myFraction. Innym czĊsto stosowanym skrótem jest wáączenie alokacji i inicjacji do wiersza dekla- racji, jak poniĪej: Fraction *myFraction = [[Fraction alloc] init]; Tego typu instrukcje bĊdą wielokrotnie uĪywane w dalszej czĊĞci ksiąĪki, a wiĊc ko- niecznie zapoznaj siĊ z ich dziaáaniem. We wszystkich przedstawionych dotychczas programach dokonywano alokacji puli automatycznej: NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; 52 Czúħè I ‹ Júzyk Objective-C 2.0 Tym razem komunikat alloc zostaá wysáany do klasy NSAutoreleasePool w celu utwo- rzenia jej nowego egzemplarza. NastĊpnie nowo utworzony obiekt zainicjowano, wy- syáając do niego komunikat init. Wracając do programu z listingu 3.2, moĪemy juĪ ustawiü wartoĞü uáamka. Robią to poniĪsze wiersze kodu: // Ustawienie uáamka na 1/3 [myFraction setNumerator: 1]; [myFraction setDenominator: 3]; Pierwsza instrukcja wysyáa do obiektu myFraction komunikat setNumerator:. Jako ar- gument przekazano wartoĞü 1. Zaraz potem nastĊpuje przekazanie sterowania do meto- dy setNumerator: zdefiniowanej dla klasy Fraction. System Objective-C „wie”, Īe jest to metoda z tej klasy, poniewaĪ „wie”, Īe myFraction jest jej obiektem. W metodzie setNumerator: nastĊpuje zapisanie przekazanej jej wartoĞci 1 w zmiennej n. Jedyny wiersz kodu skáadający siĊ na implementacjĊ tej metody zapisuje tĊ wartoĞü w zmien- nej egzemplarza numerator. Mówiąc krótko, zmienna numerator zostaáa ustawiona na 1. NastĊpny jest komunikat wywoáujący metodĊ setDenominator: na rzecz obiektu myFraction. Przekazany do niej argument 3 zostaje przypisany do wewnĊtrznej zmien- nej d. NastĊpnie wartoĞü ta zostaje zapisana w zmiennej egzemplarza denominator i na tym koĔczy siĊ proces przypisywania wartoĞci 1/3 obiektowi myFraction. Teraz moĪna wyĞwietliü wartoĞü uáamka, do czego sáuĪą poniĪsze wiersze z listingu 3.2: // WyĞwietlenie uáamka przy uĪyciu metody print NSLog (@ Wartoħè mojego uđamka wynosi: ); [myFraction print]; Funkcja NSLog wyĞwietla nastĊpujący tekst: Wartoħè mojego uđamka wynosi: PoniĪsze wyraĪenie wywoáuje metodĊ print: [myFraction print]; Metoda print wyĞwietla wartoĞci zmiennych numerator i denominator, oddzielając je ukoĞnikiem. PoniĪszy komunikat zwalnia pamiĊü, która byáa uĪywana przez nasz obiekt klasy Fraction: [myFraction release]; PowyĪszy wiersz to bardzo waĪny element dobrego stylu programowania. Tworząc obiekt, zawsze prosisz system o alokowanie dla niego obszaru w pamiĊci. Kiedy juĪ go nie uĪywasz, Twoim obowiązkiem jest zwolnienie tej pamiĊci. OczywiĞcie pamiĊü i tak zostanie zwolniona po zamkniĊciu programu, ale kiedy zaczniesz pisaü bardziej rozbu- dowane aplikacje uĪywające setek albo nawet tysiĊcy obiektów, to bardzo szybko moĪe Ci zabraknąü pamiĊci, jeĞli nie bĊdziesz jej na bieĪąco zwalniaü. Czekanie ze zwalnianiem Rozdziađ 3. ‹ Klasy, obiekty i metody 53 pamiĊci na zamkniĊcie programu jest marnotrawstwem tego zasobu, moĪe spowolniü dziaáanie programu oraz stanowi przykáad bardzo záego stylu programowania. Dlatego najlepiej od razu wyrób sobie nawyk zwalniania pamiĊci, kiedy tylko siĊ da. W systemie wykonawczym Apple wbudowany jest specjalny mechanizm nazywany systemem usuwania nieuĪytków (ang. garbage collector), który automatycznie zwal- nia nieuĪywaną pamiĊü. Lepiej jednak umieü zarządzaü pamiĊcią samodzielnie, niĪ caákowicie zdawaü siĊ na ten algorytm. Na niektórych platformach, takich jak iPhone i iPad, w ogóle nie jest on obsáugiwany. Dlatego opis tego mechanizmu odáoĪymy na póĨniej. Patrząc na kod Ĩródáowy programów 3.1 i 3.2, moĪna spostrzec, Īe ten drugi jest znacz- nie dáuĪszy, chociaĪ robi to samo co pierwszy. Mimo to podstawowym celem uĪywania obiektów jest uáatwianie pisania programów, zarządzania nimi oraz ich rozszerzania. Stanie siĊ to oczywiste nieco póĨniej. Wróümy jeszcze na chwilĊ do deklaracji obiektu myFraction: Fraction *myFraction; i ustawiania jego wartoĞci. Zwróè uwagö, Ĕe Xcode w pierwszym wierszu funkcji main, w którym tworzony jest obiekt NSAutoreleasePool, automatycznie wstawia spacjö za znakiem *. Spacja ta nie jest potrzebna, a wiöc tak jak wiökszoĈè programistów nie bödziemy jej wstawiaè. Gwiazdka znajdująca siĊ przed nazwą myFraction w deklaracji oznacza, Īe myFraction w rzeczywistoĞci jest referencją (wskaĨnikiem) do obiektu typu Fraction. Zmienna o tej nazwie tak naprawdĊ nie przechowuje danych uáamka (tzn. wartoĞci jego zmien- nych numerator i denominator), lecz referencjĊ do nich — bĊdącą adresem w pamiĊci — która wskazuje miejsce zapisania obiektu w pamiĊci. BezpoĞrednio po zadeklarowaniu zmienna myFraction nie ma Īadnej wartoĞci, poniewaĪ nie zostaáa ustawiona ani nie ma wartoĞci domyĞlnej. Zmienną myFraction moĪna sobie wyobraziü jako pudeáko, w któ- rym znajduje siĊ wartoĞü. Początkowo w pudeáku znajduje siĊ niezdefiniowana wartoĞü, poniewaĪ nic mu nie przypisano. Pokazano to na rysunku 3.2. Rysunek 3.2. Deklaracja Fraction *myFraction; Kiedy alokowany jest nowy obiekt (na przykáad przy uĪyciu metody alloc), nastĊpuje zarezerwowanie iloĞci pamiĊci trochĊ wiĊkszej, niĪ trzeba do przechowywania jego zmiennych. NastĊpnie metoda alloc zwraca informacjĊ o miejscu zapisu tego obiektu (referencjĊ do danych) i przypisuje ją do zmiennej myFraction. Wszystko to dzieje siĊ w wyniku wykonania poniĪszej instrukcji z programu 3.2: myFraction = [Fraction alloc]; AlokacjĊ obiektu i zapisanie referencji do niego w zmiennej myFraction pokazano na rysunku 3.3: 54 Czúħè I ‹ Júzyk Objective-C 2.0 Rysunek 3.3. Relacje miödzy zmiennñ myFraction i jej danymi Na rysunku nie pokazano wszystkich danych, które sñ zapisywane wraz z obiektem, ale na razie nie musisz siö tym przejmowaè. Zwróè uwagö, Ĕe zmienne egzemplarza zostaäy ustawione na 0, co jest dzieäem metody alloc. Mimo to obiekt nie jest poprawnie zainicjowany i trzeba uĔyè metody init, aby to zmieniè. Zwróü uwagĊ na strzaákĊ na powyĪszym rysunku. Wskazuje ona kierunek poáączenia, jakie zostaáo wykonane miĊdzy zmienną myFraction a alokowanym obiektem (w zmiennej w rze- czywistoĞci zapisany jest tylko adres w pamiĊci, pod którym znajdują siĊ dane obiektu). PóĨniej nastĊpuje ustawienie wartoĞci zmiennych numerator i denominator. Na rysunku 3.4 pokazano w peáni zainicjowany obiekt klasy Fraction, którego zmienna numerator jest ustawiona na 1, a denominator na 3. Rysunek 3.4. Ustawienie wartoĈci zmiennych numerator i denominator W nastĊpnym przykáadzie zobaczysz, jak moĪna uĪyü wiĊcej niĪ jednego uáamka w jednym programie. Program przedstawiony na listingu 3.3 wartoĞü jednego uáamka ustawia na 2/3, a drugiego na 3/7. Listing 3.3. // Program do wykonywania dziaáaĔ na uáamkach — kontynuacja #import Foundation/Foundation.h //---- Sekcja @interface ---- @interface Fraction: NSObject { int numerator; int denominator; } -(void) print; -(void) setNumerator: (int) n; -(void) setDenominator: (int) d; @end //---- Sekcja @implementation ---- @implementation Fraction -(void) print { NSLog (@ i/ i , numerator, denominator); } Rozdziađ 3. ‹ Klasy, obiekty i metody 55 -(void) setNumerator: (int) n { numerator = n; } -(void) setDenominator: (int) d { denominator = d; } @end //---- Sekcja programu ---- int main (int argc, char *argv[]) { NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; Fraction *frac1 = [[Fraction alloc] init]; Fraction *frac2 = [[Fraction alloc] init]; // Ustawienie pierwszego uáamka na 2/3 [frac1 setNumerator: 2]; [frac1 setDenominator: 3]; // Ustawienie drugieg
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Objective-C. Vademecum profesjonalisty. Wydanie III
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ą: