[Powered by Google Translate] [Seminarium] [iOS: Pisanie Aplikacji Like a Boss]
[Tommy MacWilliam] [Harvard University]
[To jest CS50.] [CS50.TV]
>> Dobra, wszyscy, zapraszamy do iOS: Pisanie Aplikacji jak Boss.
To seminarium ma zamiar skupić się na pisaniu aplikacji dla iPhone
az kolei pisanie aplikacji dla iPad, a więc jesteśmy w zasadzie zamiar przejść przez
kilka różnych przykładów jak zrobić aplikację, prosta gra jak Tic Tac Toe,
lub jeśli jesteś bardziej zainteresowany w tworzeniu app jak jakiś czytnik wiadomości
lub coś, co współgra z Internetu będę mówić o tym również.
Oto nasz krótki program.
>> Aplikacje IOS są napisane w języku zwanym Objective-C,
i tak to jest trochę podobny do C, ale naprawdę nie jest w ogóle,
więc będziemy rozmawiać trochę o samym języku
, a następnie, jak zbudować iPhone apps za pomocą tego programu Aplikacja o nazwie Xcode,
które, jeśli nie pobrało go jeszcze tutaj, aby rozpocząć pobieranie teraz.
Jest kilka gigabajtów.
Powinno być za darmo na App Store, więc musisz mieć Mac
doskonale działa z najnowszej wersji OS X.
Jeśli nie jesteś, nie ma problemu.
Mamy komputery Mac w centrum nauki do dyspozycji
z XCode zainstalowany, a więc zachęcamy do korzystania z tych, dla rozwoju.
Jeśli chcesz złożyć aplikację, ale nie masz Maca, nie martw się.
Istnieje mnóstwo zasobów kampusu za to.
I tak potem idziemy na pokrycie 2 większych przykładów różnych aplikacji można dokonać.
Objective-C jest technicznie, co nazywa się super zestaw C
To oznacza, że ​​każdy kod C obowiązuje również kod Objective-C.
To oznacza, że ​​rodzaj kanału kręcony dodatkowe funkcje do C.
Niektóre z tych funkcji są nie konieczności kiedykolwiek napisać malloc ponownie, dzięki Bogu,
nie martwiąc się o tych głupich wskaźników i uwolnienie ich i wszystkie rzeczy
nienawidzisz o C, a to trochę już w Objective-C.
>> Teraz, celem C również większe biblioteki standardowej,
więc nie ma dużo więcej funkcji można uzyskać za darmo wewnątrz Objective-C.
Pamiętaj, gdy pisaliśmy PHP zauważyliśmy, że poszliśmy z
to najmniejszy język giganta biblioteki tych wszystkich rzeczy szalonych możesz zrobić.
To samo dzieje się w iOS.
Jest obiekty dla rzeczy jak kalendarz buddyjski, i naprawdę nic
można ewentualnie pomyśleć prawdopodobnie istnieje już w realizacji celu C w.
Celem części Objective-C jest odwołanie coś
nazywany Object-Oriented Programming.
Jest to rodzaj nowej koncepcji, ale my rzeczywiście w większości dowiedziałem
Wiele z tych pojęć już.
Ideą programowania obiektowego jest, że idziesz do struktury
Dużo kodu wokół tych rzeczy nazywane klas,
a te zajęcia są naprawdę uwielbiony przypisać struktury.
Wewnątrz struct my w zasadzie powiedział tutaj jest rzeczą,
i to coś może mieć członków.
Na przykład, węzeł połączonej liście może mieć inne rzeczy
jak wartości, wskaźnik do następnego węzła na liście
i razem, że wskaźnik i ta wartość składa tę jedną instancję struktury.
Zajęcia są bardzo podobne, z wyjątkiem
Zajęcia mogą mieć także funkcje wewnątrz nich.
Kiedy oświadczył struct, możemy tylko powiedzieć, int n lub * węzła następnego.
>> Teraz z Objective-C faktycznie możemy umieścić funkcje
wewnątrz z tych rzeczy.
Inną rzeczą, którą możemy zrobić, to zajęcia mogą dziedziczyć dane z innych klas.
Na przykład, będziemy patrzeć na kilka wbudowanych w Objective-C klasy.
Jedna z nich może być klasa, która reprezentuje widok dla ekranu
a więc, mówiąc, że chcą wprowadzić własne poglądy
my w zasadzie powiedzieć, kogoś na Apple, prawdopodobnie naprawdę mili ludzie,
napisał tę klasę dla mnie, i obsługuje on takie rzeczy jak wyświetlanie przycisków
lub uczynienie ekranu, i będziemy bardzo zasmucony
do wdrożenia wszystkich tych funkcji sami, i tak po prostu
dziedziczenie danych można powiedzieć, że zrobiłeś wszystko, co w tej klasie
Chcę również wewnątrz mojej klasie, a potem zamierzam zrobić kilka innych rzeczy,
mianowicie wdrożenie aplikacji.
To właśnie, że dziedziczenie słowo oznacza. Zobaczymy bardziej konkretny przykład.
>> I wreszcie, klucz z programowania obiektowego jest
prowadzi do kapsułkowania danych.
W niektórych z naszego problemu ustawia może mamy te duże, zmienne globalne
i globals wszędzie, i to jak chcielibyśmy śledzić stanu.
Z klas możemy zacząć enkapsulacji informacji wewnątrz obiektu.
Jeśli mamy jeden ekran na naszej aplikacji, tak naprawdę nie trzeba mieć żadnych danych z
kolejny ekran w naszej wewnętrznej aplikacji tego,
i tak przez umieszczenie rzeczy w klasach to rzeczywiście prowadzi
znacznie lepszego projektowania kodu, to jest możliwe, a niektóre z funkcji dodatkowych
z Objective-C.
Ostrzegawcza, składnia Objective-C to banany.
To jest jak nic widzieliśmy wcześniej,
tak to jest trochę krzywa uczenia się przyzwyczaić
Co do cholery to znaczy?
Ale po przeszłości, że początkowy krzywej uczenia się jest to bardzo, bardzo gładka
zacząć pisać aplikacje.
>> Aby zadeklarować klasę, tu powiedzieć to moja klasa, istnieje,
a może są tu pewne rzeczy, które mam zamiar określić później,
Zamierzam powiedzieć interfejs @.
Zamierzam powiedzieć interfejs @. Mam zamiar dać mojej klasie nazwę.
A potem gdzieś idę powiedzieć @ end,
i wszystko, co w między @ interface i koniec @
będzie moja klasa.
Że będzie to, co jest wewnątrz naszych plików. Godz.
Podobnie jak w C nasze pliki. H zasadzie powiedział, oto kilka rzeczy, które istnieją.
Ja nie zawsze mówi ci to, co robią jeszcze,
ale kompilator musi wiedzieć, że one istnieją.
Później w środku naszego. M files-bo m dla Objective-C
jest, dokąd faktycznie się określić, co te zajęcia zrobić.
Podobnie jak w naszych plików. C, zapewniliśmy implementację dla funkcji.
Wewnątrz naszego. M pliku będziemy tu powiedzieć to, co wszystkie funkcje
wewnątrz moja klasa-co oni wszyscy.
I w końcu, wewnątrz struktury moglibyśmy powiedzieć wewnątrz tych nawiasów klamrowych
int n lub węzeł * next,
w Objective-C mamy zamiar użyć słowa kluczowego właściwość @,
i to, co się określa właściwości
lub braku funkcji, które są częścią moich zajęć.
>> Wywołanie funkcji w Objective-C jest również banany.
Kiedy zadeklarowanych funkcji w C powiedzieliśmy coś int foo
i otwarty nawias, a następnie dał mu listę argumentów.
To właśnie stwierdzenie metody lub funkcji wygląda w Objective-C.
Jeśli chcę zadeklarować funkcji lub metody
gdy mówię metody jest tak naprawdę funkcja jest członkiem klasy,
więc rodzaj wymienne, ale nie bardzo,
tak wewnątrz mojej metody chcę utworzyć nową metodę.
To będzie powrót nic, więc to będzie typu void.
Jest to rodzaj powrotu mojej funkcji.
Teraz mamy nawiasy tutaj, bo-nie wiem.
Następna będzie nazwa mojej funkcji,
i wreszcie mamy średnik tak jak mieliśmy w C.
Nowością jest ten facet tutaj.
Ten łącznik jest rzeczywiście konieczne, i co to mówi, że
metoda ta musi tu być nazywany w instancji klasy.
>> Po zadeklarowaliśmy nasze przypisać struktury zapewne powiedział coś
struct n węzłów, i że faktycznie stworzył
lub wystąpienia jednego z tych strukturach, abym mógł zacząć pracę
z tym, co znajduje się w jej środku, więc ta kreska oznacza, że ​​mamy do
instancji klasy, tak jak my, że instancja struct
przed możemy wywołać tę metodę na nim.
Jeśli chcę, aby rozpocząć dodawanie argumenty do moich metod
będzie jeszcze więcej bananów.
Oto moja nazwa metody.
Wtedy będę mieć dwukropek, a po tym dwukropku jest napisane tutaj jest kilka argumentów.
Ta metoda przyjmuje jeden argument.
Typ jego argumentu jest int, a nazwa tego argumentu
lub zmienna, której mam zamiar zacząć używać wewnątrz metody jest nazywany i.
Ponownie, jest to sposób. Ona jeden argument.
>> Jeśli chcesz, aby rozpocząć dodawanie więcej argumentów robi więcej bananów
na tym, że mamy ten dwukropek, że mówi tu przychodzi moja lista argumentów.
Ten pierwszy argument jest liczbą całkowitą.
Teraz ten drugi argument jest ciekawy.
Zmienna, że ​​mam zamiar używać wewnątrz mojej funkcji
nazywa f, tak wewnątrz mojej funkcji można powiedzieć
f + = 1 czy coś.
To coś tu jest w zasadzie kluczem do tego argumentu lub parametru.
Tak jak mieliśmy kluczowych par wartości i coś jak JSON lub tablice asocjacyjne
Objective-C podjął decyzję, aby powiedzieć, w porządku, po prostu tak, że to jest naprawdę jasne
podczas wywołania metody, co wszystkie te parametry są
Jestem rzeczywiście będzie je wszystkie wymienić.
Podczas wywoływania metody, będziesz faktycznie powiedzieć andFloat,
a potem zdać go w.
>> Interesujące jest to nie pochodzi, ale z innymi parametrami, są
więc jeśli mieliśmy 3-szy argumentu mogę powiedzieć andFloat
i innego przepływu i tak dalej.
Kiedy dzwonię do tych metod jest bananów kursu,
więc jeśli mam obiektu, i określono metodę o nazwie foo,
i chcę to nazwać, zamiast mówić foo otworzyć / zamknąć nawiasy
Zamierzam otworzyć uchwyt.
Tutaj jest nazwa mojej metody.
Mam zamiar zamknąć uchwyt, a to obiekt Wołam ją.
Pamiętaj, że wszystkie te metody istnieją w klasach
ponieważ klasy mogą mieć metody zdefiniowane wewnątrz nich.
>> Tutaj mam arbitralnie tworzone obiekt jakiejś klasy,
i to jest składnia to robić.
Istnieją 2 kroki tworzenia obiektu.
Pierwszym krokiem jest, że chcę przeznaczyć przestrzeń.
Jest to równoważne z malloc. Nie mamy do powiedzenia malloc anymore.
Wpadliśmy na m, dotarł Alloc, i zastąpił. C z. Metrów.
Po czymś alloc my wtedy trzeba go zainicjować.
Zasadniczo podczas tworzenia obiektów może chcesz mieć trochę logiki
, który wykonuje, gdy są one tworzone, więc można przekazać w niektórych wartości domyślnych
lub coś w tym stylu, i tak ta metoda init jest to, co w rzeczywistości tworzy obiekt.
Najpierw alokacji przestrzeni, tak jak robiliśmy to w C,
a potem zainicjować, które mogą, ale nie do dużo.
Potem wracasz to coś w obiekt o.
Jest tu, bo gwiazda jest to technicznie wskaźnik,
ale nie martw się, wskaźniki nie są tak wielkie rzeczy w Objective-C więcej.
>> Teraz mamy instancja tej klasy o nazwie NSObject,
i jest to tylko random class, że Apple ma.
Mamy instancja tego, a teraz mam wystąpienie tej klasy
w obiekt O, więc oznacza to, że jeżeli określone
Metody te można nazwać je tak.
Podobnie, jeśli chcę wywołać metodę z jednym argumentem,
jest to więc metoda bar, które ma jeden argument,
i tutaj jest baz: Metoda qux, więc zajmuje to 2 argumenty.
To jest wywołanie jednej funkcji na tym obiekcie o.
Ma sens?
Składnia powinna mieć sens, ale trochę się do niego przyzwyczaić.
>> Dobrze, porozmawiajmy o kilku rzeczach, które są wbudowane w Objective-C
, które niekoniecznie muszą być wbudowane w C.
W języku C mamy rodzaj miał do czynienia z tekstem, jak te głupie tablic znakowych
i zrobiło się naprawdę denerwujące.
Objective-C posiada te wszystkie zbudowane w dla nas, i jest zbudowany w
korzystania z tej klasy o nazwie NSString.
Kiedy chcę utworzyć NSString mamy bardziej złożoną składnię.
Zamiast mówić "CS50" Mówimy @ "CS50"
i jest to tylko składnia deklarowania ciągów w Objective-C.
Jest to bardzo łatwo zapomnieć, więc nie.
Teraz, kiedy mam to, to jest ciąg, ale zauważ
to naprawdę tylko przedmiot.
Powiedziałem NSString, co oznacza, że ​​instancja klasy
nazywa NSString, które ktoś inny napisał o mnie,
i byli bardzo mili o tym, i tak teraz
Mogę zacząć wywołanie metod na jej temat.
Jeśli zadzwonię długość metody na tym obiekcie s
to wróci do mnie na długość łańcucha.
To jest jak strlen w C.
To wróci 4.
>> Podobnie inna metoda może chcę się martwić o to characterAtIndex.
Jest to metoda, która mówi o tym string s
Chcę, aby uzyskać 0-szy charakter
i tak to wróci do mnie znak c,
i jest tam cała masa z tych metod, które można google naprawdę łatwo.
Dokumentacja Apple jest super, a my zapraszamy do obejrzenia, że ​​w nieco.
Są to ciągi.
Posiadamy również tablice zmiennych rozmiar wbudowane
Zapamiętaj w C kiedy zadeklarowaliśmy tablicę
mieliśmy, że masz 5 elementów, koniec historii.
Kiedy dotarliśmy do JavaScript i PHP możemy zacząć
robić rzeczy, jak dodanie elementów lub ruchomych elementów.
Możemy zrobić to samo w Objective-C.
Zamiast tworzenia tablicy w sposób normalny C
mamy ponownie inną klasę o nazwie NSMutableArray.
Jest też NSArray,
i to będzie w zasadzie enkapsulacji jakąś tablicę.
Ten mówi, pierwszą rzeczą, którą chcesz zrobić, to chcę, aby przydzielić
przestrzeń dla nowej tablicy, a po I przeznaczyć go
I wtedy trzeba go zainicjować.
Ponownie, po prostu nazywanie tych 2 metod.
Teraz oznacza to, że wnętrze tego obiektu jest
I pusta tablica siedzi.
Jeśli chcę coś dodać do tej tablicy, mogę zadzwonić do addObject metody.
Chcę dodać obiekt do tablicy A i chcę dodać ciąg CS50.
Jeśli chciałem odwrotnie usunąć to mogę powiedzieć, że chcą
usunąć obiekt na pierwszym miejscu na tablicy lub obiektu.
>> Ma sens?
Dobra, trochę przyzwyczaić się do tego kwadratowy rzeczy wspornika.
Nawiasem mówiąc, w środku wielu bibliotek Apple zobaczysz tę NS.
NS naprawdę oznacza kolejnego etapu, który był jedną z firm, Steve Jobs po pierwsze,
i to, gdzie tak naprawdę zacząłem pisać dużo kodu
jako swego rodzaju podstawę do systemu Mac OS X i wszystkich innych rzeczy,
i tak to NS jest rodzaj tej miłej spuścizny krzyczeć do jednego z wcześniejszych spółek
z powrotem, gdy Apple po raz pierwszy zaczynają.
Jest wszędzie.
Rzućmy okiem na bardziej holistyczne Objective-C przykład.
Oto jestem wewnątrz XCode.
Aby się tu dostać, najpierw pobrać XCode z App Store,
otworzył ją, a następnie udałem się tutaj do pliku,
tutaj do nowego projektu, a następnie.
Po zrobić, że mam te wszystkie opcje, co chcę stworzyć,
i tak będziemy spojrzeć na te opcje później
ale tylko na tym przykładzie, bo nie jesteśmy rzeczywiście będzie app jeszcze,
Przyszłam tu, a ja powiedziałem Narzędzie linii poleceń,
i jest to aplikacja, która można uruchomić z wiersza poleceń
tak jak my został uruchomiony z C.
Tak właśnie stworzył ten projekt, a więc teraz jestem tu,
Więc pierwsze spojrzenie na tym pliku, i to powinno wyglądać dość znajomo.
Mam int nazwę. To mój przyjaciel argc, mój inny kolega argv.
I tak widzimy, że jest to punkt wyjścia dla mojej pierwszej Objective-C wniosku.
Tutaj możemy ignorować tego teraz.
Jest to po prostu niektóre rzeczy zarządzania pamięcią, które nie będziesz naprawdę
kiedykolwiek się martwić.
>> Przyjrzyjmy się tym pierwszym bloku tutaj.
Ta pierwsza linia, jeśli powiem, Student * alice = [[alloc Student] init] co to robisz?
Ten pierwszy uczeń tutaj, to prawdopodobnie klasy.
To nie klasa, że ​​Apple to napisał, ale jest to klasa, która napisałem.
Pierwszą rzeczą, którą chcesz zrobić, to chcę, aby przydzielić miejsca dla nowego ucznia,
a następnie chcę, aby zainicjować go, więc to daje mnie
Ten nowy obiekt student, a ja jestem w tym przechowywania w zmiennej o nazwie Alice.
Skąd to klasa pochodzi?
Cóż, tutaj z lewej strony to wszystko z różnych plików wewnątrz mojego projektu.
Widzimy tutaj mam Student.h i Student.m.
Plik. H, pamiętaj, gdzie jest Oświadczam wszystkie rzeczy
która istnieje w klasie.
>> Rzućmy okiem na to.
Dobra, mamy to @ interface, a ten mówi, że nadchodzi
deklaracje wszystkiego, co będzie istnieć w mojej klasie.
Następnie mam dwukropek. Wtedy mam ten NSObject rzeczy.
To oznacza, że ​​dwukropek trochę spadków Rozmawialiśmy trochę wcześniej.
To mówi wszystko NSObject może zrobić
gdzie NSObject jest ta klasa napisana przez kogoś innego,
wszystko to NSObject może zrobić chcę być w stanie to zrobić.
Mówiąc: NSObject to oznacza, że ​​ja w zasadzie
dziedziczone wszystkich funkcji innej klasy.
To naprawdę dał mi całą masę różnych metod i właściwości, które można wykorzystać.
Tu tworzę 2 właściwości.
To oznacza, że ​​mój uczeń, gdyby to było struct, byłyby to 2 rzeczy
wewnątrz mojej struktury, więc każdy uczeń ma imię
to jest ciąg znaków, a uczeń ma również klasy,
który jest int.
>> Wreszcie tu zamierzam stworzyć metodę dla mojego ucznia.
Zadzwoniłem moja metoda, initWithName i trwa jeden argument,
i ten argument jest ciągiem, i nazwał go nazwać.
Teraz przyjrzyjmy się, jak w rzeczywistości realizowane tej klasy.
Tutaj, teraz jestem w środku mojego pliku. M,
m do realizacji, chyba.
Mam wykonania, mój koniec, a tu, gdzie jestem naprawdę definiowania
co initWithName robi.
Mam initWithName, nazwę mojego parametru, a następnie ten
jest, gdy jestem naprawdę tworząc studenta
a więc jest to trochę tajemnicze, ale jest to rodzaj boilerplate
, które chcesz umieścić w swoich konstruktorów.
Ta funkcja inicjalizacji tutaj initWithName, jest rodzajem konstruktora.
Jesteś w zasadzie budowę nowego obiektu studentów
i może wysyłać niektóre dane znajdujące się wewnątrz niej.
Pierwszą rzeczą, którą chcesz zrobić, to chcę zadzwonić init, na tej super rzeczy.
>> Pamiętaj, że kiedy powiedziałem tu w pliku. H
że wszystko NSObject ma uczeń posiada.
Oznacza to, że podczas tworzenia studenta, co również trzeba zrobić, to
upewnić się, że NSObject że jestem dziedziczenie wszystkich tych danych z
jest poprawnie zainicjowany.
Co muszę powiedzieć, to to super faktycznie się odnoszą się do klasy nadrzędnej
że jestem dziedziczenie z, więc chcę się upewnić, zainicjować
wszystko to, co mam w zależności od zanim zacznę próbować go użyć.
Następnie jeśli zainicjalizowany poprawnie to jest tak jak mówią, jeśli malloc
nie zwróci wartość null, wówczas można rozpocząć ustawienie niektórych właściwości.
>> W JavaScripcie i PHP mieliśmy ten parametr nazywa to
i ten odniósł się do bieżącej instancji klasy.
W Objective-C nazywamy to ja.
Kiedy mówię self.name, co oznacza, że ​​obiekt
I właśnie utworzony, kiedy powiedziałem alloc uczeń init
że zamierza mi zwrócić obiekt.
To znaczy, że chcę, aby ustawić nazwę tego obiektu
do tego, co właśnie przeszedł w.
Podobnie jak w C, mamy dostęp użytkowników z tej kropki,
tak self.name mówi nazwa obiektu studenckiej
teraz będzie cokolwiek właśnie przeszedł w.
I tak w końcu, mogę go zwrócić, więc rzeczywiście wrócić coś.
>> Pytania?
Okay, więc to samo = Super init
jeśli nie całkowicie rozumiem rzeczy dziedziczenia nie martw się.
Wystarczy wiedzieć, że jeśli kiedykolwiek chcesz zrobić własny metoda init tylko
zrobić, a będziesz dobrze iść.
Tak. >> [Student] Co oznacza, jeśli średnią siebie?
Oznacza to, że gdy malloc coś zawsze sprawdzany, jeśli była równa null,
i czy to null, potem odszedł.
To jest to samo, bo jeśli ta zwraca null, to pewnie będzie seg winy
jeśli zaczniemy próbuje manipulować.
To jest nasza klasa student.
To oznacza, że ​​możemy zainicjować naszych uczniów w jeden z dwóch sposobów.
Jeśli powiem alloc uczeń init, nie używam tej metody, że po prostu napisał,
a zamiast tego można po prostu powiedzieć, alice.name,
i teraz mam zamiar ustawić tę nazwę właściwości.
>> Podobnie, jeśli chcę użyć tej metody initWithName
Mogę po prostu powiedzieć, Alloc, a następnie zamiast mówić startowych
Mam zamiar zadzwonić tę metodę, że po prostu stworzone, i mam zamiar przejść w Boba.
W tym momencie, obiekt Bob nazwę równą Boba.
Dobra, tu używam tego NSMutableArray że przyjrzeliśmy wcześniej.
Jestem przydzielania space.Then Jestem inicjowanie nową tablicę.
Mam zamiar dodać 2 rzeczy do niego.
Tablica ta posiada obecnie obiektów studenckich.
Zauważ, że nigdzie nie muszę powiedzieć, że jest to tablica studentów.
I powiedział, że to array, period.
Następnie można umieścić cokolwiek wewnątrz niego, że chcę.
Tutaj mam 2 obiekty.
>> Wreszcie, mam inny obiekt tutaj, to TF.
Tutaj w zasadzie TF.h samo.
Jestem dziedziczy z NSObject, a przy okazji,
podczas tworzenia klas jest to wszystko zrobić dla ciebie,
ten rodzaj boilerplate interfejsu.
Ma właściwości uczniów.
Mam Metody para tutaj nie naprawdę dużo,
i tak, że oznacza po utworzeniu tego obiektu TF
Mogę nazwać ten gatunek metody na to w ten sposób.
Wszelkie pytania dotyczące składni Objective-C, zanim zacznie się na kilka
interesujący rozwój aplikacje rzeczy?
>> Ok, więc niech rzeczywiście zrobić app iPhone.
Klas podstawowych, które będziesz używać wewnątrz Twojego iPhone app nazywane są kontrolery widok,
i kontroler widoku zasadniczo reprezentuje pojedynczy ekran
wewnątrz swojej aplikacji, więc jeśli jestem na aplikacji muzycznej, na przykład,
jeden widok kontroler może reprezentować pogląd, w którym zobaczyć wszystkie utwory na moim iPhone.
Kolejny kontroler widoku może być po kliknięciu utwór i rozpocząć odtwarzanie
lub jak jestem drążenia do artystów.
Każdy z tych innych ekranów mogą być reprezentowane innego sterownika widoku
i kontroler widoku jest naprawdę tylko klasy, który mówi, jak ten ekran działa.
Rzeczy wewnątrz kontrolera widoku, będziemy mieć właściwości
więc takie rzeczy jak przycisk będzie własnością naszego kontrolera widoku.
>> Mamy również zamiar mają metody, a te są w zasadzie obsługi zdarzeń.
Ta metoda mówi, po naciśnięciu tego przycisku
Chcę coś zrobić, a na końcu znowu
będziemy używać tego samo słowo kluczowe, aby uzyskać dostęp do bieżącej instancji.
Do tworzenia interfejsów w iOS jest rzeczywiście bardzo, bardzo proste.
Mają ten miły interfejs przeciągnij i upuść nazwie Interface Builder,
i 2 podstawowych pojęć, że drut swojej Objective-C do Interface Builder
są IBOutlet i IBAction.
IBOutlet mówi po prostu, że jeśli zadeklarować właściwość, że znajduje się przycisk,
i chcesz podłączyć go do czegoś w aktualnej UI,
masz zamiar powiedzieć, że to gniazdo.
Podobnie, jeśli chcesz reprezentować obsługi zdarzeń
następnie masz zamiar powiedzieć, że jest to działanie.
>> Aby faktycznie drut aż ten graficzną reprezentację
a kod to jest naprawdę proste.
Jeśli chcesz dołączyć IBOutlet, wszystko co musisz zrobić, to kontrolować kliknięcia
i zobaczymy przykład to naprawdę szybko.
Możesz kontrolować kliknij gdzie mówi Controller View.
Masz zamiar przeciągnąć do interfejsu, lub odwrotnie,
jeśli chcesz podłączyć moduł obsługi zdarzeń będziesz przeciągać z interfejsu
w drugim kierunku.
Rzućmy okiem na bardzo prostym przykładzie iOS.
>> Stwórzmy nowy projekt.
Mam zamiar przyjechać tu do stosowania,
i mam zamiar kliknąć pojedynczej aplikacji Widok.
Idę do kliknij next. Podam mój projekt nazwę.
Nazwijmy go Hello.
Co ciekawe, Apple zakłada, że ​​tworzysz produkt
tak, że można go sprzedać i mogą zarabiać pieniądze.
Tu mam zamiar powiedzieć, że jest to aplikacja na iPhone.
Można utworzyć aplikację iPad, lub jeśli chcesz stworzyć jedną z tych aplikacji,
który obsługuje zarówno urządzenia, które możesz zrobić, że zbyt.
Są to, co chcesz, aby Twoje znacznikami wyboru wyglądać.
>> Chcesz korzystać storyboardy, które zobaczymy później,
i na pewno chcemy korzystać z automatycznego liczenia odniesienia,
co jest dobrą cechą, która eliminuje konieczność powiedzieć malloc i free.
Chyba, że ​​chcesz wywołać malloc i wolne, chciałbym pozostawić to sprawdzone.
Będę kliknij obok, i wreszcie, to będzie o mnie, gdzie chcę, aby go zapisać.
Uderzę tworzyć i jedziemy.
Stworzyłem nowy projekt.
Tutaj po lewej stronie są wszystkie pliki, które znajdują się wewnątrz mojego projektu,
i zauważ, że mam całą masę, a ja nawet nie robić nic.
IOS jest świetny.
>> Na przykład, tutaj to ViewController.h,
to będzie reprezentować swój pierwszy kontroler widoku,
więc pierwszym ekranie wewnątrz mojej aplikacji.
Teraz już wiemy, co to mówi.
Mówimy dzwonię ten ViewController klasy,
i robi wszystko, aby ViewController UIViewController robi,
i to znowu jest jakaś klasa, że ​​Apple napisał robi wiele rzeczy dla nas wygodny
jak wyświetlić ekran.
Tutaj jest miejsce gdzie mogę zacząć definiowanie co mój kontroler widoku robi,
i okazuje się, że tak naprawdę nie potrzebuję tego.
To jest kod boilerplate że Apple daje mi za darmo.
Ja potrzebuję tej pierwszej linii, albo nie mam klasy,
więc możemy pozbyć się tego i pozbyć się tego.
Ok, więc to jest mój pusty ekran.
>> Teraz kliknij na ten MainStoryboard.storyboard,
i to, gdy zaczyna się interesujące.
Jest to pierwszy ekran na moim app.
Jeśli chcę dodać przycisk w HTML musiałem utworzyć tag przycisk.
W Android musisz utworzyć tag przycisku,
ale w iOS jeśli tylko przyjść tutaj w prawym dolnym rogu
i jeśli mogę kliknąć na ten 3-ta jeden tu, gdzie mówi obiekty,
i można przewijać, czy mogę zacząć szukać przycisku.
I patrzeć, przycisk, więc jeśli rzeczywiście przeciągnąć to prawo tam,
Właśnie dodałem przycisk do tego ekranu na mojej aplikacji.
Jeśli chcę zmienić tekst, mogę kliknij go dwukrotnie,
powiedzieć coś kuszące jak "Naciśnij mnie".
Dobra, a teraz jeśli uruchomić tę aplikację, więc go skompilować,
tak, aby go uruchomić i kliknąć przycisk odtwarzania w lewym górnym rogu, a tam moja aplikacja.
Ja nic nie zrobiłem, i mam słodki szuka app iPhone.
Jeśli chcę go zatrzymać, możesz kliknąć przycisk stop
ponieważ jest więcej zabawy.
>> Powiedzmy, że faktycznie chcę coś się stało po naciśnięciu tego przycisku.
Aby to zrobić, co trzeba zrobić, to trzeba utworzyć
nowy uchwyt zdarzenia lub działania.
To oznacza, że ​​trzeba stworzyć pewne metody, które chcę być nazywany
po naciśnięciu przycisku, więc stwórzmy nową metodę.
Jestem wewnątrz ViewController.h.
Muszę powiedzieć, że metoda istnieje.
Muszę myślnik pierwszy, ponieważ mam zamiar być wywołanie to na kontrolerze widoku.
Muszę dać ten typ.
Typ to będzie to coś IBAction które widzieliśmy wcześniej.
To jest zdarzenie, tak to się zwróci IBAction,
i jest to aluzja do XCode powiedzieć, że
to jest coś, co chcę podłączyć coś.
Mogę dać mu nazwę, jak buttonPressed, średnikiem.
>> Teraz już ogłosił nową metodę wewnątrz z mojej klasy.
Powiedziałem, metoda ta ma istnieć.
Teraz wchodzą ViewController.m,
i powiedzmy, że to, co ta metoda może zrobić.
Jeśli zacznę pisać, na przykład, (void) buttonPressed
Anons XCode jest naprawdę ładne i autocompletes dla mnie.
To naprawdę wspaniałe.
Zauważcie, że wewnątrz. M pliku można również powiedzieć, nieważne,
a to dlatego, że w rzeczywistości nie jest IBAction typu.
To faktycznie hashtag zdefiniowane gdzieś być unieważnione,
i znowu, to tylko wskazówka do XCode, który mówi
Chcę to być zdarzenie, a my zobaczymy, dlaczego w ciągu sekundy.
Po naciśnięciu tego przycisku mam zamiar zrobić coś, przykry
jak wyświetlić okienko.
>> W tym celu można utworzyć nową instancję tej klasy o nazwie UIAlertView,
i jest to klasa, która napisała, że ​​firmy Apple zamierza wyświetlać denerwujących pop-upów.
Nazwijmy to okienko alert, a ja mam 2 kroki, pamiętaj, do tworzenia tego obiektu.
Pierwszą rzeczą, którą musisz zrobić, to przydzielić miejsca.
Chcę UIAlertView.
Chcę przeznaczyć przestrzeń. To moja pierwsza metoda.
Moja kolejna metoda to chcę go zainicjować,
i tak mam ten duży, długi metodę zwaną initWithTitle.
To w zasadzie będzie kontrolować, co to okienko mówi.
Tytuł mojego popup może być hello.
Przesłanie to okienko może być "to iOS."
Delegat rzeczą, ja nie wiem, co to jest.
Powiedzmy, że to nic.
Teraz przycisk, który będzie pojawiać się może powiedzieć coś takiego: "To na pewno jest"
a ja nie chcę żadnych innych przycisków, więc niech ją usunąć i zamknąć uchwyt.
>> Okay, I stworzył dodatkowy jeden. Proszę bardzo.
W ten sposób można utworzyć nowy popup.
Jeśli chcę, aby rzeczywiście zobaczyć okienko chcę wywołać metodę show.
Aby to zrobić, że mogę powiedzieć, alarm i pokazanie,
i znowu, autouzupełnianie był super miły.
Jeśli nie pamiętam, co to było, gdybym po prostu wpisane w s,
Można przewijać, żeby dowiedzieć się, co to było,
i filtruje ładnie.
Teraz stworzyliśmy nowy popup.
Wrócimy do tego, co oznacza, delegat później
i teraz chcę powiedzieć, że metoda ta ma być zwolniony
po naciśnięciu przycisku, więc mam zamiar wrócić do mojej serii ujęć
i chcę teraz dołączyć to IBAction.
Pierwszą rzeczą, którą chcesz zrobić, to kliknąć przycisk.
Po naciśnięciu tego przycisku, chcę coś się wydarzy.
I nie zamierzam się przytrzymać kontrolę.
Idę do kliknij i przeciągnij z przycisku
się tu, gdzie mówi kontroler widoku.
Możemy zobaczyć, że ładnie się świecą.
>> Jeśli mam odejść z mojej myszki teraz mam to okienko tu gdzie mam kilka opcji.
Jedna z nich to wydarzenia, które można zarejestrować.
Są to wszystkie z tych metod i zadeklarowane w moim pliku h jako IBActions.
To jest jak XCode wie co powinien pojawić się w tej małej listy,
więc to tylko wskazówka.
Jeśli I kliknij na wciśniętym przycisku, już teraz zarejestrowała obsługi zdarzeń.
W JavaScript mamy powiedzieć, że niektóre kod, który zarejestrował obsługi zdarzeń.
W Objective-C to naprawdę takie proste.
Jeśli to uruchomić ponownie
teraz po naciśnięciu przycisku mój obsługi zdarzeń będzie ogień,
i mam zamiar uzyskać to okienko.
Super, super proste tam.
>> Jeśli kiedykolwiek chcesz zobaczyć wszystkie wydarzenia, które mają być rejestrowane
na części, jeśli klikniesz na ten przycisk
i przyjść tutaj po prawej stronie
początku możesz zobaczyć tu można zrobić takie rzeczy jak rodzaj przycisku,
więc jeśli chcesz, aby jeden z tych, męskie lub przycisk Dodaj Kontakt
lub cokolwiek.
Jeśli chcesz zobaczyć wszystkie zdarzenia, które są na tym przycisku
gdybym przychodziła tu z prawej strony
Widzimy tutaj, w wydarzeniach, jakie mają wszystkie z tych różnych wydarzeń.
Można nacisnąć przycisk, kiedy puścić przycisk, kiedy dwukrotnie dotknij lub cokolwiek,
i jeden I tylko zarejestrowane jest to wydarzenie o nazwie Touch Up Inside,
a ten mówi, że jak tylko mój palec schodzi przycisk
że zdarzenie będzie ognia, a to jest dokładnie to, co się właśnie stało.
Jest to rodzaj domyślny przycisk przypadku prasowanego.
>> Wszelkie pytania do tej pory?
Dobra, to jak możemy zacząć podłączać się rzeczy w naszym kodzie
do rzeczy wewnątrz naszego interfejsu.
Pamiętaj, pierwszą rzeczą, jaką musiałem zrobić, aby znaleźć kod,
a potem okablowany interfejs do kodu,
i jest to nasz pierwszy app.
Ok, to było naprawdę fajne, i stworzyliśmy ten przycisk.
Co zrobić jeżeli nie chcemy, aby stworzyć kilka właściwości
reprezentujących te przyciski?
Na przykład, w Tic Tac Toe mam 9 przycisków,
i byłoby super, super denerwujące przeciągnij i upuść 9 razy
lub jeśli miałem do Tic Tac Toe z 81 zamiast 9
i musiałem przeciągnąć 81 razy, i to jest żałosne.
Co możemy zrobić, a nie jest tak jak HTML
kiedy mieliśmy takie rzeczy identyfikatorów i nazw i możemy szukać rzeczy
według ich ID, jest podobny pogląd w iOS nazwie tags.
>> Tag jest po prostu niepowtarzalny numeryczny identyfikator dla składnika.
To znaczy, jeśli znacznik jest 0, na przykład
jeśli utworzyć przycisk i dać mu znak 0, a my zobaczymy, jak to zrobić w ciągu zaledwie sekundy,
jeśli chcę dostać ten przycisk można po prostu powiedzieć, że chcesz się połączyć
viewWithTag metodę na obiekcie tutaj,
self.view, który reprezentuje bieżący ekran, na przykład.
Jeśli zgłoszę tę metodę viewWithTag, zamierzam się wycofać przycisk ze znacznikiem 0.
Rzućmy okiem na to, budując Tac Toe Tic.
Po pierwsze, jest to mój storyboard.
Stworzyłem te 10 przycisków interfejsu użytkownika.
Zauważ, wszystkie są tej samej wielkości.
Jeśli I kliknij jedną z nich i wrócę tu na tej prawej stronie
zobaczysz I dostosować czcionkę tu, więc zrobiłem czcionki trochę większe,
ale to, co również nie było ustawić ten tag.
Powiedziałem, że to ma tag 1, i to jest w lewym górnym rogu.
>> Teraz, gdy klikam przycisk innego, jak ten drugi tutaj,
teraz widać, że mój tag jest 2.
Każdy z tych przycisków po prostu ma niepowtarzalny tag,
i tak to później, jak mam zamiar rozpocząć interakcję
z mojej aplikacji.
Wszystko to jest wewnątrz jeden widok regulatora
ale o to, co mamy.
Mamy 3 właściwości tutaj.
Pierwsza i ostatnia będą przedstawiają stan mojej płyty.
Zasadniczo pierwszy jest tablica reprezentująca gdzie Xs i Os są.
Ta druga tu mówi nam, którego jest tura.
Zauważysz, że ja też mam te rzeczy tutaj.
Wcześniej, kiedy oświadczył właściwości daliśmy im nazwę i typ.
Możemy także dać im kilka dodatkowych informacji tutaj.
Ten pierwszy mówi nonatomic i co to mówi
jest w zasadzie tylko jedna rzecz nigdy nie będzie próbował uzyskać dostęp do tej zmiennej w czasie.
Można zrobić bardziej złożonych aplikacji, które są wielowątkowe,
i tak z powrotem w Scratch mieliśmy różne wątki,
i mogą być różne duszki robi różne rzeczy w tym samym czasie.
>> Jeśli tak nie jest, co nie jest w nic, że będziemy patrzeć na to,
jeśli mówimy nonatomic to faktycznie zrobi wszystko trochę szybciej.
Mamy też to coś o nazwie przywiąż, silny lub słaby.
Ten przypisać po prostu mówi, że jest to standardowy typ.
To nie jest obiekt lub wskaźnik jest, bo to jest tylko bool,
tak bool jest wbudowany w Objective-C.
Ten mówi, nie próbuj niczego ozdobnego z wskaźniki tutaj.
Jest regularny stary skalowania.
Silne i słabe, to mówi, że faktycznie słaby
Chcę, aby było to wskazuje na coś w kontrolerze widoku.
I nie zamierzam faktycznie przeznaczyć albo w init to samodzielnie.
Budowniczy interfejs, kiedy uruchomić aplikację, będzie obsługiwać wszystkie te inicjalizacji.
Jeśli powiem, że słaby, że mówi ktoś inny ma być stworzenie tego.
Jeśli powiem, że silny, to mówi, że mam zamiar być tym
który jest tworzenie tego obiektu pokładzie,
a więc mam trochę więcej metod tutaj
np. skarga o kiedy nowa gra przycisk jest wciśnięty,
działanie, gdy którykolwiek z pozostałych przycisków zostanie naciśnięty,
i et cetera.
>> Nie dostanie się zbyt dużo logiki Tic Tac Toe,
chociaż jest to bardzo ekscytujące, ale rzućmy okiem na
niektóre z rzeczy, które możemy zrobić wewnątrz iOS.
Ta nowa metoda gry zostanie zwolniony
ilekroć nacisnąć nowy przycisk gry.
Spinanie, że aż po prostu przyjść do mnie ujęć.
Kliknąłem na nowej grze.
Jeśli przyjdę tu na prawo widzę, że
Touch Up Inside jest podłączony do newGame metody.
Dlatego to będzie się strzały.
Metoda newGame zrobi jakąś strukturę.
Zapowiada się, że chcę, aby wyczyścić stan płyty.
Jest to miły sposób na zmienne tablic.
To powie to teraz kolej na X,
i teraz mam zamiar skorzystać z tej viewWithTag rzeczy.
>> Wiem, że moje przyciski posiadają tagi 1-9,
i to jest coś, co arbitralnie zrywane.
Jeśli chcę, aby tekst każdego przycisku być pusty
bo właśnie zacząłem nową grę, a ja nie chcę
Xs lub Os należy pozostawić ponad mogę tego zrobić.
Mogę powiedzieć, że chcę widoku z tagu, 1, 2, 3, 4 et cetera.
Będzie to ciągnąć inny przycisk za każdym razem.
Tutaj mam zamiar oddać go do UIButton.
Tak jak mogliśmy oddać Ints do pływaków i odwrotnie
to mówi, że chcę oddać to do UIButton.
Oznacza to, że typ będzie * UIButton
z powodu wskaźników, ale nie martw się, że nie są już straszne.
>> Kiedy mam ten przycisk, mam zamiar wywołać metodę na nim.
Metoda ta nazywana jest setTitle forState, a więc to mówi
Chcę ustawić tekst przycisku jest pusty ciąg znaków,
i ma to być ciąg pusty, gdy nie jest wciśnięty.
Jeśli używam tej metody, można zmienić tekst przycisku
tak szybko, jak ktoś uderzy, ale chcemy powiedzieć, gdy przycisk jest po prostu siedzi tam
Chcę tekst być puste.
Wreszcie, mamy zamiar zainicjować deskę,
i mam zamiar powiedzieć, że wszystko, co jest obecnie na 0,
więc to zarząd niezmienna jest zmienny array,
co oznacza, że ​​można wywołać addObject metodę i tylko 0 jej wnętrzu.
To, co się dzieje, gdy tworzę nową grę.
>> Rzućmy okiem na inny.
Ta metoda jest tu IBAction że zamierza być wciśnięty
za każdym razem jeden z tych pól jest wciśnięty.
Teraz mamy kilka Tic Tac Toe logika tutaj.
Dowiemy się, którego jest tura,
i na podstawie, że albo ustawić X lub O,
ale widzimy, że mamy do ponownego użycia tego samego obsługi zdarzeń
na każdym z tych przycisków.
Oznacza to, że nie ma sposobu górę lewego,
innej metody przycisku prawym dolnym rogu, chociaż mogłem zrobić.
To nie będzie naprawdę dobry projekt.
Co ja tutaj robię to ja faktycznie się określić
co znacznika, że ​​przycisk został wciśnięty jest.
Można zauważyć, że metoda ta gra ma jeden argument.
To się nazywa nadawca, a co nadawca jest nadawca będzie
reprezentuje dokładnie to, co zostało zrobione na akcję.
Jeśli naciśniesz przycisk, to nadawca będzie że UIButton
I rzeczywiście, że przycisk, więc oznacza to, że UIButton
ma identyfikator, bo stworzył tag.
>> Jeśli chcę uzyskać w tagu można po prostu powiedzieć,
Chcę tag z nadawcy,
i znowu, właśnie oddano go do UIButton.
I stało się, że nadawca będzie UIButton.
To nie zawsze musi być UIButton.
Mógłbym na przykład zarejestrować tę samą procedurę obsługi zdarzenia
jednego dla przycisku, po jednym dla suwaka.
W tym przypadku, wiem, że są wszystkie przyciski, więc powiem
Chcę to być przycisk, a następnie można uzyskać tagu
i od słowa teraz wiem, gdzie jestem w środku planszy.
Następnie można po prostu ustawić X lub O, może odwrócić kolej,
sprawdzić, kto wygrał, et cetera.
>> Wszelkie pytania na ten temat do tej pory?
Ok, kod wysłaliśmy online-nie chcemy dostać się do zbyt
logiki Tic Tac Toe, ale teraz widać, że naprawdę
wszyscy robimy to jesteśmy w pętli na tej tablicy
więc mamy kilka pętli tutaj, a my po prostu, aby zobaczyć porównanie
mamy mecz we wszystkich rzędach, meczu w kolumnie lub coś w tym rodzaju.
Aby rzeczywiście uruchomić tę aplikację, jeśli dotknąć jednego z tych przycisków
metoda zabaw został zwolniony, więc to oznacza, że ​​wystarczy ustawić
Przycisk jest X, teraz ten przycisk będzie O, i tak dalej,
i tak to jest, jak zaczynamy wchodzić w interakcje z tym jednym app strony.
>> Będziemy pisać kod, tak więc zapraszamy do zapoznania się, że
ale niech się teraz mówić o niektórych aplikacji, które są czymś więcej niż tylko jednej stronie.
Tak ekscytujące jak Tic Tac Toe było wiele aplikacji wewnątrz iOS
są rodzajem tych drążyć rzeczy z wielu ekranach.
Pierwsza koncepcja, że ​​musimy porozmawiać o to protokoły,
oraz protokół prostu zestaw metod
Obiecuję, że można zdefiniować.
Jeśli utworzyć ten nowy protokół z 2 metod, ten pierwszy,
jeśli typ zwracany jest nieważna, nazwałem to foo.
To nie potrzebuje żadnych argumentów. Mam inną metodę.
Zwraca int. Nazwałem ją zablokować, a to trwa jeden argument.
Wszystko to jest protokół, który jest nazywany SomeProtocol tu,
jest to zbiór rzeczy, które ktoś może wdrożyć.
I nie wewnątrz tego protokołu powiedział, co foo robi.
Zamiast tego, tylko mówię można zdefiniować foo, jeśli chcesz.
Jeśli tworzę kontroler widoku lub tworząc klasę
Mogę wewnątrz tej obietnicy klasy do wdrożenia
Niektóre z tych metod, tak na przykład, gdy mówi
to teraz mówi, że robię ci obietnicę, że wewnątrz
tej klasy kontrolera widoku będę mieć definicje obu foo i bar.
>> Dlaczego jest to przydatne?
Wiele elementów wewnątrz iOS to wykorzystać
wzorzec projektowy zwany delegację, i co mówi, delegacja
jest to, że, na przykład, jeśli mają pole tekstowe
i jest kilka wydarzeń, które mogą być rejestrowane wewnątrz mojego pola tekstowego,
zamiast tworzyć osobne wydarzenia, co mogę zrobić, to mogę powiedzieć,
delegat tym polu będzie kilka obiektów.
Kiedy mówię, że jest to delegat to oznacza, że ​​teraz
ilekroć pewne zdarzenia zostałby zwolniony w polu tekstowym
zamiast go zarejestrować, czy coś w tym stylu
to po prostu się do wywołania metody na delegata.
Na przykład, we wnętrzu moim polu tekstowym mam metodę po naciśnięciu
tego zrobić przycisk w prawym dolnym rogu,
i tak zamiast rejestracji obsługi zdarzeń, co mogę powiedzieć to to,
pole tekstowe, tutaj jest obiekt, który chcę Ci do wywołania metody na
za każdym razem ktoś naciśnie przycisk Gotowe,
a to oznacza, że ​​obiekt musi zaimplementować protokół
mówi, że obiecuję definiuje tego zrobić akcję przycisku,
bo jeśli nie definiuje tę metodę i naciśnij Gotowe,
wtedy będzie to mylące.
>> Rzućmy okiem na przykład.
Tu po prostu jednego pola tekstowego,
i jedną z właściwości tego pola tekstowego, tu na tej prawej stronie jest delegatem.
To właściwości klasy.
Co ja o to kontrolować kliknięciu i przeciągnąłem z tego miejsca tutaj
do kontrolera widok, i mówi, że teraz delegata tym polu tekstowym
będzie kontroler widoku.
Oznacza to, że gdy niektóre działania się zamiast rejestracji
oddzielne obsługi zdarzeń chcę Ci wysłać je do delegata.
Teraz rzućmy okiem na moje kontrolera widoku.
Wewnątrz pliku. H. Zrobiłem obietnicy.
Obiecałem wdrożyć niektóre metody wewnątrz tego protokołu
nazywa UITextFieldDelegate, i znowu,
to tylko niektóre lista niektórych rzeczy, które mogę wybrać do wdrożenia.
>> Gdybym tu w moim. M pliku, I wprowadziły jedną taką metodę.
Zadzwoniłam to textFieldShouldReturn
bo to jest to, co nazwano wewnątrz protokołu.
A teraz, gdy naciskam przycisk wykonane wewnątrz tego pola tekstowego
jest to, co się się nazywa, więc nie zarejestrować obsługi zdarzeń.
I podłączony delegata, a gdy to zdarzenie jest opalane
jest to metoda, która zostanie wywołana, więc jeśli tu przyjść do mojego ujęć i uruchomić go-
podczas gdy jest ładowanie możemy zobaczyć co to robi.
Na moim ekranie mam 2 rzeczy.
Mam to pole tekstowe, i mam tę etykietę.
Mówię po prostu, chcę tekst tej etykiety
równa co użytkownik wpisze w wewnątrz pola tekstowego.
To następna linia to po prostu metoda Dzwonię
w polu tekstowym, które mówi, że chce, aby ukryć klawiaturę.
To jest po prostu arbitralne metody, które Apple wybrał.
>> Ponownie, zanim zrobiłem coś musiałem podłączyć wszystko, tak więc po raz pierwszy przyjechałem tutaj.
Od kontrolera widoku I przeciągnij do pola tekstowego.
Odpuścić, i widzę tutaj, że mogę zrobić to właściwość pola tekstowego
ponieważ tutaj w kontrolerze widoku I zostały zdefiniowane właściwości
to IBOutlet pola tekstowego.
To mówi, że można podłączyć ten obiekt się
do pola tekstowego w moim UI.
Teraz gdy klikam to mogę zacząć pisać.
Teraz, gdy klikam przycisk done to będzie ogień
wydarzenie, które teraz mogę odpowiedzieć.
Brak obsługi zdarzeń.
Tak się po prostu odpowiedziała na ten przycisk Gotowe.
Ma sens?
>> To nie jest to, że wzorzec projektowy-nie może kiedykolwiek znaleźć się
tworząc swój własny protokół, ale po prostu wiem, że niektóre
różne składniki iOS zarejestrować wydarzenia na różne sposoby.
Przyciski, na przykład, wykorzystać te IBActions.
Pola tekstowe, z drugiej strony, będzie używany delegatów.
Widzimy i można sprawdzić wszystkie tego wewnątrz dokumentacji.
Nawiasem mówiąc, jest rzeczywiście mnóstwo rzeczy UI wbudowany iOS dla Ciebie,
tak na przykład sposób, w jaki odbywa się to mówi w prawym dolnym
Wybrałem się pole tekstowe.
Przyjechałem tutaj.
I przewijane w dół trochę wrócić klucz
i mogę rzeczywiście zrobić to cała masa rzeczy, jak, jeśli chcę powiedzieć, że
awaryjne zadzwonić zamiast mogę to zrobić, co jest całkowicie losowy,
i nie wiem, dlaczego jest wbudowany przycisk alarmowy,
ale nie, to mówi alarmowy literami naprawdę małe.
Proszę bardzo.
>> Zdecydowanie zbadania wszystkich tych różnych opcji w iOS.
Wszelkie pytania dotyczące delegatów?
Ponownie, po prostu ciekawy wzorzec projektowy, który powinien być świadomy.
Dobra, następny spojrzeć na widoki tabeli.
Widok tabeli jest w zasadzie, że lista elementów, które jest w każdym miejscu, w iOS.
Kiedy przeglądasz wszystkie kontakty, szukasz na
ustawienie strony, i tego rodzaju listy rzeczy nazywany jest widok tabeli.
Implementacja widoku tabeli w iOS jest dość prosta.
Zamiast klasy, która zstępuje z tego UIViewController
jak zrobiliśmy wcześniej po prostu trzeba powiedzieć, a nie
wszystko UIViewController nie chcę zrobić,
I powiedzieć wszystko UITableViewController nie chcę zrobić,
tak, że po prostu dodaje kilka dodatkowych rzeczy, które są całkowicie dla nas uczynił.
Musimy zrobić bardzo niewiele, aby właściwie wypełnić puste wewnątrz tabeli.
>> Aby wyświetlić tabelę muszę odpowiedzieć na kilka pytań.
Pierwsze pytanie trzeba odpowiedzieć, to ile sekcje są w tabeli?
Kiedy przeglądasz Twojej aplikacji Kontakty można zauważyć, że jest to swego rodzaju
zorganizowane przez As, następnie masz BS, a masz ten mały sub nagłówek.
Każda z tych części jest nazywane.
Państwo może, ale nie trzeba tych.
Pierwszą rzeczą, którą musisz zrobić, to wdrożyć metodę
nazywa tableView: numberOfSectionsInTableView.
Że po prostu zwraca ile sekcje masz,
tak więc można powiedzieć, zwrócić jeden, jeśli masz jeden wielki widok tabeli.
Kolejne pytanie, które iOS musi wiedzieć, ile wierszy masz?
Na przykład, jesteś przeglądając widoku tabeli.
Masz stałą liczbę utworów ty patrzysz na lub stałą liczbę kontaktów.
Jeśli ja, oczywiście, nie, że wielu,
i tak to jest, jak iOS wie, ile komórek do wyświetlenia.
>> Ponownie, to może powiedzieć coś w stylu powrotu 3.
Mój pogląd tabela zawiera 3 wiersze.
Wreszcie, iOS musi wiedzieć, co każda komórka wygląda,
więc co to faktycznie zrobić to wywołanie tej metody, tu,
ta tableView: cellForRowAtIndexPath.
To będzie wywołać tę metodę na każdej pojedynczej komórki wewnątrz tabeli.
Jak to jest wiedzieć, ile razy to nazwać?
Cóż, powiedział to w środku liczby wierszy w sekcji.
Będziemy nazywają to na każdej z naszych komórek,
i wewnątrz jest to, gdzie rzeczywiście można robić takie rzeczy jak
ustaw tekst lub powiedzieć, co ten mały niebieski przycisk z prawej strony robi.
Wzór do uzyskania tych komórek, będziemy korzystać z tej metody
nazywa dequeueReusableCellWithIdentifier.
>> Objective-C jest rzeczywiście bardzo dobrze znana na śmiesznej długości ich nazw metod,
i to jest naprawdę miłe miejsce w przykładzie pkt.
Co ta metoda nie jest to po prostu mówi: Chcę, żebyś mi komórkę.
Podobnie rzecz iOS.
Jeśli masz coś 100.000 piosenek na iPodzie
co iOS nie chce zrobić, to przeznaczyć 100.000 komórek,
bo jeśli jesteś na górze listy, czy naprawdę trzeba przydzielić pamięci
do komórki, która znajduje się 99.000 wierszy w dół?
Nie, bo jak jesteś przewijania można rodzaj przeznaczenia, jak iść.
Odbywa się to za Ciebie.
Nie musisz martwić się o tym wszystkim głupim wydajności.
Wszystko co mówisz jest nazywać to dequeueReusableCellWithIdentifier metody,
i to mówi, dobrze, jeśli trzeba Zamierzam utworzyć nową komórkę dla Ciebie.
>> Ale jeśli jesteś na dole tabeli, a już przydzielone niektóre komórki
w górnej części tabeli, która naprawdę nie będzie potrzebował w najbliższym czasie
Mam zamiar dać ci jeden z nich z powrotem zamiast przydzielania nowego,
i tak jest to miły dotyczą wydajności.
Nie musisz przeznaczyć Komórki siebie.
Że zamierza oddać komórkę.
To będzie powrót do ciebie obiekt komórek.
Kiedy już masz obiekt komórek można zrobić rzeczy do niego.
Można ustawić tekst komórki z tego obiektu o nazwie label text.
Można dodać, że strzałka na prawej lub innej rzeczy przypadkowej
z tym inne własności zwanej accessoryType i tak dalej, i tak dalej.
>> Rzućmy okiem na faktycznie wdraża widok tabeli teraz.
Po utworzeniu tego projektu
zamiast mówić jeden wniosek widok I rzeczywiście przyszedł tutaj
do master-detail aplikacji, a więc w zasadzie odpowiada to aplikacji poczty
na iPad z widoku tabeli po lewej stronie, a następnie zawartość po prawej stronie.
Na iPod lub iPhone to będzie odpowiadać jednej widoku tabeli.
To miejsce, gdzie dostałem kodu startowego.
>> Niech najpierw przyjrzeć się serii ujęć.
Wszystko to było dla mnie zrobił, zasadniczo tworzony.
Ten pasek nawigacji pokazał mi, co komórka przykład mógłby wyglądać,
i mogę kliknąć dwukrotnie, zmień tytuł.
Wszelkie inne kwestie UI Poradzę tam.
Plik nagłówkowy wygląda naprawdę proste.
Zamiast mówić to UIViewController jesteśmy teraz mówiąc jest to
TableViewController, więc wiemy, że chcemy, aby wywołać wszystkie te metody w tabeli.
Dalej chcę utworzyć właściwość, która się dzieje do reprezentowania
rzeczy wewnątrz moim stole.
Ta tabela będzie arbitralnie wyświetlić
Lista owoców, a więc trzeba stworzyć jakiś tablicę
w którym można wstawić owoce.
Wewnątrz mojego pliku wdrażania pierwszą rzeczą chcę zrobić
to chcę się upewnić, zainicjować tę tablicę.
>> Powiedziałem alloc init, stworzyłem tablicę owoców,
i dodaję 4 rzeczy do niego, z których jeden jest o wiele bardziej kontrowersyjne niż w innych 3.
I teraz mam tablicę o rozmiarze 4.
Jesteśmy kręcąc go w CS50.
Mam teraz tablicę wielkości 4.
Teraz mam zamiar zacząć odpowiedzi na te pytania, a właściwie,
kiedy stworzył tę aplikację to wszystko było już dla mnie zrobił.
Nie trzeba wpisywać się liczbę sekcji w widoku tabeli.
To było już tam, a ja wypełniając formularz.
Ile sekcji mam?
One. Wszystko zrobione.
Ile wierszy mam?
Cóż, mam jeden wiersz dla każdego owocu, więc ta liczba
jest własnością wszystkich tablic, które mówi, jak duże to jest?
To, ile wierszy mam.
Wreszcie, muszę powiedzieć, co ma każda komórka wygląda?
Zamierzam powiedzieć dequeueReusableCellWithIdentifier.
>> Ponownie, to już było napisane dla mnie.
Nie musisz tego robić sam, i chcę wrócić
komórka w tym miejscu.
Pamiętaj, że mamy wywołanie tej samej metody na każdej komórki,
i ten argument tutaj, ten argument indexPath,
mówi to, co rząd jestem w.
Jeśli powiem indexPath.row tu
to jest 0, to jest 1, to będzie 2, i jest to tak, znam
co komórka Jestem aktualnie wyświetlane.
Chcę ustawić tekst w komórce za pomocą tej właściwości TextLabel
, aby przejść w mojej tablicy owoców i uzyskać
object do każdego wiersza.
Jeśli jest to ciąg, jestem teraz ustawienie
Właściwość text na ciąg.
Można zrobić jedną rzecz.
Mogę również zarejestrować obsługi zdarzeń w każdej z komórek,
więc kiedy dotknąć każdego z tych komórek
ta didSelectRowAtIndexPath, to będzie się nazywać dla mnie,
tak po prostu przez określenie to mogę obsłużyć, co się dzieje
po dotknięciu komórkę, i znowu, jesteśmy przechodząc w którym komórka był na podsłuchu
tak, że możemy wykorzystać ten sam obsługi zdarzeń dla wszystkich naszych komórek.
>> Ponownie, jest to coś, iOS robi dla mnie.
Miejmy wyświetlić inny przykry popup
który po prostu mówi, że wziął coś, gdzie, że coś
będzie obiekt wiersz.
Gdy uruchomię to będę mieć ten miły widok tabeli
jednym wierszu dla każdego z tych owoców, a jeśli ja dotknij jednego
mówi mi, co się stało.
Ma sens?
Zbudujmy nieco bardziej skomplikowane z app,
jak kliknięcie wybrałeś pomidora jest.
Miły część o storyboardów
jest to nie tylko pomoże nam ekrany projekt indywidualnie,
to też pomoże nam powiązać całą naszą aplikację,
więc końcowy app będziemy budynek jest ten miły sport czytnik wiadomości,
i tak będzie musiał kilka ekranów, a więc faktycznie mogę reprezentować
każda z tych wielu ekranach w serii ujęć
i mogę pomniejszyć i widzieć moją app z wysokim poziomie.
>> W celu stworzenia nowego wnętrza elementem mojej serii ujęć
to naprawdę proste wewnątrz konstruktorze Interface.
Jeśli chcesz dodać kolejny ekran do tego, na przykład,
Dostanie najpierw pomniejszyć z pinch zoom, że Apple kocha tak bardzo,
a tu przed I szukać przycisku
i przeciągnąć przycisk
jeśli chcę, aby utworzyć nowy ekran faktycznie mogę po prostu przeciągnij i upuść
cały regulator zewnętrzny, więc jeśli mogę odebrać to, wyciągnij go tu,
hej, jest jeszcze jeden ekran, a więc teraz przy użyciu tego samego pliku storyboard
Mogę mieć wszystkich ekranach wewnątrz z mojej aplikacji, i mogę pomniejszyć
i zobaczyć, jak one oddziałują.
To nie będzie oddziaływać jeszcze.
Sposób, w jaki te 2 ekrany interakcji jest zdefiniowanie relacji.
Można w zasadzie powiedzieć, z tego ekranu, po naciśnięciu tego przycisku
Chcę, abyś ślizgać się do tego nowego ekranu.
To oznacza, że ​​jest to rodzaj relacji między
Pierwszy ekran, a drugi ekran.
Będziesz musiał w zasadzie strzałę z tego przycisku do drugiego ekranu
mówiąc, że po naciśnięciu tego przycisku, który znajduje się tam, gdzie chcę iść.
Tak jak możemy kontrolować kliknął i zaciągnął do określenia tych punktów
mamy zamiar zrobić to samo określenie tych segues.
>> Zobaczymy na przykład, że i zanim faktycznie przejście
z jednego ekranu na drugi iOS jest na tyle miły, aby wywołać tę metodę
nazywa prepareForSegue, i to, gdzie możemy zacząć
wysyłanie danych z jednej aplikacji do drugiej.
W przykładzie mamy zamiar spojrzeć na to będzie w zasadzie pozwala nam
filtrować drużyn baseballowych przez ligi i podziałów.
Kiedy wybieram ligę, na przykład, chcę przejście
do mojego kolejnego ekranu, na którym można wyświetlić wszystkich działów
w tej lidze, czy wszystkie zespoły różnych.
Muszę wysłać do tego ekranu, co zespoły należy wyświetlić.
Aby to zrobić, że mam zamiar skorzystać z tej metody tutaj.
>> Wreszcie, po prostu przypadkowy punkt na iOS.
Jeśli chcesz przechowywać dane jest jeszcze to, co nazywa się podstawowe dane,
która jest faktycznie trochę skomplikowane w użyciu.
Można również użyć SQL do przechowywania danych,
które ponownie, jest ładny, ale trochę z boku bardziej skomplikowane do pracy,
ale iOS również wspiera te naprawdę fajne rzeczy nazywane wykazy nieruchomości,
oraz wykaz nieruchomości jest tylko plik, który reprezentuje najważniejsze par wartości.
Zdefiniować listę kluczy, i powiedzieć, że to klucz będzie tablica.
Klucz ten będzie łańcuch, iw zasadzie wszystko, co można zrobić
w JSON można zrobić wewnątrz wykazu nieruchomości,
i tak to bardzo ładnie pozwala nam pracować z niektórych danych.
Na przykład, mam ten Teams.plist że utworzony.
I stworzył nowy plik plist i mogę drążyć.
To jest słownik, to słownik, są smyczki,
i tak jest to miły graficzne przedstawienie dokumentu JSON
lub po prostu zbiór podstawowych par wartości,
a więc jest to dane, że będę pracować z wnętrza mojej aplikacji.
>> Niech najpierw przyjść tutaj. Mamy o wiele więcej teraz pliki.
Ale niech najpierw dojść tu do serii ujęć.
Storyboard tu czy mogę pomniejszyć-
teraz możemy zobaczyć, że to jest przepływ mojej aplikacji.
Jestem 1-ty ruszy na tym ekranie.
Będę drążyć do tego ekranu,
i będę drążyć do tego ekranu, i widzimy tutaj, że jeśli rodzaj
przenieść jeden z nich wokół nas te strzałki dzieje stąd dotąd,
i sposób, w jaki definiuje tego strzałkę było gdybym powiększyć trochę,
i gdybym przyszedł do tego kontrolera widoku
i tu jest komórka, i chcę powiedzieć, że po dotknięciu komórkę
Chcę byś przesunąć do innego ekranu.
Mogę po prostu przytrzymaj kontrolę,
przejdź na trochę, przytrzymaj kontrolę, przeciągnij komórkę nad i puścić.
>> A tutaj mówimy, co jest przejście, które chcesz użyć?
Czy chcesz korzystać z tej rzeczy slajdów, który jest zwany Push?
Chcesz przesunąć od dołu?
To się nazywa modalne.
I raz kliknąć jeden z nich, to będzie narysować tę strzałkę, dla mnie,
a to oznacza, że ​​mam faktycznie obchodzić, co się dzieje po naciśnięciu tego przycisku, w formie graficznej.
Nie napisałem żadnego kodu faktycznie slajdów z jednego ekranu do następnego.
I określono to wizualnie wnętrze konstruktorze Interface.
Jeśli kliknij na strzałkę, możemy zobaczyć, że dałem to coś nazwę.
Nazwałem to showDivisions, i to jest tak, że mogę wiedzieć
co przejście ma się pojawić, a my zobaczymy, dlaczego w ciągu zaledwie sekundy.
To jak mam podłączane różne ekrany w mojej aplikacji.
Gdyby tak było, gwarantujące przykład zamiast widoku tabeli
Mogłem kontrolować kliknij na przycisk, przeciągnij do następnego ekranu,
i to jak można zrobić w ten sposób nawigacji.
>> Bardzo szybko, jeśli dojdziemy do MasterViewController,
ponownie, jesteśmy po prostu będzie zdefiniować listę rzeczy
, które będą wyświetlane w widoku tabeli.
Tutaj mówię chcę żebyś to plist,
i chcę, załadowanie go do słownika,
i raz masz ten słownik, mam zamiar odpowiedzieć na te same pytania ponownie.
Tutaj jest liczba sekcji.
One, jest jeden wiersz dla każdej ligi, a tekst z każdej komórki
powinna być pierwsza, Lig, League drugi, i tak dalej.
Wreszcie, mam zamiar skorzystać z tej metody, że właśnie widział nazwie prepareForSegue,
i jest to metoda, która zamierza zostać zwolniony po kliknięciu
w jednym z tych rzędów, a w związku z tym, że przejście aktywacji
że mogę ustawić za pomocą strzałek.
To mówi, że można mieć wiele
relacje z jednego ekranu do drugiego.
Jeśli mam 2 przyciski, a każdy przycisk przeniesie Cię do innego ekranu
Mam zamiar mieć 2 segues, 1 dla każdego przycisku.
Jednak jest to prepareForSegue znowu będzie ponownie
dla każdego z różnych związków, więc oznacza to, że potrzebny jest sposób i
identyfikacji, jeśli pierwszy przycisk lub naciśnij drugi przycisk.
>> Pamiętaj, że kiedy dałem Segue nazwę, to showDivisions,
to jak teraz wiem, że to jest Segue że zostało aktywowane.
Wszystko co chcę zrobić, to chcę powiedzieć,
Chcę dowiedzieć się, co po prostu hit,
i tak się to dostać, mogę powiedzieć, chcę indexPath dla wybranego wiersza,
Pamiętam indexPath tylko mówi, gdzie po prostu kliknąć,
i chcę powiedzieć, chcę dowiedzieć się, gdzie idę.
Ten destinationViewController, to własność Segue.
To ekran będę,
tak wiem, że ekran będę nazywa DivisionsViewController
bo stworzył tę klasę,
więc teraz, jeśli powiem d.divisions
Jestem teraz ustawienie właściwości kontrolera widoku mam zamiar przejść.
To jak mam wysyłać dane z jednego ekranu do innego ekranu.
>> Po prostu patrząc na to DivisionsViewController
widać tutaj, że w pliku. h
istnieją podziały nieruchomości, a to, co mam w zasadzie wypełniania,
tak to wiem, że jestem wyświetlania podziałów odpowiadających
liga, że ​​kliknąłem, i znowu,
rzeczywisty widok tabeli wygląda niemal tak samo, po prostu odpowiadając na te
3 proste pytania, jak również identyfikujące
co się dzieje, kiedy przejść do następnego ekranu.
Wystarczy kilka innych rzeczy.
Można zauważyć na górze tutaj zamiast mówić # include
Jestem teraz mówią # import.
To jest po prostu rzeczą Objective-C.
Import jest w zasadzie ładniejsza wersja obejmują,
i na przykład, musimy wiedzieć, co to jest klasa,
, więc nie można po prostu powiedzieć DivisionsViewController.
Gdybyśmy nie hashtag standardio.c wnętrze naszego pliku. C
kompilator nie miał pojęcia, co printf był.
Podobnie, jeśli nie importować DivisionsViewController
kompilator naprawdę nie ma pojęcia co DivisionsViewController jest.
Wystarczy upewnić się, że w środku swoich różnych. Pliki m upewnić zaimportować
odpowiednie pliki. h tak, że kompilator nie wie, co się dzieje.
>> Wreszcie, co Apple ostatecznie zgadza się wyświetlać niektórych danych przy użyciu widoku sieciowego,
i tak widok internetowych jest obiekt, w którym można osadzić
mała przeglądarka wewnątrz Twojej aplikacji.
Wszystko, co musisz zrobić, to dostarczyć adres URL do przeglądarki internetowej,
więc chcę iść do mlb.mlb.com,
i jest to w jaki sposób można uzyskać dostęp do strony startowej dla każdego zespołu,
i tak przez przekazanie tego adresu URL
zobacz internetowa może wyświetlać to dla mnie, a ja mogę zajrzeć,
i symulator jest używany przez tego.
Teraz przyszedł z mojego plist.
Jeśli I kliknij ten to również pochodzi z mojego plist, i to było obsługiwane przesuwne
definiując te segues.
Klikam to i jeszcze jeden,
i teraz tu jest mój UIWebView, więc tak po prostu
tutaj jest strona internetowa o adresie URL, które po prostu osadzony,
i nie ma potrzeby obsługi nic szalonego.
To jest, jak wyświetlić stronę internetową.
Rzeczy takie jak tego przycisku Wstecz tutaj są podane także do mnie
całkowicie za darmo, bo już zdefiniowane te relacje za pomocą segues.
>> Masz pytanie? Tak.
[Student] Więc po użyciu alloc, nie musisz do swobodnego cokolwiek?
Dokładnie, kiedy zadzwonić alloc i init nie masz, aby uwolnić ją.
IOS będzie obsługiwać to wszystko dla Ciebie.
To wspaniałe, i nie łamiesz żadnych zasad. Tak.
[Student] Jeśli było to więcej zespołów, które zmieści się na ekranie,
to automatycznie posiada opcję przewijania, czy jest to coś trzeba dodawać?
Dokładnie, gdybym miał więcej drużyn, na przykład, to automatycznie obsłużyć
przewijanie do mnie, a wszystkie obawy wydajność
z ogromnym stole są również obsługiwane całkowicie dla mnie.
>> Inne pytania?
Cały ten kod ma być wysłana.
Mamy rodzaju tabu trochę szczegółów więcej drobnych,
ale takie rzeczy jak ustawienie niektóre właściwości do widoku internetowej
są po prostu rzeczy, które można uzyskać, przeglądając dokumentację Apple,
który jest naprawdę ładnie rozplanowany.
Mają wiele przykładowych aplikacji i przykład zwyczajów
różnych API, więc na pewno czytać tych, jeśli możesz.
Tylko niektóre pomocne linki warto przyjrzeć.
Oto kilka przydatnych przewodników dokumentacji.
Adresy URL są ogromne, więc są one skrócone.
Ten pierwszy jest cała biblioteka dokumentacji.
Jest małe bary wyszukiwania, więc jeśli przycisk start pisania
rozpocznie podając wszystkie informacje o wszystkich rzeczy można zrobić za pomocą przycisku.
Mam również widoku tabeli Programming Guide.
Zajmuje widoki tabeli bardziej szczegółowo,
jak robić rzeczy, jak dynamicznie dodawać komórki lub edytować komórki lub ich usunięcia.
>> Jest wiele aplikacji, próbka z Apple, który pokaże Ci, jak to zrobić,
i wreszcie, ta ostatnia jest ludzki Wytyczne Interface,
i to jest w zasadzie pewne omówienie elementów interfejsu użytkownika,
rzeczy, jak nie zrobić przycisk, który znajduje się w 4 pikseli na 4 piksele.
To zły pomysł, i inne rzeczy, że Apple chce, aby zrobić
zachęcić dobrego wzornictwa.
>> Jakieś ostatnie pytania zanim skończę?
W porządku, na pewno tutaj, ale jesteśmy będzie mieć specjalne etykiety na dyskutować.
Będziemy mieć iOS jeden, więc na pewno tutaj wykorzystuje to.
Jeśli chcesz pracować z kolegami na temat projektów
lub pomóc wymyślić jakiś random stuff iOS
krępuj się napisz do mnie, a na pewno czytać cały kod online ponieważ
tylko w interesie raz rodzaj tabu więcej
drobnoziarnista szczegóły rzeczy.
Ale jeśli nie, to powodzenia na projekty iOS i mam nadzieję, że mamy
duży napływ aplikacji w App Store.
[CS50.TV]