[Powered by Google Translate] [სემინარი] [iOS: წერა პროგრამები მსგავსად Boss]
[Tommy MacWilliam] [ჰარვარდის უნივერსიტეტის]
[ეს არის CS50.] [CS50.TV]
>> ყველა უფლება, ყველას, კეთილი იყოს iOS: წერა პროგრამები მოსწონს Boss.
ეს სემინარი მიმდინარეობს ფოკუსირება წერილობით apps for iPhone
და თავის მხრივ წერილობით apps for iPad, და ა.შ. ჩვენ ძირითადად აპირებს გავლა
წყვილი სხვადასხვა მაგალითები, თუ როგორ გახადოს app, მარტივი თამაში, როგორიცაა Tic TAC Toe,
ან თუ თქვენ უფრო აინტერესებთ, მიღების app მოსწონს რაღაც ახალი ამბები მკითხველს
ან რაღაც, რომ ურთიერთქმედებს ინტერნეტ ვილაპარაკებ, რომ ისევე.
აი ჩვენი ხანმოკლე დღის წესრიგში.
>> IOS apps იწერება ენის მოუწოდა Objective-C,
და ა.შ. ეს ცოტა მსგავსი C მაგრამ ნამდვილად არ იყოს,
ამიტომ ჩვენ უნდა საუბარი ცოტა ენების შესახებ თავად
და შემდეგ როგორ უნდა ავაშენოთ iPhone apps გამოყენებისას app პროგრამის მოუწოდა XCode,
რომელიც თუ არ გადმოწერილი ამაზე მოგერიდებათ დაიწყოს ჩამოტვირთვა არის.
ეს რამდენიმე ადის.
ეს უნდა იყოს უფასოდ App Store, ასე რომ თქვენ უნდა აქვს Mac
იდეალურად გაშვებული ბოლო ვერსია OS X.
თუ თქვენ არ, არ არის პრობლემა.
ჩვენ გვყავს Macs წელს მეცნიერების ცენტრი ხელმისაწვდომია თქვენს
ერთად XCode დაყენებული და ასე მოგერიდებათ გამოიყენოს იმ განვითარებისთვის.
თუ გინდათ app მაგრამ არ აქვს Mac, არ ინერვიულოთ.
არსებობს უამრავი კამპუსში რესურსი, რომ.
და ასე შემდეგ ჩვენ ვაპირებთ დაფარავს 2 უფრო დიდი მაგალითები სხვადასხვა apps შეგიძლიათ.
Objective-C არის ტექნიკურად რასაც სუპერ კომპლექტი C.
ეს იმას ნიშნავს, რომ ნებისმიერი C კოდის ასევე მოქმედებს Objective-C კოდი.
ეს იმას ნიშნავს, რომ ჩვენ სახის სადინარში სატელეფონო ზოგიერთ დამატებითი თვისებების C.
ზოგიერთი ნიშნებია არ მქონე ოდესმე წერენ malloc ერთხელ, მადლობა ღმერთს,
არ მქონე ფიქრი იმ სულელური მაჩვენებლებისა და ათავისუფლებს მათ და ყველა რომ პერსონალი
თქვენ სძულდა შესახებ C, და მისი სახის Gone in Objective-C.
>> ახლა, Objective-C ასევე აქვს გაცილებით სტანდარტული ბიბლიოთეკა,
ამიტომ იქ ბევრი ფუნქციონალური თქვენ მიიღებთ უფასოდ შიგნით Objective-C.
დამახსოვრება როდესაც ჩვენ წერილობით PHP ჩვენ შევამჩნიეთ, რომ წავედით საწყისი
ამ პატარა ენის გიგანტი ბიბლიოთეკის ყველა ამ გიჟები რამ რისი გაკეთებაც შეგიძლიათ.
იგივე ხდება iOS.
არსებობს ობიექტების რამ, როგორიცაა ბუდისტი კალენდარი, და რეალურად არაფერი
თქვენ შესაძლოა ვიფიქროთ, ალბათ არსებობს უკვე Objective-C განხორციელებას.
ობიექტური ნაწილი Objective-C არის referencing რაღაც
მოუწოდა ობიექტის ორიენტირებული პროგრამირება.
ეს არის სახის ახალი კონცეფცია, მაგრამ ჩვენ რეალურად ძირითადად შეიტყო
ბევრი ეს კონცეფციები უკვე.
იდეა უკან ობიექტის ორიენტირებული პროგრამირება არის, რომ თქვენ აპირებს სტრუქტურირებაზე
ბევრი თქვენი კოდი გარშემო ეს ყველაფერი მოუწოდა კლასების,
და ეს კლასები ნამდვილად glorified structs.
შიგნით struct ჩვენ ძირითადად განაცხადა აქ რამ,
და ეს საგანი შეიძლება ჰქონდეს წევრები.
მაგალითად, node in უკავშირდება სია შეეძლო სხვა რამ
მოსწონს ღირებულება, მომცეთ შემდეგი კვანძის სიაში,
და ერთად რომ მომცეთ და რომ ღირებულება შედგება ამ ერთი შემთხვევის struct.
კლასები ძალიან ჰგავს გარდა
კლასები შეიძლება ასევე აქვს ფუნქციების შიგნით მათ.
როდესაც ჩვენ განაცხადა struct, შეიძლება მხოლოდ ამბობენ int n ან კვანძის * შემდეგი.
>> არის ობიექტური-C შეგვიძლია რეალურად დააყენა ფუნქციები
შიგნით იმ რამ.
სხვა საქმეა, რომ კლასების შეგიძლიათ გააკეთოთ მათ შეუძლიათ მემკვიდრეობით მონაცემებს სხვა კლასებს.
მაგალითად, ჩვენ უნდა ეძებს bunch of ჩამონტაჟებული Objective-C-კლასი.
ერთი მათგანი შეიძლება იყოს კლასის, რომელიც წარმოადგენს view for ეკრანზე,
და ასე განაცხადა მინდა განახორციელოს საკუთარი დასაწყისში
ჩვენ ძირითადად ამბობენ ვინმე ზე Apple, ალბათ მართლაც ლამაზი ადამიანები,
წერდა ამ კლასში ჩემთვის, და ეს სახელურები რამ, როგორიცაა ჩვენებისას ღილაკები
ან გაწევის ეკრანზე, და ჩვენ მართლაც pained
განახორციელოს ყველა რომ ფუნქციონალური თავს, და ასე უბრალოდ
inheriting მონაცემები, ჩვენ შეგვიძლია ვთქვათ, რომ ყველაფერი გააკეთეთ, რომ კლასის
მინდა ასევე შიგნით ჩემი კლასის, ხოლო შემდეგ მე ვაპირებ დაკავდით სხვა პერსონალი,
კერძოდ განახორციელოს app.
სწორედ რომ სიტყვა მემკვიდრეობის ნიშნავს. ჩვენ დავინახავთ, უფრო კონკრეტული მაგალითია.
>> და ბოლოს, გასაღების ობიექტის ორიენტირებული პროგრამირება არის, რომ
მას მივყავართ მონაცემები encapsulation.
ზოგიერთ ჩვენი პრობლემა ადგენს ჩვენ შეგვეძლო ამ დიდი, გლობალური ცვლადები
და globals ყველგან, და ასე მინდა ტრეკზე სახელმწიფო.
With კლასების ჩვენ შეგვიძლია დავიწყოთ encapsulating ინფორმაციას შიგნით ობიექტი.
თუ ჩვენ გვაქვს ერთი ეკრანზე ჩვენს app, ჩვენ ნამდვილად არ უნდა ჰქონდეს ნებისმიერი მონაცემების
კიდევ ერთი ეკრანზე ჩვენი app შიგნით რომ,
და ა.შ. მიერ encapsulating რამ ფარგლებში კლასების ამ ფაქტობრივად მივყავართ
უნდა ბევრად უკეთესი კოდი დიზაინი, და ეს შესაძლებელია ზოგიერთი დამატებითი ფუნქციები
ობიექტური-C.
Forewarning, სინტაქსი Objective-C არის ბანანი.
ეს იგივეა არაფერი ჩვენ ვნახეთ ადრე,
ასე რომ ცოტა სასწავლო მრუდი შეგუება
რა heck ნიშნავს ეს?
მაგრამ ერთხელ თქვენ წარსულში, რომ საწყის სასწავლო მრუდი ეს მართლაც, ნამდვილად გლუვი
დაიწყოს წერა ნაკადი.
>> განაცხადოს კლასის, ვთქვა აქ არის ჩემი კლასი, ის არსებობს,
და იქნებ აქ არის რამოდენიმე რამ, რომ მე ვაპირებ განსაზღვროს შემდეგ,
მე ვაპირებ ვთქვა @ ინტერფეისი.
მე ვაპირებ ვთქვა @ ინტერფეისი. მე აპირებს ჩემი კლასის სახელი.
და შემდეგ სხვაგან მე ვაპირებ ვთქვა @ end,
და ყველაფერი შორის @ ინტერფეისი და @ end
იქნება ჩემი კლასი.
რომ იქნება რა შიგნით ჩვენი. თ files.
ისევე, როგორც C ჩვენი. თ ფაილები ძირითადად განაცხადა აქ არის რამოდენიმე რამ, რომ იარსებებს.
მე აუცილებლად არ გეუბნებოდით რას აკეთებს მაინც,
მაგრამ შემდგენელი უნდა გაიგოს, რომ არსებობს.
მოგვიანებით შიგნით ჩვენი. მ files-რადგან m ობიექტური-C
სადაც ჩვენ რეალურად აპირებს განსაზღვროს რა ამ კლასების გავაკეთოთ.
ჰგავს ჩვენი. გ ფაილი, ჩვენ მოწოდებული განხორციელება ფუნქციები.
შიგნით ჩვენი. მ ფაილის ჩვენ ვაპირებთ ამბობენ აქ არის ის, რაც ყველა ფუნქციებს
შიგნით ჩემი საკლასო რაც მათ ყველა გააკეთებს.
და ბოლოს, შიგნით struct შეიძლება ითქვას შიგნით იმ Curly braces
int n ან კვანძის * მომდევნო,
და Objective-C ჩვენ ვაპირებთ გამოვიყენოთ სიტყვით @ ქონება,
და ეს არის ის, რაც ხდება, რომ განსაზღვროს თვისებები,
ან არასამთავრობო ფუნქციებს, რომლებიც ნაწილი ჩემი კლასი.
>> დარეკვის ფუნქციების Objective-C არის ასევე ბანანი.
როდესაც ჩვენ განაცხადა ფუნქციების C ვთქვით რაღაც int foo
და ღია PAREN და შემდეგ მისცა სიაში არგუმენტები.
ეს არის ის, რაც გამოცხადების მეთოდები ან ფუნქციების ჰგავს ობიექტური-C.
თუ მინდა განვაცხადო, ფუნქციის ან მეთოდი
სადაც მე ვარ ამბობდა მეთოდი მართლაც მხოლოდ ფუნქციას რომ წევრი კლასის,
ასე სახის ურთიერთშემცვლელნი, მაგრამ არა რეალურად,
ასე შიგნით ჩემი მეთოდი მინდა შეიქმნას ახალი მეთოდი.
ის დაბრუნებას აპირებს არაფერი, ასე რომ იქნება ტიპის ბათილად.
ეს არის დაბრუნების გაცნობის ჩემი ფუნქცია.
ახლა ჩვენ გვაქვს parens აქ იმიტომ-არ ვიცი.
შემდეგი იქნება სახელწოდება ჩემი ფუნქცია,
და მაშინ საბოლოოდ გვაქვს მძიმით ისევე გვქონდა in C.
რა არის ახალი აქ არის ამ ბიჭს აქ.
ეს დეფისი არის რეალურად საჭირო, და რა ეს ამბობს ის არის, რომ
ეს მეთოდი აქ უნდა მოუწოდა ინსტანციის კლასი.
>> მას შემდეგ რაც განაცხადა ჩვენი structs ჩვენ ალბათ განაცხადა მსგავსი რამ
struct კვანძის N, და რომ რეალურად შექმნილი
ან instantiated ერთ იმ structs ისე, რომ მე ვერ რეალურად დაიწყოს მუშაობა
რა არის შიგნით, ასე რომ ამ dash იმას ნიშნავს, რომ ჩვენ უნდა
instantiate კლასის ისევე, როგორც ჩვენ instantiated რომ struct
სანამ ჩვენ შეგვიძლია მოვუწოდებთ ამ მეთოდით მასზე.
თუკი მინდა დაიწყოს დასძინა არგუმენტები ჩემი მეთოდები
იგი იღებს უფრო მეტი ბანანი.
აი ჩემი მეთოდი სახელი.
მაშინ მე ვაპირებ აქვს მსხვილი ნაწლავის და შემდეგ ამ ორი წერტილი ნათქვამია აქ მოდის გარკვეული არგუმენტები.
ეს მეთოდი იღებს ერთ არგუმენტად.
გაცნობის მისი არგუმენტი არის int, და სახელი რომ არგუმენტი
ან ცვლადი, რომ მე ვაპირებ დაიწყება გამოყენებით შიგნით მეთოდი ეწოდება მე.
ისევ და ისევ, ეს მეთოდი. იგი იღებს ერთი არგუმენტი.
>> თუ გსურთ დაიწყოთ დასძინა მეტი არგუმენტი იგი იღებს უფრო bananas
წელს, რომ ჩვენ ამ ორი წერტილი, რომელიც ამბობს, აქ მოდის ჩემი სია არგუმენტები.
ეს პირველი არგუმენტი არის მთელი რიცხვი.
ახლა, ამ მეორე არგუმენტი არის საინტერესო.
ცვლადი, რომ მე ვაპირებ იყოს გამოყენებით შიგნით ჩემი ფუნქცია
ეწოდება F, ისე შიგნით ჩემი ფუნქცია მე შეიძლება ითქვას,
ვ + = 1 ან რამე.
ეს რამ აქ ძირითადად გასაღები ეს არგუმენტი ან პარამეტრი.
ისევე, როგორც ჩვენ გვქონდა გასაღები მნიშვნელობის წყვილის და რაღაც JSON ან ასოციაციურ კოლექტორები
Objective-C მიიღო გადაწყვეტილება, რომ ამბობენ, okay, მხოლოდ ისე, რომ ეს მართლაც ნათელია
როცა რეკავთ მეთოდი რა ყველა ამ პარამეტრების
მე რეალურად აპირებს ასახელებს მათ ყველა.
როცა რეკავთ მეთოდით, თქვენ რეალურად ამბობენ andFloat,
და შემდეგ თქვენ უნდა გაიაროს ეს სისტემაში
>> საინტერესოა, ამ ერთი არ არის დასახელებული, მაგრამ ყველა სხვა პარამეტრების,
ასე რომ, თუ ჩვენ გვქონდა მე -3 არგუმენტი მე შეიძლება ითქვას andFloat
და კიდევ ერთი float და ასე შემდეგ.
როდესაც მე მოვუწოდებ ამ მეთოდების რა თქმა ბანანები,
ასე რომ, თუ მაქვს ობიექტი, და მე განსაზღვრული მეთოდი მოუწოდა foo,
და მინდა მოვუწოდო მას, ვიდრე ამბობდა foo ღია / მჭიდრო parens
მე ვაპირებ გახსნას bracket.
აქ სახელს ჩემი მეთოდი.
მე ვაპირებ დახურვა bracket, და ეს ობიექტი მე მოუწოდებდა მას.
გახსოვდეთ, ყველა ეს მეთოდები არსებობს ფარგლებში კლასები
რადგან კლასები შეიძლება ჰქონდეს მეთოდები განისაზღვრება შიგნით მათ.
>> აქ მე თვითნებურად შექმნილი ობიექტი გარკვეული კლასის,
და ეს არის სინტაქსი აკეთებს, რომ.
არის 2 ნაბიჯები შექმნის ობიექტს.
პირველი ნაბიჯი არის იმის თქმა მინდა, გამოუყოს ფართი.
ეს არის ეკვივალენტი malloc. ჩვენ არ გვაქვს იმის თქმა malloc უქმნით.
ჩვენ დაეცა მ, გახადა alloc, და შეცვალა. გ ერთად. მ.
მას შემდეგ რაც alloc რაღაც ჩვენ მაშინ უნდა ინიციალიზაცია იგი.
ძირითადად, როცა ობიექტის შესაქმნელად დაგვჭირდება გარკვეული ლოგიკა
რომ ახორციელებს, როდესაც ისინი შექმნილია, ასე რომ თქვენ შეგიძლიათ გადასცეთ ზოგიერთ ნაგულისხმები მნიშვნელობების
ან რამე მაგდაგვარს და ა.შ. ამ init მეთოდი არის ის, რაც რეალურად ქმნის ობიექტს.
ჩვენ პირველი გამოყოფს სივრცეში, ისევე, როგორც ჩვენ გააკეთა C,
და მაშინ ჩვენ ინიციალიზაცია, რომლებიც შეიძლება იყოს ან არ გააკეთებს მთელი ლოტი.
მაშინ ჩვენ დაბრუნების ამ რამ შევიდა ობიექტი o.
არსებობს ვარსკვლავი აქ რადგან ეს ტექნიკურად მაჩვენებელი,
მაგრამ არ ინერვიულოთ, მითითებები არ არის, რომ დიდი გარიგების Objective-C უქმნით.
>> ახლა ჩვენ instantiated ამ კლასის მოუწოდა NSObject,
და ეს მხოლოდ შემთხვევითი კლასი, რომელიც Apple-მა.
ჩვენ instantiated ამ, და ახლა მე მაგალითად ამ კლასის
ამ ობიექტის o ისე, რომ ნიშნავს, რომ თუ განსაზღვრული
ამ მეთოდების მე შეიძლება მოუწოდოს მათ მოსწონს ეს.
ანალოგიურად, თუ მინდოდა დარეკვა მეთოდით ერთი არგუმენტი,
ასე რომ, ეს მეთოდი ბარი, რომ იღებს ერთი არგუმენტი,
და აქ არის baz: qux მეთოდი, ასე რომ ეს იღებს 2 არგუმენტები.
ეს არის მოუწოდებდა ერთი ფუნქცია ამ ობიექტის o.
აზრი?
სინტაქსი უნდა აქვს აზრი, მაგრამ თქვენ სახის შეეგუება ამას.
>> Okay, მოდით ვისაუბროთ რამდენიმე რამ, რომ შენდება შევიდა Objective-C
რომ არ იყვნენ აუცილებლად ჩაშენებული C.
In C ჩვენ სახის მოუწია გამკლავება სიმები როგორც ეს სულელური ხასიათი მასივები,
და მას ნამდვილად შემაშფოთებელი.
Objective-C აქვს იმ ყველა აგებული ჩვენთვის და ეს აშენდა
გამოყენებით ამ კლასის მოუწოდა NSString.
როდესაც მინდა, რომ შევქმნათ NSString გვაქვს მეტი arcane სინტაქსი.
იმის ნაცვლად, რომ "cs50" ჩვენ ვამბობთ, @ "cs50"
და ეს მხოლოდ სინტაქსი გამოცხადების სიმებისათვის Objective-C.
ეს არის ძალიან ადვილი უნდა დაგვავიწყდეს, ისე კი არა.
ახლა, ერთხელ მაქვს ეს, ეს არის ტექსტი, მაგრამ შეამჩნია
ეს მართლაც მხოლოდ ობიექტი.
მე ვუთხარი NSString, რაც იმას ნიშნავს, მე instantiated კლასის
მოუწოდა NSString, რომელიც სხვისი დაწერა ჩემთვის,
და ისინი ძალიან ლამაზი ამის შესახებ, და ა.შ. ახლა
შემიძლია დაიწყოს მოუწოდებდა მეთოდები მასზე.
თუ მოვუწოდებ მეთოდი სიგრძე ამ ობიექტის s
ის დაბრუნებას აპირებს ჩემთვის სიგრძეზე სიმებიანი.
ეს არის, ისევე, როგორც strlen in C.
ეს დაბრუნდნენ 4.
>> ანალოგიურად, სხვა მეთოდი მე დაგვჭირდება აინტერესებს ეს characterAtIndex.
ეს არის მეთოდი, რომელიც ამბობს ამ string s
მინდა კიდევ zeroth ხასიათი,
და ა.შ. ამ დაბრუნდნენ ჩემთვის ხასიათის გ,
და არსებობს მთელი bunch მეტი ასეთი მეთოდები, რომ თქვენ შეგიძლიათ Google მართლაც მარტივად.
Apple-ის დოკუმენტაცია დიდია, და ჩვენ შევხედოთ, რომ ცოტა.
ეს ის სიმები.
ჩვენ ასევე ცვლადი ზომა კოლექტორები აშენდა შემოსული
მახსოვს C როდესაც ჩვენ განაცხადა მასივი
ჩვენ გვქონდა იმის თქმა აქვს 5 ელემენტები, ბოლოს ამბავი.
როდესაც მივიღეთ, რომ JavaScript და PHP შეგვეძლო დაიწყება
აკეთებს რამ, როგორიცაა დასძინა ელემენტები ან მოძრავი ელემენტები.
ჩვენ შეგვიძლია გავაკეთოთ იგივე ობიექტური-C.
იმის ნაცვლად, რომ შექმნას მასივი ჩვეულებრივი C გზა
ჩვენ ისევ მეორე კლასის მოუწოდა NSMutableArray.
არსებობს ასევე NSArray,
და ამ აპირებს ძირითადად encapsulate ზოგიერთი მასივი.
ეს ამბობს პირველი, რაც მინდა გააკეთოთ მინდა გამოყოფს
ფართი ახალი მასივი, და შემდეგ მე გამოყოფს მას
მე მაშინ უნდა ინიციალიზაცია იგი.
ისევ და ისევ, მხოლოდ დარეკვით ამ 2 მეთოდები.
ახლა ეს იმას ნიშნავს, რომ შიგნით ეს ობიექტი
მე ცარიელი მასივი სხდომაზე.
თუკი მინდა დაამატოთ რაიმე ამ მასივი, მე შემიძლია მოვუწოდო addObject მეთოდი.
მინდა დაამატოთ ობიექტი მასივი, და მინდა დაამატოთ სიმებიანი CS50.
თუ მინდოდა პირიქით ამოიღოთ, რომ შემიძლია ვთქვა, მინდა
ამოიღონ ობიექტი პირველ ადგილზე მასივი ან საგანი.
>> აზრი?
Okay, თქვენ სახის შეეგუება ამ მოედანზე bracket რამ.
სხვათა შორის, შიგნით ბევრი Apple-ის ბიბლიოთეკები დაინახავთ ამ NS.
NS რეალურად დგას შემდეგი ნაბიჯი, რომელიც იყო ერთერთი სტივ ჯობსი პირველი კომპანიები,
და ეს სადაც რეალურად წერა დაიწყო ბევრი კოდი
როგორც სახის საფუძველი Mac OS X და ყველა სხვა პერსონალი,
და ა.შ. ამ NS არის სახის ამ ლამაზი მემკვიდრეობა shout out ერთი ადრე კომპანიები
უკან, როდესაც Apple პირველად დაწყებული გარეთ.
ეს ყველგან.
მოდით შევხედოთ უფრო ჰოლისტიკური Objective-C მაგალითად.
აქ მე ვარ შიგნით XCode.
მისაღებად აქ, მე პირველად გადმოწერილი XCode საწყისი App Store,
გაიხსნა it up, და შემდეგ მე ავიდა აქ ფაილი,
მეტი აქ ახალი და შემდეგ პროექტი.
შემდეგ გავაკეთო, რომ მე ყველა ეს ვარიანტი რაც მე მინდა, რომ შევქმნათ,
და ა.შ. ჩვენ შევხედოთ ამ კონფიგურაციის შემდეგ,
მაგრამ მხოლოდ ეს მაგალითი, რადგან ჩვენ რეალურად არ აპირებს app არის,
მე დაინგრა აქ, და მე ვუთხარი ბრძანების ინსტრუმენტი,
და ეს არის აპლიკაცია, რომ მე ვერ აწარმოებს ბრძანებათა ზოლს
ისევე, როგორც ჩვენ გაშვებული საწყისი C.
ასე მე შექმნილი ეს პროექტი, და ა.შ. ახლა მე აქ,
მოდით პირველი შევხედოთ ამ ფაილის, და ეს უნდა გამოიყურებოდეს საკმაოდ ნაცნობი.
მაქვს int სახელი. იქ ჩემი მეგობარი argc, ჩემი სხვა მეგობარი argv.
ასე რომ, ჩვენ ვხედავთ, რომ ეს არის შესვლის წერტილი ჩემი პირველი Objective-C განაცხადი.
აქ ჩვენ შეგვიძლია იგნორირება ამ დროისთვის.
ეს არის ძირითადად ზოგიერთი მეხსიერების მართვა პერსონალის, რომ თქვენ არ ნამდვილად
ოდესმე უნდა ფიქრი.
>> მოდით შევხედოთ ამ პირველი ბლოკი აქ.
ეს პირველი ხაზი, თუ ვიტყვი სტუდენტური * Alice = [[სტუდენტური alloc] init] რა რომ აკეთებს?
ეს პირველი სტუდენტი აქ, ეს არის ალბათ კლასის.
ეს არ არის კლასი რომელიც Apple წერდა, მაგრამ კლასი, რომელიც მე დავწერე.
პირველი, რაც მინდა გააკეთოთ მინდა გამოყოს ფართი ახალი სტუდენტი,
და შემდეგ მინდა ვრთავ, ასე რომ ამ მაძლევს უკან
ამ ახალი სტუდენტი ობიექტს და მე შენახვა ამ ცვლადში Alice.
სად, რომ კლასის მოდის?
ისე, მეტი აქ მარცხენა მხარეს ეს ყველა სხვადასხვა ფაილები შიგნით ჩემი პროექტი.
ჩვენ აქ მაქვს Student.h და Student.m.
. თ ფაილი, გახსოვდეთ, სადაც ვაცხადებ ყველა რამ
რომ იარსებებს ფარგლებში კლასი.
>> მოდით შევხედოთ, რომ.
ყველა უფლება, აქ ჩვენ გვაქვს ამ @ ინტერფეისი, და ეს ამბობს, რომ აქ მოდის
დეკლარაციები ყველაფერი რომ იარსებებს ფარგლებში ჩემი კლასი.
მერე აქვს მსხვილი ნაწლავის. მაშინ მე ამ NSObject რამ.
ეს მსხვილი ნაწლავის ნიშნავს, რომ მემკვიდრეობის bit ჩვენ განიხილავდნენ ცოტა უფრო ადრე.
ეს ნათქვამია ყველაფერი NSObject შეუძლია გააკეთოს
აქ NSObject არის ამ კლასის მიერ დაწერილი სხვისი,
ყველაფერი ეს NSObject შეუძლია გააკეთოს მინდა გამოუვა, რომ.
განაცხადა: NSObject, რაც იმას ნიშნავს, რომ მე ძირითადად
მემკვიდრეობით ყველა ფუნქციონალური მეორე კლასი.
რომ ნამდვილად მომცა მთელი bunch სხვადასხვა მეთოდები და თვისებები, რომ მე შეიძლება გამოიყენოს.
Down აქ მე შექმნა 2 თვისებები.
ეს იმას ნიშნავს, ჩემი სტუდენტი, თუ ამ იყვნენ struct, ეს იქნება 2 რამ
შიგნით ჩემი struct, ამიტომ ყველა სტუდენტმა სახელი
რომ არის ტექსტი, და სტუდენტი ასევე აქვს კლასის
რაც int.
>> და ბოლოს, ქვემოთ აქ მე ვაპირებ შექმნას მეთოდი ჩემი სტუდენტი.
დავურეკე ჩემი მეთოდი, initWithName, და ეს გრძელდება ერთ არგუმენტს,
და ეს არგუმენტი არის ტექსტი, და მე მას სახელი.
ახლა მოდით წავიკითხოთ როგორ ჩვენ რეალურად განხორციელდეს ამ კლასში.
აქ, ახლა მე შიგნით ჩემი. მ ფაილი,
მ განხორციელებისათვის, ვფიქრობ.
მე მაქვს ჩემი განხორციელება, ჩემი ბოლომდე, და აქ არის, სადაც მე რეალურად განსაზღვრის
რა initWithName აკეთებს.
მაქვს initWithName, სახელით ჩემი პარამეტრი და შემდეგ ამ
სადაც მე რეალურად შექმნის სტუდენტი,
და ა.შ. ეს ცოტა cryptic, მაგრამ ეს არის ერთგვარი boilerplate
რომ გსურთ მოიცავს თქვენს მშენებლები.
ეს ინიციალიზაციისას ფუნქცია აქ, initWithName, არის ტიპის მშენებელი.
თქვენ ძირითადად აშენებენ ახალ სტუდენტი ობიექტი
და შესაძლოა გაგზავნის გარკვეული მონაცემები შიგნით მას.
პირველი, რაც მინდა გააკეთოთ მინდა მოვუწოდო init ამ სუპერ რამ.
>> გახსოვდეთ, რომ როდესაც ვთქვი უკან აქ. თ ფაილი
რომ ყველაფერი NSObject აქვს სტუდენტი ასევე აქვს.
ეს იმას ნიშნავს, როცა შექმნა სტუდენტი რა უნდა გავაკეთოთ არის
დარწმუნდით, რომ NSObject რომ მე inheriting ყველა რომ მონაცემები
ასევე ინიციალიზაცია სათანადოდ.
რა უნდა ვთქვა, ამ სუპერ რეალურად აპირებს მიმართოს მშობელს კლასის
რომ მე inheriting საწყისი, ამიტომ გვინდა დავრწმუნდეთ მე ინიციალიზაცია
ყველაფერი, რაც მე დამოკიდებულია ადრე დავიწყო ცდილობს გამოიყენოს იგი.
თუ რომ ინიციალიზაცია სწორად ეს ისევე, როგორც ვამბობთ, თუ malloc
არ დაუბრუნებია null მერე შეიძლება დაიწყოს შექმნის ზოგიერთი თვისებები.
>> In JavaScript და PHP გვქონდა ამ სიტყვის უწოდა,
და ამ მოხსენიებული მიმდინარე ინსტანციის კლასი.
ობიექტური-C ჩვენ მოვუწოდებთ ამ თვით.
როდესაც ვამბობ self.name, რაც იმას ნიშნავს, რომ ობიექტი
მე უბრალოდ შექმნილი, როდესაც ვთქვი სტუდენტი alloc init,
რომ აპირებს მომეცი უკან ობიექტი.
ეს იმას ნიშნავს, მინდა მითითებული სახელწოდება, რომ ობიექტი
to whatever მე უბრალოდ გაიარა სისტემაში
ისევე, C, ჩვენ შედიხართ წევრები ამ dot,
ასე self.name ამბობს სახელით სტუდენტი ობიექტი
არის იქნება რასაც თქვენ უბრალოდ გაიარა სისტემაში
და ა.შ. საბოლოოდ, შემიძლია მისი დაბრუნება, ამიტომ რეალურად კიდევ რაღაც თავში.
>> კითხვები?
Okay, ასე რომ ეს თვითმმართველობის = super init,
თუ არ სრულიად მესმის მემკვიდრეობის პერსონალის არ ინერვიულოთ.
უბრალოდ ვიცი, რომ თუ ოდესმე გვინდა, რომ საკუთარი init მეთოდი მხოლოდ
ამისათვის, და თქვენ გექნებათ კარგი წასვლა.
Yeah. >> [სტუდენტური] რას თუ თვით ნიშნავს?
ეს ნიშნავს, როდესაც ჩვენ malloc რაღაც ჩვენ ყოველთვის გადაამოწმა, თუ იგი შეადგინა null,
და თუ ეს იყო null, მაშინ ჩვენ აღელვებული ადევნებს თვალყურს.
ეს არის იგივე, რადგან თუ ამ ბრუნდება null, მაშინ ჩვენ ალბათ აპირებს seg ბრალია
თუ ჩვენ დავიწყებთ ცდილობს მის მართვას.
სწორედ ჩვენი სტუდენტი კლასში.
ეს იმას ნიშნავს, რომ ჩვენ შეგვიძლია ინიციალიზაცია ჩვენი სტუდენტების ერთი ორი გზა.
თუ მე ვიტყვი, სტუდენტი alloc init მე არ იყენებს, რომ მეთოდი, რომ მე უბრალოდ წერდა,
და ნაცვლად შემიძლია უბრალოდ ვთქვა alice.name,
და ახლა მე ვაპირებ, რომ მითითებული ქონება სახელი.
>> ანალოგიურად, თუ მინდა გამოიყენოს რომ initWithName მეთოდი
მე შემიძლია ვთქვა, უბრალოდ alloc, შემდეგ კი, ვიდრე ამბობდა init
მე ვაპირებ მოვუწოდო, რომ მეთოდი, რომ მე უბრალოდ შექმნილი, და მე ვაპირებ კორიდორი Bob.
ამ ეტაპზე, ეს ობიექტი ბობ აქვს სახელი ტოლია Bob.
Okay, ქვემოთ აქ მე გამოყენებით რომ NSMutableArray რომ ჩვენ შევხედე ადრე.
მე გამოყოფის space.Then მე ინიციალიზაციისას ახალი მასივი.
მე ვაპირებ დაამატოთ 2 რამ მას.
ეს მასივი ახლა ფლობს სტუდენტი ობიექტები.
გაითვალისწინეთ, რომ არსად არც უნდა ვთქვა, რომ ეს მასივი სტუდენტებს.
მე ვთქვი, რომ ეს მასივი, პერიოდში.
მაშინ შემიძლია დააყენა რასაც შიგნით რომ მინდა.
აქ მაქვს 2 ობიექტები.
>> და ბოლოს, მე მაქვს სულ სხვა ობიექტი აქ, ამ TF.
მეტი აქ TF.h ძირითადად იგივე.
მე inheriting საწყისი NSObject, და სხვათა შორის,
როდესაც თქვენ შექმნით კლასების ეს ყველაფერი კეთდება თქვენთვის,
ამგვარი ინტერფეისი boilerplate.
მას გააჩნია ქონებაზე სტუდენტებს.
მაქვს რამდენიმე მეთოდები აქ რომ ნამდვილად არ გავაკეთებ მთელი ლოტი,
და ა.შ. ეს იმას ნიშნავს შემდეგ შევქმნა ამ TF ობიექტი
შემიძლია მოვუწოდო ამ მეთოდით Grade მასზე მოსწონს ეს.
ნებისმიერი შეკითხვა Objective-C სინტაქსი დაწყებამდე მოძრავი შევიდა კიდევ რამდენიმე
საინტერესო apps განვითარების პერსონალის?
>> Okay, მოდით რეალურად მიიღოს iPhone app.
ძირითადი კლასების, რომ თქვენ გამოიყენებთ შიგნით თქვენი iPhone app უწოდებენ ხედი კონტროლერები,
და ხედი კონტროლერი ძირითადად წარმოადგენს ერთ ეკრანზე
შიგნით თქვენი app, ასე რომ, თუ მე მე მუსიკა app, მაგალითად,
ერთი ხედი კონტროლერი შეიძლება წარმოადგენს მოსაზრება, რომელიც მე ყველა სიმღერა ჩემი iPhone.
კიდევ ერთი ხედი კონტროლერი შეიძლება იყოს როცა დააწკაპუნეთ სიმღერა და დაუკარით ეს
ან როგორც მე ბურღვა down შევიდა მხატვრები.
თითოეული მათგანი სხვადასხვა ეკრანები შეიძლება წარმოდგენილია როგორც განსხვავებული აზრი კონტროლერი,
და ხედი კონტროლერი მართლაც მხოლოდ კლასის, რომელიც ამბობს, თუ როგორ ამ ეკრანზე მუშაობს.
Things შიგნით დასაწყისში კონტროლერი, ჩვენ ვაპირებთ აქვს თვისებები,
ასე რამ, როგორიცაა ღილაკს იქნება ქონებას ჩვენი აზრით კონტროლერი.
>> ჩვენ ასევე ვაპირებთ აქვს მეთოდები, და ეს ძირითადად ღონისძიების ელფოსტის.
ეს მეთოდი ამბობს, როდესაც ამ ღილაკს
მინდა, რომ რამე, და ბოლოს, კიდევ ერთხელ,
ჩვენ ვაპირებთ იყოს გამოყენებისას თვითმმართველობის სიტყვით წვდომისათვის მიმდინარე მაგალითად.
აშენება ინტერფეისები წელს iOS არის რეალურად მართლაც, მართლაც ადვილი.
მათ აქვთ ამ ლამაზი გადააადგილება ინტერფეისი მოუწოდა Interface Builder,
და 2 ძირითადი ცნებები, რომ მავთულის თქვენი Objective-C-დან Interface Builder
არიან IBOutlet და IBAction.
IBOutlet უბრალოდ ამბობს, რომ თუ თქვენ გამოაცხადოს ქონება რომ ღილაკს,
და გსურთ Hook ეს რაიმე თქვენს ფაქტობრივი UI,
თქვენ აპირებს ვთქვა ეს outlet.
ანალოგიურად, თუ გსურთ წარმოადგენს ღონისძიების დამმუშავებლის
მაშინ თქვენ აპირებს ვთქვა ეს ქმედება.
>> რეალურად WIRE ამ გრაფიკული წარმომადგენლობა
და თქვენი კოდი ეს მართლაც, ნამდვილად მარტივი.
თუ გსურთ ვანიჭებთ IBOutlet, ყველა თქვენ უნდა გააკეთოთ თქვენ კონტროლი დაწკაპუნებით,
და ვნახავთ, მაგალითად ამ მართლაც სწრაფი.
თქვენ კონტროლი დააწკაპუნეთ, სადაც იგი აცხადებს, View Controller.
თქვენ აპირებს გადაიტანეთ შევიდა ინტერფეისი, ან პირიქით,
თუ გსურთ Hook up ღონისძიება დამმუშავებლის თქვენ აპირებს გადაიტანეთ ინტერფეისი
მეორე მიმართულებით.
მოდით შევხედოთ ნამდვილად მარტივი iOS მაგალითად.
>> მოდით შევქმნათ ახალი პროექტი.
მე ვაპირებ ამუშავება აქ განაცხადის,
და მე ვაპირებ დააწკაპუნეთ უცოლო დასაწყისში განაცხადი.
მე ვაპირებ დააჭირეთ შემდეგი. მე მივცემ ჩემს პროექტის სახელი.
მე ეძახით Hello.
საინტერესოა, Apple ვარაუდობს, თქვენ შექმნით პროდუქტის
ასე რომ თქვენ შეგიძლიათ გაყიდვებს და მათ შეუძლიათ გამოიმუშაოთ ფული.
Down აქ მე ვაპირებ ვთქვა, რომ ეს არის iPhone app.
თქვენ შეგიძლიათ შექმნათ iPad app, ან, თუ გსურთ, რომ შევქმნათ ერთი იმ apps
რომელიც მხარს უჭერს ორივე მოწყობილობები შეგიძლიათ გააკეთოთ, რომ ძალიან.
ეს არის ის, რაც თქვენ გინდათ თქვენი checkmarks რომ გამოიყურებოდეს.
>> გსურთ გამოიყენოთ storyboards, რომელიც ჩვენ დავინახავთ შემდეგ,
და თქვენ ნამდვილად გინდათ გამოიყენოთ ავტომატური მინიშნება დათვლა,
რაც ლამაზი ფუნქცია, რომელიც ხელს უშლის თქვენ მქონე ვთქვა malloc და თავისუფალი.
თუ თქვენ მინდა მოვუწოდო malloc და თავისუფალი, მინდა დატოვება ამ შემოწმდება.
მე დააჭირეთ შემდეგი, და საბოლოო ჯამში, ეს აპირებს მკითხავთ აქ მინდა შეინახეთ იგი.
მე მოხვდა შექმნა, და აქ ჩვენ მივდივართ.
მე შექმნილი ახალი პროექტი.
მეტი აქ მარცხენა არის ყველა ფაილი რომელიც არის შიგნით ჩემი პროექტი,
და შენიშნავს, რომ მე მივიღე მთელი bunch და მე კი არ არაფერი.
IOS არის დიდი.
>> მაგალითად, აქ ამ ViewController.h,
ამ აპირებს წარმოადგინოს ჩემი პირველი ხედი კონტროლერი,
ამიტომ პირველ ეკრანზე შიგნით ჩემი app.
ახლა ჩვენ ვიცით, რა ეს დაყრდნობით.
ჩვენ ვამბობთ, მე მოუწოდებდა ამ კლასის ViewController,
და ViewController ყველაფერს აკეთებს, რომ UIViewController აკეთებს,
და ეს, კიდევ ერთხელ, არის რამდენიმე კლასი, რომელიც Apple წერს, რომ ჯერ ბევრი მოსახერხებელი პერსონალის ჩვენთვის
მინდა არიან ეკრანზე.
აქ არის, სადაც მე შემიძლია რეალურად დაიწყოს განსაზღვრის რა ჩემი აზრით კონტროლერი აქვს,
და აღმოჩნდება, რომ მე ნამდვილად არ გვჭირდება რაიმე ამ.
ეს არის boilerplate კოდი, რომელიც Apple მაძლევს უფასოდ.
მე სჭირდება, რომ პირველ ხაზზე, ან მე არ მაქვს კლასის,
ამიტომ ჩვენ შეგვიძლია დავაღწიოთ რომ მოშორებას ამ.
Okay, ასე რომ ეს არის ჩემი ცარიელი ეკრანზე.
>> ახლა მოდით დააჭირეთ ამ MainStoryboard.storyboard,
და ეს არის, სადაც ეს იწყება მიიღოს საინტერესო.
ეს წარმოადგენს პირველი ეკრანზე ჩემს app.
თუკი მინდა ღილაკის დასამატებლად in HTML მქონდა შექმნათ ღილაკს ტეგით.
In Android თქვენ უნდა შექმნათ ღილაკს tag,
მაგრამ iOS, თუ უბრალოდ ჩამოდი აქ ქვედა მარჯვენა
და თუ მე დააჭირეთ ამ მე -3 ერთი აქ, სადაც იგი აცხადებს, ობიექტები,
და შემიძლია გადახვევა down, ან შემიძლია დაიწყოს ეძებს ღილაკს.
და მოუთმენლად, ღილაკს, ასე თუ რეალურად გადააადგილება ეს უფლება იქ,
მე უბრალოდ დასძინა ღილაკს ამ ეკრანს ჩემს app.
თუკი მინდა შეცვალოს ტექსტი, შემიძლია ორმაგად დაწკაპეთ იგი,
ამბობენ რაღაც enticing როგორიცაა "პრეს ჩემთვის."
Okay, ახლა თუ აწარმოებს ამ app, ასე რომ ჩვენ კომპილირება,
ასე გაუშვით მე დააწკაპუნეთ პიესის ღილაკი ზედა მარცხენა და იქ ჩემი app.
მე არაფერი, და მე მივიღე ტკბილი ეძებს iPhone app.
თუკი მინდა შეჩერება, თქვენ შეგიძლიათ დააჭიროთ გამორთვის ღილაკი
იმიტომ რომ სიამოვნება.
>> ვთქვათ, რომ მე ნამდვილად გინდათ რამე რომ მოხდეს, როდესაც მე ამ ღილაკს.
გავაკეთოთ, რომ რაც მე მხოლოდ უნდა მე უნდა შევქმნათ
ახალი თარიღის დამმუშავებლის ან ქმედება.
ეს იმას ნიშნავს, რომ მე უნდა შევქმნათ გარკვეული მეთოდი, რომ მინდა იყოს მოუწოდა
როცა დააჭირეთ ღილაკს, ამიტომ მოდით შევქმნათ ახალი მეთოდი.
მე შიგნით ViewController.h.
მე უნდა ვთქვა, რომ მეთოდი არსებობს.
მე უნდა დეფისი პირველი რადგან მე ვაპირებ იყოს მოუწოდებდა ეს ხედი კონტროლერი.
მე უნდა მივცეთ ამ ტიპის.
გაცნობის ამ იქნება რომ IBAction რაც ჩვენ ვნახეთ ადრე.
ეს არის ღონისძიება დამმუშავებლის, ამიტომ დაბრუნებას აპირებს IBAction,
და ეს არის მინიშნება რომ XCode ვთქვა, რომ
ეს არის ის მინდა WIRE რაღაც.
შემიძლია მისცეს მას სახელი, ისევე როგორც buttonPressed, მძიმით.
>> ახლა მე გამოაცხადა ახალი მეთოდი შიგნით ჩემი კლასი.
მე განაცხადა, რომ ეს მეთოდი უნდა არსებობდეს.
ახლა მოდით მოვიდა ViewController.m,
და ვთქვათ, რა ამ მეთოდით შეგვიძლია გავაკეთოთ.
თუ დავიწყო აკრეფით, მაგალითად, (void) buttonPressed
გაფრთხილების XCode მართლაც ლამაზი და autocompletes ჩემთვის.
რომ მართლაც შესანიშნავი.
გაითვალისწინეთ, რომ შიგნით. მ ფაილის შემიძლია ასევე ვთქვა, ბათილად,
და ეს იმიტომ, რომ IBAction არ არის რეალურად ტიპის.
სინამდვილეში hashtag განსაზღვრული სადღაც იქნება ბათილად,
და ისევ, ეს მხოლოდ მინიშნება, რათა XCode რომ ამბობს
მინდა ეს უნდა იყოს მოვლენა დამმუშავებლის და ვნახავთ, თუ რატომ მხოლოდ მეორე.
როდესაც ამ ღილაკზე თითის დაჭერის მე ვაპირებ რაღაც უსიამოვნოს
მინდა ცარიელია popup.
>> გავაკეთოთ, რომ მე შეიძლება შექმნათ ახალი ინსტანციის ამ კლასის მოუწოდა UIAlertView,
და ეს არის კლასი რომელიც Apple წერს, რომ აპირებს ცარიელია უსიამოვნოს popups.
ჩვენ მოვუწოდებთ ამ popup ყურადღებიანობა, და მე 2 ნაბიჯები, გახსოვდეთ, რომ შექმნა ეს ობიექტი.
პირველი, რაც უნდა გავაკეთოთ, არის გამოყოს ფართი.
მინდა UIAlertView.
მინდა გამოყოფს სივრცეში. ეს არის ჩემი პირველი მეთოდი.
ჩემი შემდეგი მეთოდი მინდა ინიციალიზაცია ის,
და ა.შ. მე ამ დიდი, ხანგრძლივი მეთოდი მოუწოდა initWithTitle.
რომ ძირითადად აპირებს გაკონტროლება, თუ რა ამ popup ამბობს.
ტიტული ჩემი popup შეიძლება hello.
გაგზავნა ამ popup უნდა იყოს "ეს არის iOS."
დელეგატი რამ, არ ვიცი რა, რომ არის.
ვთქვათ ეს არაფერი.
ახლა ღილაკს რომ აღიმართება შეიძლება ითქვას რაღაც "ეს არის დარწმუნებული,"
და მე არ მინდა სხვა ნებისმიერი ღილაკები, მოდით წაშლა რომ და დახურვა bracket.
>> Okay, მე შექმნილი დამატებით ერთი. იქ ჩვენ წავიდეთ.
აი როგორ შეიძლება შექმნათ ახალი popup.
თუკი მინდა რეალურად ნახოთ popup მინდა მოვუწოდო შოუ მეთოდი.
გავაკეთოთ, რომ შემიძლია ვთქვა, ყურადღებიანობა და შოუ,
და ისევ, თვითდასრულება იყო სუპერ ლამაზი.
თუ დამავიწყდა რა, რომ იყო, თუ უბრალოდ აკრეფილი s,
შემიძლია გადახვევა მეშვეობით აქ გაერკვნენ, რა იყო,
და ეს ფილტრები ლამაზად.
ახლა იქმნება ახალი popup.
ჩვენ დავბრუნდებით, თუ რა დელეგატი ნიშნავს მოგვიანებით,
და ახლა მინდა ვთქვა, მინდა ეს მეთოდი უნდა გასროლა
როცა დააჭირეთ ღილაკს, ამიტომ მე ვაპირებ დაბრუნებას ჩემი storyboard,
და მინდა ახლა ვანიჭებთ ამ IBAction.
პირველი, რაც გსურთ არის დააჭირეთ ღილაკს.
როდესაც მე ამ ღილაკს მინდა რაღაც მოხდეს.
მე არ ვაპირებ გეჭიროთ კონტროლი.
მე ვაპირებ დაწკაპეთ და გადაათრიეთ საწყისი ღილაკს
მეტი აქ, სადაც იგი აცხადებს, View Controller.
ჩვენ ვხედავთ, რომ ლამაზად lights up.
>> თუ მე გაუშვებენ, რომ ჩემს მაუსის მე ახლა ამ popup მეტი აქ, სადაც მე გარკვეული პარამეტრები.
რომელთაგან ერთი არის ის მოვლენები, შემიძლია რეგისტრაცია.
ეს არის ყველა იმ მეთოდებს მე განაცხადა ჩემი თ ფაილი, როგორც IBActions.
ეს არის, თუ როგორ XCode იცის, რა უნდა გამოჩნდება ამ პატარა სია,
ასე რომ უბრალოდ მინიშნება.
თუ მე დააჭირეთ ღილაკს დაპრესილი, მე ახლა დარეგისტრირებულ ღონისძიება დამმუშავებლის.
In JavaScript გვქონდა სათქმელი მაქვს რაღაც კოდი, რომელიც რეგისტრირებულია ღონისძიება დამმუშავებლის.
ობიექტური-C ეს იყო მართლაც რომ ადვილი.
თუ მე აწარმოებს ეს კიდევ ერთხელ
ახლა, როდესაც მე დააჭირეთ ღილაკს ჩემი ღონისძიება დამმუშავებლის აპირებს ცეცხლი,
და მე ვაპირებ ამ popup.
სუპერ, სუპერ მარტივი არსებობს.
>> თუ თქვენ ოდესმე გვინდა, რომ ყველა მოვლენები, რომლებიც არ უნდა იყოს რეგისტრირებული
on კომპონენტი, თუ დააწკაპუნეთ ამ ღილაკს
და მე მეტი აქ მარჯვენა მხარეს
პირველი ხედავთ აქ შემიძლია რამ, როგორიცაა გაცნობის ღილაკს,
ასე რომ, თუ გსურთ ერთი იმ მე ან კონტაქტის დამატება ღილაკს
ან რასაც.
თუ მსურს, რომ ყველა მოვლენები, რომლებიც ამ ღილაკს
თუ მე მოვდივარ ყველა გზა ზე აქ მარჯვენა მხარეს
ვხედავთ აქ მოვლენების მაქვს ყველა ეს სხვადასხვა მოვლენები.
შემიძლია დააჭირეთ ღილაკს, როდესაც მე გაუშვებენ of ღილაკს, როდესაც მე გაორმაგდება ონკანის ან რასაც,
და ერთი მე მხოლოდ დარეგისტრირებულ არის ამ ღონისძიების მოუწოდა Touch Up Inside,
და ეს ამბობს, რომ როგორც კი ჩემი თითი მოდის off ღილაკს
რომ ღონისძიება აპირებს ცეცხლის, და სწორედ ის, რაც უბრალოდ მოხდა.
ეს არის სახის ნაგულისხმევი ღილაკს დაპრესილი ღონისძიება.
>> ნებისმიერი კითხვები აქამდე?
Okay, რომ როგორ შეგვიძლია დავიწყოთ WIRE up რამ ჩვენი კოდი
შევიდა რამ შიგნით ჩვენი ინტერფეისი.
დამახსოვრება პრიველი რაც უნდა გაეკეთებინათ იყო მოძიების კოდი,
და მაშინ ჩვენ სახაზო up ინტერფეისის კოდი,
და იქ ჩვენი პირველი აპლიკაცია.
Okay, რომ მართლაც მაგარი, და ჩვენ შევქმენით ამ ღილაკს.
რა მოხდება, თუ ჩვენ არ გვინდა, რომ უნდა შევქმნათ bunch of თვისებები
წარმოადგენს ამ ღილაკებიდან?
მაგალითად, Tic TAC Toe მაქვს 9 ღილები,
და ეს მინდა იყოს სუპერ, სუპერ შემაშფოთებელი რომ უნდა გადააადგილება 9 ჯერ
ან თუ მე უნდა გაეკეთებინათ Tic TAC Toe with 81 ნაცვლად 9
და მე უნდა გადააადგილება 81 ჯერ და ეს კოჭლი.
რა შეგვიძლია გავაკეთოთ ნაცვლად ძალიან ჰგავს HTML
როდესაც ჩვენ გვქონდა რამ, როგორიცაა პირადობის მოწმობა და სახელები და ჩვენ შეგვიძლია მოძებნოთ ნივთები
მათი პირადობის მოწმობა, არსებობს მსგავსი ცნება წელს iOS მოუწოდა tags.
>> Tag უბრალოდ უნიკალური რიცხვითი იდენტიფიკატორი ამისთვის კომპონენტი.
თუ მე ვიტყვი, ეს tag of 0, მაგალითად,
თუ შექმნა ღილაკს და მისთვის tag of 0, და ვნახავთ, თუ როგორ უნდა გავაკეთოთ, რომ სულ რაღაც მეორე,
თუ გვინდა, რომ ღილაკს შემიძლია ვთქვა უბრალოდ მინდა მოვუწოდო
viewWithTag მეთოდი ობიექტის მეტი აქ,
self.view, რომელიც წარმოადგენს მიმდინარე ეკრანზე, მაგალითად.
თუ მოვუწოდებ, რომ viewWithTag მეთოდი, მე ვაპირებ უკან დახევის ღილაკს ტეგით 0.
მოდით შევხედოთ ამ მშენებლობით Tic TAC Toe.
პირველი, ეს არის ჩემი storyboard.
მე შექმნილი ეს 10 UI ღილაკებით.
გაითვალისწინეთ ისინი ყველა იმავე ზომის.
თუ მე დააჭირეთ ერთ ამ და მე დავბრუნდებით მეტი აქ ამ მარჯვენა მხარეს
თქვენ ნახავთ მე მორგებული შრიფტის უფლება აქ, ამიტომ მე მივიღე შრიფტის ცოტა დიდია,
მაგრამ, რაც მე ასევე გააკეთა, მე მითითებული ამ ტეგით.
მე ვთქვი, რომ ეს tag: 1, და რომ ზედა მარცხენა.
>> ახლა, თუ მე დააჭირეთ მეორე ღილაკს, ისევე როგორც ამ მეორე აქ,
ახლა თქვენ ნახავთ, რომ ჩემი tag არის 2.
თითოეული ეს ღილაკები მხოლოდ აქვს უნიკალური tag,
და ასე რომ, ეს მოგვიანებით, როგორ მე ვაპირებ დაიწყება ინტერაქციაში
სწორედ ჩემს app.
ეს არის ყველა შიგნით ერთი ხედი კონტროლერი,
მაგრამ აქ არის ის, რაც ჩვენ გვაქვს.
ჩვენ გვყავს 3 თვისებები აქ.
პირველი და ბოლო ერთი ვაპირებთ წარმოადგენენ სახელმწიფოს ჩემი ფორუმში.
ძირითადად ეს პირველი არის მასივი წარმოადგენს სადაც XS და Os არიან.
ეს მეორე აქ გვეუბნება, რომლის მხრივ ეს არის.
თქვენ შეამჩნევთ, რომ მე ასევე აქვს ეს ყველაფერი აქ.
სანამ როდესაც ჩვენ განაცხადა თვისებები მივეცით სახელი და ტიპის.
ჩვენ შეგვიძლია ასევე მისცეს მათ გარკვეული დამატებითი ინფორმაცია აქ.
ეს პირველი ამბობს nonatomic, და რა ეს ამბობს
ძირითადად მხოლოდ ერთი რამ ოდესმე მოხდეს ცდილობს გავქთ ამ ცვლადის დროს.
თქვენ შეეძლო უფრო რთული განაცხადების, რომლებიც მრავალ ნაკადიან,
და ასე უკან Scratch გვქონდა სხვადასხვა თემა,
და სხვადასხვა sprites შეიძლება აკეთებს სხვადასხვა რამ ამავე დროს.
>> თუ ეს ასე არ არის საქმე, რომელსაც ის არ არის არაფერი რომ ჩვენ უნდა ეძებს,
თუ ვიტყვით nonatomic სინამდვილეში აპირებს რამ ცოტა უფრო სწრაფად.
ჩვენ ასევე გვაქვს ამ რამ მოუწოდა გაასხვისოს, ძლიერი, ან სუსტი.
ეს დაავალოს მხოლოდ ამბობს, რომ ეს არის სტანდარტული ტიპის.
ეს არ არის ობიექტის ან კურსორი რადგან ეს მხოლოდ bool,
ასე bool აგებულია შევიდა Objective-C.
ეს ამბობს, ნუ ეცდებით არაფერს ხელნაკეთობების ერთად პოინტერები აქ.
ეს რეგულარული წლის scaler.
ძლიერი და სუსტი, ამ სუსტი ნათქვამია, რომ რეალურად
მინდა ეს უნდა იყოს მიუთითებს რაღაც ხედი კონტროლერი.
მე არ ვაპირებ რეალურად გამოყოფას ან init ამ თავს.
ინტერფეისი მშენებელი, როცა აწარმოებს app, აპირებს გაუმკლავდეს ყველა რომ ინიციალიზაციისას.
თუ მე ვიტყვი, სუსტი, რომ ამბობს ვინმე აპირებს შექმნით ამ.
თუ მე ვიტყვი, ძლიერი, ამ ნათქვამია, რომ მე ვაპირებ იყოს ერთი
რომ შექმნა ამ ფორუმში ობიექტი,
და ა.შ. აქ მე კიდევ რამდენიმე მეთოდები აქ,
მაგალითად, აქცია, როცა ახალი თამაში ღილაკი დაპრესილი,
აქცია, როდესაც რომელიმე სხვა ღილაკების დაპრესილი,
და et cetera.
>> ჩვენ არ მოხვდება ზედმეტად ლოგიკა Tic TAC Toe,
თუმცა ეს ძალიან საინტერესო, მაგრამ მოდით შევხედოთ
ზოგიერთი რამ, რომ ჩვენ შეგვიძლია გავაკეთოთ შიგნით iOS.
ეს ახალი თამაში მეთოდი იქნება ნასროლი
როდესაც მე დააჭირეთ ახალი თამაში ღილაკს.
To Hook რომ უბრალოდ გადმოდიოდნენ ჩემს storyboard.
მე დაწკაპავთ ახალი თამაში.
თუ მე მეტი აქ უფლება მე ვხედავ, რომ
Touch Up Inside არის სადენიანი to newGame მეთოდი.
ამიტომ ამ აპირებს მიიღოს სამსახურიდან გაათავისუფლეს.
NewGame მეთოდით აპირებს ზოგიერთი წყობის.
იგი აპირებს ამბობენ მინდა გარკვევა სახელმწიფო საბჭოს.
ეს არის ლამაზი მეთოდი on mutable მასივები.
ეს ხდება იმის თქმა, რომ ეს არის X-ს თავის მხრივ,
და ახლა მე ვაპირებ ისარგებლოს ამ viewWithTag რამ.
>> მე ვიცი, რომ ჩემი ღილაკები აქვს tags 1-9,
და ეს რაღაც მე თვითნებურად აიღო.
თუკი მინდა მითითებული ტექსტი ყოველი ღილაკს იყოს ცარიელი
რადგან მე მხოლოდ დაიწყო ახალი თამაში და არ მინდა რაიმე
XS ან Os უნდა დარჩენილი შემიძლია ამის გაკეთება.
შემიძლია ვთქვა, მინდა ხედს tag, 1, 2, 3, 4 et cetera.
ეს იქნება დახევის სხვადასხვა ღილაკს ყოველ ჯერზე.
აქ მე ვაპირებ მიცემული მას UIButton.
ისევე, როგორც ჩვენ შეგვიძლია მიცემული ints რომ მოძრავი და პირიქით
ამ ნათქვამია, რომ მინდა მიცემული ეს UIButton.
ეს იმას ნიშნავს ტიპის ეს იქნება UIButton *
გამო პოინტერები, მაგრამ არ ინერვიულოთ, ისინი არ საშინელი უქმნით.
>> ერთხელ მაქვს ამ ღილაკს მე ვაპირებ მოვუწოდო მეთოდით მასზე.
ეს მეთოდი ეწოდება setTitle forState და ა.შ. ეს ამბობს
მინდა მითითებული ტექსტი ღილაკს იყოს ცარიელი სტრიქონს,
და მინდა, რომ იყოს ცარიელი სტრიქონს როდესაც ეს არ დაპრესილი.
თუ მე ამ მეთოდით, შემიძლია შეცვლის ტექსტი ღილაკს
როგორც კი ვინმე ჰიტები, მაგრამ ჩვენ გვინდა, რომ ვთქვათ, როდესაც ღილაკი უბრალოდ სხდომაზე
მინდა ტექსტი ცარიელი.
საბოლოოდ, ჩვენ ვაპირებთ ინიციალიზაცია ჩემი საბჭო,
და მე ვაპირებ ვთქვა, რომ ყველაფერი არის გაკეთებული at 0,
ამიტომ ამ ფორუმის წევრები immutable არის mutable მასივი,
რაც იმას ნიშნავს, მე შემიძლია მოვუწოდო addObject მეთოდი და უბრალოდ 0 შიგნით მას.
რაც ხდება, როდესაც მე შექმნა ახალი თამაში.
>> მოდით შევხედოთ მეორე.
ეს მეთოდი აქ IBAction რომ იქნება დაპრესილი
ყოველ ჯერზე ერთი იმ მოედნებზე არის დაპრესილი.
ახლა ჩვენ გვაქვს გარკვეული Tic TAC Toe ლოგიკა აქ.
ჩვენ გაერკვნენ, რომლის მხრივ ეს,
და ეფუძნება, რომ ჩვენ არც მითითებული X ან O,
მაგრამ ჩვენ რომ ჩვენ მეორეული გამოყენება ამავე ღონისძიებაზე დამმუშავებლის
ამისთვის თითოეული იმ ღილაკებით.
ეს იმას ნიშნავს, რომ მე არ მაქვს მეთოდი ზედა მარცხენა ღილაკს,
სხვადასხვა მეთოდი ქვედა მარჯვენა ღილაკს, თუმცა მე ვერ გავაკეთეთ, რომ.
რომ ნამდვილად არ იქნება კარგი დიზაინით.
რა ვარ აკეთებს აქ მე რეალურად აპირებს, რათა დადგინდეს
რა tag of ღილაკს, რომელიც დაპრესილი არის.
თქვენ შეამჩნევთ, რომ ეს პიესა მეთოდი იღებს ერთ არგუმენტად.
ეს მოუწოდა გამგზავნი და რა გამგზავნი არის არის გამგზავნი აპირებს
წარმოადგენს სწორედ ის, რაც გადაიყვანეს სამოქმედო საფუძველზე.
თუ მე დააჭირეთ ღილაკს, ამ გამგზავნი იქნება, რომ UIButton
რომ მე ფაქტობრივად დაპრესილი, ასე რომ იმას ნიშნავს, რომ, რომ UIButton
აქვს tag რადგან მე შექმნილი ტეგით.
>> თუ მინდა კიდევ ზე tag შემიძლია უბრალოდ ვთქვა
მინდა tag გამომგზავნის,
და ისევ, მე უბრალოდ მონაწილე მას UIButton.
მე მოხდეს ვიცი, რომ გამგზავნი იქნება UIButton.
ეს ყოველთვის არ უნდა იყოს UIButton.
შემეძლო, მაგალითად, რეგისტრაცია ამავე ღონისძიებაზე დამმუშავებლის
ერთი ამისთვის ღილაკს, ერთი სლაიდერი.
ამ შემთხვევაში, მე ვიცი, ისინი ყველა ღილები, ისე მე ვაპირებ ვთქვა
მინდა ეს უნდა იყოს ღილაკი და მერე შეიძლება კიდევ tag,
და tag მე ახლა ვიცი, სად ვარ შიგნით ფორუმში.
მაშინ მე უბრალოდ მითითებული ან X ან O, შეგიძლიათ Flip მხრივ,
შეამოწმეთ რომელმაც მოიგო, et cetera.
>> ნებისმიერი კითხვები ამ აქამდე?
Okay, ყველა კოდი ჩვენ posted Online-არ გვინდა შეღწევას ძალიან ბევრი
საქართველოს Tic TAC Toe ლოგიკა, მაგრამ ახლა თქვენ ხედავთ, რომ ნამდვილად
ყველა ვაკეთებთ არის ჩვენ looping ამ მასივი,
ამიტომ ჩვენ გვაქვს რამდენიმე ამისთვის მარყუჟების აქ, და ჩვენ უბრალოდ შედარებით ვხედავ
გვაქვს მატჩი ყველა სტრიქონების, მატჩი სვეტი ან არაფერი რომ.
რეალურად აწარმოებს ამ app, თუ დაკრავენ ერთი ამ ღილაკებიდან
რომ პიესა მეთოდით გაათავისუფლეს, ისე, რომ ნიშნავს მე უბრალოდ მითითებული
ღილაკს იყოს X, ამიტომ ახლა ამ ღილაკს იქნება O, და ასე შემდეგ,
და ა.შ. ასე რომ ჩვენ დაწყებული ურთიერთქმედება ამ ერთი გვერდი app.
>> ჩვენ პოსტი კოდი, ასე მოგერიდებათ peruse რომ,
მაგრამ მოდით ახლა ვისაუბროთ ზოგიერთი apps რომ უფრო მეტია ვიდრე უბრალოდ ერთი გვერდი.
როგორც მღელვარე, როგორც Tic TAC Toe იყო, ბევრი apps შიგნით iOS
არიან სახის ამ საბურღი ქვემოთ რამ მრავალი ეკრანები.
პირველი კონცეფცია, რომ ჩვენ უნდა ვისაუბროთ are ოქმები,
და ოქმი უბრალოდ კომპლექტი მეთოდები
რომ თქვენ შეგიძლიათ გპირდებით, რომ განსაზღვროს.
თუ შევქმნა ახალი პროტოკოლით 2 მეთოდები, ამ პირველი,
თუ დაბრუნების ტიპის ბათილია, მე მას foo.
იგი იღებს არანაირი არგუმენტი. მე მაქვს სულ სხვა მეთოდით.
ის დააბრუნებს int. მე მას ბარი, და ეს ხდება ერთი არგუმენტი.
ყველა ამ ოქმის ის არის, რომ ე.წ. SomeProtocol აქ,
ეს არის კომპლექტი რამ, რომ ვინმეს შეუძლია განახორციელოს.
მე არ შიგნით ამ ოქმის განაცხადა რა foo აკეთებს.
სამაგიეროდ, მე უბრალოდ ვამბობ, რომ თქვენ შეიძლება განსაზღვროს foo თუ გსურთ.
თუ მე შექმნის დასაწყისში კონტროლერი ან ქმნის კლასის
შემიძლია შიგნით რომ კლასის დაპირება განახორციელოს
ზოგიერთი მეთოდები, ასე მაგალითად, თუ ვიტყვით,
ეს ახლა ამბობს მე მიღების დაპირება, რომ შიგნით
ამ დასაწყისში კონტროლერი კლასის მექნება განმარტებები ორივე foo და ბარი.
>> რატომ არის, რომ სასარგებლო?
ბევრი კომპონენტები შიგნით iOS ისარგებლოს ამ
დიზაინის ნიმუში მოუწოდა დელეგაცია, და რა დელეგაციის ამბობს
ის არის, რომ, მაგალითად, თუ მაქვს ტექსტი ყუთი
და არსებობს მოვლენები, რომლებიც შეიძლება დარეგისტრირებულ შიგნით ჩემი ტექსტური ყუთი,
ვიდრე შექმნის ცალკე მოვლენების რა შემიძლია არის შემიძლია ვთქვა
დელეგატი ეს ტექსტი ყუთში იქნება გარკვეული ობიექტი.
როდესაც ვამბობ, რომ ეს არის დელეგატი არის, რაც იმას ნიშნავს, რომ
როდესაც რამდენიმე ღონისძიება იქნებოდა ცეცხლი ტექსტი ყუთი
ვიდრე მქონე რეგისტრაცია ან არაფერი რომ
უბრალოდ ვაპირებ მოვუწოდო მეთოდი on დელეგატი.
მაგალითად, შიგნით ჩემი ტექსტური ყუთი მაქვს მეთოდი როცა დააჭირეთ
რომ გაკეთდეს ღილაკს ქვედა მარჯვენა,
და ასე, ვიდრე რეგისტრაციით ღონისძიება დამმუშავებლის შემიძლია ვთქვა არის
text box, აქ არის ობიექტი, რომელსაც მინდა მოვუწოდო მეთოდით შესახებ
ყოველ ჯერზე ვინმე სინჯავს გაკეთდეს ღილაკს,
და ეს იმას ნიშნავს, რომ ობიექტი უნდა განახორციელოს გარკვეული ოქმი
რომელიც ამბობს, მე გპირდებით, რომ განსაზღვროს, რომ გაკეთდეს ღილაკს ქმედება,
რადგან თუ ეს არ განმარტავენ, რომ მეთოდი და დააჭერთ გაკეთდეს,
მაშინ იქნება დამაბნეველი.
>> მოდით შევხედოთ მაგალითს.
აქ უბრალოდ აქვს ერთი ტექსტი ყუთი,
და ერთი თვისებების ამ ველში მეტი აქ ამ მარჯვენა მხარეს არის დელეგატი.
ეს არის ქონების კლასი.
რა გავაკეთე აქ მე გააკონტროლოს დააწკაპებთ, და მე გამოათრიეს ამ ადგილზე მეტი აქ
to view კონტროლერი, და რომ ამბობს ახლა დელეგატი ამ ველში
იქნება ხედი კონტროლერი.
ეს იმას ნიშნავს, რომ როდესაც ზოგიერთი ქმედებები მოხდება, ვიდრე რეგისტრაციით
ცალკე ღონისძიება ელფოსტის მინდა გააგზავნოთ დელეგატი.
ახლა მოდით შევხედოთ ჩემი აზრით კონტროლერი.
შიგნით. თ ფაილის მე გააკეთა დაპირება.
მე დაპირდა განახორციელოს გარკვეული მეთოდები შიგნით ამ ოქმის
მოუწოდა UITextFieldDelegate, და ისევ,
ეს მხოლოდ რამდენიმე სიაში ზოგი რამ, რომ მე შეგიძლიათ განახორციელოს.
>> თუ მე აქ ჩამოვედი ჩემი. მ ფაილი, მე არ განხორციელდა ერთი ასეთი მეთოდი.
მე მას textFieldShouldReturn
იმიტომ, რომ ის, რაც მას ეწოდა შიგნით ოქმს.
და ახლა როდესაც მე დააჭირეთ გაკეთდეს ღილაკს შიგნით რომ ტექსტური ველი
ეს რა ხდება მისაღებად მოუწოდა, ამიტომ არ გაატარა ღონისძიება დამმუშავებლის.
მე დაკავშირებული დელეგატი, და როდესაც ეს ღონისძიება ნასროლი
ეს მეთოდი რომ მიიღებს მოუწოდა, ასე რომ, თუ მე მეტი აქ ჩემი storyboard და გაუშვით-
ხოლო რომ დატვირთვისა ვხედავთ რა ეს იმას.
ჩემს ეკრანზე მაქვს 2 რამ.
მაქვს ამ ველში, და მე ამ ნიშანს.
მე უბრალოდ ვამბობ, მინდა ტექსტი ამ ნიშანს
უნდა იყოს ტოლი რასაც მომხმარებლის აკრეფილი შიგნით ტექსტური ველი.
ეს შემდეგი ხაზი აქ არის უბრალოდ მეთოდი, რომ მე მოუწოდებენ
ტექსტზე სფეროში, რომელიც ამბობს, მინდა დამალვა კლავიატურაზე.
ეს არის მხოლოდ თვითნებური მეთოდით რომ Apple შეარჩია.
>> ერთხელ, სანამ მე არაფერი მომიწია WIRE ყველაფერი მდე, ასე რომ მე პირველი მოვიდა აქ.
მდებარეობა View კონტროლერი მე გადაიტანეთ მეტი ტექსტი ყუთში.
მე გაუშვებენ, და მე ვხედავ, აქ რომ მე შემიძლია ამ ველში ქონება
რადგან მეტი აქ ხედი კონტროლერი მე განსაზღვრული ქონება
რომ არის IBOutlet of ველში.
ეს ამბობს, რომ შემიძლია WIRE ამ ქონების up
to ველში ჩემი UI.
ახლა, როდესაც მე დააჭირეთ შემიძლია დაიწყება აკრეფით.
არის თუ დააწკაპუნეთ გაკეთდეს ღილაკს ამ აპირებს ცეცხლი
ღონისძიება, რომ შემიძლია ახლა რეაგირება.
არარის ღონისძიება ელფოსტის.
ასე უბრალოდ უპასუხა, რომ გაკეთდეს ღილაკს.
აზრი?
>> ეს არ არის დიზაინის ნიმუში, რომ-თქვენ შეიძლება არ ოდესმე მოვძებნოთ თავს
შექმნის საკუთარ ოქმი, მაგრამ ვიცი, რომ ვიღაც
სხვადასხვა iOS კომპონენტები რეგისტრაცია მოვლენების სხვადასხვა გზით.
ღილები, მაგალითად, გამოიყენოთ იმ IBActions.
ტექსტი სფეროში, მეორეს მხრივ, ვაპირებთ გამოვიყენოთ დელეგატი.
ჩვენ ვხედავთ და შეგიძლიათ გამოიყურებოდეს ყველა რომ შიგნით დოკუმენტაცია.
სხვათა შორის, იქ რეალურად ტონა UI პერსონალის ჩაშენებული iOS თქვენთვის,
ასე მაგალითად, გზას მე მივიღე, რომ აცხადებენ, კეთდება ქვედა მარჯვენა
არის მე შერჩეული ამ ველში.
მე მოვიდა აქ.
მე scrolled ქვემოთ bit დაბრუნების გასაღები,
და მე შემიძლია რეალურად ეს მთელი bunch რამ, როგორიცაა, თუ მინდა, რომ ვთქვა
საგანგებო მოვუწოდებთ ნაცვლად შემიძლია, რომ, რომელიც მთლიანად შემთხვევითი,
და მე არ ვიცი, თუ რატომ არის ჩამონტაჟებული გადაუდებელი ზარის ღილაკს,
მაგრამ, ნათქვამია საგანგებო ზარის წელს მართლაც მცირე ასოებით.
აქ თქვენ წასვლა.
>> აუცილებლად შეისწავლონ ყველა ეს სხვადასხვა პარამეტრების iOS.
ნებისმიერი შეკითხვა დელეგატი?
ისევ და ისევ, მხოლოდ საინტერესო დიზაინის ნიმუში, რომ თქვენ უნდა იცოდეს.
Okay, მოდით შემდეგი შევხედოთ მაგიდა views.
ცხრილის ძირითადად, რომ სიაში ელემენტი რომ არის მთელი ადგილი iOS.
როდესაც თქვენ flipping მეშვეობით ყველა თქვენი კონტაქტები, თქვენ ეძებს
შექმნის გვერდზე, და რომ ერთგვარი სია რამ ჰქვია ცხრილის.
განმახორციელებელი მაგიდა View in iOS საკმაოდ მარტივია.
იმის ნაცვლად, მიღების კლასი რომელიც descends რომ UIViewController
როგორც ჩვენ გავაკეთეთ ადრე ჩვენ უბრალოდ უნდა ვთქვათ, ვიდრე
ყველაფერი UIViewController ამჯამად მინდა გავაკეთოთ,
მე ვიტყვი, ყველაფერი UITableViewController ამჯამად მინდა გავაკეთოთ,
ასე რომ უბრალოდ დასძენს ზოგიერთი დამატებითი რამ, რომ მთლიანად კეთდება ჩვენთვის.
ჩვენ გვჭირდება ძალიან ცოტა ძირითადად შეავსონ ბლანკები შიგნით მაგიდასთან.
>> იმისათვის, რომ არიან მაგიდასთან მე უნდა უპასუხოს გარკვეული კითხვები.
პირველი კითხვა მე უნდა უპასუხოს არის რამდენი კვეთები ცხრილში?
როდესაც თქვენ flipping საშუალებით თქვენი კონტაქტების app თქვენ შეამჩნევთ, რომ ეს ერთგვარი
მიერ ორგანიზებული როგორც, მაშინ თქვენ გაქვთ BS, და თქვენ, რომ პატარა ქვე header.
თითოეული მათგანი ეწოდება მონაკვეთზე.
თქვენ შეიძლება იყოს ან არ გვჭირდება ამ.
პირველი, რაც თქვენ გჭირდებათ რომ გააკეთოთ, არის განახორციელოს მეთოდი
მოუწოდა tableView: numberOfSectionsInTableView.
რომ უბრალოდ ბრუნდება რამდენი სექციები გაქვთ,
ასე რომ, ეს შეიძლება ითქვას დაბრუნებას ერთი თუ თქვენ გაქვთ ერთი დიდი მაგიდა ხედი.
შემდეგი საკითხი, რომ iOS უნდა გაიგოს, თუ რამდენად ბევრი რიგები გაქვთ?
მაგალითად, თქვენ flipping მეშვეობით ცხრილის.
თქვენ გაქვთ ფიქსირებული პუნქტების სიმღერები თქვენ ეძებს ან ფიქსირებული რაოდენობის კონტაქტები.
თუ თქვენ მე, რა თქმა უნდა, არ არის, რომ ბევრი,
და ა.შ. ასე iOS იცის რამდენი საკნები ცარიელია.
>> ისევ და ისევ, ეს შეიძლება ითქვას, რაღაც დაბრუნების 3.
ჩემი ცხრილის აქვს 3 რიგები.
საბოლოოდ, iOS უნდა გაიგოს, თუ რა თითოეული უჯრედის ჰგავს,
ამიტომ რასაც ის რეალურად აპირებს არის მოვუწოდებთ ეს მეთოდი ქვემოთ აქ,
ამ tableView: cellForRowAtIndexPath.
ეს ვაპირებ მოვუწოდო ამ მეთოდის ყოველ ერთ საკანში შიგნით თქვენი მაგიდასთან.
როგორ ვიცი რამდენჯერ უნდა დავარქვათ?
ისე, თქვენ განუცხადა მას შიგნით სტრიქონების რაოდენობა მონაკვეთზე.
ჩვენ ვაპირებთ, რომ მოვუწოდო ამ თითოეული ჩვენი საკნები,
და შიგნით ეს სადაც შეგიძლიათ მართლაც რამ, როგორიცაა
მითითებული ტექსტი ან გითხრათ რა რომ პატარა ლურჯი ღილაკს მარჯვენა მხარეს არ.
ნიმუში მისაღებად ამ საკნებში, ჩვენ ვაპირებთ ამ მეთოდის გამოყენება
მოუწოდა dequeueReusableCellWithIdentifier.
>> Objective-C არის ძალიან ცნობილია სასაცილოა სიგრძე მათი მეთოდი სახელები,
და ეს მართლაც ლამაზი მაგალითია მაგალითად.
რა ეს მეთოდი არ არის ამ უბრალოდ ამბობს მინდა მომეცი საკანში.
უბრალოდ iOS რამ.
თუ თქვენ გაქვთ რაღაც 100,000 სიმღერები თქვენს iPod
რა iOS არ სურს გააკეთოთ გამოყოფს 100,000 საკნები,
რადგან თუ თქვენ ზედა თქვენს სიაში, თქვენ ნამდვილად უნდა გამოყოს მეხსიერება
ამისთვის საკანში რომ 99.000 რიგები ქვემოთ?
არა, რადგან როგორც თქვენ სენსორული შეგიძლიათ სახის გამოყოფას, როგორც თქვენ წავიდეთ ერთად.
ეს კეთდება თქვენთვის.
თქვენ არ ინერვიულოთ შესახებ ყველა რომ სულელური შესრულება პერსონალის.
ყველა ამბობთ არის რეკავთ ამ მეთოდით dequeueReusableCellWithIdentifier,
და ეს ამბობს, okay, თუ საჭიროა მე ვაპირებ, რომ შევქმნათ ახალი საკანში თქვენ.
>> მაგრამ თუ თქვენ ბოლოში მაგიდა და თქვენ უკვე გამოყო გარკვეული უჯრედების
ზედა მაგიდაზე, რომ თქვენ ნამდვილად არ სჭირდება უახლოეს მომავალში
მე ვაპირებ მოგცემთ ერთი იმ თავში ნაცვლად გამოყოფის ახლის,
და ა.შ. ეს არის ლამაზი შესრულება შეშფოთებას.
თქვენ არ გამოყოს უჯრედების თავს.
რომ აპირებს მოგცემთ უკან საკანში.
ის დაბრუნებას აპირებს თქვენ საკანში ობიექტი.
ერთხელ თქვენ საკანში ობიექტი შეგიძლიათ გააკეთოთ პერსონალის მას.
შეგიძლიათ დააყენოთ ტექსტი საკანში ეს უძრავი მოუწოდა text label.
თქვენ შეგიძლიათ დაამატოთ, რომ ისარი მარჯვნივ ან სხვა შემთხვევითი პერსონალის
ამ სხვა ქონება მოუწოდა accessoryType და ასე შემდეგ და ასე შემდეგ.
>> მოდით შევხედოთ რეალურად განხორციელების ცხრილის არის.
როდესაც მე შექმნილი ეს პროექტი
ვიდრე ამბობდა ერთჯერადი ხედი განაცხადის მე რეალურად მოვიდა აქ
მაგისტრის-დეტალურად განაცხადი და ისე ძირითადად ამ შეესაბამება გვერდის app
on iPad ერთად ცხრილის მარცხენა და შემდეგ შინაარსი მარჯვენა.
On iPod ან iPhone ამ აპირებს შეესაბამება ერთ მაგიდასთან ხედი.
სწორედ აქ მე მივიღე ჩემი შემქმნელის კოდი.
>> მოდით პირველი შევხედოთ storyboard.
ყველა ამ გაკეთდა ჩემთვის, ძირითადად შექმნილია.
ეს ნავიგაციის პანელი მიჩვენა რა მაგალითად საკანში შეიძლება გამოიყურებოდეს,
და შემიძლია ორმაგად დაწკაპეთ ამ, სახელწოდების შეცვლის.
ნებისმიერი სხვა UI შეშფოთება მე შეუძლია იქ.
Header ფაილი გამოიყურება ნამდვილად მარტივი.
იმის ნაცვლად, რომ ამ არის UIViewController ჩვენ ახლა ვამბობთ, რომ ეს არის
TableViewController, ამიტომ ჩვენ ვიცით, რომ ჩვენ გვინდა მოვუწოდებთ ყველა იმ მაგიდასთან მეთოდები.
შემდეგი მინდა შეიქმნას საკუთრების რომ აპირებს წარმოადგენენ
რამ შიგნით ჩემი მაგიდა.
ამ მაგიდის აპირებს თვითნებურად ცარიელია
სიაში ხილი, და ამიტომ უნდა შევქმნათ გარკვეული მასივი
რომელშიც I ჩადეთ ხილი.
შიგნით ჩემი განხორციელების ფაილის პირველი რაც მინდა გააკეთოს
არის მე გვინდა დავრწმუნდეთ მე ვრთავ ამ მასივი.
>> მე ვუთხარი alloc init შექმნილი ჩემი ხილის მასივი,
და მე დასძინა 4 რამ მას, რომელთაგან ერთი ბევრად უფრო საკამათო ვიდრე სხვა 3.
და ახლა აქვს მასივი ზომა 4.
ჩვენ შერყევისკენ it up in CS50.
მე ახლა მასივი ზომა 4.
ახლა მე ვაპირებ დაწყება ავტომოპასუხეები ამ კითხვებზე, და ფაქტობრივად,
როცა შექმნა ეს app ყველა ამ უკვე გაკეთდა ჩემთვის.
მე არ უნდა აკრიფოთ გარეთ ხმების სექციების ცხრილის.
ეს იყო უკვე იქ და მე შევსების ბლანკები.
რამდენი სექციები მაქვს?
ერთი. ყველა გაკეთდეს.
რამდენი რიგები მაქვს?
ისე, ერთი რიგის ყველა ხილი, ასე რომ ეს რაოდენობა
არის საკუთრების ნებისმიერი მასივი, რომელიც ამბობს, რამდენად დიდი არის ეს?
ასე ბევრი რიგები მაქვს.
და ბოლოს, მე უნდა ვთქვა რა ყოველ საკანში გამოიყურებოდეს?
მე ვაპირებ ვთქვა dequeueReusableCellWithIdentifier.
>> ერთხელ, ეს იყო უკვე დაწერილი ჩემთვის.
მე არ უნდა გავაკეთოთ ამ თავს, და მე მინდა დავუბრუნდეთ
ამ საკანში ამ ადგილას.
გახსოვდეთ, რომ ჩვენ მოუწოდებდა ამ იგივე მეთოდით ყოველ ერთ საკანში,
და ეს არგუმენტი აქ, ამ indexPath არგუმენტი,
ამბობს რა ზედიზედ მე შემოსული
თუ მე ვიტყვი, indexPath.row ქვემოთ აქ
ეს იქნება 0, მაშინ ეს იქნება 1, შემდეგ ეს იქნება 2, და ეს ასე ვიცი
რა საკანში მე გაკეთებული ჩვენებისას.
მინდა მითითებული ტექსტი საკანში გამოყენებისას textLabel ქონება
წასვლა შიგნით ჩემი ხილის array და მიიღეთ
ობიექტის შესაბამისი თითოეული მწკრივი.
თუ ეს ტექსტი, მე ახლა განსაზღვრავს
ტექსტი ქონების სიმებიანი.
შემიძლია ერთი რამ სხვა.
შემიძლია ასევე რეგისტრაცია ღონისძიება დამმუშავებლის თითოეული საკნები,
ასე რომ, როდესაც მე დაკრავენ თითოეულ ამ უჯრედების
ამ didSelectRowAtIndexPath, ეს იქნება მოუწოდა ჩემთვის,
ასე უბრალოდ განსაზღვრის ამ შემიძლია ახლა ამუშავებს რა ხდება
როდესაც თქვენ დაკრავენ საკანში, და კიდევ ერთხელ, ჩვენ ავლით რომელშიც საკანი იყო გეხმარებოდნენ
ასე, რომ ჩვენ შეგვიძლია reuse ამ ამავე ღონისძიებაზე დამმუშავებლის ყველა ჩვენი უჯრედები.
>> ისევ და ისევ, ეს არის ის, iOS აკეთებს ჩემთვის.
მოდით არიან სხვა უსიამოვნოს popup
რომ უბრალოდ ამბობს თქვენ აიყვანეს რაღაც აქ რომ რაღაც
იქნება ზედიზედ ობიექტი.
როდესაც მე აწარმოებს ამ, მე ვაპირებ ამ ლამაზი ცხრილის
ერთ მწკრივში თითოეული ამ ხილის, და თუ დაკრავენ ერთი
ეს მეუბნება, თუ რა მოხდა.
აზრი?
მოდით ავაშენოთ ცოტა მეტი კომპლექსი app,
ისევე როგორც დაწკაპვით თქვენ აიყვანეს ტომატის არის.
ლამაზი ნაწილი შესახებ storyboarding
არის არა მხოლოდ აპირებს დაგვეხმარება დიზაინი ეკრანები ინდივიდუალურად,
ის ასევე აპირებს დაგვეხმარება უსიამოვნოა ერთად ჩვენი მთელი app,
ამიტომ საბოლოო app ჩვენ იყოს შენობა ამ ლამაზი სპორტული ამბები მკითხველს,
და ამიტომ აპირებს რამდენიმე ეკრანები და ა.შ. მე შემიძლია რეალურად წარმოადგენენ
თითოეულ ამ მრავალჯერადი ეკრანები on storyboard,
და შემიძლია დააშორებს და ვხედავ ჩემი app საწყისი მაღალ დონეზე.
>> იმისათვის, რომ შევქმნათ ახალი ელემენტს შიგნით ჩემი storyboard
ეს მართლაც მარტივი შიგნით Interface Builder.
თუკი მინდა დაამატოთ კიდევ ერთი ეკრანზე ამ, მაგალითად,
შემიძლია პირველი zoom out ერთად pinch Zoom რომ Apple უყვარს იმდენად,
და ქვევით აქ ადრე მე მოძებნოთ ღილაკს
და მე გადააადგილება ღილაკს
თუ მინდა, რომ შევქმნათ ახალი ეკრანის შემიძლია რეალურად მხოლოდ გადააადგილება
მთელი ხედი კონტროლერი, ასე რომ, თუ მე აირჩიოთ ამ, გაიყვანოს მას მეტი აქ,
hey, არსებობს კიდევ ერთი ეკრანზე, და ა.შ. ახლა გამოყენებისას იგივე storyboard ფაილი
შემიძლია აქვს ყველა ეკრანები შიგნით ჩემი app, და შემიძლია დააშორებს
და ვხედავ, როგორ შეარჩიონ.
ეს არ შეარჩიონ ამჟამად.
გზა, რომელიც ამ 2 ეკრანები ურთიერთქმედება არის თქვენ განსაზღვრავს ურთიერთობებს.
შეგიძლიათ ძირითადად ამბობენ, რომ ეს ეკრანზე, როდესაც თქვენ დააჭირეთ ამ ღილაკს,
მინდა ლღობას მეტი ამ ახალ ეკრანზე.
ეს იმას ნიშნავს, არსებობს ასეთი სახის ურთიერთობის
პირველი ეკრანზე და მეორე ეკრანზე.
თქვენ ძირითადად arrow რომ ღილაკს მეორე ეკრანზე
ამბობდნენ, რომ როდესაც ამ ღილაკს რომ სადაც მინდა წასვლა.
ისევე, როგორც ჩვენ ვაკონტროლებთ დააწკაპებთ და გამოათრიეს, განისაზღვროს იმ საშუალებების
ჩვენ ვაპირებთ იგივე უნდა განსაზღვროს ამ segues.
>> ჩვენ დავინახავთ, მაგალითი, რომ, და სანამ ჩვენ რეალურად გარდამავალი
ერთი ეკრანზე სხვა iOS არის ლამაზი საკმარისი მოვუწოდო ამ მეთოდით
მოუწოდა prepareForSegue, და ეს არის სადაც ჩვენ შეგვიძლია დავიწყოთ
გაგზავნის მონაცემები ერთი app სხვა.
მაგალითში ჩვენ შესახებ შევხედოთ იგი ძირითადად საშუალებას მოგვცემს
რათა გავფილტროთ ბეისბოლის გუნდები მიერ ლიგები და სამმართველოების.
როდესაც მე შეარჩიეთ ლიგა, მაგალითად, მინდა გარდამავალი
ჩემს შემდეგ ეკრანზე, სადაც მე ვერ არიან ყველა დაყოფა
ამ ლიგის ან ყველა სხვადასხვა გუნდები.
მე უნდა გავუგზავნოთ, რომ ეკრანზე რა გუნდები უნდა ცარიელია.
გავაკეთოთ, რომ მე ვაპირებ ისარგებლოს ამ მეთოდით აქ.
>> საბოლოოდ, მხოლოდ შემთხვევითი წერტილი iOS.
თუ გსურთ შეინახოთ მონაცემები არსებობს ამ რამ მოუწოდა ძირითადი მონაცემები,
რაც რეალურად სახის გართულებული მუშაობა.
ასევე, შეგიძლიათ გამოიყენოთ SQL შესანახად მონაცემები,
რომელიც, კიდევ ერთხელ, არის ლამაზი, მაგრამ სახის შესახებ უფრო რთული მხარე მუშაობა,
მაგრამ iOS მხარს უჭერს ამ მართლაც მაგარი რამ მოუწოდა ქონება სიები
და საკუთრების სიაში მხოლოდ ფაილი, რომელიც წარმოადგენს გასაღები მნიშვნელობის წყვილის.
თქვენ განსაზღვრავს სიაში გასაღებები, და თქვენ ამბობენ, რომ ეს გასაღები იქნება მასივი.
ეს გასაღები იქნება სიმებიანი, და ძირითადად არაფერი შეგიძლიათ გააკეთოთ
წელს JSON შეგიძლიათ გააკეთოთ შიგნით ქონების სია,
და ამიტომ ეს მართლაც ლამაზად საშუალებას გვაძლევს ვიმუშაოთ ზოგიერთი მონაცემები.
მაგალითად, მე მაქვს ამ Teams.plist რომ მე შეიქმნა.
მე შექმნილი ახალი plist ფაილის, და შემიძლია საბურღი down.
ეს არის ლექსიკონი, ეს არის ლექსიკონი, ეს სტრიქონები,
და ა.შ. ეს არის ლამაზი გრაფიკული წარმომადგენლობა JSON დოკუმენტი
ან უბრალოდ კომპლექტი გასაღები მნიშვნელობის წყვილის,
და ა.შ. ეს მონაცემები რომ მე მუშაობს შიგნით ჩემი app.
>> მოდით პირველ გადმოდიოდნენ აქ. ჩვენ კიდევ ბევრი გვაქვს ფაილი არის.
მაგრამ მოდით პირველ გადმოდიოდნენ აქ storyboard.
Storyboard აქ თუ შემიძლია zoom out-
ჩვენ შეგვიძლია ახლა ვხედავ, რომ ეს არის ნაკადი ჩემი app.
მე პირველი იწყებს ამ ეკრანზე.
მე ვაპირებ საბურღი ქვემოთ ამ ეკრანზე,
და მე ვაპირებ საბურღი ქვემოთ ამ ეკრანზე, და ვხედავთ, რომ თუ სახის
გადაადგილება ერთი ამ გარშემო ჩვენ ამ ისრებით აპირებს აქედან აქ,
და გზა მე განმარტავენ, რომ arrow იყო თუ მიუახლოვდით ცოტა,
და თუ მე მეტი ამ თვალსაზრისით კონტროლერი,
და აქ საკანში, და მე მინდა ვთქვა, რომ როდესაც თქვენ დაკრავენ საკანში
მინდა ლღობას მეტი სხვა ეკრანზე.
მე შემიძლია უბრალოდ გეჭიროთ კონტროლის,
გადახვევა მეტი ცოტა, გეჭიროთ კონტროლის, გადაიტანეთ ამ საკანში მეტი და გაუშვებენ.
>> და აქ ჩვენ ვამბობთ, რა გარდამავალი რომ გსურთ გამოიყენოთ?
გსურთ გამოიყენოთ, რომ სლაიდ, რაც ე.წ. ბიძგი?
გსურთ ლღობას მდე ბოლოში?
რომ ე.წ. მოდალური.
და კიდევ მე დააჭირეთ ერთ ამ, ის აპირებს გავამახვილო ამ arrow ჩემთვის,
და ეს იმას ნიშნავს რომ მე ფაქტობრივად სიფრთხილით რა ხდება, როდესაც მე ამ ღილაკს გრაფიკულად.
არ დავწერე ნებისმიერი კოდი რეალურად ლღობას ერთი ეკრანზე ერთი.
მე განისაზღვრება ამ ვიზუალურად შიგნით Interface Builder.
თუ მე დააჭირეთ ამ arrow, ვხედავთ, რომ მე გავეცი ეს საგანი სახელი.
მე მას showDivisions, და ეს იმდენად, რომ შემიძლია ვიცი
რა გარდამავალი დაახლოებით დადგომას, და ვნახავთ, თუ რატომ მხოლოდ წ.
ასე მე სადენიანი მდე სხვადასხვა ეკრანები ჩემი app.
თუ ეს იყო კლავიში, მაგალითად, ვიდრე მაგიდაზე აზრით,
მე ვერ აკონტროლებენ დააჭირეთ ღილაკს, გადაიტანეთ გადასცა შემდეგ ეკრანზე,
და ასე შემიძლია ნავიგაცია, რომ გზა.
>> მართლაც სწრაფად, თუ ჩვენ მოვიდეს MasterViewController,
ერთხელ, ჩვენ უბრალოდ აპირებს განსაზღვროს სია რამ
რომ იქნება ნაჩვენები ცხრილის.
აქ მე ვამბობ, მინდა მიიღოს, რომ plist ფაილის,
და მინდა ჩატვირთვა it up შევიდა ლექსიკონი,
და კიდევ თქვენ გაქვთ, რომ ლექსიკონის, მე ვაპირებ ეპასუხა იგივე კითხვები ისევ.
აქ არის რამდენიმე მონაკვეთისაგან.
ერთი, არის ერთი რიგის ყველა ლიგის და ტექსტი თითოეული უჯრედის
უნდა იყოს პირველი, პირველი ლიგის, მეორე ლიგის, და ასე შემდეგ.
და ბოლოს, მე ვაპირებ ამ მეთოდის გამოყენება, რომ ჩვენ უბრალოდ ვნახე მოუწოდა prepareForSegue,
და ეს არის მეთოდი, რომ იქნება ნასროლი, როდესაც მე დააჭირეთ
ერთ იმ სტრიქონები და ამიტომ გააქტიურების რომ გარდამავალი
რომ მე შექმნილი ისრებით.
ეს ამბობს, რომ მე შემიძლია მქონდეს
ურთიერთობები ერთი ეკრანზე სხვა.
თუ მაქვს 2 ღილაკების და თითოეულ ღილაკს მოგაწვდით სხვადასხვა ეკრანზე
მე ვაპირებ აქვს 2 segues, 1 თითოეულ ღილაკს.
მაგრამ ეს prepareForSegue არის, კვლავ, იქნება reused
თითოეული სხვადასხვა ურთიერთობები, ისე, რომ ნიშნავს, რომ მე უნდა გზა
რაოდენობის დასადგენად, თუ დააჭერთ პირველ ღილაკს ან დააჭერთ მეორე ღილაკს.
>> დამახსოვრება როდესაც მივეცი, რომ segue სახელი, ამ showDivisions,
ასე მე ახლა ვიცი, რომ ეს არის segue რომ ამოქმედდა.
ყველა მინდა გააკეთოთ მინდა ვთქვა
მინდა გაერკვნენ, რა მე უბრალოდ მოხვდა,
და ასე მიიღოს, რომ, შემიძლია ვთქვა, მინდა indexPath ამისთვის შერჩეული ზედიზედ
გახსოვთ indexPath უბრალოდ ამბობს, სადაც მე უბრალოდ დაწკაპავთ,
და მაშინ მე მინდა ვთქვა, მინდა გაერკვნენ, სადაც მე ვაპირებ.
ეს destinationViewController, რომ ქონებას segue.
სწორედ ეკრანზე მე ვაპირებ,
ასე ვიცი, რომ ეკრანზე მე ვაპირებ ეწოდება DivisionsViewController
იმიტომ, რომ მე შექმნა, რომელიც კლასის,
და ა.შ. ახლა თუ ვიტყვი d.divisions
მე ახლა შექმნის ქონების ხედი კონტროლერი მე დაახლოებით წასვლა.
ეს არის როგორ მე ვაგზავნი მონაცემები ერთი ეკრანზე სხვა ეკრანზე.
>> Just ეძებს ამ DivisionsViewController
ხედავთ აქ რომ. თ ფაილი
არსებობს, რომ საკუთრების დივიზია, და რომ ის, რასაც მე ძირითადად მცხოვრებ,
ასე რომ, როგორ მე ვიცი, რომ მე ჩვენებისას დაყოფა შესაბამისი
ლიგა რომ მე დააწკაპებთ, და ისევ,
ფაქტობრივი ცხრილის გამოიყურება საკმაოდ ბევრი იგივე, უბრალოდ პასუხობდა იმ
3 მარტივი კითხვები ასევე საიდენტიფიკაციო
რა ხდება, როდესაც თქვენ გადატანა მომდევნო ეკრანზე.
მხოლოდ რამდენიმე სხვა რამ აქ.
თქვენ შეამჩნევთ ზედა აქ რომ ვიდრე ამბობდა # include
მე ახლა ვამბობ, # იმპორტი.
ეს არის მხოლოდ Objective-C რამ.
იმპორტი ძირითადად გავალამაზოთ ვერსია მოიცავს,
და მაგალითად, ჩვენ უნდა ვიცოდეთ რა ეს კლასი არის,
ასე არ შემიძლია უბრალოდ, ვამბობთ DivisionsViewController.
თუ ჩვენ არ hashtag standardio.c შიგნით ჩვენი. გ ფაილი
შემდგენელი წარმოდგენაც კი არ ჰქონდათ, თუ რა printf იყო.
ანალოგიურად, თუ არ იმპორტი DivisionsViewController
შემდგენელი ნამდვილად არ აქვს, როგორია DivisionsViewController არის.
უბრალოდ, დარწმუნდით, რომ შიგნით თქვენი განსხვავებული. მ ფაილი თქვენ დარწმუნდით იმპორტი
შესაბამისი. თ ფაილი ისე, რომ შემდგენელი იცის, რა ხდება.
>> და ბოლოს, რა Apple საბოლოოდ ამჯამად არის არიან ზოგიერთი მონაცემების გამოყენებით ვებ აზრით,
და ასე ვებგვერდი ხედი არის ობიექტი, რომელიც შეგიძლიათ ხმა
პატარა ბრაუზერში შიგნით თქვენი app.
ყველა თქვენ მხოლოდ უნდა მიაწოდოს URL თქვენს ბრაუზერში,
ამიტომ მინდა წასვლა mlb.mlb.com,
და აი როგორ შეგიძლიათ თქვათ საწყისი გვერდი თითოეული გუნდი,
და ა.შ. გავლით ამ URL
ვებ დასაწყისში შეგიძლიათ ცარიელია ამ ჩემთვის და შემიძლია დაათვალიეროთ გარშემო,
და სიმულატორი გამოიყენება, რომ ერთი.
ახლა ეს მოვიდა ჩემი plist.
თუ მე დააჭირეთ ამ ასევე მოვიდა ჩემი plist, და ამ გადაადგილებადი იყო სიფრთხილით
მიერ განსაზღვრის იმ segues.
მე დააჭირეთ და კიდევ ერთი,
და ახლა აქ არის ჩემი UIWebView, ამიტომ, ისევე, როგორც რომ
აქ ვებგვერდი URL რომ მე უბრალოდ ჩართული,
და მე არ უნდა გაუმკლავდეს არაფერი გიჟები.
ეს არის, თუ როგორ არიან ვებ გვერდზე.
რამ, როგორიცაა ამ თავში ღილაკს აქვეა მოცემული ჩემთვის
სრულიად უფასოდ რადგან მე განისაზღვრება ამ ურთიერთობების გამოყენებით segues.
>> ნებისმიერი კითხვები? Yeah.
[სტუდენტური] ასე რომ, როდესაც თქვენ იყენებთ alloc, თქვენ არასოდეს არ თავისუფალი არაფერი?
სწორედ, როცა რეკავთ alloc და init თქვენ არ გასათავისუფლებლად იგი.
IOS აპირებს გაუმკლავდეს ყველა რომ თქვენთვის.
ეს მშვენიერი, და თქვენ არ არღვევს რაიმე წესები. Yeah.
[სტუდენტური] თუ იყო მოიცავს მეტი გუნდები, რომლებმაც შეიძლება ეტევა ეკრანზე,
რომ ის ავტომატურად აქვს გადახვევა ვარიანტი, ან არის, რომ რაღაც თქვენ უნდა დაამატოთ?
სწორედ, მე რომ უფრო მეტი გუნდები, მაგალითად, ეს იქნებოდა ავტომატურად ამუშავებს
სენსორული ჩემთვის და ყველა სპექტაკლი შეშფოთება
ერთად უზარმაზარი მაგიდა ასევე სიფრთხილით მთლიანად ჩემთვის.
>> გაქვთ სხვა კითხვები?
ყველა ამ კოდექსის აპირებს გამოქვეყნდება.
ჩვენ სახის glossed ზე ცოტა მეტი არასრულწლოვანი ინფორმაცია
მაგრამ რამ, როგორიცაა შექმნის ზოგიერთი ქონების ვებგვერდი დასაწყისში
უბრალოდ რამ, რომ შეგიძლიათ მიიღოთ მიერ ათვალიერებს Apple-ის დოკუმენტაცია,
რაც რეალურად, მართლაც ლამაზად ასახული.
მათ აქვთ უამრავი ნიმუში apps და მაგალითად ჩვეულებების
სხვადასხვა APIs, ამიტომ აუცილებლად peruse იმ შემთხვევაში, თუ შეგიძლიათ.
რამოდენიმე სასარგებლო ბმულები დაგვჭირდება შევხედოთ.
ეს არის რამოდენიმე მოსახერხებელი დოკუმენტაცია გიდები.
მისამართები არის მასიური, ამიტომ ისინი შეუმცირდა.
ეს პირველი არის მთელი ბიბლიოთეკა დოკუმენტაცია.
არსებობს პატარა ძებნა ბარები, ასე რომ, თუ თქვენ დაიწყება აკრეფით ღილაკს
ეს დაიწყება გაწვდით ყველა ინფორმაციას ყველა რამ რომ თქვენ ღილაკს.
მე ასევე მაგიდა View პროგრამირება სახელმძღვანელო.
ეს სახელურები მაგიდა views ბევრად უფრო დეტალურად,
როგორ გავაკეთოთ რამ, როგორიცაა დინამიურად დაამატოთ უჯრედების ან შეცვალონ უჯრედების ან ამოიღონ მათ.
>> არსებობს უამრავი ნიმუში apps from Apple რომ გაჩვენებთ თუ როგორ კეთდება ეს,
და ბოლოს, ამ ბოლო ერთი ადამიანის Interface სახელმძღვანელოს
და ეს არის ძირითადად გარკვეული განხილვა UI კომპონენტების,
რამ, როგორიცაა არ აკეთებენ ღილაკს რომ 4 პიქსელი მიერ 4 pixels.
სწორედ ცუდი იდეა, და სხვა რამ, რაც Apple სურს რომ გააკეთოს
წაახალისოს კარგი დიზაინით.
>> ნებისმიერი ბოლო კითხვები სანამ დასრულდება up?
ყველა უფლება, აუცილებლად მოგერიდებათ-we're გვექნება სპეციალური ეტიკეტები შესახებ იმსჯელეს.
ჩვენ გვექნება iOS ერთი, ასე რომ აუცილებლად მოგერიდებათ გამოიყენოს რომ.
თუ გსურთ მუშაობა თქვენს თანაკლასელებს პროექტებში
ან დაეხმაროს გაერკვნენ ზოგიერთი შემთხვევითი iOS პერსონალის
მოგერიდებათ ელ ჩემთვის და აუცილებლად peruse ყველა კოდი ხაზზე რადგან
მხოლოდ ინტერესი დროს ჩვენ სახის glossed ზე მეტი
finer წვრილმარცვლოვანი დეტალები რამ.
მაგრამ თუ არა, მაშინ წარმატებას გისურვებთ თქვენს iOS პროექტებს, და იმედი მაქვს, რომ ჩვენ გვაქვს
დიდი შემოდინება of apps in App Store.
[CS50.TV]