Meniul
AcasăTehnică

Objective-C ca prim limbaj de programare. Dezvoltare iOS pentru începători: învățați să creați aplicații iOS de la zero

Tutorialul conține informații utile despre limbajul Objective-C, baza acestuia și caracteristici suplimentare. Cartea conține tot ce aveți nevoie pentru a crea aplicații pentru iPod Touch și iPhone 3G Ajutor Apple SDK. O mare parte din material este dedicat dezvoltării de interfețe pentru programatori, motorului de baze de date SQLite și procesării XML Hbxml2.

Când a creat tutorialul „Programare pentru iPhone”, autorul a adus un omagiu capacităților iPhone-ului ca navigator GPS. Programarea iPhone este dedicată dezvoltatorilor cu un nivel ridicat de cunoștințe pentru a-și îmbunătăți abilitățile și pentru a dobândi altele noi. Autorul Maher Ali a ținut cont de toate elementele esențiale din cartea sa, care fără îndoială merită un numar mare feedback pozitiv si note mari.

Pentru cei care doresc să lucreze cu produse Apple, denumirile Xcode, iOS și Mac OS X nu sunt doar cuvinte goale, ci instrumente de dezvoltare și sisteme de operare. Un începător în programare și un profesionist care dorește să învețe principiile dezvoltării software în Objective-C vor găsi în egală măsură carte utilă Aaron Hilegass „Obiectiv-C. Programare pentru iOS și MacOS."

Până de curând, politica de programare a Apple a fost, pentru a spune ușor, închisă, iar găsirea de instrumente pentru crearea de programe pentru MacOS era pur și simplu nerealistă. Astăzi când piata calculatoarelor devine din ce în ce mai mobil, iar ponderea iPhone, iPad și a altor dispozitive iOS în el este în creștere, nu în ultimul rând datorită numărului mare programe gratuite, apariția instrumentelor de dezvoltare în Objective-C, un limbaj special conceput pentru aceste scopuri, a devenit complet logică. Astăzi, oricine vrea să se alăture Lumea Apple, poate fi descărcat gratuit de pe Mac Magazin de aplicații Program Xcode și începe programarea atât pentru iOS, cât și pentru Mac OS X, în care va fi ajutat de cartea „Objective-C” de Aaron Hilegass. Programare pentru iOS și MacOS."

Titlul original al manualului este „Objective-C Programming: The Big Nerd Ranch Guide”, și se bazează pe cursul de formare dezvoltat de centrul educațional Big Nerd Ranch ca curs de inițiere în programare în Obiectivul C. Structura acestui manual este de așa natură încât va fi la fel de util atât pentru începători completi în programare, cât și pentru profesioniști care doresc să se familiarizeze cu un alt domeniu de aplicare a abilităților lor - programarea pentru dispozitive mobile și computere Apple. Ca bază pentru antrenament, cartea oferă iOS 5 și Max OS X 10.7 Lion, cunoscute pentru stabilitatea lor, iar versiunea aleasă pentru dezvoltarea software este Xcode 4.2.

În zilele noastre aproape toată lumea folosește cele mai noi dispozitive Dispozitive bazate pe iOS, cum ar fi iPhone și iPad. Sunt folosite la muncă, în studiu și pentru divertisment general. Și pentru aceste dispozitive puteți veni cu cele mai interesante aplicații si programe. Dacă ai astfel de gânduri, dar nu știi de unde să începi, atunci această carte te va ajuta doar să faci primii pași.

Tutorialul va explica de la bun început cum puteți crea aplicații noi pentru dispozitivele iPhone și iPad. Tutorialul îi va învăța pe toată lumea cum să proiecteze o nouă aplicație și să o aducă la viață în cel mai scurt timp posibil. Cartea va oferi tuturor șansa de a-și crea prima aplicație unică, care cu siguranță nu va fi ultima.

Cartea va ajuta pe toată lumea să stăpânească elementele de bază ale programării în Objective-C, precum și să înțeleagă cum să lucreze cu instrumentele iPhone SDK. Manualul îi va învăța pe toți de la zero și îi va face un maestru în crearea de noi aplicații pentru cele mai populare dispozitive. Tot ce veți avea nevoie este multă dorință și entuziasm, manualul va face restul. El va oferi tuturor cunoștințele necesare și fundația de bază, astfel încât oricine să poată începe să-și creeze propria lor, aplicații unice pentru dispozitivele iPhone și iPad.

Cartea va începe cu primii pași și termenii de bază pe care toată lumea ar trebui să-i cunoască înainte de a începe lucrul. Aceasta este una dintre cele mai importante secțiuni ale cărții căreia fiecare cititor ar trebui să-i acorde atenția cuvenită. La urma urmei, doar aici sunt explicate toate abilitățile de bază, iar apoi vor trebui folosite în practică.

Următoarea secțiune a tutorialului vă va spune despre toate tipurile de aplicații pentru iPhone și iPad și vă va învăța abilitățile de bază pentru a le crea. Apoi va exista un capitol special care este dedicat învățării să lucreze cu programul Objective-C și toate funcții utile, pe care fiecare specialist în programare ar trebui să-l cunoască.

Următorul capitol al tutorialului ne va spune despre mai multe vizualizări și va afișa tabele detaliate pe acest subiect. Totul va fi prezentat atât de simplu, încât orice programator începător sau fără experiență va putea să înțeleagă rapid esența problemei și să înțeleagă acest subiect. Următorul subiect din carte va fi despre vizualizarea modală și toate funcțiile acesteia.

În continuare, cartea ne va introduce în salvarea aplicațiilor, editarea și sortarea acestora. Iată diverse tehnici de editare pe care fiecare programator ar trebui să le cunoască. De asemenea, ne vor spune cum să dezvoltăm aplicații pentru întreprinderi.

În acest tutorial vom găsi secțiuni despre migrare și optimizare cu Core Data. Și într-una dintre cele mai importante secțiuni, vom învăța cum să creăm o interfață pentru aplicația noastră și vom afla totul despre interfețele naturale.

Tot în cartea „Programare pentru iPhone și iPad” găsim două aplicații importante, spre final. Prima va acoperi patru subiecte relevante care nu au fost prezentate în capitolele acestei cărți. Și în a doua anexă, autorii cărții, D. Pailon și T. Pailon, spun fiecărui cititor cum să-și pregătească propriul proiect pentru distribuție.

Această carte va oferi informații esențiale despre elementele de bază ale dezvoltării de noi aplicații și programe pentru iPhone, iPad și iPod touch. Acest manual va fi scris într-o formă interesantă, fără a-l încărca cu termeni grei. Deci, orice începător va fi bucuros să stăpânească acest material și să-l aplice cu pricepere în practică.

Cartea va începe cu un capitol, cu nume interesant- "Bun venit in jungla." Nu întâmplător autorii folosesc un astfel de vocabular, pentru că prin aceasta încearcă să captiveze cititorul și să-i prezinte informații complexe în cel mai simplu și mai interesant mod. Acest capitol va vorbi despre toate abilitățile de bază care sunt necesare pentru a crea acest tip de program.

Următorul capitol al acestui tutorial ne va arăta clar cum să creăm noi aplicații în mediul Xcode și, de asemenea, ne va arăta cum să folosim diverse programe pentru acest tip de lucru. După aceasta vom fi ajutați și să înțelegem șlefuirea aplicațiilor noastre și toate detaliile finale.

Următorul capitol al acestei cărți va fi dedicat noilor exerciții cu interfața, de unde putem afla informații foarte utile. Aici vom întâlni controale active și pasive și vom învăța cum să lucrăm cu acestea. Această secțiune a manualului ne va spune și despre reprezentare graficăși despre definirea rezultatelor și acțiunilor. Acest capitol va fi unul dintre cele mai mari și va exista informatii vitale pentru muncă și pentru crearea de noi aplicații.

Un alt subiect din această carte va fi dedicat rotației și redimensionării automate. Aici fiecare începător va putea învăța cum să gestioneze rotațiile schimbând dimensiunea, precum și să configureze suportul pentru rotația dorită.

Autorii Dave Mark, Jack Nutting și Jeff LaMarche consacră secțiuni suplimentare ale acestei cărți funcțiilor esențiale, tabelelor și diferitelor metode pentru crearea de noi aplicații. Cartea „Dezvoltarea de aplicații pentru iPhone, iPad și iPod touch cu folosind iOS SDK.RUS.2012" ne va prezenta în detaliu controlerele de navigație și diverse sisteme de masă. Aici putem afla toate caracteristicile de programare pentru iPad și să învățăm cum să creăm ultimele proiecte. De asemenea, în acest tutorial vom afla totul despre setările utilizatorului și cum funcționează acestea, precum și ne vom familiariza cu persistența datelor. Toată lumea de aici poate învăța cum să organizeze diverse procesări de fundal cele mai noi tehnologii si mijloace. Prin urmare, este recomandat să citiți această carte tuturor celor care doresc să creeze noi, aplicații creative pentru cele mai populare dispozitive.

Cartea „Objective-C 2.0 and Programming for Mac” conține material extins despre predarea programării în limbajul Objective-C. Fiind limba principală pentru crearea de aplicații pentru Mac OS X și iPhone, acum devine din ce în ce mai populară și solicitată. Mac este o platformă destul de puternică, iar Objective-C este ideal pentru scris codul programului sub ea. Cartea dezvăluie capabilitățile bogate ale Objective-C, în special protocoalele și instanțierea. De asemenea, sunt descrise mediul de dezvoltare pentru Mac Xcode și setul de instrumente Cocoa. Cititorul poate învăța nu numai limbajul de programare Objective-C pentru Mac OS X și iPhone, ci și concepte avansate de programare, cum ar fi principiul deschis-închis, programarea orientată pe obiecte, codarea cheie/valoare, refactorizarea și predicate. Cartea este scrisă într-un stil simplu și chiar vesel, ceea ce va face studierea materialului extrem de ușoară și interesantă.

Cartea „iPhone. Open Source Application Development” este dedicat în întregime dezvoltării de aplicații pentru iPhone în Objective-C prin utilizarea celor mai ultima versiune programe iPhone API-ul open source care a fost actualizat pentru software-ul iPhone 2.x și 3G. Această carte acoperă rularea și personalizarea aplicațiilor iPhone și proiectarea interfețelor cu utilizatorul folosind UIK.it. Această publicație descrie în detaliu programarea grafică, inclusiv animația, precum și transformarea tridimensională a suprafețelor. Aici se acordă destul de multă atenție problemelor de înregistrare și redare ulterioară a diferitelor fișiere de sunet. Aplicația descrie cu atenție diverse tehnici de programare, precum și clase sursa deschisa, conceput pentru a scrie aplicații iPhone cu propriile mâini. Cartea descrisă este creată pentru programatori.

Profesia de programator este una dintre cele mai prestigioase și solicitate, acesta este un fapt. Industria de dezvoltare software are nișele sale. Dintre acestea, cea cu cea mai rapidă creștere și, în același timp, cea mai bine plătită, este dezvoltarea de software pentru dispozitive mobile. După cum știți, s-a întâmplat ca, lăsându-și concurenții mult în urmă, trei rivali constante au luat conducerea. Trucul este că unul dintre acești trei este liderul incontestabil, în timp ce cineva ajunge mereu din urmă.

Pe segmentul tehnologiei mobile, Apple este, fără îndoială, lider cu smartphone-ul său iPhone. La o prezentare desfășurată în septembrie, compania din Cupertino a demonstrat cea de-a 7-a versiune a dispozitivului mobil. Odată cu acesta, Apple a introdus o nouă versiune a sistemului său de operare mobil. sisteme iOS 10. Acum este cel mai important sistem de operare din lume, ca și predecesorii săi. De aici rezultă că învățarea dezvoltării iOS este cea mai mare investiție profitabilă timp si bani.

Ecosistemul mere

Astăzi vom dezvolta o aplicație mobilă simplă pentru iOS. Desigur, un Mac nativ este cel mai potrivit pentru asta. Dar dacă sunteți un susținător Windows sau pur și simplu nu aveți un Mac, puteți instala sistem de operare macOS pentru o mașină virtuală în Windows. Pe Internet, nu vă va fi dificil să găsiți o versiune de macOS special adaptată pentru PC, numită popular Hackintosh. Simțiți-vă liber să îl instalați pe o mașină virtuală VMware, VirtualBox - alegerea dvs. Permiteți-mi să vă avertizez imediat că tastatura PC-ului nu are unele dintre tastele care se află pe tastatura Mac și multe dintre combinațiile lor nu pot fi apăsate în Hackintosh. Acest lucru strică destul de mult starea de spirit. În caz contrar, toate operațiunile descrise mai jos pot fi efectuate cu succes pe Hackintosh.

Cunoștințe necesare

Pentru a programa în general și pentru iOS în special, trebuie să știi destul de multe. Matematica și logica pot să nu fie necesare la început, dar vor fi solicitate mai târziu. Tehnologia modernă a eliminat necesitatea ca un programator să aibă o cunoaștere aprofundată a arhitecturii computerelor, dar este necesară înțelegerea mecanismelor de bază precum sistemele numerice, conversia acestora, viteza subrutinelor sau eficiența algoritmilor (O mare).

Pentru mai mult nivel inalt Un dezvoltator iOS trebuie să aibă cunoștințe profunde despre sistemul de operare macOS și iOS însuși. De asemenea, trebuie să stăpâniți limbajul de programare Apple. Cunoștințele Delphi, C++, C# sau VB.NET nu vă vor ajuta prea mult. Apple are propriul ecosistem cu propriile sale limbaje: Objective-C și Swift. Desigur, cunoștințele despre C++ nu au afectat niciodată nimănui programele și inserțiile bazate pe acesta se găsesc peste tot, chiar și la Apple. Dar cel mai folosit prin definiție este Objective-C, pur și simplu pentru că a apărut mult mai devreme (la mijlocul anilor optzeci ai secolului trecut), în timp ce Swift cu doar doi ani în urmă (în 2014). Apple are mari speranțe în noua limbă și investește mult în ea. Objective-C este folosit pentru a susține vechiul software, iar cel nou este scris în Swift. Așa că e bine să le cunoști pe amândouă.

Pentru a nu pierde timpul, toate aceste limbaje de programare pot fi învățate sub stricta supraveghere a profesorilor de pe site.

Instrumente de dezvoltare

După cum știți, principalul instrument de dezvoltare pentru macOS și odată cu acesta iOS este mediul de programare Xcode. Include instrumente pentru crearea de aplicații pentru Mac, iPhone, iPad, Apple TV, Apple Watch. Toate platformele Apple. Xcode conține Interface Builder, un editor de cod care acceptă totul mijloace moderne lucrul cu codul. În plus, fără a părăsi Xcode, poți testa aplicația; dacă este dezvoltat pentru un dispozitiv extern, atunci poate fi rulat într-un emulator.

Sistemul include emulatori pentru toate dispozitivele, ale căror versiuni noi pot fi descărcate. În plus, Xcode conține instrumente grafice pentru a analiza performanța aplicației, inclusiv instrumente de diagnosticare a încărcării procesorului, a utilizării stocării (HDD, SDD și altele), a încărcării adaptorului grafic (din partea OpenGL).

Pe 13 septembrie, a fost lansată o nouă versiune, foarte anticipată, a mediului de dezvoltare 8.0. Versiuni stabile poate fi descărcat gratuit din App Store. Alpha și beta-urile sunt distribuite prin abonament pentru dezvoltatori. A opta versiune include: o nouă versiune a limbajului Swift 3, un instrument de învățare pentru Swift Playground pentru iPad, o nouă versiune a Interface Builder, care a devenit mai rapidă și vă permite să vizualizați aspectul aplicației pe diferite platforme, fără a fi nevoie să implementați aplicația în sine pe simulator.

Xcode 8 poate fi folosit pentru a dezvolta aplicații pentru macOS Sierra, iOS 10, watchOS 3 și tvOS 10. Toate SDK-urile sunt disponibile. Noile versiuni ale sistemelor de operare au început să apară în mod constant imediat după Prezentări Apple, a avut loc la începutul lunii septembrie.

Limbajul Objective-C

Să ne amintim pe scurt informațiile de bază despre limbă. Obiectiv-C - Obiect compilat orientat spre limbaj programare folosită pentru a scrie aplicații pentru sistemele Apple. Este un superset sau, cu alte cuvinte, un add-on la C, moștenind din acesta din urmă sintaxă, tipuri de date, metode de monitorizare a progresului execuției programului și adăugarea de capabilități bazate pe obiecte. programare orientată- descrierea claselor si metodelor.

Ca și în C++, în Objective-C rolul central este jucat de obiecte, care sunt asociate cu patru paradigme: abstractizare, încapsulare, moștenire, polimorfism. C++ este un limbaj puternic tipizat, în timp ce Objective-C este slab tipizat sau are sistem dinamic tipuri de date. La fel ca Smalltalk, Objective-C trimite mesaje către obiecte. Aceasta este o caracteristică excepțională a limbajelor dinamice, deoarece tipul de obiecte este verificat în timpul execuției, mai degrabă decât în ​​timpul compilării.

Descrierea limbajului Objective-C ocupă mai mult de un volum voluminos. Prin urmare, pentru a dobândi cunoștințe obiective, este convenabil să urmați cursul „”. O întreagă secțiune a cursului este dedicată acestei limbi.

Dezvoltare de aplicații iOS

Ca exemplu, vom dezvolta o aplicație foarte simplă. Să nu ne abatem de la tradiția sacră, să salutăm lumea. Cu toate acestea, având în vedere că avem aplicație grafică, îl vom diversifica puțin: vom adăuga un buton, la apăsare, vom afișa sau ascunde inscripția „Hello, World”.

Lansați Xcode, în fereastra care apare, selectați Creare proiect nou sau în meniul principal Fișier -> Nou -> Proiect. Următoarea fereastră vă va cere să selectați platforma țintă și tipul de aplicație.


ÎN în acest caz, Suntem interesați de platforma iOS. Există șapte tipuri de aplicații din care puteți alege. Șase dintre ele sunt șabloane pentru aplicații tipice ale sistemului de operare iOS, conținând implicit un set diferit de componente. Al șaptelea tip este jocul.

Tipuri de aplicații

  • Șablonul Aplicație cu vizualizare unică este destinat aplicare simplă cu un singur ecran. Presetarea include o componentă View Controller, care vă permite să personalizați aspectul aplicației folosind designerul de formulare Interface Builder.
  • Master Detail Application creează o aplicație în care vedere la masă este afișată o colecție de obiecte. După selectarea unuia dintre ele, sunt afișate informații detaliate despre acel obiect. Prima vedere este principala, a doua este detalierea.
  • Aplicația bazată pe pagină creează aplicații care au mai multe ecrane, cum ar fi paginile dintr-o carte. În consecință, cititoarele electronice sunt create din acest gol.
  • Aplicația cu file vă permite să creați aplicații în care fiecare ecran poate fi comutat în orice moment, adică fiecare ecran are propriul buton de activare, pe care este afișat titlul. Un exemplu este iTunes.
  • Jocul este folosit pentru a crea un șablon de joc. Există patru cadre din care puteți alege pentru a crea un joc: SpriteKit, SceneKit, OpenGL ES, Metal. Să le privim pe scurt.
    SpriteKit este un sistem pentru randarea 2D și animarea dreptunghiurilor texturate - sprites. La afișarea cadrelor, se utilizează o buclă standard, cadrul este afișat după ce a fost procesat tot conținutul scenei.
    SceneKit este un cadru de nivel înalt pentru redarea graficelor 3D fără OpenGL. Acceptă încărcarea, manipularea obiectelor 3D. Include: un motor de fizică, un generator de particule și o metodă ușoară de scripting.
    OpenGL ES este un standard în grafica computerizată. Vă permite să vizualizați scene 2D și 3D. Vă permite să descrieți conducta pentru o placă video: vârfurile sunt supuse transformării, sunt asamblate în primitive, care sunt rasterizate într-o imagine bidimensională și afișate pe ecran. Shaderele programabile pot fi incluse în conductă.
    Metal este un API de nivel scăzut care vă va permite să profitați la maximum de adaptorul dvs. video. API-urile optimizate, împreună cu shaderele precompilate și multi-threading-ul vă duc jocul la noi niveluri de performanță și calitate.
  • Sticker Pack Application este un nou tip de aplicație care a apărut în iOS 10 și Xcode 8. Este un set de imagini simple sau animate utilizate în iMessage nou. Nu necesită codificare pentru ao crea.
  • Aplicația iMessage este un nou tip de aplicație care a apărut în iOS 10 și Xcode 8. Vă permite să creați suplimente pentru iMessage, de exemplu pentru a cumpăra și descărca pachetul de stickere. De asemenea, puteți utiliza API-ul iMessage pentru a vă crea propriul analog al acestei aplicații, inclusiv redarea audio, video, utilizarea autocolantelor și multe altele.

