Objective-C. Podstawy - ebook

Jeszcze parę lat temu nie do pomyślenia było, że aplikacje na urządzenia mobilne mogą stanowić tak intratny interes. Jednak urządzenia te podbiły rynek w mgnieniu oka i dziś trudno wyobrazić sobie życie bez nich. Co więcej, dały one jeszcze większe możliwości działania różnym projektantom - praktycznie wszystkie wyposażone są w aparat fotograficzny, odbiornik GPS oraz czujniki położenia. To peryferia, o których programiści tworzący aplikacje na standardowe komputery mogą tylko pomarzyć. Zastanawiasz się, jak wykorzystać ten potencjał?

Ta książka dostarczy Ci odpowiedzi. W trakcie lektury nauczysz się tworzyć atrakcyjne aplikacje na platformę iOS. Jest ona wykorzystywana w urządzeniach firmy Apple, których nikomu nie trzeba przedstawiać. Podczas tworzenia aplikacji dla tej platformy będziesz korzystał z języka Objective-C oraz środowiska XCode 4. Zawarta tu wiedza i liczne przykłady krok-po-kroku pozwolą Ci błyskawicznie opanować trudniejsze partie materiału. Książka ta jest idealną pozycją dla wszystkich programistów chcących rozpocząć przygodę z platformą iOS.

Sprawdź:

• jak przygotować środowisko pracy XCode
• jaka jest składnia języka Objective-C
• jak uruchomić swoją pierwszą aplikację

Christopher Fairbairn, Johannes Fahrenkrug i Collin Ruffenach są profesjonalnymi twórcami oprogramowania działającego na platformach mobilnych. Każdy z nich ma więcej niż dziesięcioletnie doświadczenie w używaniu różnych systemów, takich jak iOS, Palm, Windows Mobile i Java.

Wstęp (11)

Podziękowania (13)

O książce (15)

Forum Author Online (19)

Informacje na temat ilustracji umieszczonej na okładce (20)

Część I. Rozpoczęcie pracy z Objective-C (21)

1. Twoja pierwsza aplikacja iOS (23)

• 1.1. Wprowadzenie do narzędzi programistycznych na platformę iOS (24)
  
  • 1.1.1. Dostosowanie struktur Cocoa do potrzeb urządzeń mobilnych (25)
• 1.2. Dostosowanie swoich oczekiwań (26)
  
  • 1.2.1. Specyfikacja sprzętowa na koniec 2011 roku (26)
  • 1.2.2. Spodziewaj się zawodnego połączenia z internetem (27)
• 1.3. Przygotowanie prostej gry Coin Toss w Xcode (28)
  
  • 1.3.1. Wprowadzenie do środowiska IDE firmy Apple - Xcode (29)
  • 1.3.2. Łatwe uruchamianie Xcode (29)
  • 1.3.3. Utworzenie projektu (30)
  • 1.3.4. Tworzenie kodu źródłowego (33)
• 1.4. Przygotowanie interfejsu użytkownika (37)
  
  • 1.4.1. Dodanie kontrolek do widoku (38)
  • 1.4.2. Połączenie kontrolek z kodem źródłowym (39)
• 1.5. Kompilacja gry (43)
  
• 1.6. Uruchomienie gry (44)
  
  • 1.6.1. Wybór urządzenia docelowego (44)
  • 1.6.2. Używanie punktów kontrolnych do śledzenia stanu działającej aplikacji (45)
  • 1.6.3. Uruchomienie gry Coin Toss w symulatorze (46)
  • 1.6.4. Używanie modułu usuwania błędów (47)
• 1.7. Podsumowanie (49)

2. Typy danych, zmienne i stałe (51)

• 2.1. Wprowadzenie do aplikacji Rental Manager (52)
  
  • 2.1.1. Podstawy aplikacji (53)
