>> TIANYU หลิว: Hey, วิธีการคือ มันไปทุกคนหรือไม่
และนี่คือ iOS App การเขียนโปรแกรมของการสัมมนาควัตถุประสงค์
ชื่อของฉันคือ Tianyu หลิว
ฉันจูเนียร์โลเวลล์ตอนนี้ มุ่งเน้นในสาขาวิทยาศาสตร์คอมพิวเตอร์
ดังนั้นในการสัมมนาครั้งนี้ฉัน จะสอนพวกคุณ
นิด ๆ หน่อย ๆ เกี่ยวกับวิธีการที่จะทำให้การตรวจสอบ
ยายได้รับความตื่นเต้นสำหรับมัน
>> ดังนั้นก่อนที่เราจะเริ่มต้นการดำน้ำ ในด้านการเขียนโปรแกรมที่เกิดขึ้นจริง
ขอเพียงแค่ได้อย่างรวดเร็วจริงๆพูดคุยเกี่ยวกับ ทำไมคุณอาจต้องการที่จะสร้างแอป iOS?
iOS ของคุณคือเหตุผลที่น่ากลัวเหรอ?
ดังนั้นปัญหาแรกเป็นครั้งแรก สิ่งที่สวยน่ากลัวสำหรับเรา
โดยเฉพาะอย่างยิ่ง CS50 นักเรียนคือ iOS ของคุณ
ใช้วัตถุประสงค์ C. ดีมี ภาษาใหม่ที่เรียกว่าสวิฟท์,
แต่เราไม่ได้ไป ที่ใช้ในการสัมมนาครั้งนี้
หากคุณสนใจในสวิฟท์มี เป็นงานสัมมนาเกี่ยวกับการที่เป็นอิสระ
แต่วัตถุประสงค์ C เป็นพื้น ซูเปอร์ซีความหมาย
ทุกอย่างที่คุณใช้ใน C สามารถ สามารถแปลเป็​​นวัตถุประสงค์ C
ได้อย่างง่ายดายมาก
>> ในขณะที่คุณอาจจะได้เห็นต่อไปว่าแน่นอน มีบางไวยากรณ์พื้นฐานมากเป็น
พื้นตรงเดียวกัน C และวัตถุประสงค์ C. ดังนั้น
เนื่องจากคุณได้นำ CS50 ขึ้นมาไกลขนาดนี้แล้วคุณ
ทราบวัตถุประสงค์ C อย่างน้อย 40%
นอกจากนี้แอปเปิ้ลมีจริงๆ ที่แข็งแกร่ง API สำหรับ iOS
มีจำนวนมากบ้าจริงๆมี สิ่งที่คุณสามารถทำอะไรกับมัน
ซึ่งหนึ่งในนั้นคือคน สร้างขึ้นจริงแอป iOS
สำหรับการควบคุมรถที่ เป็นที่น่าสนใจสวย
น่าจะเป็นเฮลิคอปเตอร์เป็นที่น่าตื่นเต้นมากขึ้น
แต่นั่นเป็นวิธีที่มีประสิทธิภาพ iOS ของ API สามารถ
>> และในขณะที่คุณอาจมี คิดออกตอนนี้
กองล้นอาจเป็นหนึ่งใน แหล่งข้อมูลออนไลน์ที่สำคัญที่สุด
ที่มีให้คุณ
และข่าวที่ดีสำหรับทุก ปัญหาเดียวที่คุณสามารถเป็นไปได้
คิดว่าในขณะที่อาคารของคุณ โครงการสุดท้ายในวัตถุประสงค์ C,
มีแนวโน้มตอบกองล้น
มันน่ากลัวเพียง
นอกเหนือจากนั้น iOS ของคุณเป็นจริงแพลตฟอร์ม
ที่คุณสามารถเข้าถึงมาก ผู้ชมมีความพยายามน้อย
มันไม่เหมือน Android ที่ ทุกอย่างมีการกระจายตัวสวย
>> ทุกอย่าง iOS ของคุณเป็นแบบครบวงจร
และตราบใดที่คุณสร้าง app สำหรับ iPhone,
คุณได้อย่างง่ายดายสามารถพอร์ตนั้นเพื่อ iPad, มินิ iPad, iPhone หรือขนาดที่แตกต่างกัน
เหล่านี้ล้วนเป็นความสะดวกสบายจริงๆ
และเป็นเพียงที่ดีจริงๆ สำหรับสร้างความประทับใจให้เพื่อนของคุณ
คุณก็สามารถถือ iPhone และบอกเพื่อนของคุณเดี๋ยวก่อน
นี้เป็น app ที่ผมทำ
คุณสามารถทำที่ใด ปพลิเคชันสก์ท็อปซึ่งเป็นสิ่งที่ดี
>> ทั้งหมดขวาตอนนี้ขอได้รับจริง เป็นภาษาวัตถุประสงค์ C.
ดังนั้นทำไมเราไม่เริ่มต้นด้วย บางไวยากรณ์พื้นฐานจริงๆ
ที่ผมกล่าวถึงก่อนวัตถุประสงค์ C มันเป็นพื้นซูเปอร์ซี
ดังนั้นจำนวนมากไวยากรณ์พื้นฐานเป็น จริงตรงเดียวกัน
ประกาศตัวแปรและ เพิ่มตัวแปรทั้งสองเข้าด้วยกัน
เป็นสิ่งที่เราได้ทำในมาริโอ
ไม่มีอะไรใหม่ที่นี่
>> ในทำนองเดียวกันอาศัยสำหรับวง และนอกจากนี้ยังมีสภาพเดียวกัน
คุณสามารถทำห่วงเช่นเดียวกับคุณ ได้ทำในมาริโอ [ไม่ได้ยิน]
และคุณสามารถทำเงื่อนไข เป็นเพียงสิ่งที่คุณ
ได้รับการทำในชุดพีก่อนหน้าของคุณ
อย่างไรก็ตามวัตถุประสงค์ C ไม่สมบูรณ์ซี
และมีอะไรบางอย่างที่ เป็นชนิดของแปลก ๆ เกี่ยวกับเรื่องนี้
>> คนแรกที่ถูกว่าเมื่อคุณอยู่ ทำโปรแกรม C คุณมักจะเรียก
รวมแล้วชื่อห้องสมุด
แต่ในวัตถุประสงค์ C ที่คุณเรียกว่าการนำเข้า
โดยทั่วไปการทำงานกล่าวว่า เพียงแค่ชื่อที่แตกต่างกัน
และสตริงที่มี จริงนิด ๆ หน่อย ๆ แปลก
คุณจะเห็นว่าเป็นครั้งแรก สิ่งที่เป็นชนิดของแปลก
คือคุณต้องสวย weird-- sorry-- คุณมี NS แปลกสวย
เข้าสู่ระบบที่นี่
และสิ่งที่สอง ที่ชนิดของแปลก
คือคุณต้องเข้าสู่ระบบก่อนที่ จริงประกาศสตริง
ดังนั้นที่เข้าสู่ระบบโดยทั่วไปหมายถึง ที่สตริงไม่ได้เป็นเพียงสตริง
มันเป็นจริงวัตถุ
เรากำลังจะไปอธิบาย ที่ต่อมาจึงไม่
ความตื่นตระหนกถ้าคุณทำไม่ได้ เข้าใจสิ่งที่หมายถึง
และการพิมพ์ไปยังคอนโซลเป็นนิด ๆ หน่อย ๆ แตกต่างกันเพราะใน C ที่เราเรียก printf,
แต่ใน C วัตถุประสงค์ที่เราเรียกว่า [ไม่ได้ยิน]
>> คุณอาจจะสงสัยว่าสิ่งที่เป็น
นั่นคือพื้น printf, เพียงแค่ภาษาที่แตกต่างกัน
ว่าการใช้งานเดียวกัน ว่าการทำงานเดียวกัน
ดีมันกลับกลายเป็นว่า วัตถุประสงค์ C จริง
มีคำนำหน้า ns ในเกือบ ทุกอย่างทุกชนิดข้อมูลพื้นฐาน
NSString, NSArray, NSDictionary
เหตุผลที่ว่า ns จริงยืนสำหรับขั้นตอนถัดไป
ซึ่งเป็น บริษัท ที่ สตีฟจ็อบส์ได้ก่อตั้ง,
ซึ่งเป็น บริษัท ที่ ภาษาวัตถุประสงค์ C เกิด
ดังนั้นนี่คือประเพณีพื้น
ฉันรู้ว่ามันนิด ๆ หน่อย ๆ แปลก แต่ก็เป็นแอปเปิ้ล
>> ดังนั้นสิ่งที่จะยิ่งประหลาด กว่าที่มีการประกาศฟังก์ชัน
นี้จะแตกต่างจากสิ่งที่เรา เห็นใน C เพราะที่นี่ก็จริง
ดูไม่เหมือน C อีกต่อไป
สิ่งที่คุณต้องตรงนี้โดย วิธีนี้ไม่ได้จุดที่กระสุน
นี้เป็นสัญญาณลบ
คุณมีวงเล็บเครื่องหมายลบ เป็นโมฆะแล้วชื่อฟังก์ชัน
ขอเพียงบอกว่าถ้าเรา มีสวัสดีชาวโลกแล้ว
ชนิดกลับจะถือเป็นโมฆะ เพราะเรากลับไม่มีอะไร
>> สิ่งที่ได้รับแปลกจริงๆ คือว่าเมื่อคุณ
มีมากกว่าหนึ่งพารามิเตอร์ ผ่านเข้าสู่ฟังก์ชั่นเดียวกันกับที่
จะแปลกจริงๆตามที่แสดงที่นี่
เรามีชื่อวิธีการ เรียกว่า addInt ไปที่ [ไม่ได้ยิน]
และเรากำลังผ่านหนึ่งพารามิเตอร์
แต่หลังจากที่เรามี ชื่อวิธีเพิ่มเติมได้ที่โทรด้วย
และหลังจากที่มีเรากำลังผ่าน พารามิเตอร์ที่สอง
นี้เป็นจริงนิด ๆ หน่อย ๆ แปลก แต่ทั้งหมดเหล่านี้ประกาศฟังก์ชัน
ตามรูปแบบที่เหมือนกันเช่นนี้
>> เรามีเครื่องหมายลบจะเริ่มต้นด้วย
เครื่องหมายลบอาจเป็นสัญญาณบวก บางครั้งขึ้นอยู่กับชนิดของวิธีการ
มันเป็น
วิธีที่จะเป็นพื้น ชื่อฟังก์ชั่นอื่น
และเรากำลังจะไป อธิบายว่าต่อมาเมื่อ
เรากำลังพูดถึงเกี่ยวกับวัตถุ การเขียนโปรแกรมเชิง
ขั้นแรกคุณระบุผลตอบแทน พิมพ์วงเล็บภายใน
หลังจากที่มาชื่อวิธี
คุณกำลังผ่านหนึ่งพารามิเตอร์
และถ้าคุณมีพารามิเตอร์เพิ่มเติม คุณจำเป็นต้องขยายชื่อวิธี
และโดยทั่วไปเขียนอะไรบางอย่างเพิ่มเติมได้ที่นี่
>> มันอาจจะเป็นสิ่งที่คุณต้องการ
ในกรณีของเราก็ด้วย
แต่คุณอาจจะบอกว่าปลายหรือหรือหรือ abc บาร์เต็มรูปแบบสิ่งที่คุณต้องการ
และแล้วหลังจากที่คุณ ผ่านขพารามิเตอร์
นี่คือแปลกจริงๆ การประชุม แต่เรามี
จะเห็นว่าทำไมแอปเปิ้ลต้องการ จะทำอย่างนั้นอย่างรวดเร็ว
ดังนั้นวิธีที่คุณเรียกฟังก์ชั่น?
เรียกใช้ฟังก์ชันในวัตถุประสงค์ ซียังแตกต่างจากซี
>> ที่จริงเรียก ฟังก์ชั่นในวัตถุประสงค์ C
เป็นเหมือนที่คุณกำลังพูดคุยกับคน
ที่นี่เรามีตัวเองซึ่ง ที่เรียกว่าวัตถุ
คุณพื้นบอก วัตถุที่ตัวเองจะพูดว่า "Hello World!"
นั่นคือวิธีการเรียกฟังก์ชั่น
วัตถุและชื่อวิธี รวมกับคนอื่น ๆ
และนี่คือที่นามสกุลแปลก สำหรับชื่อวิธีการจริงๆมาลงเล่น
>> ลองดูที่ตัวอย่างที่สอง
เราเพียงแค่กำหนดวิธีการที่เรียกว่า addInt กับ blah blah blah
ดังนั้นในกรณีนี้เมื่อคุณโทร ที่เฉพาะเจาะจง [? ข้อความ?] มันจะ
ให้มีลักษณะเหมือนตัวเอง addInt: 10 ด้วย: 2
มันเสียงเหมือนภาษาอังกฤษ
แม้ว่าฟังก์ชั่น ประกาศฟังก์ชั่นที่แปลก
จุดของวัตถุประสงค์ของ C รูปแบบการประกาศวิธีการ
คือว่าเมื่อคุณโทร ฟังก์ชั่นหรือวิธีการ
มันจะเสียงเหมือนภาษาอังกฤษที่เกิดขึ้นจริง
ดังนั้นจึงเป็นงานง่ายมาก เมื่อคุณได้รับเป็นมัน
>> โดยเฉพาะอย่างยิ่งในกรณีนี้ ที่คุณสามารถโดยทั่วไป
เห็นว่าชื่อฟังก์ชั่นเป็น การเรียงลำดับของการบันทึกข้อมูลของตัวเอง
คุณไม่จำเป็นต้องใด ๆ คำอธิบายเพิ่มเติมเพื่อดู
ว่าสิ่งที่เกิดขึ้นสิ่งที่ ว่าหนึ่งพารามิเตอร์ทำ
ไปไกลเกินกว่าที่เราจะมาพูดเล็ก ๆ น้อย ๆ เล็กน้อยเกี่ยวกับการเขียนโปรแกรมเชิงวัตถุ
การเขียนโปรแกรมเชิงวัตถุ หนึ่งในการเขียนโปรแกรมพื้นฐาน
เทคนิคหรือรูปแบบที่เป็น ใช้โดยวัตถุประสงค์ C. วัตถุประสงค์ C
เรียกว่าวัตถุประสงค์ C ไม่ C สำหรับเหตุผลที่ดีจริงๆ
>> ดังนั้นก่อนที่เราจะได้เป็น วัตถุประสงค์ไวยากรณ์ C,
ลองจริงๆดูได้อย่างรวดเร็ว ว่าสิ่งที่เป็นวัตถุ
เราได้ทำอะไรบางอย่างที่อาจจะ เช่นวัตถุก่อนซึ่ง
เรียกว่า struct เมื่อคุณอยู่ การดำเนินการตามต้นไม้หรือรายการที่เชื่อมโยง
หรือ [? ความพยายาม ?] ดังนั้นจึงเป็น พื้นเช่น struct,
แต่ก็มีประสิทธิภาพมากขึ้นกว่าที่
วัตถุจะมีวิธีการและคุณสมบัติ
วิธีการมีพื้นฟังก์ชั่น
โดยทั่วไปฟังก์ชั่นที่ ที่เฉพาะเจาะจงกับวัตถุบางอย่าง
>> และคุณสมบัติโดยทั่วไป ข้อมูลที่คุณระบุใน struct
ดังนั้นสำหรับทุกวัตถ​​ุเดียว เรามีสถานที่ให้บริการบางส่วน
ที่มีตัวแปรบางอย่างที่ มีความเฉพาะเจาะจงไปยังวัตถุ
และเรามีฟังก์ชั่นบางอย่างที่ นอกจากนี้ยังมีที่เฉพาะเจาะจงไปยังวัตถุ
และฟังก์ชั่นที่เรียกว่าวิธีการ และตัวแปรที่เรียกว่าคุณสมบัติ
มันเป็นเพียงชื่อแฟนซี
ในขณะที่ความเป็นจริงคุณทุกมุมมองเดียว ที่คุณเห็นในขณะที่คุณเปิดแอป iOS,
ให้เพียงกล่าวว่า Twitter หรือ Facebook, ทุกมุมมองเดียวที่คุณเห็นคือวัตถุ
และแม้กระทั่งการตรวจสอบทั้งหมดเป็น วัตถุที่จะเริ่มต้นด้วย
แนวคิดที่น่าสนใจมาก
>> และทำไมเราต้องการวัตถุ การเขียนโปรแกรมเชิง?
ดังนั้นคุณสามารถจินตนาการได้ว่าเมื่อคุณ โปรแกรมที่ได้รับความซับซ้อนสวย
ขอเพียงบอกว่าเมื่อคุณอยู่ กระดานหมากรุกดำเนินการ
ตรรกะเป็นไปได้ มีความซับซ้อนจริงๆ
คุณมี 36 ที่แตกต่างกัน ชิ้นเพื่อที่ว่าถ้าคุณ
ต้องการที่จะเขียนตรรกะทั้งหมด 36 ชิ้นที่แตกต่างกันในหมากรุก
ที่จะเป็นจำนวนมาก ฟังก์ชั่นที่แตกต่างกันและตัวแปร
มันเป็นปัญหามาก
และอาจจะคุณจะเขียน วิธีการที่แตกต่างกันหรือการทำงานที่แตกต่างกัน
สำหรับแต่ละชิ้นเพื่อ ว่าควบคุมสิ่งที่พวกเขาทำ
>> แต่ถ้าคุณทำเชิงวัตถุ การเขียนโปรแกรมทั้งหมดของชิ้นส่วนเหล่านี้
สามารถแยกออกเป็น วัตถุหนึ่งเดียว
และวัตถุที่จะมีบางอย่างร่วมกัน คุณสมบัติเช่นเดียวกับสิ่งที่ชนิดของชิ้นส่วน
มันคืออะไร?
สีมันคืออะไร?
วิธีที่จะสามารถย้าย?
และในทางที่คุณมีมาก ง่ายตรรกะของมัน
ดังนั้นจึงเป็นเพียงวิธีที่ดีจริงๆ เพื่อให้โปรแกรมที่มีความซับซ้อน
และความสัมพันธ์ของลำดับชั้น ภายในโปรแกรมที่ง่ายมาก
ขณะที่เรากำลังจะไปดู ทำไมอย่างรวดเร็วเมื่อ
เรากำลังทำจริง programming-- เมื่อเราจริง
ทำรหัส S เซสชั่นการเขียนโปรแกรมในภายหลัง
>> ดีนอกเหนือไปจากนั้น เขียนโปรแกรมเชิงวัตถุ
เป็นเพียงจำนวนมากสนุก
คุณได้รับการออกแบบวัตถุของคุณเอง
คุณได้รับการออกแบบสิ่งที่ไม่ มันมีลักษณะเหมือนด้วยตัวเอง
ไม่มีคำตอบที่เหมาะสมในการที่มันเป็น
และมันก็เป็นที่น่าสนใจทั้งหมด
ดังนั้นในการเขียนโปรแกรมเชิงวัตถุ สองแนวคิดพื้นฐาน
จะมีการเรียนและอินสแตนซ์
ชั้นเป็นพื้น แม่แบบสำหรับวัตถุ
และเช่นนั้นเป็น หนึ่งในวัตถุที่เฉพาะเจาะจง
>> ขอเพียงบอกว่าคุณกำลังทำคุกกี้
ในกรณีนี้ทุกเดียว คุกกี้คุณจริงจบลงด้วย
เป็นไปได้ที่วัตถุ
แต่แผ่นคุกกี้ที่คุณใช้ในการอบ คุกกี้ทั้งหมดจะเป็นชั้น
ชั้นเป็นพื้นแม่แบบ
และอินสแตนซ์จะเป็นหนึ่งที่เฉพาะเจาะจง วัตถุที่สร้างขึ้นมาจากชั้นเรียนที่
>> และตัวอย่างจะถูกสร้างขึ้น ขึ้นอยู่กับการประกาศคลาส,
ในขณะที่เราจะเห็นในสไลด์ในภายหลัง
ดังนั้นขอให้ทำจริงจริงๆ ตัวอย่างรวดเร็ว [ไม่ได้ยิน]
สมมติว่าเรากำลังประกาศ วัตถุสำหรับแมว
วัตถุควร have-- ชั้นแมวควร
มีคุณสมบัติบางอย่างและวิธีการ
ชนิดของคุณสมบัติที่ควร ชั้น have-- แมวควรมี?
>> ยกตัวอย่างเช่นสี อายุและสายพันธุ์เหล่านั้น
จะเป็นตัวแปรที่ มีความเฉพาะเจาะจงกับแมวแต่ละ
และผู้ที่มีบางสิ่งบางอย่าง ที่เราใช้ในการอธิบายแมว
ชนิดของวิธีการ หรือสิ่งที่แมวจะทำอย่างไร
บางตัวอย่างรวดเร็วจะไล่ล่า เมาส์, กินปลาหรือเพียงแค่ meow
นี้เป็นวิธีที่รวดเร็วจริงๆ ตัวอย่างของการเรียนแมว
และเฉพาะจริงๆ วัตถุแมวจะเป็นแมว
ที่เราระบุ สีอายุและสายพันธุ์
>> ในกรณีที่วัตถุของเราคือ ไม่มีชั้นอีกต่อไป
เราคัดลอกแม่แบบจากชั้นเรียนและ เราระบุแต่ละข้อมูลที่เฉพาะเจาะจง
กับวัตถุที่เฉพาะเจาะจง ที่จะทำให้มันเป็นอิสระ
และเมื่อคุณโทร วิธีการภายในวัตถุ,
คุณเพียงโทร Meow บนวัตถุ ซึ่งเป็นแมวที่คุณเพิ่งสร้าง
>> คุณอาจจะพิมพ์ออกมา บางอย่างเช่น "Hello World!
Meow. "
สวยน่ารัก
สิทธิทั้งหมดให้เพียง ได้รับในรายละเอียดบางอย่าง
และดูว่าสิ่งที่ไม่ว่า แปลเป็​​นกำลังการเขียนโปรแกรม iOS
ดังนั้นในการเขียนโปรแกรม iOS ทุกเดียว ชั้นจะดำเนินการในสองไฟล์
หนึ่งไฟล์อยู่ที่นี่ซึ่ง ที่เรียกว่าอินเตอร์เฟซ
ไฟล์ก็คือที่นี่ซึ่ง ที่เรียกว่าการดำเนินการ
>> โดยปกติอินเตอร์เฟซ จะมี extension.h
ที่เราได้เห็นในห้องสมุด C
และการดำเนินงานเป็นไฟล์ จะมี extension.n
มันเป็นชนิดของแปลก
แต่หมายถึงการ .n จริง .c ไม่มี ความแตกต่างพื้นฐานระหว่างผู้
สอง
ดังนั้นในกรณีนี้เราจะเห็นว่าเรา อินเตอร์เฟซที่ประกาศแมว: วัตถุ
ที่เรียกว่ามรดก
เรากำลังพื้นสืบทอด ชั้นแมวจากชั้นวัตถุ
ดังนั้นทุกสถานที่ให้บริการและวิธีการที่เป็น ที่กำหนดไว้ก่อนหน้านี้ในชั้นวัตถุ
จะถูกกำหนดโดยอัตโนมัติ ในชั้นเรียนของแมวได้เป็นอย่างดี
>> นอกจากนั้นเรากำหนดสี พันธุ์และอายุสามตัวแปร
ที่จริงดูเหมือนว่า สิ่งที่คุณได้ทำมาก่อน
ดูเหมือนว่า struct
นั่นคือโดยทั่วไปไวยากรณ์ สำหรับการประกาศ struct,
และนั่นคือที่ถูกต้องทั้งหมด
และตั้งแต่ที่ผมกล่าวถึงมาก่อน ความแตกต่าง struct
และวัตถุอย่างใดอย่างหนึ่ง ความแตกต่างพื้นฐาน
คือการที่วัตถุจะมีวิธีการ ในขณะที่โครงสร้างมีเพียงตัวแปร
ดังนั้นนอกเหนือไปจากคุณสมบัติหรือ ตัวแปรที่เราได้สร้างขึ้นสำหรับวัตถุ
เราระบุวิธีการบางอย่าง
>> ขอเพียงบอกว่าที่นี่เรามี สองวิธีหนึ่งคือแมว,
อีกคนหนึ่งเป็นเมาส์ไล่ล่า
เราอาจต้องการที่จะผ่าน พารามิเตอร์ตามวิธีการเดิมของเรา
รูปแบบการประกาศ
คุณอาจต้องการที่จะผ่านเมาส์
และคุณอาจจะต้องการ เพื่อกลับสำแดงบูล
ถ้าแมวของคุณมีประสบความสำเร็จ จับเมาส์หรือไม่
>> นี่คืออินเตอร์เฟซ แต่ที่เราสามารถทำได้ เห็นว่าอินเตอร์เฟซจริง
ไม่ได้ทำอะไร
มันก็บอกว่าสิ่งที่โปรแกรม exists-- สิ่งที่มีอยู่ในชั้นเรียนของแมว
ดังนั้นเพื่อให้ โปรแกรมที่จะทำบางสิ่งบางอย่าง
เราจำเป็นต้องมีไฟล์การดำเนินงาน
ดังนั้นนี่คือสิ่งแรกที่เราทำคือ เห็นได้ชัดว่าเรานำเข้าอินเตอร์เฟซ
หลังจากที่เรานำเข้าอินเตอร์เฟซ, เรากำหนดวิธีการ
>> ขอเพียงบอกว่าที่นี่ Meow ก็จะพิมพ์ออกมา
"Hello World!" ไปยังคอนโซล
และหลังจากการดำเนินการ ไฟล์ที่เรากำลังทำสวยมาก
นี้เป็นพื้นชั้น ประกาศสำหรับชั้นหนึ่ง
ดังนั้นตอนนี้คำถามที่จะกลายเป็น วิธีการทำคุณประกาศตัวแปร?
วิธีที่คุณใช้คลาสที่จะสร้าง วัตถุที่อยู่ในวัตถุประสงค์ C ที่เขียนไว้ที่นี่
>> คุณเป็นครั้งแรกระบุว่า นี้เป็นตัวชี้แมว
เนื่องจากวัตถ​​ุในวัตถุประสงค์ C ทุก จะดำเนินการในที่สุดก็เป็นตัวชี้
และคุณเรียกชั้นเรียกพวกเขา เป็น alloc ซึ่งเป็นพื้น malloc,
บอกระบบปฏิบัติการที่คุณ ต้องการพื้นที่หน่วยความจำบางสำหรับวัตถุนี้
หลังจากนั้นคุณมีวัตถุ แล้วและคุณเพียงแค่เริ่มต้นมัน
นี่คือแผนการเพียง
ฉันรู้ว่ามันเป็นเล็กน้อยแปลก แต่ นี้เป็นจริงว่าแอปเปิ้ลไม่สิ่ง
>> การกำหนดคุณสมบัติเป็น จริงตรงไปตรงสวย
มันคล้ายกับ สิ่งที่คุณทำเมื่อ
คุณกำลังกำหนดเฉพาะบางส่วน ข้อมูลภายในของ struct
คุณเพียงแค่ต้องตัวแปร ชื่อชื่อสถานที่ให้บริการ
และกำหนดค่าเฉพาะกับมัน
และเรียกวิธีการคล้ายกันมาก
เรียกวิธีการคือ โดยทั่วไปสิ่งที่ฉันพูดคุยเกี่ยวกับ
เรียกวิธีการใด ๆ ในวัตถุประสงค์ C.
>> คุณผ่านวัตถุใน กรณีนี้มันเป็นไปได้ myCat,
และคุณผ่านชื่อวิธี
ราวกับว่าคุณกำลังพูดคุยกับวัตถุ myCat ที่คุณควร meow
มันเป็นเรื่องที่น่าสนใจสวย
หลังจากนั้นมีหนึ่ง รูปแบบการออกแบบที่สำคัญมากขึ้น
ที่เราต้องการที่จะพูดคุยเกี่ยวกับ ก่อนที่จะเดินทางไปยังรหัส S ที่เกิดขึ้นจริง
รูปแบบการออกแบบที่เรียกว่า เหตุการณ์การเขียนโปรแกรมขับเคลื่อน
และนี่ก็อาจเป็นหนึ่งในที่สุด ความคิดพื้นฐานในการเขียนโปรแกรม iOS
>> ดังนั้นคุณอาจไม่ทราบว่าสิ่งที่ คือการเขียนโปรแกรมขับเคลื่อนเหตุการณ์
แต่มันไม่จริงที่น่ากลัว
ดีในความเป็นจริงคุณมี ทำมาแล้วว่าก่อนที่
นี้เป็นหนึ่งในสายที่คุณอาจจะ เขียนแล้วในช่วง [ไม่ได้ยิน]
ของ CS50, google.maps.event.addListener (เครื่องหมาย
"คลิกที่" ฟังก์ชั่น () {}) :.
โดยการเรียกสายคุณอยู่นี้ เป็นหลักบอกคอมพิวเตอร์
ว่าเมื่อใดก็ตามเหตุการณ์ที่เรียกว่า "คลิก" ที่เกิดขึ้นในเครื่องหมาย,
ใช้ฟังก์ชั่นที่
>> นี่คือความแตกต่างจาก สิ่งที่คุณทำใน mario.c
ใน mario.c คุณเพียงแค่เรียกใช้โปรแกรม ครั้งเดียวก็จะช่วยให้คุณเอาท์พุท,
และคุณเสร็จแล้ว
เหล่านี้เป็นประเภทเช่น หนึ่งในโปรแกรมยิง
เหตุการณ์ที่ขับเคลื่อนด้วยโปรแกรม มีความแตกต่างกันมาก
ลองจินตนาการถ้า Facebook เป็นหนึ่ง โปรแกรมยิงมันไม่ดีจริงๆ
คุณเพียงแค่ไปที่ Facebook ครั้งเดียวและมันทำ
มันจะช่วยให้คุณส่งออกบางส่วน และคุณไม่เคยได้รับมันกลับ
คุณไม่เคยได้อะไรมาก
>> ดังนั้นที่นี่โดยเฉพาะอย่างยิ่ง รูปแบบที่เราใช้คือ
เหตุการณ์ที่ขับเคลื่อนด้วยเพื่อที่ว่า ทุกฟังก์ชั่นจะ
ถูกจับตามสิ่งที่ เหตุการณ์ที่เกิดขึ้น
ยกตัวอย่างเช่นถ้าเรามี ปุ่มและเราระบุ
ว่าเมื่อใดก็ตามที่มีปุ่มคลิก เรียกใช้ฟังก์ชันที่เรียกว่า "Hello World!"
ในวิธีการที่เราสามารถทำได้จริงๆ ฟังก์ชั่นการจัดการลอจิก
การไหลในทางที่มีความยืดหยุ่นสูง
ผู้ใช้สามารถทำหรือเรียกใช้ฟังก์ชัน ที่ได้ถูกเรียกว่า
ก็ขึ้นอยู่อย่างสมบูรณ์ในสิ่งที่ผู้ใช้ทำ
>> ดังนั้นเราจะเห็นว่านี่คือ จริงดีกว่า mario.c
และข่าวดีก็คือว่ามันเป็น จริงไม่ได้เป็นแนวคิดใหม่
พวกคุณได้ทำมาแล้ว ว่าในปัญหาชุดที่ผ่านมา
ดังนั้นในวัตถุประสงค์ C มี สามแผนภาพที่แตกต่างกัน
สำหรับการเขียนโปรแกรมขับเคลื่อนเหตุการณ์
แผนภาพแรกคือ ที่เรียกว่าการดำเนินการเป้าหมาย
ที่คุณผูกปุ่ม กดที่มีฟังก์ชั่นบางอย่าง
ขอเพียงบอกว่าเมื่อใดก็ตามที่คุณคลิก ปุ่มบางอย่างที่คุณเรียกฟังก์ชั่นบางอย่าง
นี่คือการกระทำที่เป้าหมายที่ง่ายมาก
>> คนที่สองเป็น จริงที่ยากที่สุดอย่างใดอย่างหนึ่ง
ก็เรียกว่าคณะผู้แทนโปรโตคอล
เรากำลังจะไปอธิบาย ว่าในรายละเอียดมากในภายหลัง
และวิธีที่สามคือการแจ้งเตือน
นี้เป็นจริงไม่ได้ สิ่งที่สำคัญมากเท่า
ในขณะที่เรากำลังกังวลเพราะโอกาส ที่คุณกำลังจะใช้การแจ้งเตือน
ในโครงการสุดท้ายของคุณอยู่ในระดับต่ำสวย
ดังนั้นเราจึงกำลังจะข้ามส่วนที่
>> และเรากำลังจะไปดำน้ำ เป็นผู้แทนโปรโตคอล
ดังนั้นสิ่งที่ว่าเป็นโปรโตคอล?
หรือว่าเป็นสิ่งที่คณะผู้แทน?
พูดคุยเกี่ยวกับโปรโตคอลจะเริ่มต้นด้วย
โปรโตคอลจะไม่มีอะไร แต่เหตุการณ์ที่เกิดขึ้น
แต่เหตุการณ์เหล่านี้จะได้รับการ คุณโดยแอปเปิ้ลจะเริ่มต้นด้วย
ยกตัวอย่างเช่นฉันไม่ได้ สมบูรณ์แน่ใจว่าหลายท่าน
คนเดิมใช้แอปเปิ้ล จดหมายการตรวจสอบหรือการติดต่อ
แต่เวลาที่คุณเลื่อนทุก ตารางและกดเซลล์ที่เฉพาะเจาะจง
บนโต๊ะที่เป็นเหตุการณ์
>> และถ้าคุณต้องการที่จะทำ เหตุการณ์ที่ด้วยตัวเอง
ก็จริงเล็กน้อยยาก
ดังนั้นแอปเปิ้ลได้ให้ว่าแม้กับคุณ เพื่อให้คุณสามารถเพียงแค่ใช้โดยตรง
เหตุการณ์ที่จะทำบางสิ่งบางอย่างด้วยตัวคุณเอง
โปรโตคอลที่เป็นจริง จริงๆใช้กันอย่างแพร่หลาย
ในวัตถุประสงค์ C. ดีใน ความเป็นจริงทุก app เดียว
มีสิ่งที่จับผู้แทนการตรวจสอบ
ภายในที่ละเอียดอ่อนคือทั้งหมดของ โปรโตคอลสำหรับการโหลดแอพพลิเค
>> ขอเพียงบอกว่ามี เหตุการณ์สำหรับ app ได้โหลด
ดังนั้นสิ่งที่ควรจะเกิดขึ้นหลังจากที่คุณได้ สร้างแอพพลิเค, หลังจากที่คุณเปิด app ที่
หลังจากที่คุณปิด app ที่หรือหลัง คุณใส่ iPhone เพื่อการนอนหลับ
เหล่านี้เป็นเหตุการณ์ที่เกิดขึ้นทั้งหมดที่มี รับแล้วให้กับคุณ
และสร้างสรรค์ภายในอนุภาคเหล่านี้ จะมีการดำเนินการไม่มี
แอปเปิ้ลเพียงแค่บอกคุณว่าฟังก์ชั่นนี้ จะเกิดขึ้นเมื่อมีเหตุการณ์บางอย่างเกิดขึ้น
แต่สิ่งที่คุณทำกับที่ ฟังก์ชั่นสมบูรณ์ขึ้นอยู่กับคุณ
>> คณะผู้แทนเป็นพื้น บอกชั้น
ที่คุณควรจัดการโปรโตคอลเหล่านี้
มันนิด ๆ หน่อย ๆ สับสน แต่มันจะเป็น
ชัดเจนมากขึ้นเมื่อเราทำ รหัสในการดำเนินการ
คณะผู้แทนโปรโตคอลเป็นจริง กลไกที่แข็งแกร่งอย่างมากในความรู้สึก
ว่าถ้าเราทำคณะผู้แทน ในระดับที่เฉพาะเจาะจง
เราสามารถจัดการเป็นหลัก ทุกชนิดของเหตุการณ์ที่เกิดขึ้น
โดยใช้ชั้นใดที่เรามี เครื่องมือที่สะดวกมาก
>> ดังนั้นหนึ่งตัวอย่างรวดเร็วสำหรับ คณะผู้แทนโปรโตคอล
จะเป็นสิ่งที่ผมเพิ่งพูดคุยเกี่ยวกับ
โปรโตคอลนี้โดยเฉพาะที่เรียกว่า tableview [ไม่ได้ยิน] เลือกที่บทบาท
ที่ [? ดัชนี?] [? อดีต ?] ดังนั้นนี้ เหตุการณ์ที่จะถูกจับเมื่อคุณ
จริงแตะที่เฉพาะเจาะจง เซลล์ใน tableview ของคุณ
ให้เพียงกล่าวว่าในจดหมายของคุณ หรือในการตรวจสอบรายชื่อของคุณ
>> ภายในมีฟังก์ชั่น แต่เดิมทำอะไร
ฟังก์ชั่นไม่ได้ ทำอะไรไปโดยปริยาย
แต่คุณสามารถระบุ สิ่งที่ฟังก์ชั่นไม่
ได้รับสิ่งที่คุณต้องการออกจาก app ของคุณ
เครื่องมือที่สะดวกมาก
และด้วยทุกสิ่งที่ ถูกกล่าวว่าฉันเป็นพื้น
ครอบคลุมบางส่วนไวยากรณ์พื้นฐานมากและ แนวคิดพื้นฐานสำหรับวัตถุประสงค์ C
การเขียนโปรแกรมและเราสามารถทำรหัสบาง
มากที่น่าตื่นเต้นมาก
ดังนั้นรหัสคือจริง นิด ๆ หน่อย ๆ อย่างท่วมท้น
เมื่อคุณเปิดมันเป็นครั้งแรก
>> หนึ่งทราบอย่างรวดเร็วดังนั้นหากคุณ ต้องการที่จะทำการพัฒนา iOS ของคุณ,
ผมขอแนะนำให้คุณมี Mac
เพราะการทำเช่นการพัฒนาบน iOS Windows เป็นจริงๆยาก
มันเป็นไปได้ แต่มันเป็นเรื่องยากจริงๆ
และแน่นอนคุณทำ ไม่ต้องการที่จะใช้แก้ไขกรัม
ดังนั้นในรหัส S เรามี หลายพื้นที่ที่แตกต่างกัน
เมื่อคุณเปิดรหัส S คุณจะเห็นพื้นที่นำทาง
ซึ่งโดยทั่วไปจะแสดงทั้งหมด ไฟล์ที่อยู่ในโครงการปัจจุบันของคุณ
>> คุณมีพื้นที่แถบเครื่องมือซึ่ง เป็นพื้นการจัดการมุมมอง
หรือบางอย่างเล็ก ๆ น้อย ๆ อย่างรวดเร็ว เครื่องมือเกี่ยวกับรหัสของตัวเอง
และนี่คือการแก้ไขที่เกิดขึ้นจริงในพื้นที่
บริเวณนี้เป็นกรัมแก้ไขที่คล้ายกันมาก แต่ดีกว่ากรัมแก้ไข
และในพื้นที่ด้านขวานี้ เรียกว่าพื้นที่ยูทิลิตี้
พื้นที่กลายเป็นที่มีประโยชน์จริงๆเมื่อ คุณกำลังสร้างอินเตอร์เฟซหรือระบุ
การตั้งค่าบางอย่างรวดเร็วสำหรับ app ของคุณ
>> และพื้นที่สุดท้ายคือการแก้จุดบกพร่อง
บริเวณนี้มีคอนโซล
ดังนั้นเมื่อใดก็ตามที่คุณพูด ​​printf, หรือ NSLog ในกรณีของเรา
ผลลัพธ์ทั้งหมดของคุณ จะได้รับการตีพิมพ์ที่นี่
ทั้งหมดใช่มั้ย?
ผมคิดว่าเราสามารถทำอย่างรวดเร็วจริงๆ ตัวอย่างเช่นในการเขียนโปรแกรม iOS
และให้จริงเปิดรหัส S
ดังนั้นเวลาที่คุณเปิดรหัสขึ้นทุกๆมัน จะแสดงขึ้นสิ่งที่ต้องการที่
ก็จะขอให้คุณ สิ่งที่คุณต้องการจะทำอย่างไร?
คุณต้องการที่จะเริ่มต้นบางสิ่งบางอย่าง สุ่มสนามเด็กเล่นโดยทั่วไปคุณ
ก็สามารถทดสอบโค้ดโดยไม่ต้อง จริง committing เพื่อตรวจสอบใด ๆ
>> คุณต้องการที่จะสร้างโครงการใหม่ได้หรือไม่
หรือคุณต้องการที่จะดำเนินการ ทำงานในโครงการที่มีอยู่?
ในกรณีที่เรากำลังจะ เพื่อสร้างโครงการใหม่
ดังนั้นมันเป็นเรื่องดีจริงๆ s รหัสจริงที่มีอยู่แล้ว
ให้คุณแม่บาง สำหรับการสร้างวัตถุ
ถ้าคุณต้องการที่จะทำเกม, s รหัส จริงมีแม่แบบเกมสำหรับคุณ
มีการใช้งานตามหน้า แท็บการประยุกต์ใช้
ในกรณีนี้เรากำลังจะ ที่จะทำสิ่งที่ง่ายมาก
และเรากำลังจะใช้ การประยุกต์ใช้มุมมองเดียว
>> หลังจากนั้นเพียงแค่สิ่งที่คุณต้องการที่จะเรียก ผลิตภัณฑ์ของคุณและสิ่งที่ชื่อของคุณ
สิ่งที่เป็นตัวบ่งชี้ของคุณและ สิ่งที่ภาษาที่คุณใช้
ที่นี่เราไม่ต้องการที่จะ ตรวจสอบข้อมูลโดยใช้หลัก
แกนข้อมูลเป็นพื้น databasing iOS
ถ้าคุณทำหลักข้อมูล, s รหัสจะไปกำหนด
ชั้นเรียนที่มีความซับซ้อนมากขึ้นสำหรับคุณ
ดังนั้นเพื่อให้ทุกอย่างง่ายเราไม่ แค่ไปที่จะทำโดยแกนข้อมูล
ตอนนี้
>> ปัญหาที่เรากำลังจะเป็น โดยใช้เป็น that-- ปัญหา
เรากำลังจะได้รับการสร้างคือการที่เรา โดยทั่วไปต้องการที่จะนำเข้าจากมาริโอซี
เพื่อแอป iOS
ดังนั้นขอเรียกว่ามาริโอ iOS
แน่นอนคุณระบุสิ่งที่คุณ ต้องการที่จะนำในโครงการของคุณ
และมีที่เราจะไป
>> ดังนั้นนี่คือนิด ๆ หน่อย ๆ ครอบงำ แต่นี้เป็นจริง
สิ่งที่เราเห็นบนสไลด์
และพื้นที่แรกที่เราเห็นในขณะนี้ เป็นพื้นการกำหนดค่าโครงการ
ดังนั้นทุกสิ่งที่คุณต้องการจะทำ โครงการสิ่งที่ชนิดของอุปกรณ์
ขอเพียงแค่พูดในสิ่งที่ชนิดของอุปกรณ์ คุณต้องการ app ของคุณจะปรากฏบน?
มันเป็น iPhone, iPad หรือสากล?
ดังนั้นการวางอุปกรณ์ทุกสิ่งนี้
ไม่สำคัญมาก แต่อาจจะเป็น แต่นี้
เป็นสถานที่ที่คุณสามารถตั้งค่า โครงการของคุณถ้าคุณจริง
ต้องการปรับใช้ในการจัดเก็บแอปเปิ้ล
>> สิทธิทั้งหมดให้ดูที่ บางสิ่งบางอย่างที่อยู่ภายในรหัสของเรา
Let 's go ผ่านนำทางไฟล์
และเหล่านี้เป็นไฟล์ทั้งหมดที่มีอยู่แล้ว มาพร้อมกับแม่แบบที่ดีมาก
ดังนั้นเมื่อเราคลิกหนึ่งของพวกเขา นี่คือสิ่งที่ดูเหมือนว่า
คล้ายกับกรัมแก้ไข
แต่คุณจะเห็นว่า เน้นไวยากรณ์น่าจะเป็น
นิด ๆ หน่อย ๆ ดีกว่า
และมันก็เป็นจริงมากขึ้น ที่มีประสิทธิภาพกว่าการแก้ไขกรัม
และคุณสามารถที่สมบูรณ์แบบอัตโนมัติ สิ่งต่างๆมากมายสำหรับคุณ
ในขณะที่เราจะเห็นได้อย่างรวดเร็ว
>> ขอเปิดพื้นที่การแก้จุดบกพร่องได้เป็นอย่างดี
สิทธิทั้งหมดที่เราสามารถมองเห็น คอนโซลอยู่ที่นี่
นี่คือสิ่งที่คุณกำลังจะไปดูว่า คุณอยู่ใน printf หรือ nsloging บางสิ่งบางอย่าง
โดยไม่ต้องกังวลใจต่อให้จริง รวบรวมการตรวจสอบและดูสิ่งที่เกิดขึ้น
หนึ่งคุณลักษณะที่จำเป็นสำหรับ รหัสวินาที, เป็นรหัสของที่
มาพร้อมกับจำลอง iPhone
ดังนั้นคุณจึงไม่จำเป็นต้องมี iPhone จะลองโครงการของคุณ
รหัส S สามารถจำลองว่า คุณเป็นเราสามารถมองเห็นได้ในขณะนี้
>> มันสวยดี
ก็สละเล็ก ๆ น้อย ๆ บิตของเวลาที่จะรวบรวม
และโดยทั่วไปเรามี แอพลิเคชันที่ว่างเปล่า
ซึ่งอันที่จริงไม่ทำอะไรเลย
แต่ก็รวบรวม
มันน่ากลัวสวย
มันมากดีกว่า C ฮะ?
สิทธิทั้งหมดแล้วขอ พยายามที่จะเพิ่มบางสิ่งบางอย่าง
หนึ่งแฟ้มที่มีนิด ๆ หน่อย ๆ แปลกที่นี่จะเรียกว่ากระดาน
นี้เป็นจริงที่ดี คุณลักษณะที่น่ากลัวสำหรับรหัส S
เพราะในรหัสวินาที, คุณสามารถลากจริง และวางองค์ประกอบบนอินเตอร์เฟซ
และมันโดยตรงจะแสดงขึ้น
ลองว่า
>> เราวางป้ายที่นี่ "สวัสดีโลก !!!"
เราสามารถที่ศูนย์
เย็นสวย
ตอนนี้ขอทำงานจำลองหยุดนี้
ที่นี่เรามี "สวัสดีโลก !!!"
เราไม่ได้ทำการเข้ารหัสใด ๆ
ห่าที่เกิดขึ้น?
นี่คือวิธีที่มีประสิทธิภาพ Interface Builder สามารถ
ใครบางคนก็พูดว่า คุณสามารถอาจเป็นเพียงแค่
ดำเนินการตรวจสอบโดยไม่ต้องเขียน อาจจะเป็นพันสายรหัส
โดยใช้เพียงแค่ Interface Builder
แต่มันอาจจะไม่ได้ วิธีที่ดีที่สุดที่จะทำมัน
>> ตอนนี้ให้ได้รับจริงลงไปที่การเข้ารหัส
ดังนั้นโครงสร้างของแฟ้ม เป็นจริงที่น่าสนใจจริงๆ
เพราะขณะที่คุณอาจจะเห็นมี ไม่มีฟังก์ชั่นหลักที่ใดก็ได้
ดู?
ในฐานะที่เราได้กล่าวมาก่อน คุณจะเห็นว่านี้
ไฟล์การดำเนินงาน สำหรับการเรียนที่เฉพาะเจาะจง
แต่ไม่มีหลักที่ใดก็ได้
เพื่อที่จะเป็นหลัก?
ที่จริงมีหลัก แต่ หลักถูกซ่อนจริงจากคุณ
ที่สำคัญคือที่นี่
ที่มีลักษณะที่คุ้นเคย
>> ดังนั้นโดยทั่วไปสิ่งที่ iOS จะทำภายในหลัก
คือว่าเมื่อใดก็ตามที่สำคัญคือ เรียกว่าที่เป็นพื้น
เมื่อใดก็ตามที่การตรวจสอบจะถูกดำเนินการมัน สร้างวัตถุที่เรียกว่า AppDelegate
ที่ผมกล่าวถึงก่อนหน้านี้ทั้งหมด การตรวจสอบวัตถุที่เป็นจริงด้วยตัวเอง
ดังนั้นในทางนี้โดยทั่วไป แอป iOS จะบอกคอมไพเลอร์
ว่าตกลงฉันจะสร้าง ผลิตภัณฑ์ที่เรียกว่า AppDelegate,
และเป็นไปได้ที่ app ของฉัน
ดังนั้นคุณต้องไป ผ่าน AppDelegate ที่
และดูว่าผู้ชายคนที่ทำ
งานของฉันจะทำเพื่อฉัน
>> และใน AppDelegate คุณจะเห็นว่า มีบางฟังก์ชั่นที่แปลกจริงๆ
ดีจริงวิธีการที่ แอปเปิ้ลได้ให้คุณ
เหล่านี้คืออะไร
เหล่านี้เป็นจริงเพียงโปรโตคอล ว่าผมได้พูดคุยเกี่ยวกับ
ดังนั้นเหล่านี้เป็นเหตุการณ์ที่แอปเปิ้ล ได้ให้คุณเริ่มต้นด้วย
ไม่มีอะไรในบางอย่าง ฟังก์ชั่นในขณะนี้
แต่ถ้าเราต้องการที่จะเริ่มต้น บางสิ่งบางอย่างสำหรับการตรวจสอบของเรา
ก่อนที่จะได้รับในการแสดง มุมมองใด ๆ ที่เราทำที่นี่
>> คุณก็สามารถอ่านชื่อและที่ผมคิดว่า เหตุการณ์ที่เป็นจริงที่ชัดเจนจริงๆ
ดังนั้นตอนนี้หลักได้สร้าง วัตถุสำหรับ AppDelegate
และสิ่งที่ AppDelegate จะไปทำ นอกจากนี้ยังเป็นจริงที่ซ่อนอยู่จากคุณ
AppDelegate จะเริ่ม โหลดหุ้น ViewController
ดังนั้นจึงเป็นพื้นจะเริ่มต้น โหลดขึ้นทุกมุมมองที่คุณมี
และเพียงแค่ทำให้มุมมอง ขึ้นอยู่กับลำดับชั้น
>> ดังนั้นในกรณีนี้เรามีเพียง มุมมองหนึ่งซึ่งอยู่ที่นี่
เพื่อให้เป็นมุมมองเท่านั้น ที่จะถูกเรียกว่า
ตรรกะ ViewController อยู่ที่นี่
นี้เป็นรหัสที่จริง ควบคุมมุมมองที่เราเพิ่งเห็น
สิทธิทั้งหมดมาทำอะไรที่นี่
ดังนั้น viewDidLoad เสียงเหมือนเหตุการณ์ เมื่ออยู่ในความเป็นจริงนี้ยังเป็นผู้แทน,
นี้ยังเป็นโปรโตคอล
>> ดังนั้นไม่ว่ามุมมองที่ถูกโหลด ทุกอย่างภายในฟังก์ชั่น
จะถูกเรียกว่า
ในกรณีนี้เราจะเห็น "สวัสดี Tianyu! "ถ้าเราเรียกใช้โปรแกรม
มันรับนิด ๆ หน่อย ๆ ช้า รวบรวมไฟล์กระดาน
ดีแน่นอนเราจะเห็นผลลัพธ์สำหรับมัน
มันเย็นสวย
ตอนนี้ขอทำมาริโอจริง
ฉันจะกำหนด ทำงานได้อย่างรวดเร็ว
marioWithLevels: (int) ผลระดับ
>> สิทธิทั้งหมดนี้เป็นจริงที่น่ากลัว คุณลักษณะของรหัส S เสร็จอัตโนมัติ
ดังนั้นเมื่อคุณเขียนและพิมพ์ใส่ มันได้รับแล้วขึ้นแม่แบบ
สำหรับคุณซึ่งเป็นเย็นสวย
ที่ควรจะดูจริงๆ ที่คุ้นเคยกับพวกคุณ
ขออภัยที่เป็นความผิดของฉัน
สงวนเย็น
ตรรกะที่ควรมีลักษณะที่คุ้นเคยจริงๆ เพื่อคุณผู้ชายโดยเฉพาะอย่างยิ่งเพียงมาริโอ
>> แต่ตอนนี้เราจะพิมพ์ออกไป คอนโซลทุกครั้งเดียว
เพราะเราต้องการที่จะให้อย่างใด การติดตามของสิ่งที่เรามีการพิมพ์
เรากำลังจะใช้ ส่งผลอย่างใดต่อมา
เพื่อแสดงการพิมพ์ ผลออกมาให้กับผู้ใช้
ดังนั้นแทนที่จะเราเป็นแค่ ทุกอย่าง nslogging,
ซึ่งเรากำลังเก็บได้ทุกอย่าง เป็นผลการเรียกฟังก์ชั่น
แต่ตรรกะเป็นสิ่งเดียวกัน
หลังจากที่เราเสร็จเรา เพียงแค่พิมพ์ผลของเรา
>> และที่นี่แทนการพิมพ์ออกของฉัน ชื่อที่เรากำลังจะเรียกใช้ฟังก์ชัน
ลองมาดูสิ่งที่เกิดขึ้น
โอ๊ะอย่างเห็นได้ชัด
เราจะมีความสุข ปิรามิดเล็ก ๆ น้อย ๆ ออกจากที่นี่
นี้เป็นพื้น C เราไม่เพียง การจัดการที่คุณเรียกใช้ฟังก์ชัน
และวิธีการที่ไม่มองเช่นฟังก์ชั่น
ไม่มีอะไรที่แตกต่างกันคือ
แต่นี้เป็นจริง ไม่น่าตื่นเต้นมากที่นี่
เพราะเราไม่เห็น อะไรจาก app iPhone
>> ดังนั้นถ้าคุณมี iPhone จริง app-- ถ้าคุณจริงมีสิทธิมาริโอ iOS
ตอนนี้คุณไม่ได้ไป เพื่อดูสิ่งที่
มีอะไรที่จะทำอย่างไรกับมาริโอเพราะ เอาท์พุททุกคนที่เข้ามาในคอนโซล
จะถูกซ่อนไว้จากผู้ใช้
นี่คือสิ่งที่คุณเห็น ซึ่งก็คือ "สวัสดีโลก !!!"
ไม่ดี
ตอนนี้ขอพยายามที่จะทำให้ผู้ใช้เห็น ว่าสิ่งที่เรากำลังพิมพ์ออก
ดังนั้นเราจึงไม่จำเป็นต้องติดป้ายอีกต่อไป
ลองและคิดออกบางสิ่งบางอย่าง อื่น ๆ ที่อาจจะมีประโยชน์
>> มีจริงอย่างใดอย่างหนึ่ง องค์ประกอบที่เรียกว่า
ฟิลด์ข้อความซึ่งสามารถทำได้ จะเป็นประโยชน์มากสำหรับเรา
มันเป็นพื้นแสดงภูมิภาค ของข้อความที่สามารถแก้ไขได้
ดังนั้นที่มีลักษณะที่เป็นประโยชน์จริงๆ
ตอนนี้ขอลากและวาง
ว้าวเรามีมุมมองข้อความ ในมุมมองของเราจริงๆแฟนซี
นั่นเป็นนิด ๆ หน่อย ๆ มีขนาดใหญ่เกินไป
ขอให้มีขนาดเล็กลง
ใส่ลงในศูนย์
ทำให้มันเล็กได้เป็นอย่างดี
>> ตอนนี้เรามีมุมมองข้อความที่เราจะทำได้ ถูกนำมาใช้ในการแสดงผลสุดท้ายของเรา
แต่ตอนนี้มันเป็น แน่นอนไม่ได้ไปทำงาน
เพราะมี no-- ViewController เราเพียงแค่
กำหนดไว้ไม่ทราบว่า มีมุมมองที่ข้อความออกมี
ดังนั้นเราจึงจำเป็นอย่างใด เชื่อมโยงมุมมองข้อความที่เราเพิ่ง
ที่สร้างขึ้นด้วยคลาสที่ ได้มาแล้วกับเรา
>> วิธีที่เราทำว่าเป็น จริงที่วิเศษจริงๆ
ดังนั้นเปิดกระดาน
มีพิเศษคือ [ไม่ได้ยิน] เรียกว่า [? ผู้ช่วย?] [ไม่ได้ยิน]
เมื่อคุณคลิกที่มัน จะเปิดแฟ้มที่สอง
หนึ่งคือการเรียนและอื่น ๆ หนึ่ง เป็นมุมมองที่สอดคล้องกันสำหรับมัน
มันง่ายมากที่เป็นประโยชน์มาก
และขอเพียงแค่ผ่านไปไฟล์ .h
การควบคุมนี้เป็น [ไม่ได้ยิน] ตรรกะ
การควบคุมการกดและลาก มุมมองข้อความลงประกาศ
เรากำลังจะไปเรียกว่า outputView
ต่อ
ดังนั้นที่นี่เราได้ประกาศใหม่ สถานที่ให้บริการสำหรับการเรียน ViewController ของเรา
และสถานที่ให้บริการใหม่ เป็นเพียงมุมมองข้อความ
เราได้สร้างขึ้นในอาคารอินเตอร์เฟซ
ดังนั้นในทางที่เราจะทำได้ การเข้าถึงข้อมูลทั้งหมด
และจัดการกับทุกสิ่งที่อยู่ภายใน มุมมองการส่งออกซึ่งเป็นที่น่ากลัว
>> ดังนั้นในรหัสจริงของเรา ขอทำอะไรกับมัน
ดังนั้นเวลานี้เมื่อเราอยู่เช่นการพิมพ์ ออกผลขั้นสุดท้ายสำหรับมาริโอ
เรากำลังอยู่ในการเข้าสู่ระบบไม่ได้อะไร
ฉันหมายความว่าเราสามารถเก็บ งบการเข้าสู่ระบบ
นอกจากนั้นเรา ส่งกมเราเพียงแค่
สร้างขึ้นเพื่อมุมมองการส่งออกซึ่ง เป็น UI TextView เราเพิ่งสร้างขึ้น
ตอนนี้ขอดูสิ่งที่เกิดขึ้น
ว้าว
เรามีปิรามิดในการตรวจสอบในขณะนี้
>> เพื่อให้ผู้ใช้สามารถดูการส่งออกของเราเพราะ ที่เราได้คัดลอกมาจากรหัสของเรา
อินเตอร์เฟซของเรา
มันเป็นเรื่องที่ดีงาม
มันเป็นจริงไม่ ที่น่าตื่นเต้นเพราะเรา can--
ทั้งหมด app ที่จะทำคือ แสดงปิรามิดกับคุณ
และมีอะไรที่คุณสามารถทำอะไรกับมัน
มันไม่ได้เป็นที่น่าตื่นเต้นโดยเฉพาะอย่างยิ่ง
ดังนั้นตอนนี้ขอให้ปุ่ม ที่จะล้างมุมมอง
ดูเหมือนว่าปุ่มจะเป็นประโยชน์
ลากและวาง
ปุ่มเดียว
ปุ่มสอง
>> ดังนั้นเมื่อเราคลิกซ้าย ปุ่มมุมมองควรล้าง
ควรจะมีอะไรบนหน้าจอ
และเมื่อเราคลิก ปุ่มขวามาริโอ
มุมมองจะไปปรากฏตัวอีกครั้ง
ดังนั้นวิธีนี้เรายังทำ สิ่งที่วิเศษการควบคุมและการลาก
เพื่อการประกาศคลาส ใน director-- ผู้ช่วย
ในมุมมองผู้ช่วย
ในกรณีนี้เราจะมีการระบุ ว่าควรจะดำเนินการ
clearMario
>> ดังนั้นที่นี่เราได้สร้างไว้แล้ว การกระทำที่เรียกว่า clearMario,
ซึ่งเป็นวิธีการที่จะเรียกว่า เมื่อใดก็ตามที่เรากดปุ่มที่ชัดเจน
ดังนั้นในรหัสจริงของเราให้เพียง ใส่ข้อความออกและมุมมองการส่งออก
เป็นอะไรและวิธีการที่ มันจะปรากฏเป็นที่ชัดเจน
นอกจากนั้นให้สร้าง วิธีการอื่นที่เรียกว่า runMario
โอ้ขอโทษที่ไม่ควรจะเป็นสถานที่ให้บริการ
สิทธิทั้งหมดที่ควร จะดำเนินการได้เป็นอย่างดี
>> และเมื่อฟังก์ชั่นที่เป็น เรียกว่าเราก็ทำงานมาริโอสิบ
หวังว่ามันจะดี
มันรวบรวม?
ใช่
ตอนนี้เรามีมุมมอง
เรามีการส่งออก
และขอเพียงแค่เห็นสิ่งที่เกิดขึ้น
ที่หายไป
มันกลับมาอีกครั้ง
ดังนั้นที่นี่เราได้ระบุ สิ่งที่ชนิดของฟังก์ชั่น
จะถูกเรียกเมื่อ เราพิมพ์ในบางสิ่งบางอย่าง
เมื่อเรากดปุ่มที่เฉพาะเจาะจง
นี้เป็นพื้น รูปแบบการดำเนินการเป้าหมาย
สำหรับเหตุการณ์ที่ขับเคลื่อนด้วย การเขียนโปรแกรมในวัตถุประสงค์ C.
>> นอกเหนือจากนั้น มันไม่ได้เป็นที่น่าตื่นเต้นมาก
เพราะเราไม่สามารถจริงๆเปลี่ยน วิธีการที่สูงพีระมิดจะเป็น
ดังนั้นเราอาจต้องการอย่างใด ได้รับข้อมูลจากผู้ใช้
และเปลี่ยนความสูงของ ปิรามิดขึ้นอยู่กับสิ่งที่พวกเขาเอาท์พุท
ดังนั้นเราจะทำอย่างนั้น
ดังนั้นเวลานี้เมื่อเราเรียก runMario, เราไม่เพียงโทรมาริโอโดยตรง
ชื่อของคนนี้
>> ผู้แทน
นี้เป็นที่น่าสนใจมาก
ผู้แทนคืออะไร?
ฉันจะใส่ตัวเองที่นี่
และเรากำลังจะไปดู สิ่งที่หมายถึงในภายหลัง
ดังนั้นที่นี่เราได้สร้างขึ้นโดยทั่วไป กรณีเฉพาะที่เรียกว่าการแจ้งเตือน UI
ดู
มุมมองการแจ้งเตือน UI เป็น โดยทั่วไปสิ่งที่คุณจะ
เห็นทุกครั้งที่สิ่งที่ปรากฏ และขอให้คุณสำหรับการป้อนข้อมูล
เช่นเดียวกับสิ่งที่จะเกิดขึ้นเมื่อคุณกำลังพยายาม บางสิ่งบางอย่างที่จะซื้อที่ร้านค้าในการตรวจสอบ
>> นอกจากนั้นหลังจากที่คุณ สร้างมันขึ้นมาเราก็แสดงการแจ้งเตือน
สิทธิทั้งหมดให้เพียงได้อย่างรวดเร็ว การทดสอบจะเห็นว่าการทำงานหรือไม่
ที่เย็นมาก
ตอนนี้ขอจริงสร้าง ช่องใส่สำหรับการแจ้งเตือน UI
นี่คือวิธีการที่เราทำอย่างนั้น
และเราควรจะมี มุมมองการป้อนข้อมูลสำหรับการแจ้งเตือน
เด็ดมาก
ขอเพียงบอก 10
>> มันไม่ได้ทำอะไรที่ถูกต้อง ในขณะนี้เพราะโทรจริง
ไม่ได้เปลี่ยนแปลงสำหรับการดำเนินมาริโอ
ดังนั้นนี้ได้กลายเป็นเล็ก ๆ น้อย ๆ บิตแปลกเพราะเมื่อใดก็ตามที่
เรากดปุ่มลงเมื่อใดก็ตามที่เรา กดปุ่มในมุมมองการแจ้งเตือน
สิ่งที่ควรเกิดขึ้น แต่มันไม่ได้เกิดขึ้น
เราจะจับว่าอย่างไร?
เราจะรู้ว่าใช้วิธี ได้ออกแสดงการแจ้งเตือน
และแล้วป้อนหมายเลขเพราะ ขวาตอนนี้ไม่มีอะไรที่เกิดขึ้นจริง
>> ดีคุณอาจจะเดาได้ มันขวาคณะผู้แทน
ดังนั้นในนอกจากทั้งหมด ประกาศเหล่านี้
เราต้องเพิ่มการมอบหมายงานใหม่ที่จะ เรียกว่าผู้แทนมุมมองการแจ้งเตือน UI
เพื่อให้ทุกเดียว การทำงานร่วมกันหรือเหตุการณ์
ที่เรากำลังจะมี มีมุมมองที่การแจ้งเตือน UI
กำลังจะได้รับการจัดการ โดยชั้นเรียนของเราได้เป็นอย่างดี
>> ดังนั้นนอกเหนือจากการที่จะได้รับ คลิกที่ปุ่มแสดงการแจ้งเตือนที่ดัชนี
นี้จะมาถึง
ดังนั้นในกรณีที่เรามี already-- เพื่อให้เรามี
พบโปรโตคอลที่ จะจัดการกับเหตุการณ์เมื่อ
เราคลิกปุ่มเสร็จสิ้น ในมุมมองของการแจ้งเตือน
ดังนั้นเวลาที่เรายกเลิกทุก มุมมองการแจ้งเตือนนี้ควรเกิดขึ้น
ผมขอทดสอบได้อย่างรวดเร็ว
ดีแน่นอนเราได้มาถึงที่นี่
>> ดังนั้นนี่คือสิ่งที่เราจะไม่ได้ ได้รับจริงเป็นจริง
ได้รับการยกกำลังดังนั้นเราจึงต้องการที่จะได้รับการออก ข้อความที่เรามีก่อนหน้านี้
เข้ามาในมุมมองการแจ้งเตือน
และขึ้นอยู่กับข้อความที่เราไม่ จะแสดงมาริโอ
นี้ได้อย่างรวดเร็วจะเปิดออก ถ้ามันใช้งานได้จริงหรือไม่
ดังนั้นในกรณีที่ถ้าเราป้อนข้อมูล สมมุติว่า 10 เราจะเห็น 10
>> ดีมากที่เราทำมีจำนวนที่นี่
มันเป็นเรื่องที่ดีงาม
ตอนนี้ขั้นตอนสุดท้ายจะ be-- ดังนั้น ขั้นตอนสุดท้ายที่เราต้องทำในขณะนี้
เป็นเพียงการเรียกมาริโอที่มี ระดับบนพื้นฐานของข้อมูล
ที่เราได้ใส่ลงไปในมุมมองการแจ้งเตือน
ดังนั้นเราจึงจำเป็นต้องแปลง สตริงเป็น iOS ของคุณนี้
ล้นคงเป็นที่น่ากลัวมาก
และแล้วเราก็เรียกตัวเอง ค่า marioWithLevels
ลองมาดูกันว่าจะ ทำงานจริงหรือไม่
>> เรากำลังให้แล้วปิรามิด
ลองเปลี่ยนความสูง
ที่ใช้งานได้จริง
มันเย็นสวย
ดังนั้นตอนนี้คุณสามารถเพียงแค่ การป้อนค่าใด ๆ ที่คุณต้องการ
ขอเพียงบอกว่าสี่
ที่น่ากลัวสวย
ดังนั้นนี่เป็นพื้น ตัวอย่างรวดเร็วจริงๆ
สำหรับวิธีการสร้างโครงการในรหัส S และวิธีการอย่างรวดเร็วจริงๆลวดขึ้น
เหตุการณ์บางอย่างที่ง่ายจริงๆและฟังก์ชั่น
>> ดังนั้นแหล่งที่มาที่เป็นไป ที่จะใส่ออนไลน์ในภายหลัง
ดังนั้นหากคุณสนใจ ในวิธีการที่ iOS ของมาริโอทำงาน
ฉันจะใส่ตรงเดียวกัน โครงการบนเว็บไซต์ CS50 ภายหลัง
เรากำลังทำพื้นด้วย ฤดูร้อนและก่อนที่เราจะจบ
ผมแค่อยากจะชี้ให้พวกคุณไป บางแหล่งข้อมูลที่น่ากลัวจริงๆ
ที่มีอยู่ทั่วไป
>> เห็นได้ชัดว่าเอกสารแอปเปิ้ล เป็นไปได้ที่เป็นประโยชน์มาก
แต่นอกเหนือจากนั้นผมโดยเฉพาะอย่างยิ่ง แนะนำแหล่งที่สี่, โรงเรียนรหัส
บ้านต้นไม้, AppCoda และวิดีโอ WWDC
โรงเรียนรหัสและบ้านต้นไม้อยู่ สองเว็บไซต์ที่ให้ความรู้ออนไลน์
ซึ่งมุ่งเน้นเฉพาะ วิศวกรรมซอฟแวร์
โดยเฉพาะอย่างยิ่งสำหรับโรงเรียนรหัสพวกเขา มีการกวดวิชาที่ดีจริงๆบน iOS
>> นั่นคือตัวอย่างรวดเร็วจริงๆสำหรับมัน
พวกเขาจริงสร้าง cute-- จริงๆ ดูว่า iPhone น้อยน่ารัก
เพื่อนที่นั่นก็น่ากลัวสวย
และวิธีที่พวกเขาอธิบายวัตถุประสงค์ ไวยากรณ์ C เป็นที่ชัดเจนอย่างสมบูรณ์แบบ
บ้านต้นไม้เหมือนกัน
และ AppCoda เป็นฟอรั่ม
เป็นจริงบล็อกที่กำลังวิ่ง โดยมีประสบการณ์จริงๆวัตถุประสงค์ C
โปรแกรมเมอร์
และแบบฝึกหัดทุกคนใน AppCoda มี สวยสั้นและง่ายต่อการใช้
ขอแนะนำ
>> และถ้าคุณเป็นนักพัฒนา, แน่นอนไปตรวจสอบ
วิธีการวิดีโอ WWDC ที่คุณสามารถ เรียนรู้เกี่ยวกับการเขียนโปรแกรมใหม่ล่าสุด iOS
เทคนิค APIs และห้องสมุด
เพื่อให้เป็นที่สวยมาก มันสำหรับการสัมมนา
ขอบคุณมาก
และผมหวังว่าคุณจะมีความสุข การสร้างแอป iOS ของคุณเอง