Crearea primului proiect

Ca șablon pentru aplicația noastră, vom selecta Aplicația cu vizualizare unică. Deoarece nu vom dezvolta un program mare, fondurile oferite de această prevedere vor fi suficiente pentru noi. Faceți clic pe Următorul. Pe pagina următoare a expertului, trebuie să introduceți un nume de proiect, de exemplu ShowLab. În lista derulantă Limbă, lăsați selectată limba implicită - Objective-C. Apoi, în lista derulantă Dispozitive, părăsiți selecția Universală. Aici stabiliți pentru ce dispozitiv (iPhone sau iPad) se creează aplicația. Clauza universală înseamnă pentru amândoi. Să debifați casetele Include Unit Tests și Include UI Tests; nu avem nevoie de teste. Următorul. Selectați un folder pentru a salva proiectul. Acum faceți clic pe butonul Creați.

Ca rezultat, se va deschide o fereastră cu o listă cu toți parametrii aplicați proiectului. În această fereastră, puteți modifica parametrii setați anterior în asistent: orientare, dispozitiv țintă etc.


Mai întâi trebuie să creăm interfața aplicației. Pentru a face acest lucru, selectați fișierul Main.storyboard din lista din stânga cu un singur clic (dacă acest fișier nu este vizibil, extindeți conținutul folderului ShowLab). În dreapta listei, întreaga fereastră va fi ocupată de Interface Builder. Aspectul dispozitivului va fi afișat în centru. În colțul din dreapta jos al ferestrei există un panou de componente. Trageți componentele Etichetă și Buton de acolo pe aspect. Deasupra panoului de componente este o listă de proprietăți. Dacă nu îl aveți, faceți clic pe butonul Afișați inspectorul de atribute, situat sub titlul ferestrei din partea dreaptă a interfeței.

Selectați componenta Etichetă în aspect și configurați proprietatea Text: lăsați selecția Plain în lista derulantă, introduceți inscripția dorită în rândul de mai jos, în cazul nostru „Hello, World”. Dacă textul nu se încadrează în limitele etichetei, modificați-le trăgând mânerele de pe marginile componentei. Pentru a o centraliza pe orizontală, accesați pagina Size Inspector făcând clic pe butonul Show the Size Inspector (în partea dreaptă a Show the Attributes Inspector). Pe această pagină, din lista derulantă Aranjare, selectați Centrare orizontal în Container.

Acum selectați componenta Button, schimbați proprietatea Text la eticheta dorită - Comutare. Îl puteți centra în același mod ca cel descris mai sus.

Crearea unei conexiuni între elementele grafice și cod

ÎN Studio vizual(sau Delphi) obiectul din cod este creat automat în momentul în care plasați o componentă vizuală pe formular. Acest lucru nu se întâmplă în Xcode, dar nu provoacă probleme.

Deschideți conținutul fișierului antet ViewController.h într-o fereastră separată făcând dublu clic pe acesta. Acest fișier conține o declarație a unei extensii a clasei UIViewController, marcată cu cuvântul cheie @interface. Această caracteristică a fost adăugată la cea de-a doua versiune a Objective-C. Acum efectuați acest truc: mutați cursorul mouse-ului pe o componentă - o etichetă de text, țineți apăsată tasta Ctrl și butonul stâng al mouse-ului. Mutați cursorul în fereastra cu codul (fișier ViewController.h), o linie albastră va urma cursorul. Eliberați mouse-ul și tasta în descrierea interfeței ViewController.

Va apărea fereastra de creare a Prizei.


Aceasta este o proprietate a unui obiect care se referă la un alt obiect (în acest caz o componentă vizuală). Trebuie să introduceți numele obiectului Outlet, prin care veți accesa componenta vizuală, să fie lab. Apoi, se selectează tipul de obiect, acesta este selectat corect: UILabel.

Chiar mai jos în lista Stocare, selectați tipul de referință de obiect: slab sau puternic. Dacă alegeți puternic, atunci obiectul indicat de proprietate va exista atâta timp cât proprietatea indică spre el, caz în care nu va fi șters automat când nu mai este folosit. Pe de altă parte, atunci când o referință slabă este în vigoare, obiectul se poate autodistruge. Deci, selectați tipul de legătură slabă și faceți clic pe butonul Conectare. Ca rezultat, următoarea linie va fi adăugată la cod:

@proprietate (slab, neatomic) IBOutlet UILabel *lab;

Să ne asigurăm că Outlet este o proprietate.

Acum să creăm o priză pentru buton. Algoritmul rămâne același. Numai pentru proprietatea Nume trebuie să introduceți un alt nume, de exemplu, dar. Linia va fi adăugată la cod:

@proprietate (slab, neatomic) IBOutlet UIButton *dar;

Ca rezultat, avem două indicatoare către componente vizuale: laborator și, respectiv, o inscripție și un buton. Acum, folosind pointeri, putem manipula componentele din cod.

Apoi, trebuie să creați un handler de evenimente pentru clic pe buton. Pentru a face acest lucru, deschideți fișierul de implementare ViewController.m într-o fereastră separată. Exact în același mod în care ați tras linia în fișierul antet pentru a crea priza, de la buton, trageți linia în fișierul de implementare și plasați-o în paranteza de închidere a comenzii - @end. Va apărea o fereastră pentru crearea unui eveniment, similară cu fereastra pentru crearea unui priză. Vedeți diferența: o legătură către un obiect este creată în fișierul antet, o metodă este creată în fișierul de implementare.


Completați câmpul Nume, valoarea acestuia reprezintă numele proprietății - metodă. Lasă-l să fie onClick. Lăsați valoarea câmpului Tip ca implicită - id. În Obiectivul-C acest tip este strămoșul tuturor celorlalți. În lista derulantă Eveniment, este selectat implicit evenimentul Touch Up Inside, care apare atunci când indicatorul (mouse, deget...) este eliberat peste buton, adică etapa finală de apăsare a butonului. De asta avem nevoie. În lista Argumente vom lăsa valoarea implicită: Sender este obiectul care a trimis acest semnal, în cazul nostru va fi întotdeauna un buton. Faceți clic pe butonul Conectare. Ca urmare, următorul cod va fi adăugat:

- (IBAction)onClick:(id)sender ( )

Un minus la început înseamnă metoda privată(privat). Cuvântul cheie IBAction marchează evenimente (metode) ale componentelor vizuale din Interface Builder.

Între parantezele comenzii vom scrie codul care se execută la apăsarea butonului:

Lab.hidden = !_lab.hidden;

În această linie de cod inversăm valoarea proprietății ascunse. Este de tip BOOL, care are două valori: YES - true și NO - false (oarecum neobișnuit pentru programatorii Windows, unde adevărat și fals).

Acordați atenție caracterului de subliniere dinaintea numelui obiectului - eticheta (_lab). Fără el, compilarea va eșua. Sublinierea este adăugată automat pentru obiectele conținute în alte obiecte; adică, în acest caz, obiectul de laborator este conținut în obiectul ViewController. Anterior, aceasta era o convenție folosită pentru a face distincția între obiectele declarate ca membri ai unei clase și obiectele locale. Și acum aceasta este o regulă strictă implementată în compilatorul de limbă.

Acum puteți compila aplicația și o puteți rula pe simulator. Am ales simulatorul pentru iPhone 7, inclus în Xcode 8. Butonul de compilare și rulare este un dreptunghi negru și se află în bara din partea de sus a interfeței.

După compilarea aplicației, lansarea simulatorului și încărcarea aplicației noastre, interfața acesteia va fi afișată pe ecranul simulatorului: inscripția „Hello, World” și butonul Switch. Dacă apăsați pe ultimul, inscripția va dispărea dacă o apăsați din nou, va apărea din nou.

Am realizat o aplicație foarte simplă pentru a înțelege esența dezvoltării iOS. Puteți afla informații mai detaliate despre crearea aplicațiilor iOS în Objective-C din cursul prietenilor noștri de la GeekBrains „”. Cursul consacră două luni învățării acestei limbi. În prima lună - subiecte introductive, iar în a doua - codificare reală a aplicațiilor profesionale.

Limbă rapidă

În 2014, Apple a introdus un nou limbaj de programare - Swift. A devenit rapid cel mai discutat și mai dinamic limbajul în curs de dezvoltareîn lume. Este fiabil, sigur, intuitiv limbaj clar pentru dezvoltarea de aplicații pentru sisteme de operare sisteme macOS, iOS, tvOS și watchOS pentru întreaga flotă de dispozitive Apple. Swift este un limbaj de programare eficient. Este mai ușor de învățat decât predecesorul său, Objective-C, iar Swift împrumută unele dintre cele mai bune idei ale sale. În același timp, dezvoltatorii au făcut limbile compatibile, adică un program poate conține cod atât în ​​Swift, cât și în Objective-C. Există miliarde de linii de cod și sute de mii de programe vechi scrise în Objective-C în lume, așa că suportul acestuia nu va fi cu siguranță abandonat.

La dezvoltarea Swift, scopul a fost de a crea cel mai convenabil limbaj de programare de sistem - rapid, sigur și expresiv.

Algoritmul din Swift este de 2,6 ori mai rapid decât același algoritm din Objective-C și de 8,4 ori mai rapid decât în ​​Python. Utilizarea Swift face ca procesul de dezvoltare a programului să fie mai flexibil și mai convenabil.

