Podstawy_jezyka_Swift_Programowanie_aplikacji_dla_platformy_iOS_pjswif.pdf

(1253 KB) Pobierz
Tytuł oryginału: Swift Fundamentals: The Language of iOS Development
Tłumaczenie: Robert Górczyński
Projekt okładki: Studio Gravite / Olsztyn
Obarek, Pokoński, Pazdrijowski, Zaprucki
ISBN: 978-83-283-1912-7
© 2014 by LearnToProgram.tv, Incorporated
All rights reserved. No part of this document may be reproduced or transmitted in any form or by any
means, electronic, mechanical, photocopying, recording, or otherwise, without prior written permission of
LearnToProgram.tv, Incorporated.
Polish edition copyright © 2016 by Helion S.A.
All rights reserved.
All rights reserved. No part of this book may be reproduced or transmitted in any form or by any means,
electronic or mechanical, including photocopying, recording or by any information storage retrieval system,
without permission from the Publisher.
Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej
publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną,
fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje
naruszenie praw autorskich niniejszej publikacji.
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.
Materiały graficzne na okładce zostały wykorzystane za zgodą Shutterstock Images LLC.
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)
Pliki z przykładami omawianymi w książce można znaleźć pod adresem:
ftp://ftp.helion.pl/przyklady/pjswif.zip
Drogi Czytelniku!
Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres
http://helion.pl/user/opinie/
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ść
S
PIS TREŚCI
Rozdział 1. Rozpoczęcie pracy .................................................................................................. 9
1.1. Aplikacja typu „Witaj, świecie!” w języku Swift ...............................................................................9
1.2. Praca w środowisku Xcode ...............................................................................................................17
Ćwiczenia do rozdziału 1. .......................................................................................................................26
Podsumowanie .........................................................................................................................................27
Rozdział 2. Zmienne ............................................................................................................... 29
2.1. Tworzenie zmiennych i stałych ........................................................................................................29
2.2. Typy zmiennej ...................................................................................................................................35
2.3. Operatory arytmetyczne ...................................................................................................................39
2.4. Rzutowanie typu ...............................................................................................................................44
2.5. Interpolacja ciągu tekstowego ..........................................................................................................46
Ćwiczenia do rozdziału 2. .......................................................................................................................50
Podsumowanie .........................................................................................................................................50
Rozdział 3. Przepływ kontroli działania programu .............................................................. 53
3.1. Polecenie if .........................................................................................................................................53
3.2. Złożone i skomplikowane polecenia if .............................................................................................59
3.3. Konstrukcja switch ...........................................................................................................................67
3.4. Pętla while .........................................................................................................................................71
3.5. Pętla for .............................................................................................................................................76
3.6. Pętla for-in ........................................................................................................................................79
Ćwiczenia do rozdziału 3. .......................................................................................................................82
Podsumowanie .........................................................................................................................................83
Rozdział 4. Tablice i słowniki ................................................................................................. 85
4.1. Tworzenie i uaktualnianie tablic .....................................................................................................85
4.2. Funkcje array.count() i array.slice() ...............................................................................................89
4.3. Funkcje tablicy ..................................................................................................................................95
4.4. Utworzenie słownika ......................................................................................................................103
4.5. Funkcje słownika ............................................................................................................................106
Ćwiczenia do rozdziału 4. .....................................................................................................................112
Podsumowanie .......................................................................................................................................113
5
Kup książkę
Poleć książkę
Podstawy języka Swift
Rozdział 5. Funkcje ................................................................................................................115
5.1. Definicja i wywołanie funkcji ........................................................................................................115
5.2. Funkcje pobierające argumenty .....................................................................................................119
5.3. Funkcje zwracające wartość ...........................................................................................................124
5.4. Funkcje i zasięg zmiennej lub stałej ..............................................................................................129
5.5. Funkcje zagnieżdżone .....................................................................................................................133
Ćwiczenia do rozdziału 5. .....................................................................................................................136
Podsumowanie .......................................................................................................................................137
Rozdział 6. Klasy i protokoły .................................................................................................139
6.1. Typy wyliczeniowe ..........................................................................................................................139
6.2. Tworzenie klasy i jej egzemplarza .................................................................................................146
6.3. Podklasy i nadpisywanie metod .....................................................................................................154
6.4. Protokoły .........................................................................................................................................161
Ćwiczenia do rozdziału 6. .....................................................................................................................166
Podsumowanie .......................................................................................................................................167
Rozdział 7. Więcej konstrukcji języka Swift .........................................................................169
7.1. Rozszerzenia ....................................................................................................................................169
7.2. Przeciążanie operatora ...................................................................................................................173
7.3. Funkcje generyczne .........................................................................................................................176
7.4. Emotikony .......................................................................................................................................179
Ćwiczenia do rozdziału 7. .....................................................................................................................182
Podsumowanie .......................................................................................................................................183
Rozdział 8. Aplikacja iOS 8 w języku Swift ...........................................................................185
8.1. Utworzenie interfejsu użytkownika aplikacji ...............................................................................185
8.2. Utworzenie outletów i akcji ...........................................................................................................194
8.3. Uruchomienie i przetestowanie aplikacji ......................................................................................203
Ćwiczenia do rozdziału 8. .....................................................................................................................208
Podsumowanie .......................................................................................................................................212
Odpowiedzi ............................................................................................................................213
Dodatek ..................................................................................................................................225
Skorowidz ...............................................................................................................................229
6
Mark A. Lassoff
Kup książkę
Poleć książkę
R
OZDZIA
7.
W
IĘCEJ KONSTRUKCJI JĘZYKA
S
WIFT
W
ROZDZIALE
:
Dowiesz się, jak używać rozszerzeń w celu zwiększenia użyteczności klas i typów danych.
Poznasz mechanizm przeciążania operatorów i przekonasz się, że to narzędzie, które
można wykorzystać do bardzo wielu celów.
Nauczysz się wykorzystywać funkcje generyczne i zobaczysz, że ich stosowanie może
ograniczyć konieczność powielania kodu i zapewnić mu większą czytelność.
Dowiesz się, jak można używać emotikonów w języku Swift.
7.1. R
OZSZERZENIA
Jak dotąd używaliśmy elementów wbudowanych w języku Swift lub też tworzyliśmy własne
konstrukcje. Na przykład za każdym razem, gdy korzystaliśmy ze zmiennej w postaci liczby
rzeczywistej, stosowaliśmy wbudowany typ
Int
. W przypadku własnych konstrukcji, takich jak
klasy, prototypy i typy wyliczeniowe, mieliśmy możliwość zdefiniowania wymaganej
funkcjonalności. Jednak w trakcie programowania zdarzają się sytuacje, w których nie
ma możliwości bezpośredniej modyfikacji pierwotnego kodu lub też wbudowane elementy mają
zostać użyte do wykonania znacznie poważniejszych zadań niż te, do których zostały zaprojektowane.
Podczas zwiększania użyteczności istniejącego fragmentu kodu mówimy o rozszerzeniu jego
możliwości poza wbudowane. Dokładnie tym są
rozszerzenia
w języku Swift: to metody
egzemplarza dodane do istniejących klas, struktur lub typów wyliczeniowych.
Aby zademonstrować rozszerzenie, rozbudujemy jeden z podstawowych typów danych i tym
samym zwiększymy jego funkcjonalność. W Xcode utwórz nowy plik typu
playground,
po czym
umieść w nim następujący fragment kodu:
extension Double
{
// Miejsce na kod rozszerzaj cy funkcjonalno .
}
169
Kup książkę
Poleć książkę

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin