>> TIANYU LIU: Hey, როგორ არის იგი აპირებს ყველას?
და ეს არის iOS App პროგრამირების ობიექტური c სემინარი.
და ჩემი სახელი არის Tianyu Liu.
მე Lowell junior ახლა, კონცენტრაცია კომპიუტერულ მეცნიერებაში.
ასე რომ, ამ სემინარზე ვარ აპირებს გასწავლით ბიჭები
ცოტა შესახებ, თუ როგორ გახადოს app.
Yay, კიდევ აღფრთოვანებული მას.
>> ასე რომ, სანამ ჩვენ კი დაიწყება diving შევიდა ფაქტობრივი პროგრამირების მხარეს,
მოდით უბრალოდ მართლაც სწრაფად საუბრობენ რატომ გსურთ აშენება iOS app?
რატომ არის iOS ისე რა?
ასე რომ, პირველი პრობლემა, პირველი საქმე იმაშია, რომ საკმაოდ გასაოცარია ჩვენთვის,
განსაკუთრებით როგორც CS50 აბიტურიენტი, არის ის, რომ iOS
იყენებს Objective C. ისე, არსებობს ახალი ენის მოუწოდა Swift,
მაგრამ ჩვენ არ ვაპირებთ გამოიყენოთ, რომ ეს სემინარი.
თუ თქვენ დაინტერესებული Swift, არსებობს არის დამოუკიდებელი სემინარი შესახებ.
მაგრამ მიზანი C, ძირითადად, superset of C. Meaning
ყველაფერი რაც თქვენ სარგებლობთ C საიტიდან უნდა ითარგმნოს Objective C
ძალიან მარტივად.
>> როგორც თქვენ ალბათ, მოგვიანებით, რომ მართლაც არსებობს რამდენიმე ძალიან ძირითადი სინტაქსი, რომლებიც
ძირითადად ზუსტად იგივე, C და ობიექტური C. ასე რომ,
მას შემდეგ, რაც თქვენ გაქვთ აღებული CS50 ამ შორს, თქვენ უკვე
ვიცი, Objective C, მინიმუმ 40%.
ასევე, Apple აქვს ნამდვილად ძლიერი API for iOS.
არსებობს უამრავი მართლაც გიჟები რამ რისი გაკეთებაც შეგიძლიათ იგი.
რომელთაგან ერთი ვინმე ფაქტობრივად შეიქმნა iOS app
კონტროლის მანქანა, რომელიც საკმაოდ საინტერესო.
ალბათ ვერტმფრენი უფრო საინტერესო.
მაგრამ ეს რამდენად ძლიერი iOS API შეიძლება იყოს.
>> და, როგორც თქვენ ალბათ figured out ახლავე,
დასტის overflow არის ერთ-ერთი ყველაზე მნიშვნელოვანი ონლაინ რესურსები
ხელმისაწვდომი.
და კარგი ამბავია, ყოველ ერთი პრობლემა შეგიძლიათ შესაძლოა
ვფიქრობ ხოლო მშენებლობის თქვენი პროექტის საბოლოო მიზანი C
სავარაუდოდ არსებობს დასტის overflow პასუხი.
ეს უბრალოდ გასაოცარია.
გარდა ამისა, iOS მართლაც პლატფორმა
სადაც შეგიძლიათ მიღწევა დიდი აუდიტორიის მცირე ძალისხმევა.
ეს იმას არ ნიშნავს Android, სადაც ყველაფერი საკმაოდ დანაწევრებული.
>> ყველაფერი iOS ერთიანია.
და რადგან თქვენ შექმნა ოთახი iPhone,
თქვენ შეგიძლიათ ძალიან მარტივად პორტი, რომ iPad, iPad mini, ან სხვადასხვა iPhone ზომის.
ეს არის ყველა მართლაც მოსახერხებელია.
და ეს მხოლოდ ძალიან კარგი დადებით შთაბეჭდილებას ახდენენ თქვენს მეგობრებს.
შეგიძლიათ უბრალოდ გამართავს iPhone და ვუთხრა თქვენს მეგობარს hey,
ეს არის app მე.
შეგიძლიათ გააკეთოთ, რომ ნებისმიერი დესკტოპის apps, რომელიც არის ლამაზი.
>> ყველა უფლება, ახლა მოდით რეალურად მიიღონ ენაზე მიზანი C.
რატომ არ უნდა დაიწყოს ზოგიერთი მართლაც ძირითადი სინტაქსი.
როგორც უკვე აღვნიშნე Objective C ეს ძირითადად superset of C.
ასე რომ, ბევრი ძირითადი სინტაქსი არის რეალურად ზუსტად იგივე.
ცვლადის და დამატებით ორი ცვლადები ერთად
ზუსტად ისე, როგორც ჩვენ გავაკეთეთ Mario.
არაფერი ახალი აქ.
>> ანალოგიურად, lodger for loop და მდგომარეობა არის ასევე იგივე.
შეგიძლიათ გააკეთოთ ამისთვის loop ისევე, როგორც თქვენ არ გააკეთა Mario [INAUDIBLE].
და შეგიძლიათ გააკეთოთ პირობები ისევე როგორც ის, რაც თქვენ
არ აკეთებდა წინა p კომპლექტი.
თუმცა, Objective C არ არის სრულიად C,
და იქ არის რაღაც, სახის უცნაური შესახებ.
>> პირველი მათგანი, რომ როდესაც თქვენ აკეთებს C პროგრამირების, თქვენ, როგორც წესი, დარეკეთ
მოიცავს და შემდეგ ბიბლიოთეკის სახელი.
მაგრამ მიზანი C მოვუწოდებთ, რომ იმპორტი.
ძირითადად ამბობდა ფუნქციონირება, უბრალოდ სხვადასხვა სახელები.
და სიმები რეალურად ცოტა უცნაურია.
თქვენ ხედავთ, რომ პირველი მთავარია, რომ უცნაური
არის, რომ თქვენ გაქვთ საკმაოდ უცნაური ბოდიში, თქვენ გაქვთ საკმაოდ უცნაური NS
მოაწეროს აქ.
და მეორე, რომ სახის უცნაური
თქვენ უნდა at ნიშანი ადრე რეალურად გამოცხადების string.
ასე at ნიშანი ძირითადად ნიშნავს რომ სიმებიანი არ არის მხოლოდ string,
ეს არის რეალურად ობიექტი.
ჩვენ ვაპირებთ, რომ ავუხსნათ რომ მოგვიანებით ასე არ
პანიკა თუ არ რას ნიშნავს ეს.
და ბეჭდვა კონსოლი არის ცოტა სხვადასხვა რადგან C ჩვენ მოვუწოდებთ printf,
მაგრამ მიზანი C ჩვენ მოვუწოდებთ [INAUDIBLE].
>> თქვენ შეიძლება გაინტერესებთ, რა არის ის, რომ.
რომ არის, ძირითადად, printf, უბრალოდ სხვადასხვა ენაზე.
ზუსტად იგივე გამოყენება, ზუსტად იგივე ფუნქციები.
ისე გამოდის, რომ მიზანი C რეალურად
აქვს ns პრეფიქსი თითქმის ყველაფერი, ყველა ძირითადი მონაცემები ტიპის,
NSString, NSArray, nsdictionary.
მიზეზი, რომ ns რეალურად დგას შემდეგი ნაბიჯი,
რომელიც არის კომპანია, რომელიც სტივ ჯობსი დააფუძნა,
რომელიც არის კომპანია, სადაც ენის Objective C დაიბადა.
ასე რომ, ეს არის, ძირითადად, ტრადიცია.
მე ვიცი, რომ ცოტა უცნაურია, მაგრამ ეს არის Apple.
>> ასე რომ რაღაც კიდევ weirder ვიდრე ეს არის ფუნქცია დეკლარაცია.
ეს არის ძალიან განსხვავდება იმისგან, რასაც ჩვენ ხედავთ C, რადგან აქ ის რეალურად
არ ჰგავს C უქმნით.
რაც თქვენ უნდა აქ მიერ გზა, ეს არ არის ტყვია წერტილი,
ეს არის მინუსი.
თქვენ გაქვთ მინუს ნიშანი ფრჩხილებში ბათილად და შემდეგ ფუნქცია სახელი.
მოდით უბრალოდ, ვამბობთ, თუ ჩვენ აქვს hello world, მაშინ
დაბრუნების ტიპის იქნება ბათილად იმიტომ, რომ ჩვენ დაბრუნებას არაფერი.
>> რა ხდება მართლაც უცნაურია ის არის, რომ როდესაც თქვენ
რომელსაც ერთზე მეტი პარამეტრი გავლით შევიდა იგივე ფუნქცია, რომელიც
იქნება მართლაც უცნაური, როგორც ჩანს, აქ.
ჩვენ გვაქვს მეთოდი სახელი, მოუწოდა addInt [INAUDIBLE]
და ჩვენ გადადის ერთი პარამეტრი.
მაგრამ ამის შემდეგ, ჩვენ გვაქვს უფრო მეთოდის სახელი ზარი.
და შემდეგ ერთად ჩვენ გადადის მეორე პარამეტრი.
ეს არის რეალურად ცოტა უცნაური, მაგრამ ყველა ეს ფუნქცია დეკლარაციების
მოჰყვება იგივე ნიმუში, როგორც ეს.
>> გვაქვს მინუს ნიშანი დაიწყოს.
მინუს ნიშანი შეიძლება იყოს პლუს ნიშანი ზოგჯერ ეფუძნება რა სახის მეთოდი
არის ის.
მეთოდი ძირითადად კიდევ ერთი სახელი ფუნქცია.
და ჩვენ ვაპირებთ განმარტავენ, რომ მოგვიანებით, როცა
ჩვენ ვსაუბრობთ ობიექტი ორიენტირებულ პროგრამირებაში.
თქვენ პირველი მიუთითოთ დაბრუნების ჩაწერეთ შიგნით ფრჩხილებში,
რის შემდეგაც მოდის მეთოდის სახელი.
თქვენ გადადის ერთი პარამეტრი.
და თუ თქვენ გაქვთ მეტი პარამეტრი თქვენ უნდა გააგრძელოს მეთოდის სახელი
და ძირითადად წერენ რაღაც უფრო მეტი აქ.
>> ეს შეიძლება იყოს არაფერი გსურთ.
ჩვენს შემთხვევაში ეს ერთად.
მაგრამ თქვენ შეიძლება ითქვას, ბოლოს, ან, ან, ან abc სრული ბარი, რაც თქვენ გინდათ.
და შემდეგ, რომ თქვენ გავლის პარამეტრი ბ.
ეს არის მართლაც უცნაურია კონვენციის მაგრამ ჩვენ
აპირებს, თუ რატომ Apple სასურველი უნდა გავაკეთოთ, რომ ძალიან სწრაფად.
ასე რომ, მოვუწოდებთ ფუნქცია?
მოუწოდებდა ფუნქცია ობიექტური C ასევე განსხვავდება C.
>> რეალურად, მოუწოდებს ფუნქცია Objective C
უფრო მოსწონს თქვენ ესაუბრება ვინმე.
აქ ჩვენ გვაქვს თვითმმართველობის, რომელიც ეწოდება ობიექტი.
თქვენ ძირითადად ვეუბნებოდი წინააღმდეგი თვითმმართველობის ვთქვა "Hello World!"
რომ არის, თუ როგორ უნდა დარეკოთ ფუნქცია.
ობიექტი და მეთოდის სახელი შერწყმული ერთმანეთთან.
და ეს არის, სადაც უცნაური გაფართოება მეთოდით სახელი ნამდვილად ძალაში play.
>> მოდით შევხედოთ მეორე მაგალითი.
ჩვენ მხოლოდ განსაზღვრული მეთოდი მოუწოდა addInt ერთად blah blah blah.
ასე რომ, ამ შემთხვევაში, როდესაც თქვენ მოუწოდებენ რომ კონკრეტული [? გაგზავნა?] ის აპირებს
უნდა გამოიყურებოდეს თვითმმართველობის addInt: 10: 2.
ეს ჟღერს ინგლისურ ენაზე.
მიუხედავად იმისა, რომ ფუნქცია ფუნქცია დეკლარაცია არის უცნაური,
წერტილი Objective-C ის საშუალებას დეკლარაცია ნიმუში,
ის არის, რომ როდესაც თქვენ მოუწოდებენ ფუნქცია ან მეთოდი
იგი ჟღერს, როგორც ფაქტობრივი ინგლისური.
ასე რომ, ეს ძალიან ინტუიტიური ერთხელ თქვენ შეღწევას იგი.
>> განსაკუთრებით ამ შემთხვევაში, სადაც შეგიძლიათ ძირითადად
, რომ ფუნქცია სახელი სახის დოკუმენტურად თავად.
თქვენ არ გჭირდებათ რაიმე დამატებითი ახსნა, რომ ნახოთ
რა ხდება, რა ზუსტად ერთი პარამეტრი აკეთებს.
სცდება, რომ, მოდით ვისაუბროთ ცოტა ცოტა შესახებ ობიექტზე ორიენტირებული პროგრამირების.
ობიექტზე ორიენტირებული პროგრამირების არის ერთ-ერთი ძირითადი პროგრამირების
ტექნიკის ან ნიმუშების, რომ არის გამოიყენება მიზანი C. Objective C
ეწოდება Objective C, არა C, ნამდვილად კარგი მიზეზი.
>> ასე რომ, სანამ ჩვენ შეღწევას მიზანი C სინტაქსი,
მოდით ნამდვილად სწრაფად შევხედოთ რა არის ობიექტი.
ჩვენ, ალბათ გაკეთდეს რაღაც როგორც ობიექტი ადრე, რომელიც
ეწოდება struct, როდესაც თქვენ ხართ ახორციელებს ხე ან უკავშირდება სიაში
ან [? ცდილობენ. ?] ასე რომ, ეს ძირითადად მოსწონს struct,
მაგრამ ეს ბევრად უფრო ძლიერი, ვიდრე.
ობიექტს გააჩნია თვისებებს და მეთოდებს.
მეთოდები ძირითადად ფუნქციები.
ძირითადად ფუნქციონირებს რომ კონკრეტული გარკვეული ობიექტი.
>> და თვისებები, რომლებიც, ძირითადად, სფეროში მიუთითოთ struct.
ასე რომ თითოეული ობიექტი ჩვენ გვაქვს გარკვეული ქონება
რომ რაღაც ცვლადები, რომლებიც კონკრეტული ობიექტი.
და ჩვენ გვაქვს გარკვეული ფუნქციები, რომელიც ასევე კონკრეტული ობიექტი.
და ფუნქციები მოუწოდა მეთოდები და ცვლადები ეწოდება თვისებები.
ეს მხოლოდ ლამაზი სახელი.
მიუხედავად იმისა, რომ თქვენ სინამდვილეში, თითოეული კალენდარი ხედავთ ხოლო გახსნა iOS app,
მოდით უბრალოდ, ვამბობთ Twitter ან Facebook, თითოეული კალენდარი ხედავთ არის ობიექტი.
და თუნდაც მთელი app არის ობიექტი უნდა დაიწყოს.
ძალიან საინტერესო კონცეფცია.
>> და რატომ გვინდა ობიექტი ორიენტირებული პროგრამირების?
ასე რომ თქვენ წარმოიდგინეთ, რომ როდესაც თქვენ პროგრამა იღებს საკმაოდ რთული.
მოდით უბრალოდ, ვამბობთ, როდესაც თქვენ ახორციელებს ჭადრაკის დაფა,
ლოგიკა აპირებს ნამდვილად რთული.
თქვენ გაქვთ 36 სხვადასხვა ცალი, ასე რომ, თუ თქვენ
მინდა დაწერა ლოგიკა ყველა 36 სხვადასხვა ცალი ჭადრაკში,
რომ იქნება ბევრი სხვადასხვა ფუნქციები და ცვლადები.
ეს ბევრი უბედურება.
და, ალბათ, თქვენ აპირებს დაწეროს სხვადასხვა მეთოდით და სხვადასხვა ფუნქცია
თითოეული ნაჭერი ზუსტად გაკონტროლება, რასაც აკეთებენ.
>> მაგრამ თუ ობიექტზე ორიენტირებული პროგრამირების, ყველა ამ ცალი
შეიძლება ამოღებული შევიდა ერთი ობიექტი.
და ობიექტი გარკვეული საერთო თვისებები, როგორიცაა, თუ რა სახის ცალი
არის ეს?
რა ფერი არის ეს?
როგორ შეიძლება გადავიდეს?
და ამ გზით თქვენ დიდად გამარტივებული ლოგიკა ის.
ასე რომ, ეს მხოლოდ კარგი გზა რათა რთული პროგრამების,
და იერარქიული ურთიერთობა პროგრამის ფარგლებში, ძალიან მარტივია.
ჩვენ ვაპირებთ, რომ ნახოთ რატომ ძალიან სწრაფად, როდესაც
ჩვენ რეალურად აკეთებს პროგრამირების, როდესაც ჩვენ, ფაქტობრივად,
აკეთებს S კოდი პროგრამირების სხდომის შემდეგ.
>> კარგად, გარდა ამისა, ობიექტზე ორიენტირებული პროგრამირების
მხოლოდ ბევრი გართობა.
თქვენ მიიღო შეიმუშავონ საკუთარი ობიექტი.
თქვენ მიიღო, რათა შეიმუშავონ რას ის ჰგავს საკუთარ თავს.
არ არის სწორი პასუხი მას.
და ეს სრულიად საინტერესო.
ასე რომ, ობიექტზე ორიენტირებული პროგრამირების, ორი ფუნდამენტური ცნებები
იქნება კლასი და მაგალითად.
კლასი ძირითადად თარგი ობიექტი.
და მაგალითად ძირითადად ერთი კონკრეტული ობიექტი.
>> მოდით უბრალოდ, ვამბობთ, რომ თქვენ მიღების ბმულს.
ამ შემთხვევაში, თითოეული ბმულების თქვენ რეალურად დასრულდება up ერთად
იქნება ობიექტი.
მაგრამ ბმულების plate გამოიყენოთ bake ყველა cookies იქნება კლასი.
კლასი ძირითადად template.
და მაგალითად იქნება ერთი კონკრეტული ობიექტის შეიქმნა, რომ კლასი.
>> და მაგალითად შეიქმნება საფუძველზე კლასის გამოცხადებას,
როგორც ვნახავთ მოგვიანებით სლაიდები.
მოდით რეალურად გავაკეთოთ მართლაც სწრაფი მაგალითად [INAUDIBLE].
მოდით ვთქვათ, ჩვენ ვაცხადებთ ობიექტის კატა.
ობიექტი უნდა ფლობის კატა კლასი უნდა
გარკვეული თვისებები და მეთოდები.
რა სახის თვისებები უნდა კლასის ფლობის უნდა cat აქვს?
>> მაგალითად, ფერი, ასაკი და ჯიშის, იმ
იქნება ცვლადები, რომლებიც კონკრეტული ყოველი კატა.
და იმ ზოგიერთი რამ რომ ვიყენებთ აღწერს კატა.
რა სახის მეთოდი, ან რა შეიძლება კატა გავაკეთოთ?
სწრაფმა მაგალითები იქნება დევნა მაუსი, ჭამა თევზი ან უბრალოდ meow.
ეს არის ძალიან სწრაფი მაგალითად კატა კლასი.
და მართლაც კონკრეტული cat ობიექტი იქნება კატა
სადაც ჩვენ დააკონკრეტა ფერი, ასაკი და ჯიშის.
>> იმ შემთხვევაში, ჩვენი მიზანია აღარ კლასის უქმნით.
ჩვენ კოპირება template კლასის და ჩვენ დააკონკრეტა ყოველი კონკრეტული ინფორმაცია
რომ კონკრეტული ობიექტი იმისათვის, რომ ეს დამოუკიდებელი.
და როდესაც თქვენ მოუწოდებენ მეთოდი შიგნით ობიექტი,
თქვენ უბრალოდ მოვუწოდებ meow ობიექტი, რაც კატა უბრალოდ შექმნა.
>> ალბათ, ამობეჭდოთ რაღაც "Hello World!
Meow ".
საკმაოდ მიმზიდველი.
ყველა უფლება, მოდით უბრალოდ შეღწევას ზოგიერთი დეტალი
და რა ზუსტად იმას, რომ გარდაქმნა, რომ iOS პროგრამირების.
ასე რომ, iOS პროგრამირების ყოველ კლასის განხორციელდება ორი ფაილი.
ერთი ფაილი აქ, რომელიც ეწოდება ინტერფეისი.
სხვა ფაილი აქ, რომელიც ეწოდება განხორციელება.
>> როგორც წესი, ინტერფეისი ექნება extension.h
როგორც ვნახეთ, C ბიბლიოთეკები.
და განხორციელების ფაილი აპირებთ უნდა extension.n.
ეს სახის უცნაური.
მაგრამ .n ნიშნავს რეალურად გ, არ არსებობს ფუნდამენტური განსხვავება იმ
ორი.
ასე რომ, ამ შემთხვევაში, ჩვენ ვხედავთ, რომ ჩვენ გამოცხადების ინტერფეისი, Cat: ობიექტი.
რომ ეწოდება მემკვიდრეობა.
ჩვენ ძირითადად მემკვიდრეობით cat კლასის ობიექტის კლასი.
ასე რომ, ყველა ქონება და მეთოდი, რომელიც იყო მანამდე განსაზღვრული ობიექტის კლასი
ავტომატურად იქნება განსაზღვრული კატა კლასში ასევე.
>> გარდა ამისა, ჩვენ განსაზღვროს ფერის, ჯიშის და ასაკის, სამი ცვლადი.
რომ რეალურად გამოიყურება რაღაც არ მომხდარა.
ეს ჰგავს struct.
რომ არის, ძირითადად, სინტაქსი for struct დეკლარაცია,
და ეს არის აბსოლუტურად სწორი.
და რადგან მე უკვე აღვნიშნეთ, განსხვავება struct
და ობიექტი, ერთი ფუნდამენტური განსხვავებები
ის არის, რომ ობიექტი აქვს მეთოდი, ხოლო struct მხოლოდ ცვლადები.
ასე რომ, გარდა თვისებების ან ცვლადები, ჩვენ შევქმენით ობიექტი,
ჩვენ დააკონკრეტა გარკვეული მეთოდი.
>> მოდით უბრალოდ, ვამბობთ რომ აქ გვაქვს ორი მეთოდები, ერთი meow,
კიდევ ერთი საკითხი არის chase მაუსი.
ჩვენ, ალბათ, სურს იყოს გადადის პარამეტრი საფუძველზე ჩვენი წინა მეთოდი
დეკლარაციის ნიმუში.
თქვენ ალბათ მინდა უნდა ავლით მაუსის.
და თქვენ ალბათ მინდა დაბრუნების bool signifying
თუ თქვენი კატა წარმატებით დაიჭირეს მაუსის თუ არა.
>> ეს არის ინტერფეისი, მაგრამ შეგვიძლია ვხედავთ, რომ ინტერფეისი რეალურად
არაფერს არ აკეთებს.
უბრალოდ ეუბნება პროგრამა რა exists-- რა არსებობს cat კლასის.
ასე რომ, იმისათვის, რომ პროგრამა რომ რამე,
ჩვენ უნდა განხორციელების ფაილი.
ასე რომ, აქ, პირველი, რასაც ვაკეთებთ არის ცხადია, ჩვენ იმპორტი ინტერფეისი.
მას შემდეგ, რაც ჩვენ იმპორტი ინტერფეისი, ჩვენ განვსაზღვროთ მეთოდი.
>> მოდით უბრალოდ, ვამბობთ აქ meow რომ უბრალოდ ამობეჭდოთ
"Hello World!" კონსოლი.
და განხორციელების შემდეგ ფაილი, ჩვენ საკმაოდ ბევრი გააკეთა.
ეს არის ძირითადად კლასის დეკლარაციის ერთ კლასში.
ასე რომ, ახლა კითხვა ხდება, როგორ გამოაცხადოს ცვლადი?
გზა თქვენ იყენებთ კლასის შექმნა ობიექტის Objective C წერია აქ.
>> თქვენ პირველი დააკონკრეტა, რომ ეს არის cat მაჩვენებელი,
იმიტომ, რომ ყველა ობიექტი Objective C საბოლოოდ ხორციელდება როგორც მაჩვენებელი.
და რეკავთ კლასის, მოვუწოდებთ მათ როგორც alloc, რომელიც ძირითადად malloc,
ვეუბნებოდი ოპერაციული სისტემა, რომ თქვენ საჭიროა გარკვეული მეხსიერების სივრცე ეს ობიექტი.
მას შემდეგ, რაც თქვენ გაქვთ ობიექტის უკვე და თქვენ უბრალოდ ინიციალიზაცია იგი.
ეს არის მხოლოდ კონვენციას.
მე ვიცი, რომ ეს არის ცოტა უცნაური, მაგრამ ეს არის რეალურად როგორ Apple აკეთებს პერსონალი.
>> მინიჭების თვისებების რეალურად საკმაოდ მარტივია.
ეს ძალიან ჰგავს თუ რას აკეთებს, როდესაც
თქვენ მინიჭების რაიმე კონკრეტული სფეროში შიგნით struct.
თქვენ უბრალოდ უნდა ცვლადი სახელი, ქონება სახელი,
და მივანიჭოთ კონკრეტული მნიშვნელობა იგი.
და მოუწოდებს მეთოდი ძალიან ჰგავს.
მოუწოდებს მეთოდი ძირითადად რა საუბრობენ
მოუწოდებდა ნებისმიერი მეთოდით ობიექტური C.
>> თქვენ გავლის ობიექტი, ამ შემთხვევაში ეს იქნება myCat,
და თქვენ გავლით მეთოდის სახელი.
თითქოს თქვენ ვსაუბრობთ ობიექტი, myCat, რომ თქვენ უნდა meow.
ეს არის საკმაოდ საინტერესო.
ამის შემდეგ, არსებობს ერთი უფრო მნიშვნელოვანია, დიზაინი ნიმუში
რომ ჩვენ უნდა ვისაუბროთ ადრე მიღების ფაქტობრივი S კოდი.
რომ დიზაინის ნიმუში მოუწოდა ღონისძიება ორიენტირებული პროგრამირების.
ეს არის ასევე, ალბათ, ერთ-ერთი ყველაზე ფუნდამენტური იდეები iOS პროგრამირების.
>> ასე რომ თქვენ ალბათ არ ვიცი რა არის ღონისძიება ორიენტირებული პროგრამირების,
მაგრამ ეს არ არის, რომ საშინელი.
კარგად რეალურად, თქვენ უნდა უკვე გაკეთდა, რომ ადრე.
ეს არის ერთ ერთი ხაზები თქვენ ალბათ უკვე დაწერილი ბოლო [INAUDIBLE]
CS50, google.maps.event.addListener (marker,
"დაკლიკეთ", function () {}) :.
დარეკვით ეს ხაზი თქვენ არსებითად ვეუბნებოდი კომპიუტერი
რომ როდესაც ღონისძიება სახელწოდებით "დაკლიკეთ" ხდება მარკერის,
რომ ფუნქცია.
>> ეს არის ძალიან განსხვავებული რას აკეთებთ mario.c.
In mario.c უბრალოდ გაუშვით პროგრამა ერთხელ, ის გაძლევთ output,
და თქვენ კეთდება.
ეს არის ერთგვარი მოსწონს ერთი გასროლით პროგრამები.
ღონისძიება ორიენტირებული პროგრამები ძალიან, ძალიან განსხვავებული.
წარმოვიდგინოთ, თუ Facebook არის ერთი shot პროგრამა, ეს არ არის ძალიან კარგი.
თქვენ უბრალოდ წასვლა Facebook ერთხელ და ეს კეთდება.
ეს გაძლევთ რამდენიმე გამომავალი და თქვენ აღარასოდეს უკან.
თქვენ აღარასოდეს მეტი არაფერი.
>> ასე რომ, აქ, განსაკუთრებით ნიმუში ვიყენებთ არის
ღონისძიება ორიენტირებული, ისე, რომ ყველა ფუნქცია
დაიჭირეს რის საფუძველზე ღონისძიება მოხდა.
მაგალითად, თუ ჩვენ გვაქვს ღილაკს და ჩვენ დააკონკრეტა
რომ როდესაც რომ ღილაკი დაწკაპავთ, მოვუწოდებთ ფუნქცია მოუწოდა "Hello World!"
ამ გზით ჩვენ შეგვიძლია ნამდვილად მართვის ფუნქცია ლოგიკა
შემოვა ამ უაღრესად მოქნილი გზა.
მომხმარებელს შეუძლია ან დარეკეთ ფუნქცია რომელიც უკვე მოუწოდა.
ის მთლიანად ეფუძნება რა წევრებს არ.
>> ასე რომ, ჩვენ ვხედავთ, რომ ეს არის რეალურად ბევრად უკეთესია, ვიდრე mario.c.
და კარგი ამბავი ის არის, რომ ეს ფაქტობრივად, არ არის ახალი კონცეფცია.
შენ უკვე გააკეთა რომ ბოლო პრობლემა კომპლექტი.
ასე რომ, Objective C არსებობს სამი სხვადასხვა დიაგრამები
ღონისძიება ორიენტირებული პროგრამირების.
პირველი დიაგრამა ეწოდება სამიზნე ქმედება,
სადაც თქვენ სავალდებულოა ღილაკს პრეს გარკვეული ფუნქცია.
მოდით უბრალოდ, ვამბობთ, როდესაც თქვენ დააჭირეთ ზოგიერთი ღილაკს, თქვენ მოვუწოდებთ ზოგიერთი ფუნქცია.
ეს არის ძალიან მარტივი სამიზნე action.
>> მეორე რეალურად ყველაზე მძიმე ერთი,
ეს ე.წ. დელეგაცია ოქმს.
ჩვენ ვაპირებთ, რომ ავუხსნათ რომ დიდი დეტალურად მოგვიანებით.
და მესამე გზა არის შეტყობინება.
ეს რეალურად არ არის ძალიან მნიშვნელოვანია, რამდენადაც
როგორც ჩვენ შეშფოთებული, რადგან მოსალოდნელი რომ თქვენ აპირებთ გამოიყენოთ შეტყობინებას
თქვენს საბოლოო პროექტი საკმაოდ დაბალია.
ასე რომ, ჩვენ ვაპირებთ გამოტოვოთ, რომ ნაწილი.
>> და ჩვენ ვაპირებთ ჩაყვინთვის შევიდა დელეგაცია ოქმს.
ასე რომ, რა არის ოქმი?
ან რა არის დელეგაციის?
მოდით ვისაუბროთ ოქმი უნდა დაიწყოს.
ოქმები არაფერია, მაგრამ მოვლენები.
მაგრამ ამ მოვლენების გეძლევათ თქვენ მიერ Apple იწყება.
მაგალითად, მე არ ვარ სრულიად დარწმუნებული ვარ, თუ რამდენი
ბიჭები გამოიყენოთ Apple- ის ორიგინალური app ფოსტა ან კონტაქტი,
მაგრამ ყოველ ჯერზე თქვენ გადახვევა მაგიდა და დააჭირეთ კონკრეტული საკანში
მაგიდაზე, რომ არის ღონისძიება.
>> და თუ თქვენ გსურთ, რომ ღონისძიება თავს,
ეს, ფაქტობრივად, ცოტა რთულია.
ასე Apple მისცა, რომ თუნდაც თქვენ ასე რომ თქვენ შეგიძლიათ მხოლოდ პირდაპირ გამოყენება
იმ შემთხვევაში, რომ რამე საკუთარი.
ოქმები რეალურად ნამდვილად, ნამდვილად ფართოდ გამოიყენება
ობიექტური C. კარგად ფაქტობრივად, თითოეული app
აქვს რაღაც დაიჭირეს app დელეგატი.
Inside დელიკატური არის ყველა ოქმები ჩატვირთვის app.
>> მოდით უბრალოდ, ვამბობთ არსებობს ღონისძიება app გააკეთა დატვირთვა.
ასე რომ, რა უნდა მოხდეს შემდეგ თქვენ განთავსებულია app, შემდეგ გახსნა app,
მას შემდეგ, რაც თქვენ დახურვა app, ან შემდეგ დააყენა iPhone ძილის.
ეს არის ყველა ღონისძიება, რომელსაც აქვს უკვე გადაეცა თქვენ.
და თავდაპირველად შიგნით ამ ნაწილაკების არ იქნება განხორციელებას.
Apple მოგიყევით, რომ ეს ფუნქცია მოხდება მაშინ, როდესაც რამდენიმე ღონისძიება ხდება,
მაგრამ რა ვუყოთ, რომ ფუნქცია მთლიანად თქვენზეა.
>> დელეგაცია ძირითადად ვეუბნებოდი კლასის
რომ თქვენ უნდა გაუმკლავდეს ამ ოქმებს.
ეს ცოტა გაუგებარია, მაგრამ ეს იქნება
გაცილებით ნათელი, როდესაც ჩვენ გავაკეთებთ s კოდები მოქმედებაში.
დელეგაციის ოქმი ფაქტიურად უაღრესად ძლიერი მექანიზმი აზრი
რომ, თუ ჩვენ გავაკეთებთ დელეგაცია კონკრეტული კლასის,
ჩვენ შეგვიძლია არსებითად გაუმკლავდეს ყველა სახის ღონისძიებები
გამოყენებით ნებისმიერი კლასის გვაქვს, ძალიან მოსახერხებელი ინსტრუმენტი.
>> ასე რომ, ერთი სწრაფი მაგალითი დელეგაციის ოქმი
იქნება რა მე მხოლოდ ისაუბრა.
ამ ოქმის კონკრეტულად ეწოდება tableview [INAUDIBLE] აირჩიოთ როლი
at [? ინდექსი?] [? წარსულში. ?] ასე რომ, ეს ღონისძიება, რომელიც იქნება დაჭერილი, როდესაც თქვენ
რეალურად დაკრავენ კონკრეტული საკანში თქვენი tableview,
მოდით უბრალოდ, ვამბობთ თქვენს mail ან თქვენი კონტაქტების app.
>> ფუნქციის შიგნით იყო თავდაპირველად არაფერს აკეთებს.
ფუნქცია არ არაფრის იყოს.
მაგრამ თქვენ შეგიძლიათ მიუთითოთ რა ფუნქცია აქვს,
იმის გათვალისწინებით, რაც თქვენ გსურთ თქვენი app.
ძალიან მოსახერხებელი ინსტრუმენტი.
და ყველა, რომ მიმდინარეობს განაცხადა, მე ძირითადად
ფარავს რამდენიმე ძალიან ძირითადი სინტაქსური ფუნდამენტური კონცეფცია Objective C
პროგრამირების, და ჩვენ შეგვიძლია გავაკეთოთ ზოგიერთი კოდი.
ბევრად უფრო საინტერესო.
ასე s კოდი ფაქტიურად ცოტა გადაჭარბებული
როცა გახსნა პირველად.
>> ერთი სწრაფი შენიშვნა, ასე რომ, თუ თქვენ მინდა ამის გაკეთება, iOS განვითარება,
მე მაღალ რეკომენდაციას თქვენ გაქვთ Mac.
იმიტომ აკეთებს iOS განვითარების Windows მართლაც მძიმეა.
ეს შესაძლებელია, მაგრამ ეს მართლაც რთულია.
და თქვენ აუცილებლად გააკეთებს არ გინდათ გამოიყენოთ გ შეცვალონ.
ასე რომ, ის კოდი გვაქვს რამდენიმე სხვადასხვა ადგილებში.
როდესაც თქვენ პირველად გახსნა up s კოდი თქვენ ნახავთ, ნავიგაცია ნაკვეთი,
რომელიც ძირითადად გიჩვენებთ ყველა ფაილი, რომელიც არის თქვენი მიმდინარე პროექტი.
>> თქვენ გაქვთ პანელი ტერიტორია, რომელიც ძირითადად მართვის views,
ან რამდენიმე პატარა სწრაფი ინსტრუმენტები შესახებ s კოდი თავისთავად.
და ეს არის ფაქტობრივი რედაქტორი ტერიტორიაზე.
ამ სფეროში ძალიან ჰგავს გ შეცვალონ მაგრამ ბევრად უკეთესია, ვიდრე გ შეცვალონ.
და ეს უფლება ნაკვეთი, არის მოუწოდა კომუნალური ტერიტორიაზე.
სფეროში ხდება მართლაც მოსახერხებელი როდესაც თქვენ შექმნით ინტერფეისი ან სასურველი
რამდენიმე სწრაფი რეგულაციისთვის თქვენი app.
>> და საბოლოო ტერიტორია debugging.
ამ სფეროში შეიცავს კონსოლი.
ასე რომ, როცა ამბობენ printf, ან NSLog ჩვენს შემთხვევაში,
თქვენი შედეგები აპირებს დაიბეჭდება აქ.
ყველა უფლება?
ვფიქრობ ჩვენ შეგვიძლია ნამდვილად სწრაფად გააკეთოს მაგალითად, iOS პროგრამირების.
და მოდით რეალურად ქმნის კოდი.
ასე რომ ყოველ ჯერზე თქვენ გახსენით კოდი, ეს აპირებს გამოჩნდება რამე მაგდაგვარს.
ის აპირებს გთხოვოთ რა გინდათ გავაკეთოთ?
გინდათ დავიწყოთ რამე შემთხვევითი, სპორტული მოედანი, ძირითადად,
შეგიძლიათ უბრალოდ შესამოწმებლად კოდი გარეშე რეალურად ჩადენილი ნებისმიერი app.
>> გინდათ შევქმნათ ახალი პროექტი?
ან არ გსურთ გაგრძელება მუშაობა არსებული პროექტი?
ჩვენს შემთხვევაში, ჩვენ ვაპირებთ შევქმნათ ახალი პროექტი.
ასე რომ, ეს მართლაც კარგია, ის კოდი რეალურად უკვე
მოცემული ზოგიერთი თარგები შექმნის ობიექტები.
თუ თქვენ გსურთ თამაში, ეს კოდი რეალურად აქვს თამაში თარგი თქვენ,
აქვს გვერდზე დაფუძნებული პროგრამები, tab დაფუძნებული პროგრამა.
ამ შემთხვევაში, ჩვენ ვაპირებთ რამე ძალიან მარტივია,
და ჩვენ ვაპირებთ გამოვიყენოთ ერთი ხედი განაცხადის.
>> მას შემდეგ, რაც მხოლოდ ის, რაც თქვენ მინდა მოვუწოდო თქვენი პროდუქტი, და რა არის თქვენი სახელი,
რა არის თქვენი იდენტიფიკატორი, და რა ენაზე გამოიყენოს.
აქ ჩვენ არ გვინდა შეამოწმეთ გამოყენებით Core მონაცემები.
Core მონაცემთა ძირითადად databasing iOS.
თუ თქვენ აკეთებთ Core მონაცემები, s კოდი აპირებს განსაზღვროს
უფრო რთული კლასების თქვენთვის.
ასე რომ შევინარჩუნოთ ყველაფერი მარტივია, ჩვენ უბრალოდ აპირებს ამის გარეშე Core მონაცემთა
ახლავე.
>> პრობლემა ჩვენ ვაპირებთ, რომ იყოს გამოყენებით არის, რომ პრობლემა
ჩვენ ვაპირებთ, რომ უნდა შექმნას, რომ ჩვენ ძირითადად მინდა იმპორტი Mario from C
to iOS app.
მოდით მოვუწოდებთ, რომ მარიო-iOS.
რა თქმა უნდა, თქვენ დააკონკრეტა, რა მინდა დააყენოს თქვენი პროექტი.
და იქ ჩვენ წავიდეთ.
>> ასე რომ, ეს ცოტა აბსოლუტური, მაგრამ ეს არის რეალურად
რაც ჩვენ უბრალოდ ვნახე სლაიდები.
და პირველი ნაკვეთი ჩვენ ვხედავთ ახლა ძირითადად პროექტის კონფიგურაცია.
ასე რომ, ყველაფერი გსურთ გააკეთოთ პროექტი, რა სახის ასაფეთქებელი მოწყობილობა,
მოდით უბრალოდ, ვამბობთ რა სახის მოწყობილობის გსურთ თქვენი app გამოჩნდება?
ეს არის iPhone, iPad, ან უნივერსალური?
ასე მოწყობილობა ორიენტაცია, ყველა ამ პერსონალის.
არ არის ძალიან მნიშვნელოვანი, მაგრამ შეიძლება იყოს, მაგრამ ეს
არის ადგილი, სადაც თქვენ შეიქმნა თქვენი პროექტი, თუ თქვენ ნამდვილად
გსურთ განათავსოს ვაშლის შენახვის.
>> ყველა უფლება, მოდით შევხედოთ ის, რაც არის ჩვენს კოდი.
მოდით გავლა ფაილი ნავიგატორი.
და ეს არის ყველა ფაილი, რომელიც უკვე მოვიდა template, ძალიან ლამაზი.
ასე რომ, როდესაც ჩვენ დააწკაპუნეთ ერთი მათგანი ეს არის ის, რაც ჰგავს.
ძალიან ჰგავს გ შეცვალონ.
მაგრამ თქვენ ხედავთ, რომ სინტაქსის შეფერადება, ალბათ,
ცოტა გავალამაზოთ.
და ეს გაცილებით უფრო ძლიერი ვიდრე g რედაქტირება.
და თქვენ შეგიძლიათ ავტომატური სრული ბევრი რამ, რომ თქვენ,
როგორც ვნახავთ ძალიან სწრაფად.
>> მოდით გავხსნათ გამართვის ტერიტორია ასევე.
ყველა უფლება, როგორც ვხედავთ, კონსოლის უფლება აქ.
ეს არის ის, რაც თქვენ ვაპირებთ, სადაც თქვენ printf ან nsloging რაღაც.
ასე გარეშე ado, მოდით რეალურად შეადგინოს app და ვნახოთ, რა მოხდება.
ერთი არსებითი ფუნქცია კოდი, ის არის, რომ ის კოდი
გააჩნია iPhone სიმულატორი.
ასე რომ თქვენ არ უნდა iPhone ცდილობენ თქვენი პროექტი,
s კოდი სიმულაცია, რომ თქვენ, როგორც ვხედავთ, ახლა.
>> ეს არის საკმაოდ ლამაზი.
ის აღების პატარა ცოტა დროა შეადგინონ
და ძირითადად აქვს ცარიელი განცხადება,
რომელიც რეალურად არაფერს აკეთებს.
მაგრამ იგი ადგენს.
ეს საკმაოდ გასაოცარია.
ეს ბევრად უკეთესია, ვიდრე C, huh?
ყველა უფლება, მაშინ მოდით ცდილობენ დაამატოთ რაღაც.
ერთი ფაილი, რომელიც არის ცოტა უცნაური აქ ეწოდება storyboard.
ეს არის რეალურად დიდი, რა ფუნქცია კოდი.
იმის გამო, რომ ის კოდი, შეგიძლიათ რეალურად drag ჩამოაგდეს ელემენტების გადატანა ინტერფეისი
და ეს პირდაპირ გამოჩნდება.
მოდით ვეცადოთ, რომ.
>> ჩვენ ვარდნა ეტიკეტების აქ, "Hello World !!!"
ჩვენ შეგვიძლია ცენტრი, რომელიც.
საკმაოდ გრილი.
ახლა მოდით აწარმოებს ამ გაჩერება სიმულაციური.
აქ ჩვენ გვაქვს "Hello World !!!"
ჩვენ კი არ გააკეთებს ნებისმიერი კოდირების ამჟამად.
რა ჯანდაბა ხდება?
ეს არის, თუ რამდენად ძლიერი Interface Builder შეიძლება იყოს.
ვინმეს კი განაცხადა, რომ თქვენ ალბათ შეუძლია მხოლოდ
შეავსოთ app გარეშე წერა ალბათ ათასი ხაზების კოდი
უბრალოდ გამოყენებით Interface Builder.
მაგრამ ეს, ალბათ, არ საუკეთესო გზა ამის გაკეთება.
>> ახლა მოდით რეალურად მიიღოს ქვემოთ კოდირების.
ამიტომ სტრუქტურა ფაილი რეალურად ნამდვილად საინტერესო
რადგან, როგორც ხედავთ, არსებობს არ არის მთავარი ფუნქცია სადმე.
ვხედავ?
როგორც ჩვენ აღვნიშნეთ, თქვენ ხედავთ, რომ ამ
არის განხორციელება ფაილი კონკრეტული კლასის.
მაგრამ არ არის მთავარი სადმე.
ასე რომ, სადაც მთავარი?
რეალურად, არის მთავარი, მაგრამ მთავარი რეალურად იმალება თქვენგან.
მთავარი აქ არის.
რომელიც გამოიყურება ნაცნობი.
>> ასე რომ, ძირითადად, რა iOS აკეთებს შიგნით ძირითადი
არის, რომ როდესაც main არის ეწოდება, რომელიც, ძირითადად,
მაშინ, როდესაც app ხორციელდება, ეს ქმნის ობიექტი მოუწოდა AppDelegate.
როგორც უკვე აღვნიშნე, მთელი app არის რეალურად ობიექტი თავისთავად.
ასე რომ ამ გზით, ძირითადად iOS app ეუბნება შემდგენელი
რომ OK, მე ვაპირებ შექმნა პროდუქტის მოუწოდა AppDelegate,
და რომ იქნება ჩემი app.
ასე, რომ თქვენ უნდა წავიდეთ მეშვეობით, რომ AppDelegate
და ვნახოთ რა, რომ ბიჭი აკეთებს.
ჩემი სამუშაო კეთდება ჩემთვის.
>> და AppDelegate თქვენ ხედავთ, რომ არსებობს რამდენიმე მართლაც უცნაური ფუნქციები,
ასევე ფაქტობრივად მეთოდები, რომ Apple უკვე მოცემული.
რა არის ეს?
ეს არის, ფაქტობრივად, მხოლოდ ოქმები რომ მე საუბარი.
ასე რომ ეს მოვლენები, რომ Apple მოცემული უნდა დაიწყოს.
არაფერი არ არის გარკვეული ფუნქციების ახლა,
მაგრამ თუ ჩვენ გვინდა ინიციალიზაცია რაღაც ჩვენი app
სანამ მისაღებად შევიდა ჩვენებისას ნებისმიერი მიზნით, ჩვენ გავაკეთოთ, რომ აქ.
>> თქვენ შეგიძლიათ უბრალოდ წაიკითხა სახელი და ვფიქრობ, ღონისძიება არის რეალურად მართლაც ნათელია.
ახლა მთავარ შექმნა ობიექტის AppDelegate.
და რა AppDelegate აპირებს რეალურად ასევე იმალება თქვენ.
AppDelegate დაწყებას აპირებს ჩატვირთვის ViewController საფონდო.
ასე რომ, ეს ძირითადად აპირებს დაიწყოს ჩატვირთვის up ყველა შეხედულებას, რომ თქვენ უნდა
და მხოლოდ გაუწიოს კალენდარი საფუძველზე იერარქიაში.
>> ასე რომ, ამ შემთხვევაში ჩვენ მხოლოდ ერთი ხედი, რომელიც აქ.
ასე რომ ეს არის ერთადერთი კალენდარი რომ აპირებს ეწოდოს.
ViewController ლოგიკა არის სწორი აქ.
ეს არის კოდი, რომელიც რეალურად აკონტროლებს ხედი ჩვენ უბრალოდ დაინახა.
ყველა უფლება, მოდით რაღაც აქ.
ასე viewDidLoad ჟღერს ღონისძიება, როდესაც რეალურად ეს არის ასევე დელეგატი,
ეს არის ასევე ოქმს.
>> ასე რომ, რასაც ხედი არის დატვირთული, ყველაფერი შიგნით ფუნქცია
დაერქმევა.
ამ შემთხვევაში ჩვენ უნდა დაინახოს "Hello Tianyu! "თუ ჩვენ აწარმოებს პროგრამა.
ის მიღების ცოტა ნელი შედგენის storyboard ფაილი.
კარგად მართლაც, ჩვენ ვხედავთ გამომავალი ამისთვის.
ეს არის საკმაოდ გრილი.
ახლა მოდით რეალურად ამის Mario.
მე ვაპირებ განსაზღვროს ფუნქციონირებს ძალიან სწრაფად.
marioWithLevels: (int) დონის შედეგებს.
>> ყველა უფლება, ეს არის რეალურად რა თვისება s კოდი ავტომობილი დასრულების შემდეგ.
ასე რომ, როდესაც თქვენ დაწერეთ და ტიპის შევა, ეს უკვე მისცა up თარგი
თქვენ, რომელიც არის საკმაოდ გრილი.
რომ უნდა გამოიყურებოდეს ნამდვილად ნაცნობი თქვენ ბიჭები.
ბოდიში, რომ ჩემი ბრალია.
ყველა უფლება, ზემოთ.
ამ ლოგიკით უნდა გამოიყურებოდეს ნამდვილად ნაცნობი თქვენ ბიჭები, განსაკუთრებით მხოლოდ Mario.
>> მაგრამ ახლა ჩვენ ამობეჭდოთ კონსოლი თითოეული დრო,
იმიტომ, რომ ჩვენ გვინდა როგორღაც შენარჩუნება სიმღერა რა ჩვენ დაბეჭდვის.
ჩვენ ვაპირებთ, რომ გამოიყენოთ შედეგები რატომღაც შემდეგ,
არაა ბეჭდვითი out გამოიწვიოს შესახებ.
ასე რომ ნაცვლად ჩვენ უბრალოდ nslogging ყველაფერი,
რომელიც ჩვენ შენახვის ყველაფერი შევიდა ფუნქცია ზარის შედეგად,
მაგრამ ლოგიკა არის ზუსტად იგივე.
შემდეგ ჩვენ დასრულდება ის, რომ ჩვენ უბრალოდ ამობეჭდოთ ჩვენი შედეგები.
>> და აქ ნაცვლად დაბეჭდვის ჩემი სახელი, ჩვენ ვაპირებთ, რომ მოვუწოდო ფუნქცია.
ვნახოთ, რა მოხდება.
Oops, ცხადია.
ჩვენ გვყავს ლამაზი პატარა პირამიდის აქ.
ეს არის ძირითადად C, ჩვენ უბრალოდ მანიპულირებენ, სადაც თქვენ მოვუწოდებთ ფუნქცია
და როგორ ფუნქცია ჰგავს.
არაფერია სხვადასხვა.
მაგრამ ეს არის რეალურად არ არის ძალიან საინტერესო აქ,
იმიტომ, რომ ჩვენ არ ხედავს არაფერი iPhone app.
>> ასე რომ, თუ თქვენ ნამდვილად აქვს iPhone app-- თუ თქვენ ნამდვილად აქვს Mario iOS უფლება
ახლა, თქვენ არ აპირებს ვხედავ, რომ არაფერი
არაფერი ერთად Mario რადგან ყველა იმ შედეგები შევიდა კონსოლი
დაუმალა შესახებ.
ეს არის, რასაც თქვენ ხედავთ, რომელიც "Hello World !!!"
არ არის კარგი.
ახლა მოდით შევეცადოთ, რათა მომხმარებლის ვხედავ რა ჩვენ დაბეჭდვისას.
ასე რომ, ჩვენ არ უნდა წარწერა აღარ.
მოდით ვეცადოთ და გაერკვნენ რაღაც სხვას, რომელიც შეიძლება იყოს სასარგებლო.
>> არსებობს ფაქტიურად ერთი ელემენტი, რომელიც ე.წ.
ტექსტური ველი, რომელიც შეიძლება ძალიან სასარგებლოა ჩვენთვის.
ეს, ძირითადად, აჩვენებს რეგიონში ტექსტი, რომელიც შეიძლება რედაქტორი.
ასე გამოიყურება ნამდვილად გამოსადეგი.
ახლა მოდით გადაიტანეთ და ჩამოაგდეს ის.
Wow, გვაქვს ტექსტის კალენდარი ჩვენი აზრით, მართლაც ლამაზი.
რომ ცოტა ძალიან დიდი.
მოდით ეს პატარა.
დააყენოს ის ცენტრი.
მას მცირე, ასევე.
>> ახლა ჩვენ გვაქვს ტექსტი ხედი, რომელიც შეგვეძლო გამოიყენება ცარიელია ჩვენი საბოლოო შედეგი.
მაგრამ ახლა ეს ნამდვილად არ იმუშავებს
იმიტომ, რომ იქ no-- ViewController ჩვენ უბრალოდ
განსაზღვრული არ იცის, რომ არსებობს ტექსტის ხედვა არსებობს.
ასე რომ, ჩვენ გვჭირდება, რათა როგორმე ბმული ტექსტის ხედვა ჩვენ მხოლოდ
შეიქმნა კლასი, რომელიც უკვე მოვიდა ჩვენთან.
>> გზა გავაკეთოთ, რომ რეალურად მართლაც ჯადოსნური.
ასე გახსენით storyboard.
არსებობს სპეციალური [INAUDIBLE] მოუწოდა [? თანაშემწე?] [INAUDIBLE].
როდესაც თქვენ დააჭირეთ, რომ ეს აპირებს გახსნას ორი ფაილი.
ერთი კლასის და მეორე არის შესაბამისი კალენდარი იგი.
ეს ძალიან, ძალიან სასარგებლო.
და მოდით, უბრალოდ გადის თ ფაილი.
კონტროლის, ეს [INAUDIBLE] ლოგიკა.
პრეს კონტროლის და drag ტექსტი ხედი შეყვანილი დეკლარაციაში.
ჩვენ ვაპირებთ, რომ მოვუწოდებთ outputView.
დაკავშირება.
ასე რომ აქ ჩვენ გამოვაცხადეთ ახალი ქონების ჩვენი ViewController კლასის.
და ახალი ქონება მხოლოდ ტექსტი კალენდარი
ჩვენ შევქმენით ინტერფეისი შენობა.
ასე რომ, ამ გზით ჩვენ შეგვიძლია წვდომა ყველა მონაცემები
და მანიპულირება ყველაფერი, რაც არის შიგნით გამომავალი აზრით, რაც გასაოცარია.
>> ასე, რომ ჩვენს ფაქტობრივი კოდი, მოდით რაღაც იგი.
ასე რომ, ეს მაშინ, როცა ჩვენ როგორიცაა ბეჭდვა საბოლოო შედეგი Mario,
ჩვენ არ შესასვლელად არაფერი.
ვგულისხმობ იმას, რომ შევინარჩუნოთ ხე განცხადებაში.
გარდა ამისა, ჩვენ გაუგზავნე მოხსნის ჩვენ უბრალოდ
განთავსებულია to გამომავალი ხედი, რომელიც არის UI TextView ჩვენ შევქმენით.
ახლა ვნახოთ, რა მოხდება.
Wow.
ჩვენ გვაქვს პირამიდის app ახლა.
>> ასე რომ მომხმარებელს შეუძლია ჩვენი გამომუშავება, რადგან ჩვენ კოპირება გამომავალი ჩვენი კოდი
ჩვენი ინტერფეისი.
ეს საკმაოდ კარგი.
ეს რეალურად არ არის, რომ საინტერესო, რადგან ჩვენ can--
ყველა app აკეთებს ნაჩვენებია პირამიდის თქვენ,
და იქ არაფერი შეგიძლიათ გააკეთოთ შესახებ.
ეს არ არის განსაკუთრებით საინტერესო.
ასე რომ, ახლა მოდით ღილაკს რომელიც გარკვევა რაოდენობა.
როგორც ჩანს, რომ ღილაკს იქნება სასარგებლო.
გადააადგილება.
ღილაკზე ერთი.
Button ორი.
>> ასე რომ, როდესაც ჩვენ დააჭირეთ მაუსის მარცხენა ღილაკს, ხედი უნდა გარკვევა.
არ უნდა იყოს არაფერი ეკრანზე.
და როდესაც ჩვენ დააჭირეთ მარჯვენა ღილაკს, Mario,
ხედი აპირებს გამოჩნდება ერთხელ.
ასე რომ, ეს გზა ჩვენ ასევე გააკეთებს ჯადოსნური პერსონალი, კონტროლი და drag
კლასს, დეკლარაციის in თანაშემწე director--
in თანაშემწე მაყურებელს.
ამ შემთხვევაში ჩვენ მითითებით , რომ უნდა იყოს action.
clearMario.
>> ასე რომ აქ ჩვენ უკვე შეიქმნა აქცია სახელწოდებით clearMario,
რომელიც არის მეთოდი, რომელიც იქნება ე.წ. როდესაც ჩვენ დააჭირეთ ღილაკს ნათელია.
ასე, რომ ჩვენს სინამდვილეში კოდი, მოდით უბრალოდ დააყენა გამოშვება ტექსტი და გამომავალი კალენდარი
შევიდა არაფერი, და ამ გზით ეს, როგორც ჩანს, წმინდა.
გარდა ამისა, რომ, მოდით შევქმნათ კიდევ ერთი მეთოდი ეწოდება runMario.
ბოდიში, რომ არ უნდა იყოს ქონება.
ყველა უფლება, რომ უნდა იყოს ქმედება, ისევე.
>> და როცა ეს ფუნქცია მოუწოდა, ჩვენ მხოლოდ აწარმოებს Mario ათი.
იმედია, რომ კარგად იქნება.
ჯერ ეს ადგენენ?
დიახ.
ახლა ჩვენ გვაქვს ხედვა.
ჩვენ გვაქვს გამომავალი.
და მოდით ვნახოთ, რა მოხდება.
რომ წავიდა.
ეს კიდევ ერთხელ.
ასე რომ, აქ ჩვენ მითითებული რა სახის ფუნქცია
დაერქმევა, როდესაც ჩვენ აკრიფოთ რაღაც,
როდესაც ჩვენ პრესა კონკრეტული ღილაკს.
ეს არის ძირითადად სამიზნე სამოქმედო სქემა
ღონისძიება ორიენტირებული პროგრამირების მიზანი C.
>> გარდა ამისა, ეს არ არის ძალიან საინტერესო
იმიტომ, რომ ჩვენ არ შეგვიძლია ნამდვილად შეცვალოს როგორ მაღალი პირამიდის იქნება,
ასე რომ, ჩვენ, ალბათ, მინდა როგორმე მიიღოს შეყვანის შესახებ
და შეცვალოს სიმაღლე პირამიდის საფუძველზე, რაც მათ გამომავალი.
ამიტომ, ჩვენ ვაპირებთ ამის გაკეთებას.
ასე რომ ამ დროს, როცა ჩვენ მოვუწოდებთ runMario, ჩვენ არ მხოლოდ მოვუწოდებთ Mario პირდაპირ.
ეს ერთი ტიტული.
>> დელეგატი.
ეს არის ძალიან საინტერესო.
რა არის დელეგატი?
მე ვაპირებ დააყენა თვით აქ.
და ჩვენ ვაპირებთ, რა, რომ ნიშნავს მოგვიანებით.
ასე რომ, აქ ჩვენ ძირითადად შეიქმნა კონკრეტულ შემთხვევაში მოუწოდა UI alert
ხედი.
UI alert ხედი არის ძირითადად რას
ვხედავ ყოველ ჯერზე რაღაც pops და მოგთხოვთ input,
როგორიცაა, რა მოხდება, როდესაც თქვენ ცდილობთ შეძენა რაღაც app store.
>> გარდა ამისა, მას შემდეგ, რაც თქვენ შექმნა, ჩვენ მხოლოდ აჩვენებს alert.
ყველა უფლება, მოდით უბრალოდ სწრაფად ტესტი იქნება, რომ ნაწარმოების ან არ.
ეს არის ძალიან მაგარი.
ახლა მოდით რეალურად შექმნა შეყვანის სფეროში UI alert.
ეს არის გზა, ჩვენ გაგვაჩნია.
და ჩვენ უნდა შეტანის მიზნით, რომ მზადყოფნაში.
ძალიან მაგარი.
მოდით უბრალოდ, ვამბობთ 10.
>> ის არაფერს არ აკეთებს მარჯვენა ახლა, რადგან ზარი რეალურად
არ შეცვლილა შესრულებაში mario.
ასე რომ, ეს გახდა პატარა ცოტა უცნაურია იმიტომ, რომ როდესაც
ჩვენ დააჭირეთ ღილაკს ქვემოთ, როდესაც ჩვენ დააჭირეთ ღილაკს alert ხედი,
რაღაც უნდა მოხდეს, მაგრამ ეს არ მოხდება.
როგორ შეგვიძლია დაჭერა, რომ?
ვიცით, რომ მომხმარებელი გაათავისუფლა მზადყოფნაში კალენდარი
და უკვე შევიდა ნომერი, იმიტომ, რომ ახლა არაფერი ხდება რეალურად.
>> კარგად, თქვენ ალბათ მიხვდა ეს უფლება, დელეგაცია.
ასე რომ გარდა ყველა ამ დეკლარაციების,
ჩვენ უნდა დაამატოთ ახალი დელეგაცია ეს მოუწოდა UI alert კალენდარი დელეგატი.
ისე, რომ თითოეული ურთიერთქმედების ან მოვლენა
რომ ჩვენ ვაპირებთ აქვს ერთად UI alert კალენდარი
იქნება სიფრთხილით ჩვენს კლასში ასევე.
>> ასე რომ, გარდა ამისა, იქნება alert კალენდარი ღილაკს ინდექსი.
ეს არის მიღწეული.
ასე რომ, ამ შემთხვევაში ჩვენ გვაქვს already-- ამიტომ ჩვენ უნდა
აღმოჩნდა, რომ ოქმი, რომელიც გაუმკლავდეს იმ შემთხვევაში, თუ
ჩვენ დააჭირეთ შესრულებულია ღილაკს მზადყოფნაში ხედი.
ასე რომ ყოველ ჯერზე ჩვენ გადააყენოს alert აზრით, ეს უნდა მოხდეს.
ნება მომეცით შეამოწმოთ ის ძალიან სწრაფად.
კარგად მართლაც, ჩვენ მივაღწიეთ აქ.
>> ასე რომ, აქ, რასაც ჩვენ არ რეალურად კიდევ არის რეალურად
მიიღეთ the-- ასე რომ, ჩვენ გვინდა ტექსტი, რომ ჩვენ ადრე
შევიდა alert ხედი.
და საფუძველზე ტექსტი, ჩვენ აპირებს ცარიელია Mario.
ეს ძალიან სწრაფად გამოდის თუ იგი რეალურად მუშაობს თუ არა.
ასე რომ, ამ შემთხვევაში, თუ ჩვენ input, ვთქვათ, 10, ჩვენ უნდა დაინახოს 10.
>> ძალიან კარგია, რომ ჩვენ გვაქვს რიცხვი აქ.
ეს საკმაოდ კარგი.
ახლა ბოლო ნაბიჯი იქნება be-- ასე ბოლო ნაბიჯი ჩვენ უნდა გავაკეთოთ ახლა
უბრალოდ მოვუწოდებთ Mario ერთად დონის საფუძველზე input
რომ ჩვენ არ შევიდა alert ხედი.
ასე რომ, ჩვენ უნდა გარდაქმნას ეს სიმებიანი შევიდა iOS.
სტატიკური overflow ძალიან გასაოცარია.
და შემდეგ ჩვენ უბრალოდ ვუწოდებთ თვითმმართველობის marioWithLevels მნიშვნელობა.
ვნახოთ, იქნება, რომ რეალურად მუშაობს თუ არა.
>> ჩვენ უკვე მისცა პირამიდის.
მოდით ცდილობენ შეცვალოს სიმაღლე.
რომ რეალურად მუშაობს.
ეს არის საკმაოდ გრილი.
ასე რომ, ახლა თქვენ შეგიძლიათ მხოლოდ შეყვანის ნებისმიერი ღირებულების გსურთ.
მოდით უბრალოდ, ვამბობთ ოთხ.
ეს არის საკმაოდ გასაოცარია.
ასე რომ, ეს არის, ძირითადად, მართლაც სწრაფი მაგალითად
როგორ შევქმნათ პროექტი s კოდი და როგორ ნამდვილად სწრაფად საბანკო up
ზოგიერთი მართლაც მარტივი ღონისძიებები და ფუნქციები.
>> ასე წყარო აპირებს უნდა დააყენოს მოგვიანებით.
ასე რომ, თუ თქვენ დაინტერესებული როგორ iOS Mario მუშაობს,
მე ვაპირებ რომ ზუსტად იგივე პროექტები გადატანა CS50 ვებ-გვერდზე მოგვიანებით.
ჩვენ ძირითადად კეთდება ზაფხულში, და სანამ დასრულდება
მე უბრალოდ მინდა აღვნიშნო, რომ თქვენ ბიჭები მართლაც გასაოცარია რესურსი, რომელიც
ხელმისაწვდომია ონლაინ რეჟიმში.
>> აშკარად Apple დოკუმენტაცია იქნება ძალიან სასარგებლო.
მაგრამ გარდა იმისა, რომ, მე განსაკუთრებით რეკომენდაცია ოთხი წყაროები, კოდი სკოლის,
ხის სახლი, AppCoda და WWDC videos.
კოდი სკოლის და ხის სახლი ორი ონლაინ სწავლების საიტებზე,
რომელიც კონკრეტულად ფოკუსირება პროგრამული უზრუნველყოფის საინჟინრო.
განსაკუთრებით კოდი სკოლა, მათ მართლა კარგი ი iOS.
>> რომ არის მართლაც სწრაფი მაგალითად მას.
ისინი რეალურად შეიქმნას მართლაც cute-- შეხედეთ, რომ პატარა cute iPhone
dude იქ, ეს საკმაოდ გასაოცარია.
და გზა ისინი განმარტავენ, Objective C სინტაქსი სრულიად ნათელია.
ხის სახლი არის იგივე.
და AppCoda ფორუმზე.
ეს, ფაქტობრივად, წაკითხვა, რომელიც აწარმოებს მიერ ნამდვილად გამოცდილი Objective C
პროგრამისტი.
და ყველა იმ გაკვეთილები AppCoda არიან საკმაოდ მოკლე და მარტივი განხორციელება,
რეკომენდირებულია.
>> და თუ თქვენ დეველოპერი, აუცილებლად წავიდეთ სანახავად
როგორ WWDC ვიდეო სადაც შეგიძლიათ გაეცნონ უახლესი iOS პროგრამირება
ტექნიკას, APIs და ბიბლიოთეკები.
ასე რომ საკმაოდ ბევრი ის სემინარი.
დიდი მადლობა, რომ.
და იმედი მაქვს, თქვენ გაქვთ გართობა შექმნა თქვენი საკუთარი iOS app.