Datorită dezvoltării sale exponențiale, limbajul Swift a fost lansat comunității open source pe 3 decembrie 2015. În același timp, Apple își monitorizează cu strictețe dezvoltarea, organizând un comitet pentru dezvoltarea acesteia. Swift este acum disponibil nu numai pe sistemele Apple, ci și pe Linux. Toate instrumentele suplimentare pentru lucrul cu limbajul, inclusiv un depanator, o bibliotecă standard, un manager de pachete, sunt, de asemenea, gratuite și deschise.

Această limbă este viitorul. Puteți afla informații mai detaliate despre acesta din cursul menționat de la GeekBrains „”, în care o lună întreagă este dedicată învățării acestui limbaj de programare.

Magazin de aplicații

Mai simplu spus, App Store este un magazin de conținut pentru întreaga gamă de dispozitive Apple. Aici puteți cumpăra jocuri și aplicații atât de la companii mari, cât și de la dezvoltatori independenți. Fiecare dezvoltator, indiferent în ce țară locuiește, își poate vinde sau distribui gratuit programele pe această platformă de distribuție digitală. Pentru a începe să faceți acest lucru, trebuie să vă înregistrați ca dezvoltator și să cumpărați o licență pentru a vă vinde aplicațiile. Aceasta este o taxă pentru serviciul furnizat și dezvoltarea App Store.

Rezultate

Am dezvoltat o aplicație simplă pentru sistemul de operare mobil iOS folosind sistemul de programare Xcode împreună cu limbajul Objective-C. Am testat aplicația finită pe un simulator iPhone 7. Am învățat cum să construim interfața cu utilizatorul utilizând Interface Builder, cum să conectați elemente grafice cu codul aplicației, cum să creați handlere de evenimente. Ne-am familiarizat cu elementele de bază ale Objective-C. În plus, am atras atenția asupra promițătorului limbaj Swift, folosit pentru a dezvolta puternic și aplicații securizate pentru ecosistemul „măr”.

Cu toate acestea, materialul studiat este doar începutul. Pentru a vă actualiza intens în direcția codării mobile și a dezvoltării aplicațiilor care se vând efectiv, vă recomandăm să urmați cursul „” de pe site-ul prietenilor noștri.

Acesta este un curs demn: dacă îl urmezi, cu siguranță nu îți vei pierde timpul. Începe cu două cursuri detaliate despre limbajul Java, urmate de învățarea programării de bază pentru sistemul de operare mobil Android. Urmează un curs despre bazele de date în general și limbajul SQL în special. Apoi un curs aprofundat despre dezvoltarea aplicațiilor profesionale Android. După aceasta, vectorul de studiu se va îndrepta către sistemele Apple: doi curs detaliat despre limbajul Objective-C și un curs util despre Swift.


Prelegerile cursului sunt susținute de profesori profesioniști cu o vastă experiență în dezvoltarea de software. Dacă ceva nu este clar, puteți pune o întrebare fără întârziere. În general, învățarea pe GeekBrains este un proces live, puteți comunica, pune întrebări și ajuta cu răspunsuri. Pentru a testa cunoștințele dobândite, profesorii dau teme, care sunt apoi verificate. După finalizarea instruirii, veți avea un stagiu garantat într-o companie IT. Și atunci totul depinde de tine, dacă te arăți ca un specialist competent, vei fi invitat să lucrezi.

Proiect special cu firma

tricton 2 februarie 2013 la 04:21

Objective-C ca prim limbaj de programare

  • programare,
  • Obiectivul C
  • Tutorial

Această postare a fost concepută după ce nu s-au găsit răspunsuri clare la unele întrebări importante. Nu mă prefac că sunt un programator grozav. Nu, totul este încă înainte, dar perioada de incubație a trecut deja. Acesta este un articol din seria „Dacă nu știi cum să faci singur, învață pe altcineva”. Adică, pentru a înțelege ceva mai bine, trebuie să îi explici cuiva. Mopedul nu este al meu, am mai întâlnit această frază în publicațiile despre Habré. Unele lucruri sunt foarte greu de înțeles. Iar oamenii care înțeleg de obicei nu pot explica unui începător. Poate asta ma asteapta si pe mine. Este ca o conversație între un adult și un copil. Aproape un conflict generațional. Până când nivelul meu se dezvoltă într-un profesionist, trebuie să-mi contur viziunea actuală.

În articol, termenii care sunt utilizați pentru a explica diferite concepte sunt plasați între ghilimele. Articolul a fost scris pentru persoanele care au învățat deja să distingă buclele de matrice și să înțeleagă ce sunt o funcție și o metodă.
Dacă nu ați programat niciodată, atunci cartea lui Kernighan și Ritchie (în orice ediție) vă va depăși în mod clar puterile. Nu există în natură o astfel de voință care să te oblige să citești o carte până la capăt și, în același timp, să rezolvi toate problemele date.
Recomand cu căldură BecomeAnXcoder. Totul acolo este scris destul de clar pentru oamenii care știu foarte puțin despre programare. Informațiile sunt puțin depășite, dar vă vor ajuta să începeți. Poate că l-ați întâlnit deja sau chiar l-ați descărcat, dar puneți-l deoparte în catalogul de literatură (ei bine, toată lumea are un astfel de catalog, ocupă zeci de gigaocteți și vom citi toate asta de îndată ce avem timp liber, iar catalogul crește... ).
Este clar că cea mai buna varianta- MAC. În cel mai rău caz - Hackintosh sau mașină virtuală. Și chiar dacă procesorul nu vă permite să rulați oricare dintre cele de mai sus, puteți începe direct în notepad, urmat de compilare pe linia de comandă.
Pe multe forumuri puteți găsi o întrebare populară adresată de oameni care par să fie într-un tanc puternic blindat: „Un programator Objective-C trebuie să învețe C?” Peste tot scriu același lucru. Cei care au barbă și au început cu programare structurată- se spune că pur și simplu trebuie să deveniți cel puțin un MiddleDeveloper în C și abia apoi să căutați o cale în sălbăticia feroce a OOP, care este Objective-C, dar au obținut deja statutul de MiddleDeveloper , Ei obiectează: spun ei, învață cum sunt desenate butoanele de pe iPhone și cum să le atribui o funcție, iar hardware-ul va fi apoi ajustat după cum este necesar. Declar categoric că învățarea modului în care funcțiile sunt atribuite butoanelor nu este programare! Nu susțin să petreceți șase luni pentru a înțelege C pur. Dar merită să petreceți câteva săptămâni sau o lună. Acest lucru va oferi un fundal ambițiilor tale. Pe măsură ce învățați Objective-C, vor apărea inevitabil structuri de cod care nu vor clarifica nimic. De aceea, vă propun, fără niciun fanatism, ci să vă familiarizați în detaliu cu cartea lui A.B. „Învățarea C”. Este de 3 ori mai mare decât precedentul ca volum, dar se citește ușor și natural. Cartea, din nou, explică elementele de bază ale programării la un nivel destul de accesibil. În el puteți învăța cum să distingeți o matrice de o buclă și ce sunt pointerii.
Recent, pe Habré a apărut un articol, unde autorul a citat o grămadă de literatură, pe care o sfătuia să o citească și să meargă la muncă ca junior pentru pâine. Dacă citești pur și simplu toată literatura dată în acel articol, nu vei învăța nimic, dar dacă poți re-rezolva și memora din nou toată literatura, atunci vei putea deveni nu un junior, ci un dezvoltator respectat.

Start: metoda clasei și metoda instanței

Ce este o metodă? Acesta este un set de comenzi/instrucțiuni sau o comandă/instrucțiune care poate fi aplicată unui obiect și provoacă procesele necesare în el. Dacă acest lucru nu este complet clar, citiți mai departe și veți înțelege. De fapt, este dificil de înțeles ce sunt o metodă de clasă și o metodă de instanță. Toată lumea spune: „cu semnul „+” este o metodă de clasă, dar cu semnul „-” este o metodă de instanță. Este clar?" Și, ca răspuns, aud: „Da, o metodă de clasă și o metodă de instanță”. Personal, la început am înțeles doar că sunt diferite, dar ce și când să folosim au rămas neclare. Wikipedia repetă în mod persistent aceleași lucruri pe care le-am auzit și le-am citit.
În marea majoritate a cazurilor, veți lucra cu metode de instanță.
Deci, metoda instanței. Să ne imaginăm că avem un program în care vom folosi 2 clase: Primus și Kitchen.
Orice clasă (cu excepția abstractelor) are metode și/sau funcții. O clasă poate avea mai multe metode cu semnul „+” în fața numelui metodei (metoda clasei) și mai multe metode cu semnul „-” în fața numelui metodei (metoda instanței). Acestea sunt metodele pe care le folosim în mod activ cu semnul „-” în legătură cu obiecte - instanțe ale clasei și ale clasei în sine. Și metodele cu semnul „+” pot fi aplicate numai clasei în care a fost declarată această metodă.

Ce este o instanță a unei clase?