• 2.2. Podstawowe typy danych (55)
  
  • 2.2.1. Liczenie na palcach - liczby całkowite (56)
  • 2.2.2. Liczby zmiennoprzecinkowe (59)
  • 2.2.3. Znaki i ciągi tekstowe (61)
  • 2.2.4. Wartości boolowskie (63)
• 2.3. Wyświetlanie i konwersja wartości (65)
  
  • 2.3.1. Funkcja NSLog() i specyfikatory formatu (65)
  • 2.3.2. Rzutowanie typów i konwersja typów (67)
• 2.4. Tworzenie własnych typów danych (69)
  
  • 2.4.1. Typy wyliczeniowe (69)
  • 2.4.2. Struktury (71)
  • 2.4.3. Tablice (73)
  • 2.4.4. Waga odpowiednich nazw (75)
• 2.5. Ukończenie aplikacji Rental Manager 1.0, czyli kierujemy się do App Store! (77)
  
• 2.6. Podsumowanie (79)

3. Wprowadzenie do obiektów (81)

• 3.1. Krótkie wprowadzenie do koncepcji programowania zorientowanego obiektowo (82)
  
  • 3.1.1. Co złego jest w języku proceduralnym, takim jak C? (82)
  • 3.1.2. Czym jest obiekt? (83)
  • 3.1.3. Czym jest klasa? (83)
  • 3.1.4. Dziedziczenie i polimorfizm (83)
• 3.2. Brakujący typ danych - id (84)
  
• 3.3. Wskaźniki i różnice pomiędzy odniesieniem i wartością typu (85)
  
  • 3.3.1. Mapowanie pamięci (86)
  • 3.3.2. Pobieranie adresu zmiennej (86)
  • 3.3.3. Podążanie za wskaźnikiem (87)
  • 3.3.4. Porównywanie wartości wskaźników (88)
• 3.4. Komunikacja z obiektami (89)
  
  • 3.4.1. Wysyłanie wiadomości obiektowi (89)
  • 3.4.2. Wysyłanie wiadomości klasie (90)
  • 3.4.3. Wysyłanie nieistniejących wiadomości (90)
  • 3.4.4. Wysłanie wiadomości do nil (92)
• 3.5. Ciągi tekstowe (93)
  
  • 3.5.1. Tworzenie ciągu tekstowego (93)
  • 3.5.2. Wyodrębnianie znaków z ciągu tekstowego (94)
  • 3.5.3. Modyfikacja ciągu tekstowego (95)
  • 3.5.4. Porównywanie ciągów tekstowych (96)
• 3.6. Przykładowa aplikacja (97)
  
• 3.7. Podsumowanie (100)

4. Przechowywanie danych w kolekcjach (101)

• 4.1. Tablice (102)
  
  • 4.1.1. Budowa tablicy (102)
  • 4.1.2. Uzyskanie dostępu do elementów tablicy (104)
  • 4.1.3. Wyszukiwanie elementów tablicy (105)
  • 4.1.4. Iteracja przez tablice (106)
  • 4.1.5. Dodawanie elementów do tablicy (108)
• 4.2. Słowniki (110)
  
  • 4.2.1. Tworzenie słownika (110)
  • 4.2.2. Uzyskanie dostępu do par przechowywanych w słowniku (112)
  • 4.2.3. Dodawanie par klucz-wartość (113)
  • 4.2.4. Wyświetlenie wszystkich kluczy i wartości (114)
• 4.3. Boxing (116)
  
  • 4.3.1. Klasa NSNumber (117)
  • 4.3.2. Klasa NSValue (118)
  • 4.3.3. nil kontra NULL kontra NSNull (118)
• 4.4. Aplikacja Rental Manager zaczyna używać danych (119)
  
• 4.5. Podsumowanie (122)

Część II. Tworzenie własnych obiektów (123)

5. Tworzenie klas (125)

• 5.1. Tworzenie własnej klasy (126)
  
  • 5.1.1. Dodanie nowej klasy do projektu (126)
• 5.2. Deklaracja interfejsu klasy (127)
  
  • 5.2.1. Zmienne egzemplarza (129)
  • 5.2.2. Deklarowanie metod (130)
  • 5.2.3. Przygotowanie pliku nagłówkowego dla klasy CTRentalProperty (133)
• 5.3. Utworzenie implementacji klasy (135)
  
  • 5.3.1. Zdefiniowanie implementacji metody (135)
  • 5.3.2. Uzyskanie dostępu do zmiennych egzemplarza (135)
  • 5.3.3. Wysyłanie wiadomości do self (136)
  • 5.3.4. Uzupełnienie pliku metody klasy CTRentalProperty (137)
• 5.4. Zdefiniowane właściwości (138)
  
  • 5.4.1. Składnia @property (138)
  • 5.4.2. Automatyczne wygenerowanie metod typu getter i setter (141)
  • 5.4.3. Składnia z użyciem kropki (143)
• 5.5. Tworzenie i usuwanie obiektów (144)
  
  • 5.5.1. Tworzenie i inicjalizacja obiektów (145)
  • 5.5.2. Metoda init nie jest najsprytniejsza (146)
  • 5.5.3. Połączenie alokacji i inicjalizacji (148)
  • 5.5.4. Usuwanie obiektów (149)
• 5.6. Używanie klasy w aplikacji Rental Manager (150)
  
• 5.7. Podsumowanie (153)

6. Rozszerzanie klas (155)

• 6.1. Tworzenie podklas (156)
  
  • 6.1.1. Dlaczego tworzymy podklasy? (156)
• 6.2. Dodawanie nowych zmiennych egzemplarza (158)
  
• 6.3. Uzyskiwanie dostępu do istniejących zmiennych egzemplarza (161)
  
  • 6.3.1. Podejście polegające na ręcznym utworzeniu metod typu getter i setter (162)
• 6.4. Nadpisywanie metod (163)
  
  • 6.4.1. Nadpisywanie metody description (164)
• 6.5. Klastry klas (166)
  
  • 6.5.1. Dlaczego stosowane są klastry klas? (167)
  • 6.5.2. Wiele klastrów publicznych (167)
• 6.6. Kategorie (168)
  
  • 6.6.1. Rozszerzenie klasy bez użycia podklasy (168)
  • 6.6.2. Używanie kategorii (169)
  • 6.6.3. Rozważania dotyczące używania kategorii (170)
• 6.7. Zastosowanie podklas w aplikacji Rental Manager (171)
  
  • 6.7.1. Utworzenie klasy CTLease i jej podklas (172)
  • 6.7.2. Utworzenie podklasy CTPeriodicLease jako podklasy CTLease (173)
  • 6.7.3. Utworzenie podklasy CTFixedLease jako podklasy CTLease (174)
• 6.8. Podsumowanie (176)

7. Protokoły (177)

• 7.1. Definiowanie protokołu (179)
  
• 7.2. Implementacja protokołu (180)
  
  • 7.2.1. Tworzenie funkcji wywoływania metod protokołu (180)
  • 7.2.2. Zapewnienie klasie zgodności z protokołem (182)
• 7.3. Ważne protokoły (185)
  
  • 7.3.1. Protokół UITableViewDataSource (185)
  • 7.3.2. Protokół UITableViewDelegate (188)
  • 7.3.3. Protokół UIActionSheetDelegate (192)
  • 7.3.4. Protokół NSXMLParser (193)
• 7.4. Podsumowanie (198)

8. Dynamiczne określanie typu i ustalanie typu w trakcie działania aplikacji (199)

• 8.1. Typy statyczne kontra dynamiczne (200)
  
  • 8.1.1. Przyjmowanie założeń dotyczących typu ustalanego w trakcie działania aplikacji (201)
• 8.2. Łączenie dynamiczne (202)
  
• 8.3. Jak działają wiadomości? (203)
  
  • 8.3.1. Metody, selektory i implementacje (204)
  • 8.3.2. Obsługa nieznanych selektorów (205)
  • 8.3.3. Wysyłanie wiadomości do nil (207)
• 8.4. Informacje o typie dostarczane w trakcie działania aplikacji (208)
  
  • 8.4.1. Ustalenie, czy wiadomość odpowie na wiadomość (208)
  • 8.4.2. Wysyłanie wiadomości wygenerowanej w trakcie działania aplikacji (208)
  • 8.4.3. Dodawanie nowych metod do klasy podczas działania aplikacji (210)
• 8.5. Praktyczne wykorzystanie introspekcji typu podczas działania aplikacji (212)
  
• 8.6. Podsumowanie (213)

9. Zarządzanie pamięcią (215)

• 9.1. Własność obiektu (216)
  
• 9.2. Licznik użycia obiektu (218)
  
  • 9.2.1. Zwolnienie obiektu (219)
  • 9.2.2. Przytrzymanie obiektu (220)
  • 9.2.3. Określenie bieżącej wartości licznika użycia (221)
• 9.3. Pule autorelease (223)
  
  • 9.3.1. Czym jest pula autorelease? (224)
  • 9.3.2. Dodawanie obiektów do puli autorelease (224)
  • 9.3.3. Utworzenie nowej puli autorelease (224)
  • 9.3.4. Usuwanie obiektów z puli (226)
  • 9.3.5. Dlaczego puli autorelease nie można wykorzystywać w każdej sytuacji? (226)
• 9.4. Strefy pamięci (229)
  
• 9.5. Reguły własności (231)
  
• 9.6. Ostrzeżenie o małej ilości dostępnej pamięci (232)
  
  • 9.6.1. Implementacja protokołu UIApplicationDelegate (233)
  • 9.6.2. Nadpisanie metody didReceiveMemoryWarning (234)
  • 9.6.3. Obserwacja powiadomienia UIApplicationDidReceiveMemoryWarningNotification (237)
• 9.7. Podsumowanie (239)

Część III. Maksymalne wykorzystanie funkcji struktur (241)

10. Obsługa błędów i wyjątków (243)

• 10.1. NSError - obsługa błędów w sposób zgodny z Cocoa (244)
  
  • 10.1.1. Komunikacja z NSError (245)
  • 10.1.2. Analiza słownika userInfo klasy NSError (245)
• 10.2. Tworzenie obiektu NSError (247)
  
  • 10.2.1. Wprowadzenie RentalManagerAPI (247)
  • 10.2.2. Obsługa i wyświetlanie błędów w aplikacji RentalManagerAPI (250)
• 10.3. Wyjątki (251)
  
  • 10.3.1. Zgłaszanie wyjątku (251)
  • 10.3.2. Przechwytywanie wyjątku (252)
• 10.4. Podsumowanie (253)

11. Key-Value Coding i NSPredicate (255)

• 11.1. Zapewnienie obiektom zgodności z KVC (257)
  
  • 11.1.1. Uzyskanie dostępu do właściwości za pomocą KVC (258)
  • 11.1.2. Tworzenie ścieżek kluczy (258)
  • 11.1.3. Zwracanie wielu wartości (259)
  • 11.1.4. Agregacja i zbieranie wartości (259)
• 11.2. Obsługa przypadków specjalnych (261)
  
  • 11.2.1. Obsługa nieznanych kluczy (261)
  • 11.2.2. Obsługa wartości nil (262)
• 11.3. Filtrowanie i dopasowywanie za pomocą predykatów (263)
  
  • 11.3.1. Obliczenie predykatu (263)
  • 11.3.2. Filtrowanie kolekcji (264)
  • 11.3.3. Wyrażenie warunku predykatu (264)
  • 11.3.4. Bardziej skomplikowane wyrażenia (265)
  • 11.3.5. Używanie ścieżek kluczy w wyrażeniu predykatu (266)
  • 11.3.6. Parametryzowanie i stosowanie szablonu wyrażenia predykatu (267)