Sună mândru, dar nu este clar. Cine își amintește de curs şcolar: În geometrie, un punct este părintele unui cerc, al unei linii și al altor forme, deoarece fiecare formă este formată din mai multe puncte.
O clasă pentru Objective-C, pe unele resurse este interpretată ca obiect și invers. De fapt, este un pic dezactivat. Putem spune că un obiect este o instanță a unei clase. Ca exemplu specific al unui primus în bucătărie, este o copie a tipului „Primus”: cu butoane, un arzător etc. Acesta nu este doar un primus - este primul tău. Clasa este un exemplu de urmat. Un exemplu exemplu de ceva care poate îndeplini și unele funcții datorită metodelor de clasă (cu semnul „+”). Îl poți citi puțin mai detaliat.
Există, de asemenea, „protocoale” și „clase de abstract”. Aici totul este mai interesant, dar pragul de înțelegere este mai mare decât cel al unei clase și al unui obiect. Diferența este că un „protocol” nu poate avea o subclasă sau un obiect copil care nu moștenește de la acesta, trebuie să se conformeze acestuia. Ca cerință la angajare. Aplicarea protocoalelor în viata reala Voi atinge în acest articol. O clasă abstractă este o entitate care este ca o clasă, dar nu chiar o clasă concretă și, prin urmare, abstractă. De exemplu, din nou, casa dvs. Primus este o instanță a clasei „Primus”, și nu o clasă abstractă „Aparat de încălzire”. Nu poți avea un dispozitiv de încălzire acasă fără un clan și un trib (poate fi și un șemineu și un calorifer). Astfel, clasa „Primus” poate fi un succesor al clasei abstracte „Aparat de încălzire”. Și primus-ul tău este un exemplu de definiție specifică a unui primus. Și pentru atributele sale - proprietăți, metode, protocoale, atunci când este folosit, se întoarce la clasa sa și verifică ce poate face, ce nu poate face și chiar ce poate avea la dispoziție.
Să ne imaginăm că există o anumită clasă „Arzător cu gaz” - moștenitorul clasei abstracte „Dispozitiv de încălzire”. Clasa „Arzător cu gaz” va fi clasa părinte pentru „Primus” și „Sobă cu gaz”. Pentru a vă apropia de programare, trebuie să faceți puțin abstract.
Objective-C are o clasă părinte NSObject. Într-un limbaj de programare este ca un punct în geometrie. Acest clasa perfecta: nu este nimic de prisos în ea, nu face nimic specific, dar poți crea orice din ea. Acesta este blocul de construcție al universului. Dacă țineți apăsat butonul „Comandă” în Xcode și faceți clic pe NSObject, conținutul fișierului NSObject.h se va deschide în fața dvs. Conține aproximativ 200 de rânduri de descriere a diferitelor metode. Există metode cu semnul „+” în fața numelui, precum și metode cu semnul „-”. Esența metodelor cu semnul „+” este că ele pot fi aplicate doar direct la NSObject în sine. Această metodă este, de exemplu,

+(id) aloc;
și îl poți folosi doar așa:

;
Orice alt obiect din Objective-C este, prin definiție, un descendent al NSObject. Se implementează metode suplimentare, care îi conferă trăsături de personalitate. Să spunem că acesta este NSResponder. Acest descendent - NSResponder - poate avea și obiecte copil. De exemplu UIView. Mai departe de-a lungul arborelui de moștenire, puteți lua ca exemplu UIScrollView. Apoi - UITableView. În fiecare caz, descendenții dobândesc funcționalități suplimentare. Pe lângă faptul că știu să facă ceva propriu, individual, pot face tot ce ar putea face strămoșul lor. Asta e - moştenire.
Dacă nu doriți ca clasa descendentă să copieze în mod absolut comportamentul clasei părinte, atunci puteți reface orice metodă a clasei părinte după bunul plac. Aceasta este - polimorfism.
În programele dvs., veți lua clasa de care aveți nevoie și îi veți adăuga metodele necesare - extindeți funcționalitatea acesteia. De asemenea, poți lua o clasă pe care ai creat-o și să-i faci descendentă, extinzând din nou funcționalitatea și creând în același timp un instrument unic pentru a rezolva problema dorită. Mecanismul descris se numește crearea de subclase.
Nu voi intra în descrieri ample ale metodelor cu semnul „+”. Va fi mai clar să se arate că aplicarea metodei

+(id) aloc;
pentru orice clasă sau subclasă, alocă cantitatea necesară de memorie în memoria RAM a computerului pentru aceasta.


Aplicarea metodei

-(id)init;
inițializează obiectul, îi alocă spațiu în RAM și, după aceea, obiectul începe să existe și poate fi lucrat.


Aceste 2 metode ("alloc" și "init") tocmai au creat un obiect "obiect". Și obiectul dat este o instanță a unui obiect sau o instanță a clasei NSObject. Dacă aceste metode sunt aplicate separat

NSObject *obiect = ; ;
atunci va fi creat și obiectul. Dar există o probabilitate diferită de zero ca să creați obiectul greșit căruia i-a fost alocată memoria. Să spunem apelarea unei metode

NSObject *obiect = ;
i-a alocat o astfel de adresă în memorie

0x000000000
Acest lucru se întâmplă deoarece în timpul inițializării, mediul de rulare setează toate obiectele la valoarea „nil” pentru a evita referirea la o locație de memorie plină cu „gunoi”. Sau referiri la un alt obiect specific, care de fapt este deja „gunoi”, pentru că și-a încheiat ciclul de viață și nu mai este „stocat” în memorie, ci pur și simplu „localizat”. Pentru a înțelege ce este „gunoiul”, creați un program simplu în care declarați

Int i;
fără a-i atribui o valoare și apoi tipăriți-i valoarea pe consolă

NSLog(@"%i", i);
Vei fi surprins de ceea ce înseamnă „i” tău.
Va fi creată și o instanță a obiectului „isa”, care va fi discutată mai târziu. Acesta este singurul pointer non-null atunci când vă creați obiectul. Să presupunem că acesta este un fir către un obiect părinte, care va genera propria instanță și va da viață obiectului nostru.
Adică, teoretic, obiectul există deja după aplicarea metodei „alloc”. Dar nu va putea trece testul

Dacă (!auto)( ... )
O astfel de bucată de cod poate fi văzută în orice obiect șablon din metoda „init” sau derivatele sale.
În acest caz, obiectul pare să existe, dar în principiu este egal cu „nul”. Un obiect neinițializat este ca o mașină pe care tocmai ești pe cale să o cumperi pe credit. Se pare că este, dar nu este al tău. Și dacă, fără a părăsi casa de marcat, folosește metoda „init”.

NSObject *obiect = [init];
apoi „Bingo!”, iar obiectul îți aparține, poți face ce vrei cu el. Dar dacă îi aplicați metoda

;
apoi un alt obiect poate fi inițializat. Se pare că ai plătit un împrumut pentru o mașină, dar s-a dovedit că a fost pentru mașina greșită și în loc de o mașină îți dau alta. La prima vedere, nu se pot distinge unul de celălalt. Dar au numere „VIN” diferite, ceea ce înseamnă că la verificarea la postul de poliție rutieră vei fi informat că mașina nu este a ta. O explicație extinsă a acestui fenomen va fi dată mai jos.
După cum ați înțeles deja, metoda „+alloc” este o metodă de clasă, iar metoda „-init” este o metodă de instanță.
Permiteți-mi să vă dau un exemplu cu lucruri reale.
Implementarea completă a metodei include de obicei 2 fișiere cu extensiile *.h și *.m. Poate exista un număr diferit, în funcție de ce fel de clasă este și ce obiective urmărește.
Există o clasă „Primus” în programul tău. Următoarele metode sunt declarate în fișierul Primus.h:

Primus. h //Metoda clasei, poate fi aplicată numai la clasa "Primus" +(Primus *) hotAsHell; //metoda instanță, inițializează o instanță a clasei „Primus” //metoda instanță, setează parametrii flacără //metoda instanță, dar aplicarea acesteia la clasa curentă apelează o instanță a unui obiect complet diferit -(MasterPoRemontu *) masterPoRemontuWithServiceItems: (NSArray *)i serviceSkills: (NSArray *)s;
Programul are, de asemenea, o clasă „Bucătărie”, în care următoarele metode sunt declarate în fișierul „Bucătărie.h”:

Metoda Kitchen.h //clasă, creează o instanță a obiectului „Bucătărie” și se aplică direct obiectului „Bucătărie” +(Bucătărie *) bucătărieMobilă:(NSArray *)mobilier otherDishes:(NSArray *)dish; //metoda instanței, aplicând-o în bucătărie apelează o instanță a altui obiect -(UkrainianBorsch *) borschWithIngredients:(NSarray)ingredients casserolAndPan:(NSArray)pan;

În fișierele „Primus.m” și „Kitchen.m” trebuie implementate toate metodele declarate, adică descrise: cum și ce se întâmplă în fiecare metodă.
Dacă intenționați să creați o instanță a unui obiect dintr-o altă clasă din orice clasă, atunci în antet va trebui să importați fișierul *.h al obiectului creat, de exemplu, în antetul fișierului Kitchen.h. va scrie


#import „Primus.h”
Adică, va fi posibilă crearea clasei „Primus” în cadrul clasei „Bucătărie”.
Deoarece am importat fișierul antet Primus.h în fișierul „Kitchen.h”, în clasa „Bucătărie” acele metode ale instanței clasei „Primus” care sunt declarate în fișierul Primus.h au devenit disponibile pentru noi. Ele pot fi aplicate fie unei clase, fie unei instanțe a clasei Primus.
În fișierul Primus.m, trebuie să implementați toate metodele care au fost declarate în fișierul Primus.h, dar puteți implementa și orice metodă care nu este declarată în fișierul antet Primus.h. Această metodă va fi accesibilă numai din interiorul clasei și nu poate fi apelată din altă clasă din program. De asemenea, puteți crea variabile în interiorul fișierului Primus.m - nici ele nu vor fi disponibile pentru uz extern. Pur și simplu nu știu despre ei. De aceea un fișier *.h se numește interfață de clasă. Doar ceea ce este menționat în mod explicit în el este accesibil din exterior către clasa în care este scris #import „Primus.h”. Inaccesibilitatea metodelor și variabilelor către alte părți ale programului se numește - încapsulare.

Mai întâi, să creăm o instanță a clasei „Primus” în cadrul clasei „Bucătărie”.


După cum puteți vedea, trimitem metoda cu „+” nu la o instanță a clasei „myPrimus”, ci direct la clasa „Primus”. A fost creată o instanță a clasei „Primus” numită „myPrimus”. În viitor, metodele din „Primus.h” cu semnul „-” vor fi aplicate unei instanțe a clasei „myPrimus”. Și dacă dorim să creăm o nouă instanță a clasei „Primus”, putem folosi din nou metoda „+hotAsHell”. Tot în clasa „Primus” există o metodă

-(id) initWithGas:(Gas *)temperatura gazului:(NSInteger)t;
De obicei, toate metodele ale căror nume încep cu „init” fac același lucru ca metoda „init” a clasei NSObject, doar cu capabilități extinse. Și în acest caz, folosind metoda „init” din această perspectivă

Primus *myPrimus = [ initWithGas:Temperatura propan:750];
va crea un nou obiect din clasa Primus cu caracteristici unice.
În exemplul descris, a fost folosită o metodă cu argumente. În acest caz particular, este folosit pentru a crea o instanță a clasei „Primus” cu clar caracteristici date. Din denumirea caracteristicilor este clar că acest exemplu din clasa Primus va funcționa pe gaz propan și la o temperatură de 750 de grade.
Rețineți că numele metodelor din Objective-C sunt destul de semnificative. Uneori vei fi uimit de titlurile lor de 10 cuvinte, dar asta te va ajuta să înțelegi mai bine ce este scris. În linii mari, codul se dovedește a fi auto-documentat. Ceea ce desigur nu exclude necesitatea de a scrie comentarii. Dar dacă faceți o regulă pentru a vă crea propriile metode, al căror nume va purta o încărcare semantică și va avea legătură cu crearea de variabile în același mod, atunci numărul de comentarii din cod poate fi redus semnificativ.
Spre deosebire de alte limbaje de programare, în Objective-C metodele nu sunt numite, ci mai degrabă trimise la obiecte. Astfel, această limbă se referă la „limba orientată pe mesaje” în rusă nu sună atât de strict, așa că nu ofer o traducere.
De asemenea, rețineți că toate metodele care, după trimiterea către un obiect, creează (întorc) un nou obiect au între paranteze după „+” sau „-” fie numele specific al obiectului a cărui instanță o vor returna, fie „id”. Adică prin ce obiect este indicat între paranteze imediat după semnul „+” sau „-”, putem judeca ce vom primi după trimiterea acestei metode. Ce este „id”? Acesta este un tip de obiect care poate lua forma (tipul) oricărui alt obiect. Să presupunem că acesta este un tip de obiect „slab”. Nu în sensul că ceva este „slab” pentru el. Vorbind în termeni general acceptați, acesta este un obiect slab tastat. Prezența unor astfel de obiecte într-o limbă îl face slab tipărit.
Puteți găsi, de asemenea, tipul „void” în aceleași paranteze.

Ce este „golul”?

Toată lumea spune: „Acesta este atunci când o metodă nu returnează nimic”. De ce este nevoie? Folosirea acestui tip de metodă produce încă manipulări cu obiecte, structuri și numere. De asemenea, obiectele și cantitățile scalare incluse în el ca argumente se pot schimba sau dispărea cu totul. Totul depinde de ceea ce este implementat în fiecare metodă specifică. Cert este că „golul” nu returnează nimic... nou. După cum s-a spus, argumentele incluse în acesta se pot schimba singure sau influența alte obiecte care sunt manipulate în metodă cu „void”. Poate chiar să creeze noi obiecte în interiorul său, dar nimic nu este returnat în mod explicit în exterior. De obicei, o metodă care returnează ceva are cuvântul cheie „return” la sfârșit. Dar o metodă precum „void” nu are „întoarcere” la sfârșit. El o poate avea în propriile bucle sau condiții, astfel încât să le poată întrerupe la locul potrivit. Dar nu la final. Metoda nu creează nimic fundamental nou, pur și simplu, lucrând cu un pointer către un obiect (număr, matrice, celulă etc.), modifică datele de la această adresă sau le folosește pentru a calcula alte date pe care le atribuie altor obiecte.

Ce este „sinele”?

Acest cuvânt este foarte des folosit oriunde. Însuși faptul utilizării sale în tot felul de locuri introduce confuzie în depozitele ordonate ale cunoștințelor tale.
Să revenim la orele Primus și Bucătărie. Să luăm o metodă specifică a clasei „Primus” și să luăm în considerare cum va arăta implementarea acesteia în fișierul „Primus.m”. De exemplu, aceasta este o metodă.

-(void) doFireWithGas:(Gas *)gaz;
poate fi implementat astfel:

-(void) doFireWithGas:(Gas *)gaz ( id myPrimus; if (!self)( myPrimus = ; ) ... ... ... )
Implementarea sau „implementarea” metodei are loc în acolade. În acest caz, implementarea metodei se citește astfel: dacă nu myPrimus, atunci executați comanda

;
care la rândul său scrie: inițializați-vă cu gaz: temperatura gazului: 750. Adică, metoda este trimisă către ea însăși și nu către alt obiect. În acest caz, „self” este clasa „Primus”, deoarece metoda se află în interiorul clasei „Primus”. Declarația sa se află în dosarul Primus.h iar implementarea sa se află în dosarul Primus.m.
De asemenea, puteți observa că metoda nu returnează nimic „void”. Adică, se dovedește a fi un joc de cuvinte: dacă nu există primus, atunci îl creăm, dar nu iese din metodă. De ce să-l creez atunci? Să presupunem că funcționalitatea sa este implementată astfel:

Id myPrimus;
Și aici este deja clar că undeva în interiorul metodei apare un primus reparator.
De ce a fost folosit semnul exclamării "!" între paranteze după „dacă”? În programare, acesta este un semn negativ. Adică „!=" sună ca „nu este egal”. Această metodă de afecțiune este convenabilă datorită conciziei sale. ÎN în acest exemplu a fost posibil să se utilizeze o condiție cu o structură diferită care ar avea aceeași funcție.

Dacă (myPrimus == zero)()
Această condiție este de două ori mai lungă și trebuie să citiți întregul rând pentru a o înțelege. Această condiție este mică, dar dacă trebuie să scrieți așa ceva

Dacă ((myPrimus == nil || yourPrimus == nil) && (mamaPrimus == nil || papaPrimus == nil))()
atunci această structură

Dacă ((!myPrimus || !yourPrimus) && (!mamaPrimus || !papaPrimus))()
va fi într-o poziţie mai avantajoasă, atât din punct de vedere al conciziei cât şi dimensiune fizică. Construcția anterioară este banală și poate pur și simplu să nu se potrivească într-o singură linie.
Să luăm în considerare cum ar arăta implementarea acestei metode în cadrul clasei „Bucătărie”. În fișierul Kitchen.m, aceeași metodă ar fi implementată astfel:

-(void) doFireWithGas:(Gas *)gaz ( Primus *myPrimus; if (!myPrimus)( Primus *myPrimus = ; ) MasterPoRemonty *master = ; ... ... )
Se poate observa că aici trebuie să indicați ce obiect va fi creat, ce instanță va fi numită și apoi să trimiteți metoda direct la clasa părinte.
Adică, cuvântul complicat „self” este folosit în interiorul clasei, ca și cum ai fi creat deja o instanță a acestuia.

Primus *myPrimus;
și accesați o instanță a clasei. Singurul truc este că nu ați creat nimic și nu accesați instanța, ci direct la clasă. Pentru claritate, am creat un obiect

Id myPrimus;
care poate fi accesat printr-o metodă. Dar a fost posibil să nu o creăm, ci să implementăm o structură mai complexă care să îndeplinească aceleași funcții

Dacă (!self)( MasterPoRemonty *master = [ masterPoRemontuWithServiceItems:someItemsArray serviceSkills:someSkillsAray]; )
Pentru a înțelege dacă puteți scrie „self” sau nu, imaginați-vă ce metodă către ce obiect doriți să trimiteți și începeți să tastați cuvântul „self”, dar nu complet, de exemplu „sel”. Xcode va oferi mai multe opțiuni, printre care se va număra „self”. În stânga acestuia va fi o descriere a clasei. Dacă aceasta este exact clasa căreia ați vrut să trimiteți metoda dorită (clasa în cadrul căreia efectuați în prezent acțiunea), atunci utilizați „self”. Dacă Xcode indică faptul că „self” nu este obiectul de care aveți nevoie, atunci utilizați numele clasei sau instanței de care aveți nevoie.
De asemenea, este clar că aici au fost implicate argumente. Fiecare argument are un tip, care este descris și în paranteze, dar după două puncte. După paranteze cu tipul argumentului urmează numele argumentului. Dacă există un „*” în paranteze după tipul de argument, atunci este un obiect. Dacă nu există semnul „*”, atunci acesta tip scalar, cum ar fi „NSInteger”, care este în esență un simplu „int”. De asemenea, „NSInteger” poate fi cu semnul „*” pentru argumentul transmis. În acest caz, nu vom schimba variabila în sine, ci indicatorul către ea. Subiectul Indexurilor depășește domeniul de aplicare al acestui articol. Numele argumentului din această metodă

-(void) doFireWithGas:(Gas *)gaz;
va suna ca „gaz”. Ați observat că implementarea nu a folosit numele normal pentru gaz? De exemplu "Propan". Faptul este că argumentul „gaz” transmite numele necesar al gazului. Unde? Ne-am uitat la modul în care este implementată metoda

-(void) doFireWithGas:(Gas *)gaz;
A implicat o metodă

-(id) initWithGas:(Gas *)temperatura gazului:(NSInteger)t;
Această metodă a avut 2 argumente „gaz” și „t”. Când trimitem metoda către obiect, am indicat temperatura și pur și simplu am duplicat tipul de gaz din metodă

-(void) doFireWithGas:(Gas *)gaz;
Adică această metodă este trimisă și undeva. Să aruncăm o privire mai atentă asupra metodei

(Primus *) hotAsHell;
Implementarea sa ar putea arăta astfel

+(Primus *) hotAsHell( self = ; if (self)( ; ) return self; )
Observați semnificația argumentului „propanButan” trimis. Aceasta este transmisă în toată clasa, de la metodă la metodă.
De asemenea, puteți vedea aici că metoda este trimisă obiectului în anumite condiții.
Trebuie să știi că niciuna dintre metodele tale nu poate funcționa singură. Are nevoie de o lovitură din afară. Când un buton este apăsat, are loc un eveniment sau are loc un eveniment, acesta trebuie să fie declanșat printr-o metodă de protocol care rulează timpul de execuție în momentul de care are nevoie. Această metodă „hotAsHell” este trimisă numai după un apel explicit, nu este o metodă de sistem, trebuie de asemenea înregistrată undeva sau atribuită la ceva.
Acum să ne uităm la metodă

-(id) initWithGas:(Gas *)temperatura gazului:(NSInteger)t;
Este format dintr-un tip de returnare, tipuri de argumente, argumente și un selector. Un selector este ceea ce rămâne dintr-o metodă atunci când tipul obiectului returnat, tipul argumentelor și argumentele sunt luate din el.