• 11.4. Przykładowa aplikacja (268)
  
• 11.5. Podsumowanie (271)

12. Odczyt i zapis danych aplikacji (273)

• 12.1. Historia Core Data (275)
  
  • 12.1.1. Do czego służy Core Data? (275)
• 12.2. Obiekty Core Data (276)
  
  • 12.2.1. Kontekst obiektów zarządzanych (277)
  • 12.2.2. Koordynator trwałego magazynu danych (277)
  • 12.2.3. Model obiektu zarządzanego (277)
  • 12.2.4. Magazyn trwałych obiektów (278)
• 12.3. Zasoby Core Data (278)
  
  • 12.3.1. Encje Core Data (278)
  • 12.3.2. Atrybuty Core Data (279)
  • 12.3.3. Związki w Core Data (280)
• 12.4. Utworzenie aplikacji PocketTasks (281)
  
  • 12.4.1. Analiza szablonu Xcode z obsługą Core Data (281)
  • 12.4.2. Budowa modelu danych (281)
  • 12.4.3. Definicje związków (282)
  • 12.4.4. Tworzenie encji Person (284)
  • 12.4.5. Pobieranie encji Person (286)
  • 12.4.6. Dodanie TableView (287)
  • 12.4.7. Dodawanie i usuwanie osób (290)
  • 12.4.8. Zarządzanie zadaniami (294)
  • 12.4.9. Używanie obiektów modelu (297)
• 12.5. Wykraczając poza podstawy (299)
  
  • 12.5.1. Zmiana modelu danych (299)
  • 12.5.2. Wydajność (301)
  • 12.5.3. Obsługa błędów i weryfikacja (302)
• 12.6. Podsumowanie (304)

13. Bloki i technologia Grand Central Dispatch (305)

• 13.1. Składnia bloków (306)
  
  • 13.1.1. Blok stanowi zamkniętą całość (309)
  • 13.1.2. Bloki i zarządzanie pamięcią (310)
  • 13.1.3. API bazujące na blokach w strukturach iOS dostarczanych przez Apple (313)
• 13.2. Asynchroniczne wykonywanie zadań (314)
  
  • 13.2.1. Poznaj technologię GCD (315)
  • 13.2.2. Podstawy technologii GCD (315)
  • 13.2.3. Budowa aplikacji RealEstateViewer (316)
  • 13.2.4. Asynchroniczne przeprowadzanie wyszukiwania obrazów (321)
  • 13.2.5. Asynchroniczne wczytywanie obrazów (322)
• 13.3. Podsumowanie (324)

14. Techniki usuwania błędów (325)

• 14.1. Utworzenie aplikacji zawierającej błędy (326)
  
• 14.2. Zrozumienie funkcji NSLog() (327)
  
• 14.3. Kontrola wycieków pamięci za pomocą narzędzia Instruments (331)
  
• 14.4. Wykrywanie zombie (333)
  
• 14.5. Podsumowanie (336)

Dodatki (337)

A: Instalacja iOS SDK (339)

• A.1. Instalacja iOS SDK (340)
  
• A.2. Przygotowanie urządzenia iOS (341)

B: Podstawy języka C (345)

• B.1. Konwencje nazw zmiennych (346)
  
• B.2. Wyrażenia (349)
  
• B.3. Polecenia warunkowe (353)
  
• B.4. Polecenia pętli (358)
  
• B.5. Podsumowanie (364)

C: Alternatywy dla Objective-C (365)

• C.1. Krótka historia Objective-C (366)
  
• C.2. Alternatywy dla Objective-C i Cocoa (368)
  
• C.3. iPhone SDK - Safari (369)
  
• C.4. Języki skryptowe - Lua i Ruby (374)
  
• C.5. Waga ciężka - Adobe Flash (376)
  
• C.6. Mono (.NET) (378)
  
• C.7. Podsumowanie (380)

Skorowidz (381)