InitWithGas:temperatură:
cu două puncte. Dacă nu există argumente, atunci nu există nici două puncte, ca în cazul „hotAsHell”. De multe ori te vei confrunta cu nevoia de a folosi un selector. Acum știi ce să mănânci.
Conceptul „super” a fost folosit puțin mai sus.

Ce este „super”?

Luați în considerare metoda „hotAsHell” implementată mai sus. Are acest design

Sinele = ;
Așa se obișnuiește să inițializezi o clasă copil - prin inițializarea părintelui.
Să presupunem că clasa „Primus” este un descendent direct al clasei „NSObject”. Clasa care se află în ierarhia imediat deasupra clasei cu care lucrăm are dreptul să fie numită „super”. Echipă

;
Apelează metoda init a instanței NSObject. Adică, o instanță a progenitorului tuturor obiectelor - NSObject - este creată automat, cu parametrii impliciti (pur ai NSObject) Trimiterea metodei "init" NSObject"y returnează "self" de la NSObject"a al NSObject"a însuși. Și această instanță este atribuită obiectului nostru „Primus”. La urma urmei, „sinele” în acest caz este tocmai „Primus”. Și în această etapă obținem o instanță a obiectului „Primus”, care nu este diferit de NSObject. Premisa metodei noastre îi oferă caracteristici individuale

;
precum și alte metode implementate în cadrul acestei clase.
Proiecta

Dacă (auto) (...)
aceasta este doar reasigurare în cazul în care ceva nu merge bine și nu este creat un Primus implicit. acestea. metoda init a clasei părinte nu va fi executată. În acest caz, de obicei o fac

Altfel (...)
unde încearcă să corecteze situația, dar, din păcate, nu este cazul și „altceva” nu ne va mai ajuta.
Și aici vreau să vă reamintesc despre obiectul neinițializat de la începutul articolului. Atunci când o instanță de obiect este inițializată de superclasa sa, i se atribuie o locație de memorie și este transmis un pointer către această locație de memorie. Și când verificăm

Dacă (self = )
atunci chiar în acest moment „sinele” poate primi o adresă neașteptată în memorie. Adică, indicatorul rezultat nu va mai fi „self”. Superclass nu ne va întoarce ceva ieșit din comun. Instanța obiectului va fi identică cu cea cu care vom lucra. Dar o instanță a acestui obiect anume nu va fi instanța de care avem nevoie. Aceasta este o eroare atât de rară încât este posibil să nu o vedeți în aplicațiile dvs. pentru o perioadă foarte lungă de timp. La un moment dat, aplicația dvs. poate începe să producă erori exotice. Ca urmare, va trebui să petreci timp găsindu-le cauza. Memoria alocată pentru obiectul dvs. nu a fost folosită. Un pointer aleatoriu care nu avea nicio legătură cu obiectul căruia i-a fost alocată memoria folosind metoda „alloc” putea fi inițializat. Atunci „sinele” pică testul

Dacă (auto) (...)
În metoda de inițializare luată în considerare. Și totul pentru că la un moment dat în program, când acest obiect a fost apelat, inițializarea nu a fost efectuată corect.
Ultimul lucru pe care trebuie să-l facem pentru a finaliza inițializarea este

Întoarce-te pe sine;
Deoarece această metodă nu este „nulă”, se așteaptă să îi spunem ce să returneze la sfârșit. În acest caz, va fi returnat un obiect de tip „Primus”, deoarece „self” din această clasă este tocmai „Primus”. De asemenea, tipul obiectului returnat ne spune că „Primus” este de așteptat.
În aceste metode

+(Bucatarie *) bucatarieMobila:(NSArray *)mobila alteleVase:(NSArray *)vase; -(UkrainianBorsch *) borșWithIngredients:(NSarray)ingredients casserolAndPan:(NSArray)pan;

-(MasterPoRemontu *) serviceItems:(NSArray *)i serviceSkills:(NSArray *)s;
tipul de obiecte returnate este „Bucătărie”, „UkrainianBorsch” și „MasterPoRemontu”. Astfel, în metoda „hotAsHell” spunem că la sfârșitul execuției acestei metode dorim să primim un obiect de tip „Primus” cu.

parametrii dați

Care sunt exact parametrii specificati?

Să descriem o astfel de implementare a metodei
- (id) initWithGas:(Gas *)temperatura gazului:(NSInteger)t ( ... ; ; ... )

Aceasta înseamnă că atunci când apelați această metodă
Primus *myPrimus = [ initWithGas:metan temperature:500];

; ;
literal sunt setati urmatorii parametri
Parametrii sunt setați la variabilele care sunt declarate în fișierul *.h

Acordați atenție construcției cuvântului „setGas” sau „setTemperature”. Dacă există o variabilă, de exemplu „variabilă”, atunci o puteți seta la valoarea dorită folosind prefixul „set”:
SetVariable
în acest caz, prima literă a variabilei devine majusculă. Astfel, am aflat că variabilele „gaz” și „temperatură” au fost declarate în fișierul Primus.h. Dar însăși prezența variabilelor nu ne oferă posibilitatea de a le atribui folosind prefixul „set”.

Pentru a realiza această caracteristică, trebuie să declarați proprietăți pentru aceste variabile. Sa spunem:

@proprietate (nonatomică, puternică) Gaz *gaz; @property (nonatomice) NSInteger temperatură;

Și în fișierul de implementare va trebui să scrieți
@gaz de sinteză, temperatură;
și numai după aceasta va fi posibil să le atribuiți valori prin „setGas” și „setTemperature”. Aceste prefixe se numesc setters.

; ;
În orice moment convenabil, puteți cere obiectului Primus să vă arate aceste valori accesând instanța acestuia

sau
MyPrimus.gas; myPrimus.temperatura;

de exemplu pentru o echipă
NSLog(@"Primusul de gaz funcționează cu marca de gaz %@, temperatura de funcționare %i", , myPrimus.temperature);
Aceste metode sunt numite getters. Când accesați valori din numele variabilei, nu trebuie să adăugați nimic.

;
Rețineți că proprietatea unui obiect poate fi accesată fie prin construct

si prin
MyPrimus.gas;
Există un truc atunci când accesați variabile obiect. Acest lucru se poate face nu numai prin proprietăți, ci și prin accesul la acestea folosind principiul cheie-valoare „codare cheie-valoare”. Adică puteți accesa variabila

si prin
Asa de

;
Am accesat valoarea care se află în obiectul „Primus” în cuvânt cheie"gaz".
Și acest design

;
în contextul „codării cheie-valoare” va arăta astfel

;
Utilizarea „codării cheie-valoare” în loc de proprietăți este o sarcină destul de obositoare. Dar este necesar să aveți o înțelegere a acestuia, astfel încât în ​​cazurile în care nu vă puteți lipsi de el, să îl puteți folosi.
De asemenea, ar fi util să subliniem faptul că, recent, variabilele nu mai sunt folosite în programarea Objective-C. Proprietățile sunt folosite în schimb. Proprietățile pot fi fie accesibile din exterior, fie încapsulate. Desigur, variabilele pot și ar trebui să fie utilizate pentru utilizarea în interiorul metodelor. Dar declararea variabilelor în blocul „ivar”, care se află în interfața clasei, este deja un anacronism.

timpul de rulare

Chiar dacă acest lucru nu s-a întâmplat încă, există șansa ca în curând să întâlniți cuvântul „runtime” în documentație și, în cadrul aceluiași articol, cuvântul „isa”.
Conceptul de „runtime” poate fi descris ca „mediul în care codul tău este tradus în cod de nivel inferior”. „runtime” este scris direct folosind C și Assembly. Aceasta nu este încă o traducere în cod automat, ci o reducere a codului dvs. la limbaje C și Asamblare. Metoda ta

;
în „runtime” în C arată cam așa

Objc_msgSend(myPrimus,@selector(initWithGas:temperature:),gelium,nil);
Acest lucru ar trebui să fie suficient pentru ca un programator novice Cocoa să înțeleagă: este mai bine să nu mai intri în buruieni. Imediat ce vei trece pragul de aderare la club, vei putea găsi informațiile de care ai nevoie.

Deocamdată, ne interesează ce este „isa”.

Aceasta este o variabilă care este declarată direct în NSObject. Singura ei variabilă. Când am numit metoda

;
atunci a fost creată nu numai o instanță a clasei NSObject, ci și o instanță a acestei variabile „isa”, care se referă la NSObject. Adică, îi spune în mod specific timpului de execuție că aparține unui NSObject. Aceasta înseamnă că trebuie să lucrați cu o instanță a obiectului dvs. nou creat în același mod ca și cu un NSObject. Un pointer către obiectul părinte pe care trebuie să-l moștenim este scris în „isa”. Să presupunem că obiectul tău este un descendent al NSArray sau UITableView sau CFDictionaryRef sau al oricărui alt obiect. Într-un astfel de caz, „isa” indică un NSArray sau un UITableView sau un CFDictionaryRef sau, respectiv, orice alt obiect. Deci, crearea unei instanțe a oricărui obiect creează și o variabilă de clasă - „isa”, care se referă direct la clasa părinte, drept urmare „runtime” știe ce va face cu fiecare instanță.
Aceste informații în stadiul de învățare sunt necesare nu pentru ceva specific, ci, în principiu, pentru o înțelegere mai cuprinzătoare a filozofiei de programare Objective-C.
În procesul de citire a cărților și a diverselor documente, veți întâlni conceptul de „singleton” de mai multe ori. După cum spune o meme populară de pe Internet: „Nu poți să iei și să înțelegi imediat ce este un „singleton”. 


Ce este un singleton?

Să ne imaginăm că trebuie să creați un obiect care returnează aceeași instanță de fiecare dată când este apelat oriunde în aplicație. De fapt, în procesul de creare a aplicațiilor, va trebui de fapt să creați una. Deci, de ce nu puteți crea un obiect de mai multe ori și să îi atribui aceleași date prin metoda „initWithSomething:” sau folosind setari? Totul este să lucrezi cu memorie și viteză și să petreci, de fapt, mai puțin timp scriind cod. Există întotdeauna puțină memorie și chiar și atunci când pun 2 GB de RAM pe iPhone6, din nou nu va fi suficient. Crearea unei instanțe a unui obiect și apoi accesarea acestuia economisește resursele dispozitivului și accelerează aplicația. Dar toată lumea își dorește ca aplicația lor să fie la fel de rapidă ca un „Bugatti Veyron” și la fel de utilizabilă ca cuvântul „hrean”.
Să spunem că „Primus”-ul nostru poate fi foarte bine un singleton. Apoi metoda lui

+(Primus *) hotAsHell;
când va fi implementat, va arăta așa

+(Primus*) hotAsHell( static Primus *myPrimus = nil; predicat static dispatch_once_t; return myPrimus; )
Să ne uităm la ce înseamnă asta mai târziu. Deocamdată, să aflăm de ce „Primus” ar trebui să fie făcut un singleton.
Să spunem că acesta nu este un Primus complet obișnuit, ci unul rar. Este gravat de un artist necunoscut, are un consum de gaz extrem de mic, si are si o cutie speciala in care se incadreaza perfect. Acum pune-ți întrebarea: „Ai nevoie de un alt Primus?” Desigur că nu! Dar la trimiterea metodei

Primus *myPrimus = [ initWitGas:metan temperature:500];
va fi creat un „Primus”, iar la trimiterea metodei

Primus *myPrimus = [ initWitGas:propan temperature:600];
va fi creat un „Primus” complet diferit. Fara gravura si cutie.
Acum să revenim la ceea ce este scris în implementarea metodei „hotAsHell”.
Mai întâi, trebuie să creați o instanță a unui obiect cu proprietatea „statică” pentru a bloca accesul la obiect din exterior. Apoi atribuiți-o „nil”, astfel încât să nu ia o adresă aleatorie în memorie. Proiecta

Predicat static dispatch_once_t;
creează un predicat (condiție) - „predicat” care, de asemenea, nu va fi vizibil din exterior Condiția este că apelarea automată sau dinamică a blocului din spatele predicatului este interzisă

Dispatch_once (&predicate, ^(myPrimus = [ init];));
efectuează deja toate acțiunile necesare pentru a crea copie unică obiect. Mai exact, „dispatch_once” înseamnă că expresia din paranteze după aceasta este garantată să fie rulată o singură dată pe parcursul ciclului de viață al aplicației. De asemenea, „dispatch_once” garantează siguranța firelor. Adică, atunci când rulați aplicația în modul cu mai multe fire, această funcție nu va fi apelată simultan în mai multe fire și cu siguranță nu va crea un alt „Primus” unic pentru noi. Există și un bloc

^(myPrimus = [init];)
Este ca o mică funcție sau metodă. Există și blocuri mari. În acest bloc, obiectul părinte este inițializat, după care valoarea acestuia este atribuită copilului myPrimus.
Toată linia împreună

Dispatch_once (&predicate, ^(myPrimus = [ init];));
înseamnă: o dată pe parcursul întregului ciclu de viață al aplicației, o instanță a obiectului „Primus” numită „myPrimus” va fi inițializată cu proprietățile obiectului părinte și nu va exista nicio modalitate de a accesa acest bloc în niciun alt mod. Dar nimeni nu va ști că „myPrimus” a fost creat, deoarece această instanță a obiectului nu este vizibilă din exterior. Totul se întâmplă în fundal și o singură dată. Și se întâmplă datorită GCD (Grand Central Dispatch). Povestea despre care este un subiect separat.
Și bineînțeles că la sfârșit returnăm singleton-ul creat

Returnează myPrimus;
Avem Singleton - „Primus”, acum îi putem adăuga proprietăți: casetă - „Cutie”, gravură - „Gravare”, eficiență - „Performanță”. Și dacă declarați proprietăți pentru ele, atunci puteți modifica aceste variabile din exterior. Acoperiți cutia, curățați gravura, ciobiți „Primus”-ul nostru pentru a crește eficiența. Dar va rămâne bunul nostru vechi „Primus”. Accesul extern la obiectul „Primus” va fi disponibil acelor clase în antetul cărora este declarat. Dar acum, dacă faci asta

Primus *myPrimus = ;
și apoi lucrați cu „myPrimus” ca singleton, atunci nimic nu va funcționa. Toate accesele la variabilele singleton trebuie să aibă loc în felul următor

Box *someBox = .Box;
în acest fel puteți crea o instanță de „someBox” dintr-o clasă complet diferită de cutii și îi puteți atribui valoarea pe care o are cutia singleton-ului nostru sau invers

Box = someBox;
schimba cutia Primusului nostru.
Un singleton poate fi folosit atunci când trebuie să apelați NSLog cu o descriere a proprietăților singleton-ului, dar singleton-ul în sine nu se află în această clasă, în principiu. În acest caz, trebuie doar să îl declarați în antetul fișierului și să îl apelați o dată acolo unde este necesar. Singleton poate și chiar este recomandat să fie utilizat ca variabilă globală. Mai precis, proprietățile sale vor fi variabile globale.
După stăpânirea principiilor de bază, puteți începe să rezolvați problemele propuse în manuale. Și dacă vă puteți da seama să scrieți propriile metode în propriile clase și să trimiteți metoda către un obiect, atunci va trebui să utilizați delegați, protocoale și alte MVC în viitor. Va fi necesar să folosiți documentația Apple și să aplicați mii de metode diferite create și descrise cu atenție de programatorii Cupertino.
Și aici devine neclar în principiu cum și ce funcționează. Dacă metoda pe care ai creat-o creează o matrice în interiorul ei, apoi adaugă obiecte la ea, apoi începe o buclă și face ceva în ea, iar apoi această metodă lansează o altă metodă a ta, atunci totul pare clar. Dar acum deschideți documentația pentru obiectul care vă interesează și conține 20 de metode care pot face lucruri foarte interesante. În plus, există obiecte strămoși ale căror metode le poate accepta și acest obiect. În plus, la începutul articolului am scris despre protocoalele pe care le poate respecta un obiect. În total, pot exista sute de metode. Pe care ar trebui să-l folosești? Contraîntrebare: „de ce anume aveți nevoie de o metodă?” O întrebare adresată corect este deja jumătate din răspuns. Când înțelegeți ce doriți să faceți, puteți găsi metoda care vă interesează în descrierea clasei și o puteți aplica în scopul propus. Dacă doriți ca această instanță a unui obiect să facă ceva care este unic numai pentru clasa din care a provenit, atunci în documentația pentru această clasă trebuie să căutați cu atenție o metodă care efectuează operațiunile de care aveți nevoie. Trebuie să trimiteți această metodă la un obiect ca acesta

;
Adică, în documentație ați aflat că această metodă ia argumentul specificat „Cartof” și face ceva cu el care, în cele din urmă, vă conduce la obiectiv dacă aplicați metoda obiectului „myPrimus”. Nu este nevoie să implementați această metodă, este implementată pentru dvs aplicare directă. Excepțiile sunt atunci când trebuie să luați o clasă gata făcută din cadru și să o subclasați astfel încât atunci când trimiteți metode standard exemplul lui, au avut loc acțiuni non-standard.

Protocoale

Există și metode de protocol. După cum am indicat deja la începutul articolului, ei nu pot avea descendenți. Sunt pur și simplu o colecție de metode. Pentru a aplica o metodă de protocol intern, un obiect trebuie să se conformeze protocolului respectiv. Acest lucru este indicat în fișierul *.h

@interface Primus: UIViewController
În acest caz, obiectul corespunde două protocoale „UITableViewDataSource” și „UITableViewDelegate”.

Și care este diferența dintre metodele de clasă și cele de protocol?

Dacă intrați în descrierea acestor protocoale, puteți găsi metode pe care obiectul le poate implementa. Vă rugăm să rețineți: nu trimiteți metode de protocol către obiectul dvs., dar în interiorul lor trebuie să indicați cum ar trebui să reacționeze obiectul dvs. atunci când programul apelează aceste metode. Unele metode din protocoale pot fi obligatorii. Și dacă decideți că obiectul dvs. trebuie să respecte protocolul, atunci trebuie implementate mai întâi metodele obligatorii. În cadrul oricărei metode de protocol poate exista orice metodă de clasă. Adică, o metodă de protocol este un container în care se află orice alte metode, la fel ca orice metodă pe care o implementați. Trebuie să implementați funcționalitatea necesară în cadrul fiecărei metode de protocol în funcție de nevoile dvs. De exemplu, trebuie să vă faceți matrița să facă ceva în anumite condiții. De exemplu, și-a schimbat culoarea după ce a devenit activ/inactiv. Să mergem la documentația Apple și să vedem ce protocoale implementează metodele de care aveți nevoie. Apoi căutăm la ce protocoale corespunde clasa părinte a formularului. Dacă nu există protocoale care acceptă funcționalitatea de care aveți nevoie, set standard funcții, apoi adăugați-le la< >parantezele. În descrierea acestor protocoale, căutăm metode care sunt implementate după un eveniment. Sa spunem

-(UIColor *) areaDidChangeColor:(CGRect)rect isActive:(BOOL)activ;
care se execută automat când argumentul „activ” este evaluat la „DA”. Și schimbă culoarea în partea de ecran descrisă în „rect”:

(dacă (esteActive && myForm == rect)( myColor = ; ) return myColor; )
Metodele de protocol stabilesc parametrii de funcționare ai unei instanțe de clasă, schimbă funcționalitatea și transferă valori. De exemplu:

-(NSInteger) tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)secțiune;
returnează numărul de rânduri din secțiunea pentru tableView dată.

Lasă-mă să termin aici. Dacă articolul ajută publicul țintă, care m-a inclus acum câteva luni, înseamnă că gândesc corect și sunt necesare astfel de articole. Articolele nu sunt de la profesioniști, ci de la oameni care înțeleg ceva la un nivel greu de străbătut fără sprijin sau trambulină. Sper că acest articol va fi o trambulină sau măcar un scaun pentru cineva. Lipsa unor profesori buni care să poată explica ceva corect este o problemă fundamentală a timpului nostru. Nu am o educație pedagogică, dar articolul prezintă conceptul în programare într-un mod care mi-ar fi de înțeles personal.