CodeGym – การเรียนรู้การเขียนโปรแกรมในภาษาจาวา
![ระดับเก่า 02 - 1]()
วิธีการใหม่ทั้งหมดในการศึกษาการเขียนโปรแกรมและได้รับการศึกษา? ไม่เหมือนสิ่งที่คุณเคยเห็นมาก่อน แล้วการเรียนรู้ที่คุณมีจุดมุ่งหมาย วิธีการ และผลลัพธ์ล่ะ? ฉันยินดีที่จะนำเสนอหลักสูตรการเขียนโปรแกรมออนไลน์ใหม่สำหรับการเรียนรู้ Java
1 การฝึกอบรมเป็นเกมออนไลน์
คุณรับงาน ดำเนินการ และรับรางวัล ฉันคิดว่ามันชัดเจนและเป็นเรื่องธรรมดาสำหรับคุณ งานมีหลากหลายมากที่สุด: การอ่านโค้ด, การแก้ปัญหา, บทเรียนวิดีโอ, การแก้ไขข้อผิดพลาดในโค้ด, การเพิ่มคุณสมบัติใหม่, งานขนาดใหญ่, การเขียนเกม และอื่นๆ อีกมากมาย
2 เฉพาะสิ่งที่จำเป็นเท่านั้น
เพื่อไม่ให้หลักสูตรเป็นเวลา 5 ปีฉันจึงทิ้งสิ่งที่มีประโยชน์ทั้งหมดและเหลือไว้เฉพาะสิ่งที่จำเป็นที่สุดเท่านั้น ฉันวิเคราะห์ตำแหน่งงานว่างนับสิบตำแหน่งในตลาดแรงงาน หัวข้อทั้งหมดที่มือใหม่จำเป็นต้องรู้เพื่อให้ได้งาน Java Junior Developer รวมอยู่ในหลักสูตรนี้แล้ว
3 ฉันเข้าใกล้การฝึกอบรมของคุณอย่างละเอียดแล้ว
หลักสูตรที่สมบูรณ์ประกอบด้วย
การบรรยายขนาดเล็ก 500 รายการและงานปฏิบัติ 1200 (! ) งานมีขนาดเล็ก แต่มีมากมาย มีจำนวนมากของพวกเขา เพียงทำขั้นต่ำนั้นคุณจะได้รับประสบการณ์อันมีค่าดังกล่าว นอกจากนี้ยังมีการทำงานเป็นคู่ เกมที่แตกต่างกัน งานขนาดใหญ่ โครงการจริง และการฝึกประเภทอื่นๆ
4 คุณไม่สามารถจบเกมและไม่สามารถเป็นผู้พัฒนาได้
หลักสูตรประกอบด้วย 40 ระดับ คุณสามารถเลื่อนไปยังระดับถัดไปได้ ก็ต่อเมื่อคุณได้แก้ไขงานส่วนใหญ่ในระดับปัจจุบันแล้วเท่านั้น เริ่มต้นด้วยน้อยและง่าย ลงท้ายด้วยขนาดใหญ่และมีประโยชน์มาก ผู้ที่จบแต่ละคนจะได้รับประสบการณ์ภาคปฏิบัติ 300-500 ชั่วโมง และนี่เป็นโอกาสที่ดีที่จะชนะ และเพื่อให้ได้งาน
5 การเตรียมการสัมภาษณ์งานที่มีเป้าหมาย
10 ระดับสุดท้ายมีไว้สำหรับการเขียนประวัติย่อ การเตรียมตัวสำหรับการสัมภาษณ์ และการได้รับทักษะการทำงานเป็นทีม วิดีโอการสัมภาษณ์งานและการวิเคราะห์จะถูกเพิ่มเข้าไป แน่นอน คำถามทั่วไปในการสัมภาษณ์พร้อมคำตอบ
6 คุณสามารถแก้ปัญหาได้โดยตรงที่ไซต์
มันสะดวกและมีประสิทธิภาพมาก หลังจากเพิ่งวิเคราะห์งานใหม่ในการบรรยาย คุณต้องทำการเปรียบเทียบด้วยตัวเองที่นี่ บนเว็บไซต์ สำหรับผู้ที่ต้องการทำงานใน IDE มีปลั๊กอินที่ช่วยให้คุณสามารถ
รับงานได้ในสองคลิกและส่งไปตรวจสอบในหนึ่ง การบรรยาย การวิเคราะห์ตัวอย่าง การแก้ปัญหาโดยตรงบนเว็บไซต์ การแก้ปัญหาใน IDE - ช่องว่างระหว่างทฤษฎีและการปฏิบัตินั้นเบาบางอย่างที่ไม่เคยมีมาก่อน
7 ตรวจสอบงานทันที (ในเวลาน้อยกว่าวินาที)
คุณเคยชินกับสถานการณ์เมื่อคุณส่งงาน/งานให้ตรวจแล้วต้องรอผลเป็นสัปดาห์เพราะคนตรวจงานยุ่งหรือไม่? นี่เป็นเพียงกรณีของหลักสูตรออฟไลน์ส่วนใหญ่ ใน CodeGym คุณจะได้รับผลการคอมไพล์และตรวจสอบโซลูชันงานของคุณภายในเวลาไม่ถึงวินาที หลังจากกดปุ่ม «ดำเนินการ/ตรวจสอบ»
8 CodeGym ชอบเมื่อคุณใช้เวลาบน Facebook ระหว่างการเรียน
บน Facebook มีเพจที่อุทิศให้กับโครงการ ในนั้นคุณจะพบบทความทางเทคนิคที่น่าสนใจ เรื่องราวที่สร้างแรงบันดาลใจ ข่าว CodeGym และข้อมูลที่เป็นประโยชน์อื่น ๆ อีกมากมาย
9 ความคุ้มครอง
ในการบรรยายมีการอ้างอิงมากมายไปยังเว็บไซต์ต่างๆ ซึ่งคุณสามารถอ่านคำอธิบายของอาจารย์ท่านอื่นได้
เป้าหมายของฉันคือให้คุณเข้าใจเนื้อหา ไม่ใช่ฟังฉันคนเดียว
10 คุณจะต้องใช้สมองและคอมพิวเตอร์ของคุณในการเป็นนักพัฒนา
จะใช้เวลา 3 ถึง 6 เดือนขึ้นอยู่กับระยะเวลาที่คุณฝึกฝน
11 การสนับสนุน
![ระดับเก่า 02 - 3]()
ไม่ต้องสงสัยเลยว่าคำถามจะเกิดขึ้นเมื่อคุณเผชิญกับงานนับพัน เราได้จัดตั้งบริการพิเศษซึ่งคุณจะสามารถถามคำถามเกี่ยวกับงานต่างๆ นักเรียน CodeGym ผู้ดูแล อาสาสมัคร และสมาชิกผู้ก่อตั้งบริการจะตอบคำถามคุณ
12 ชุมชน
เราเชื่อว่าความแข็งแกร่งอยู่ในความสามัคคี ดังนั้นเราจึงสร้างชุมชนที่คุณสามารถถามคำถามได้ อภิปรายหัวข้อต่างๆ แบ่งปันบทความและบล็อก นอกจากนี้ ชุมชนเป็นสถานที่ที่เหมาะสำหรับการหางานทำกับคนรู้จัก ดังนั้นอย่าลังเลที่จะถามคำถามที่ชาญฉลาดและให้คำตอบที่ชาญฉลาด ยิ่งคุณทำตัวกระตือรือร้นและช่วยเหลือผู้อื่นมากเท่าไหร่ โอกาสที่สมาชิกคนอื่นๆ ของสมาคมจะแนะนำให้คุณเข้าร่วมโครงการของพวกเขาก็จะยิ่งมากขึ้นเท่านั้น
คุณมาถึงระดับใหม่แล้ว
ระดับ 2
1 Elly พื้นฐานของทั้งหมด
- เฮ้ อามีโก้ วันนี้ฉันอยากจะบอกคุณว่า
โปรแกรม Java ทั่วไปมีโครงสร้าง อย่างไร ประเด็นคือ
ทุกโปรแกรม Java ประกอบด้วยคลาสและอ็อบเจกต์ - ฉันรู้แล้วว่าคลาสคืออะไร และวัตถุคืออะไร? - โดยเปรียบเทียบกับการสร้างเรือลำเล็ก ขั้นแรก คุณต้องวาดรูป แล้วส่งไปยังอู่ต่อเรือ เรือจะถูกประกอบขึ้นจากภาพวาดนี้ หรือห้าลำ. ตามจำนวนที่คุณต้องการจริงๆ เรือรบที่เหมือนกันหลายสิบลำสร้างขึ้นจากภาพวาดเดียว นั่นคือสิ่งที่เกี่ยวกับทั้งหมด! - ทุกสิ่งในการเขียนโปรแกรม Java นั้นเหมือนกันทุกประการ
- โปรแกรมเมอร์ก็เหมือนวิศวกรออกแบบ และถ้าวิศวกรออกแบบต้องเขียนแบบ โปรแกรมเมอร์ Java ก็ต้องเขียนคลาส จากนั้น ชิ้นส่วนต่างๆ จะถูกสร้างขึ้นตามภาพวาด และวัตถุต่างๆ จะถูกสร้างขึ้นตามคลาสต่างๆ - ขั้นแรก เราเขียนคลาส (วาดรูป) และต่อมาที่รันไทม์โปรแกรม Java Virtual Machine จะสร้างออบเจกต์โดยใช้คลาสเหล่านี้ ด้วยวิธีเดียวกับการสร้างเรือ มีหนึ่งภาพวาดและเรือจำนวนมาก มีเรือหลายลำที่มีชื่อต่างกันและบรรทุกสินค้าได้หลากหลาย อย่างไรก็ตาม พวกมันเหมือนกันมาก: พวกมันทั้งหมดมีโครงสร้างเดียวกันและสามารถทำงานเดียวกันได้
- ในกรณีของเรือ ทุกอย่างชัดเจน ขอเปรียบเทียบอีกสองสามข้อเพื่อทำความเข้าใจว่ามันเกี่ยวกับอะไรกันแน่? - แน่นอน. ตัวอย่างเช่น ผึ้ง …
![ระดับเก่า 02 - 5]()
- ไม่ เดี๋ยวก่อน ผึ้งเตือนฉันถึงสิ่งที่ไม่ดี คิดว่าดีกว่าของจอมปลวก
- จอมปลวกเป็นตัวอย่างที่ดีของการโต้ตอบของวัตถุ ในจอมปลวกที่ง่ายที่สุด มีมดสามประเภท: นางพญา มดทหาร และมดงาน จำนวนมดในแต่ละชั้นจะแตกต่างกัน ราชินีอยู่คนเดียวในรัง มีทหารจำนวนมากและมดงานหลายร้อยตัว เราสามารถพูดได้ว่ามีสามคลาสและอ็อบเจกต์หลายร้อยรายการ มดสื่อสารกันเองกับมดตัวเดียวกันและมดคลาสอื่นตามกฎที่เข้มงวด - นี่คือตัวอย่างที่สมบูรณ์แบบ สำหรับโปรแกรมทั่วไปก็เหมือนกันหมด วัตถุหลักสร้างวัตถุของคลาสอื่นทั้งหมด วัตถุเริ่มมีปฏิสัมพันธ์ซึ่งกันและกันและ "โลกภายนอก" ของโปรแกรม พฤติกรรมของออบเจกต์ถูกฮาร์ดโค้ดไว้ภายใน
- ฉันไม่ค่อยเข้าใจ ค่อนข้างไม่เข้าใจเลย - คำอธิบายทั้งสองนี้เป็นด้านที่แตกต่างกันของเหรียญเดียวกัน ความจริงอยู่ที่ไหนสักแห่งในระหว่าง ตัวอย่างแรก (ตัวอย่างที่มีรูปวาดและเรือ) แสดงความสัมพันธ์ระหว่างคลาสและวัตถุของคลาสนี้ ความคล้ายคลึงกันนั้นใกล้เคียงมาก ตัวอย่างที่สอง (อันที่มีจอมปลวก) แสดงความสัมพันธ์ระหว่างคลาสที่เขียนและออบเจกต์ที่มีอยู่ในรันไทม์
- คุณหมายความว่าก่อนอื่นเราต้องเขียนคลาสสำหรับออบเจกต์ทั้งหมดที่มีอยู่ในโปรแกรม และอธิบายถึงปฏิสัมพันธ์ของออบเจกต์เหล่านั้นคืออะไร - ใช่ แต่มันง่ายกว่าที่คิด ใน Java ทุกสิ่งในรันไทม์ของโปรแกรมคือออบเจกต์ และเมื่อคุณเขียนโปรแกรม คุณควรอธิบายวิธีต่างๆ ของการโต้ตอบออบเจ็กต์ วัตถุเพียงเรียกวิธีการของกันและกันและส่งข้อมูลที่จำเป็นให้กับพวกเขา
- ไม่ชัดเจน แต่เกือบจะชัดเจน - แต่คุณจะรู้ได้อย่างไรว่าวิธีใดที่จะเรียกใช้และคุณต้องส่งข้อมูลใดไปยังวิธีใด - แต่ละคลาสมีคำอธิบายเพื่อระบุว่าคลาสนั้นสร้างขึ้นมาเพื่ออะไร แต่ละเมธอดก็มีคำอธิบายเหมือนกันว่าทำอะไรบ้างและต้องส่งข้อมูลอะไรไป หากต้องการใช้ชั้นเรียน คุณจำเป็นต้องทราบโดยทั่วไปว่าชั้นเรียนนี้ใช้ทำอะไร นอกจากนี้ คุณต้องรู้ให้แน่ชัดว่าแต่ละเมธอดของคลาสนี้ทำหน้าที่อะไร แต่คุณ
ไม่จำเป็นต้องรู้ว่า
มันเสร็จสิ้นอย่างไร มันเป็นเวทมนตร์ชนิดหนึ่ง
- ฮึ่ม. ฟังดูแล้ว - ที่นี่ ดูรหัสชั้นเรียนที่คัดลอกไฟล์:
- มันไม่ง่ายอย่างนั้น แต่ฉันได้ภาพแล้ว - ดี. แล้วพบกันใหม่จระเข้!
2 Risha ตัวแปรและประเภทดั้งเดิม
- เฮ้คุณแรงงานฟรี - ฉันหมายถึง «สวัสดี Amigo» ฉันต้องการแนะนำให้คุณรู้จักกับโครงสร้างภายในของตัวแปร คุณรู้อยู่แล้วว่า
ตัวแปรแต่ละตัวมีชิ้นส่วนของหน่วยความจำที่เกี่ยวข้อง โดยที่ตัวแปรนั้นเก็บค่าของมันไว้ - ใช่. คุณบอกเป็นครั้งสุดท้าย - ดี. เป็นสิ่งที่ดีที่คุณจำมันได้ จากนั้นฉันจะดำเนินการต่อ -
ชั้นเรียน . เมื่อเราอธิบายคลาสใหม่ในโปรแกรม หมายความว่าเราประกาศ
ประเภทสารประกอบเชิงซ้อน ใหม่ ซึ่งข้อมูลจะเป็นประเภทเชิงซ้อนอื่นๆ หรือประเภทดั้งเดิมก็ได้
- มันยังชัดเจนสำหรับความประหลาดใจ - เนื่องจากประเภทขนาดใหญ่ (ซับซ้อน) ประกอบด้วยประเภทขนาดเล็กจำนวนมาก (ดั้งเดิม) วัตถุของพวกมันจึงใช้หน่วยความจำจำนวนมาก มากกว่าตัวแปรประเภทดั้งเดิมทั่วไป บางครั้งก็มากขึ้น การกำหนดตัวแปรประเภทที่ซับซ้อนใช้เวลานานและจำเป็นต้องคัดลอกหน่วยความจำจำนวนมาก
นั่นเป็นสาเหตุที่ตัวแปรประเภทซับซ้อนไม่เก็บวัตถุ แต่เป็นเพียงการอ้างอิงวัตถุ (นั่นคือที่อยู่สี่ไบต์) เท่านี้ก็เพียงพอแล้วสำหรับการเข้าถึงข้อมูลวัตถุ JVM จัดการกับปัญหาทั้งหมดที่เกี่ยวข้อง
- ฉันไม่เข้าใจ - เราคุยกันแล้วว่าตัวแปรก็เหมือนกล่อง หากต้องการเก็บ 13 ไว้ในนั้น คุณสามารถเขียนหมายเลขลงบนกระดาษแล้วใส่ในกล่อง - ลองนึกภาพว่าคุณต้องเก็บไว้ในกล่อง (ตัวแปร) บางอย่างที่ใหญ่กว่าเล็กน้อย ตัวอย่างเช่น สุนัข รถยนต์ หรือโจเพื่อนบ้านของคุณ เพื่อทำให้ง่ายขึ้น คุณสามารถทำสิ่งง่ายๆ: ใส่รูปสุนัขแทนสุนัข ป้ายทะเบียนรถแทนรถ และหมายเลขโทรศัพท์ของโจเขียนลงบนแผ่นกระดาษแทนตัวโจเอง - ตอนนี้เราเอากระดาษแผ่นหนึ่งแล้วเขียนหมายเลขโทรศัพท์ของโจลงไป มันเหมือนกับการอ้างอิงวัตถุ ถ้าเราดึงแผ่นกระดาษที่เขียนหมายเลขของ Joe ออกมา ทำสำเนาและใส่ลงในกล่องสองสามกล่อง การอ้างอิงถึง Joe จะเพิ่มขึ้น แต่จะมี Joe ได้เพียงตัวเดียว - ข้อดีของการจัดเก็บข้อมูลดังกล่าวก็คือ
สามารถมีได้หลายแหล่งอ้างอิงและมีเพียงหนึ่งวัตถุเท่านั้น - มันน่าตื่นเต้น. อย่างไรก็ตาม ฉันเกือบจะเข้าใจแล้ว ตอบคำถามเพียงข้อเดียว: จะเกิดอะไรขึ้นหากฉันกำหนดตัวแปรประเภทที่ซับซ้อนให้กับตัวแปรประเภทที่ซับซ้อนอื่น - จากนั้นตัวแปรทั้งสองนี้จะมีที่อยู่เดียวกัน ดังนั้น
หากคุณเปลี่ยนข้อมูลที่จัดเก็บไว้ในตัวแปรประเภทที่ซับซ้อนหนึ่ง ข้อมูลของอีกตัวแปรหนึ่งก็จะเปลี่ยนไปด้วย
เพราะคุณทราบดีว่า มี ออบเจกต์
เพียงรายการเดียวที่ตัวแปรจัดเก็บอ้างอิงถึง อย่างไรก็ตาม อาจมีตัวแปรมากมายที่เก็บการอ้างอิงไปยังวัตถุ
- และสิ่งที่เก็บไว้ในตัวแปรประเภทซับซ้อน (ประเภทการอ้างอิง/คลาส) ในขณะที่ไม่มีการอ้างอิงวัตถุ จะมีเรื่องแบบนี้ได้จริงๆเหรอ? - ใช่ อามีโก้ คุณเอาคำพูดออกจากปากฉัน ที่สามารถเป็น หากไม่มีการอ้างอิงวัตถุในตัวแปรประเภทการอ้างอิง (ซับซ้อน) จะเก็บค่า
null «การอ้างอิงค่าว่าง» พิเศษ อันที่จริง มันเพียงแค่เก็บแอดเดรสของวัตถุเท่ากับ 0 แต่ Java Virtual Machine ไม่เคยสร้างอ็อบเจกต์ที่มีแอดเดรสเป็นศูนย์ ดังนั้นจึงรู้เสมอว่าถ้าตัวแปรอ้างอิงเป็น 0 แสดงว่าไม่มีอ็อบเจกต์อยู่ที่นั่น
ฉันเข้าใจถูกต้องหรือไม่ ตัวแปรแบ่งออกเป็นสองประเภท - ดั้งเดิมและอ้างอิง ตัวแปรประเภทดั้งเดิมเก็บค่าในขณะที่ตัวแปรประเภทอ้างอิงจัดเก็บการอ้างอิงวัตถุ ประเภทดั้งเดิม ได้แก่ int, char, boolean และอื่นๆ ส่วนที่เหลือเป็นตัวแปรอ้างอิง สร้างโดยใช้คลาส - ถูกต้องเด็กชาย
3 Elly วัตถุคืออะไร
![ระดับเก่า 02 - 9]()
- นี่คือครูที่คุณชื่นชอบอีกครั้ง เนื่องจากเราก้าวไปข้างหน้าอย่างรวดเร็ว ฉันจะบอกคุณว่าวัตถุคืออะไรและจัดการกับมันอย่างไร
- ในการสร้างวัตถุใด ๆ คุณต้องเขียนชื่อประเภทวัตถุ (คลาส) และคำหลักใหม่ก่อนหน้า สมมติว่าเรามีคลาส Cat แล้ว:
- จะเกิดอะไรขึ้นถ้าคุณเพิ่งสร้างวัตถุและไม่ได้กำหนด [ข้อมูลอ้างอิง] ให้กับตัวแปรใดๆ - หากคุณทำเช่นนั้น Java Virtual Machine จะสร้างวัตถุและประกาศทันทีว่าเป็นขยะ (วัตถุที่ไม่ได้ใช้) หลังจากนั้นสักครู่ มันจะลบวัตถุนั้นระหว่างการรวบรวมขยะ
- ฉันจะทำลายวัตถุได้อย่างไรหากไม่ต้องการแล้ว - คุณไม่สามารถ
ทันทีที่ไม่มีตัวแปรในการจัดเก็บการอ้างอิงวัตถุ วัตถุจะถูกตั้งค่าสถานะเป็นขยะและ JVM จะทำลายมันในระหว่างการรวบรวมขยะครั้งต่อไป ตราบใดที่มีการอ้างอิงวัตถุอย่างน้อยหนึ่งรายการ จะถือว่าเผยแพร่อยู่และจะไม่ถูกทำลาย เมื่อคุณต้องการทำลายวัตถุอย่างรวดเร็ว ให้ตั้งค่าการอ้างอิงทั้งหมดเป็น null นั่นคือ กำหนด ค่า
nullให้กับตัวแปรทั้งหมดที่อ้างถึงวัตถุนั้น
- เข้าใจแล้ว. ดูเหมือนจะไม่ยากเลยหลังจากการบรรยายครั้งก่อน - เอาล่ะ ต่อไปนี้คืองานบางส่วนเพื่อให้คุณได้พัฒนาทักษะของคุณ เหล่านี้ยังอยู่ใน System.out แต่ต่อไปจะมีเรื่องที่ยากขึ้น และคุณสามารถแสดงให้เราเห็นว่าคุณทำจากเหล็กอะไร
งาน |
1 |
เขียนโปรแกรมที่แสดง: «ทีละขั้นตอนและสิ่งที่ทำเสร็จแล้ว». |
2 |
เขียนโปรแกรมที่แสดง 7 ครั้ง: «การทำในสิ่งที่เป็นไปไม่ได้เป็นเรื่องสนุก». |
3 |
เขียนโปรแกรมที่แสดง: «ต้องการเรียนรู้สิ่งที่มีประโยชน์เสมอ». |
4 Risha การมองเห็นของตัวแปร
- สวัสดีนักเรียนคนโปรดของฉัน ตอนนี้ฉันจะบอกคุณเกี่ยวกับ การ มอง
เห็นตัวแปร - ทำไมถึงมีตัวแปรที่มองไม่เห็นด้วย? - ไม่
ตัวแปรจะปรากฏในตำแหน่งของรหัสที่สามารถเข้าถึงตัวแปรนั้นได้ ตัวแปรบางตัวสามารถเข้าถึงได้จากทุกที่ในโปรแกรม ตัวแปรบางตัวสามารถเข้าถึงได้เฉพาะในคลาสของมัน และตัวแปรบางตัวสามารถเข้าถึงได้ด้วยเมธอดเดียวเท่านั้น - ตัวอย่างเช่น คุณไม่สามารถอ้างถึงตัวแปรก่อนที่จะประกาศ
- ก็เป็นที่ชัดเจน. - นี่คือตัวอย่างบางส่วน:
1 ตัวแปรที่ประกาศในเมธอดมีอยู่ / มองเห็นได้ตั้งแต่เริ่มต้นการประกาศจนจบเมธอด 2 มีตัวแปรที่ประกาศในบล็อกโค้ดอยู่จนถึงส่วนท้ายของบล็อกโค้ดนี้ 3 ตัวแปร - อาร์กิวเมนต์เมธอด - มีอยู่ทุกที่ภายในขอบเขตของเมธอด 4 ตัวแปรคลาส / ออบเจกต์มีอยู่ตลอดอายุการใช้งานของออบเจ็กต์ ตัวแก้ไขการเข้าถึงพิเศษแบบสาธารณะและแบบส่วนตัวจะควบคุมการมองเห็นเพิ่มเติม 5 ตัวแปรคลาสคงที่อยู่ที่รันไทม์ของโปรแกรม ตัวดัดแปลงการเข้าถึงยังกำหนดการมองเห็น - ฉันชอบรูปภาพ ทุกอย่างเข้าที่ - ดีสำหรับคุณ Amigo รู้อยู่เสมอว่าคุณเป็นคนฉลาด - ฉันจะบอกคุณเกี่ยวกับ
ตัวดัดแปลงการเข้าถึงด้วย อย่ากลัวไปเลย มันไม่ใช่วิทยาศาสตร์จรวด นี่คือคำ
สาธารณะและ
ส่วนตัวที่คุณเห็น
- ฉันไม่กลัว มันแค่หนาวที่นี่ - ใช่แน่นอน. คุณสามารถควบคุมการเข้าถึง (การมองเห็น) ของเมธอดและตัวแปรในคลาสของคุณจากคลาสอื่นๆ สำหรับแต่ละเมธอดหรือตัวแปร คุณสามารถระบุตัวแก้ไขการเข้าถึงได้เพียงตัวเดียว 1 Modifier
public ตัวแปร เมธอด หรือคลาสที่ตั้งค่าสถานะด้วย modifier public สามารถเข้าถึงได้จากทุกที่ในโปรแกรม เป็นความเปิดกว้างระดับสูงสุดโดยไม่มีข้อจำกัด 2 Modifier
private ตัวแปรหรือเมธอดที่ตั้งค่าสถานะด้วย modifier private สามารถเข้าถึงได้จากคลาสที่มีการประกาศเท่านั้น สำหรับคลาสอื่นๆ ทั้งหมด เมธอดหรือตัวแปรที่ถูกตั้งค่าสถานะจะมองไม่เห็น ราวกับว่าไม่มีอยู่จริง นี่คือระดับการปิดสูงสุด (มองเห็นได้จากคลาสเดียวกันเท่านั้น) 3 ค่าดีฟอลต์ของโมดิฟายเออร์ หากโมดิฟายเออร์ใดไม่แฟล็กตัวแปรหรือเมธอด จะถือว่าเป็นค่าดีฟอลต์ของโมดิฟายเออร์ ตัวแปรหรือเมธอดที่มีตัวแก้ไขนั้น (นั่นคือไม่มีเลย) สามารถมองเห็นได้ในทุกคลาสของแพ็คเกจที่ประกาศไว้ เฉพาะในแพ็คเกจเดียวกันเท่านั้น ตัวดัดแปลงนี้บางครั้งเรียกว่า
แพ็คเกจเพื่อบอกเป็นนัยว่าการเข้าถึงตัวแปรและเมธอดนั้นเป็นไปได้สำหรับทั้งแพ็คเกจ ซึ่งคลาสของมันอยู่ในแท็บคำอธิบาย:
5 Diego, งานสำหรับการสร้างตัวแปรจำนวนมาก
- เฮ้เพื่อน หากจำเป็น ฉันจะเก็บสำเนาสัญญาไว้ให้คุณ Risha นักสเก็ตราคาถูกที่ส่อเสียดนั้นไม่รู้ตัวอย่างมีความสุข
คุณควรจะเห็นจำนวนเงินในสัญญาของฉัน เฮ้เฮ้
- ทำได้ดีมาก ดิเอโก ฉันคิดว่าคุณสอนฉันในสิ่งที่มีประโยชน์จริงๆ - แน่นอน Amigo
ไม่มีการได้มาโดยปราศจากความเจ็บปวด แต่ก็ยังมีบางคนที่ต้องทนทุกข์ทรมานกับความเจ็บปวดโดยไม่ได้รับประโยชน์ - หันมาตั้งใจเรียนกันดีกว่า ตอนนี้ฉันจะแสดงวิธีสร้างตัวแปรมากมายด้วยวิธีต่างๆ:
- ว้าว ดิเอโก! คุณฉลาดมาก - เฮ้เฮ้! ขอบคุณ Amigo - ฉันคิดว่าคุณพลาดงานของฉันไปแล้ว นี่คือบางส่วนของพวกเขา มนุษย์ต่างดาวเหล่านั้นไม่รู้อะไรเกี่ยวกับชีวิตหุ่นยนต์ของเรา ใครนอกจากฉันจะสอนคุณว่า?
งาน |
1 |
เขียนโปรแกรมที่แสดง 3 ครั้ง: «คนจำนวนมากมีชีวิตอยู่เพียงเพราะการยิงปืนเป็นสิ่งผิดกฎหมาย». |
2 |
เขียนโปรแกรมที่แสดง: «หากฉันต้องการความคิดเห็นของคุณ ฉันจะขอให้คุณกรอกแบบฟอร์มที่จำเป็น». |
3 |
เขียนโปรแกรมที่แสดง 20 ครั้ง: «ฉันไม่เคยพูดสิ่งที่ฉันพูดเป็นส่วนใหญ่». |
6 Elly, ผ่านโดยการอ้างอิง. ตัวแปรอ้างอิง
- เฮ้ อามีโก้ นี่ฉันอีกแล้ว เอลลี่ ขออภัย ฉันมักจะพูดแบบนี้ แต่เป็นเพียงวิธีการทำสิ่งต่าง ๆ บนโลกในศตวรรษที่ 31 ฉันจะอธิบายคุณลักษณะของตัวแปรอ้างอิงและวิธีส่งอาร์กิวเมนต์อ้างอิงไปยังฟังก์ชัน (เมธอด)
- ฉันพร้อมแล้ว. - ถ้าอย่างนั้น ตัวแปรอ้างอิงคือตัวแปรทุกประเภท ยกเว้นตัวแปรดั้งเดิม ตัวแปรเหล่านี้มีเพียงที่อยู่ของวัตถุ (การอ้างอิงวัตถุ)
- ตัวแปรประเภทดั้งเดิมเก็บค่าและประเภท และตัวแปรคลาสเก็บการอ้างอิงไปยังออบเจกต์ของคลาสเดียวกัน ดี หรือเป็นโมฆะ ฉันถูกไหม? - อย่างแน่นอน.
- ดังนั้นการอ้างอิงคืออะไร? - วัตถุและข้อมูลอ้างอิงมีการเชื่อมโยงกัน เช่น ผู้ชายกับหมายเลขโทรศัพท์ของเขา หมายเลขโทรศัพท์ไม่ใช่ของผู้ชาย แต่สามารถใช้โทรหาผู้ชายเพื่อสอบถามบางอย่าง แนะนำหรือสั่งการเขาได้ การอ้างอิงยังใช้เพื่อโต้ตอบกับวัตถุ วัตถุทั้งหมดโต้ตอบกันผ่านการอ้างอิง
- ราวกับว่าผู้คนสื่อสารกันทางโทรศัพท์? - ถูกตัอง.
เมื่อคุณกำหนดวัตถุดั้งเดิม ค่าจะถูกคัดลอก (ทำซ้ำ) เมื่อคุณกำหนดตัวแปรอ้างอิง เฉพาะที่อยู่วัตถุ (หมายเลขโทรศัพท์) เท่านั้นที่จะถูกคัดลอก ไม่ใช่ตัววัตถุเอง - โอเค ฉันเข้าใจแล้ว - การอ้างอิงมีข้อดีอีกอย่าง: คุณสามารถส่งการอ้างอิงวัตถุไปยังเมธอดใดก็ได้ และเมธอดนี้จะสามารถแก้ไข (เปลี่ยนแปลง) อ็อบเจ็กต์ของเราโดยใช้การอ้างอิงโดยเรียกเมธอดของมันและเข้าถึงข้อมูลภายในออบเจกต์
![ระดับเก่า 02 - 14]()
- ค่าของตัวแปร
a & bจะถูกแลกเปลี่ยนภายในวิธี
swap เมื่อคุณเรียกใช้ เมธอด
swapตัวแปร
a & bจะได้รับสำเนาของค่า
m & n ดังนั้น ค่าของตัวแปร
m & nจะเหมือนเดิมเมื่อคุณเปลี่ยนค่าของ
a & b มองเห็นได้ชัดเจนในรหัสของคอลัมน์ด้านขวา
- พูดตามตรง ฉันไม่ได้อะไรเลย ฉันขอตัวอย่างเพิ่มเติมสักสองสามตัวอย่างได้ไหม - ในกรณีของประเภทการอ้างอิง คุณสามารถทำได้:
![ระดับเก่า 02 - 15]()
- ตัวแปร a และ b ถูกกำหนดให้เป็นการอ้างอิงถึง emma และ alice ตามลำดับ ค่า a และ b จะเปลี่ยนแปลงภายในวัตถุ emma และ alice
- เป็นไปได้ไหมที่จะประกาศคลาสภายในคลาสอื่นด้วย? ว้าว! - ส่วนที่เหลือยังไม่ชัดเจน - ไม่ใช่ทั้งหมดในเวลาเดียวกัน
7 Elly, การเรียกใช้ฟังก์ชัน, ค่าที่ส่งคืน
- ถ้าอย่างนั้นกลับกันเถอะ เราจะพูดถึงวิธีการเรียกใช้เมธอด แล้วคุณลองทบทวนการบรรยายครั้งก่อนอีกครั้ง โอเค?
- ข้อเสนอ! - ถ้าอย่างนั้นฉันจะบอกคุณเกี่ยวกับการเรียกใช้ฟังก์ชัน/เมธอดและค่าที่ส่งคืน - คำสั่งถูกจัดกลุ่มเป็นฟังก์ชัน ดังนั้นคุณจึงสามารถเรียกใช้คำสั่งเหล่านั้นได้ในบล็อกเดียว เป็นคำสั่งที่ซับซ้อนเพียงคำสั่งเดียว ในการทำเช่นนี้ คุณต้องเขียนชื่อของฟังก์ชัน (เมธอด) จากนั้นในวงเล็บตามชื่อ ให้ระบุค่าและพารามิเตอร์
![ระดับเก่า 02 - 16]()
- ในตัวอย่างข้างต้น เราเขียนฟังก์ชันแสดงสตริงที่ส่งผ่าน 4 ครั้ง จากนั้นเรา
เรียกฟังก์ชัน print4ในบรรทัดที่ 6 - เมื่อดำเนินการตามบรรทัดที่ 6 โปรแกรมจะข้ามไปที่บรรทัดที่ 9 และตัวแปร s จะกำหนดค่าเป็น
“I like to move it, move it” - จากนั้นบรรทัดที่ 11-14 จะถูกดำเนินการ และสุดท้าย ฟังก์ชันจะเสร็จสมบูรณ์และโปรแกรมจะดำเนินการต่อในบรรทัดที่ 7
- Gotcha - คุณไม่เพียงแต่สามารถส่งอาร์กิวเมนต์ (พารามิเตอร์) ไปยังฟังก์ชันเท่านั้น แต่ยังส่งกลับผลลัพธ์ (ค่า) ของการทำงานของฟังก์ชันได้อีกด้วย สิ่งนี้ทำได้โดยใช้คำหลัก return ดูเหมือนว่า:
- ฉันคิดว่าฉันกำลังจับมันอยู่ เป็นรหัสเดียวกันทางด้านซ้ายและด้านขวา ทางด้านซ้ายจะแสดงเป็นฟังก์ชันแยกต่างหาก - ฟังก์ชันจะคำนวณค่าและส่งต่อไปยังผู้ที่เรียกค่านั้นโดยใช้คำสั่ง return อย่างน้อยฉันก็คิดอย่างนั้น - โดยพื้นฐานแล้วมันเป็นเรื่องจริง
- และประเภทโมฆะคืออะไร? - บางฟังก์ชันแค่ทำบางอย่าง แต่ไม่คำนวณและส่งคืนค่าใดๆ เช่น เมธอดหลักของ
เรา(). สำหรับฟังก์ชันเหล่านั้น มันถูกสร้างขึ้นเป็นผลลัพธ์พิเศษประเภท
void (ประเภทว่าง).
- ทำไมเราระบุอะไรไม่ได้ ถ้าฟังก์ชันไม่ส่งคืนอะไรเลย - ลองนึกถึงวิธีการประกาศตัวแปรทุกตัว: ประเภทและชื่อ ฟังก์ชันถูกประกาศด้วยประเภท ชื่อ และวงเล็บ ชื่อฟังก์ชันตามด้วยวงเล็บคือการเรียกใช้ฟังก์ชัน!
- ดังนั้นจึงง่ายกว่าที่จะคิด "ประเภทว่าง" กว่าการแบ่งฟังก์ชันออกเป็นสองประเภทที่ส่งคืนค่าและไม่ส่งคืนค่า - อย่างแน่นอน! คุณเป็นคนคิดเร็ว ที่รัก
- และฉันจะส่งคืนประเภทเปล่าได้อย่างไร - คุณไม่สามารถ นี่คือวิธีการทำงาน:
เมื่อ JVM ดำเนินการส่งคืนคำสั่งจะคำนวณค่าของนิพจน์ทางด้านขวาของคำว่า return เก็บค่านั้นไว้ในพื้นที่หน่วยความจำพิเศษและออกจากฟังก์ชันทันที ใช้ค่าที่บันทึกไว้เป็นผลลัพธ์ของการเรียกใช้ฟังก์ชัน ณ ตำแหน่งที่มีการเรียกใช้ฟังก์ชัน คุณสามารถดูได้จากตัวอย่างด้านบน
- คุณหมายถึงสถานที่ที่int m = min(a,b)แปลงเป็นm = m2 ? - ใช่. หลังจากการเรียกใช้ฟังก์ชัน ทุกอย่างยังคงทำงานต่อไปราวกับว่าแทนที่จะเป็นฟังก์ชัน ผลลัพธ์จะถูกเขียนไว้ที่เดียวกัน
อ่านประโยคนั้นอีกครั้งและดูรหัสของตัวอย่างสุดท้าย - ดูเหมือนง่าย แต่ในความเป็นจริงยาก ฉันได้รับเพียงเล็กน้อย นั่นคือทั้งหมด - ใช้ได้.
ในการลองครั้งแรก คุณสามารถเข้าใจเฉพาะสิ่งที่คุณรู้แล้วเท่านั้น ยิ่งได้พื้นที่ใหม่สำหรับเธอก็ยิ่งไม่ชัดเจน และผลลัพธ์จะยอดเยี่ยมยิ่งขึ้น เวลาผ่านไป ทุกอย่างก็ชัดเจน
- ถ้าอย่างนั้นก็ไปกันต่อ
8 ดิเอโก้
- เฮ้ อามีโก้ นี่คืองานสองสามอย่างสำหรับคุณ ตอนนี้คุณสามารถทำอะไรได้มากกว่า System.out ทำให้ดีที่สุด! ฉันเชื่อในตัวคุณ!
งาน |
1 |
ตัวเลขขั้นต่ำสองตัว
เขียนฟังก์ชันที่ส่งคืนตัวเลขขั้นต่ำสองตัว |
2 |
จำนวนสูงสุดสองจำนวน
เขียนฟังก์ชันที่คืนค่าจำนวนสูงสุดสองจำนวน |
3 |
ตัวเลขอย่างน้อยสามตัว
เขียนฟังก์ชันที่ส่งคืนตัวเลขอย่างน้อยสามตัว |
4 |
ตัวเลขอย่างน้อยสี่ตัว
เขียนฟังก์ชันที่ส่งกลับตัวเลขอย่างน้อยสี่ตัว
ฟังก์ชัน min(a,b,c,d) ต้องใช้ (เรียก) ฟังก์ชัน min(a, b) |
5 |
การทำสำเนาสตริง
เขียนฟังก์ชันที่แสดงสามครั้งของสตริงที่ส่งผ่าน แต่ละสตริงควรอยู่ในบรรทัดใหม่ |
6 |
การแสดงข้อความ
เขียนฟังก์ชันที่แสดงสตริง (คำ) ที่ส่งผ่านสามครั้งในบรรทัดเดียวกัน
คำต้องคั่นด้วยช่องว่างและไม่ต้องรวมเข้าด้วยกัน |
9 ดีเอโก้ ชื่อเต็ม
![ระดับเก่า 02 - 18]()
- เฮ้ Amigo ฉันอยากจะบอกคุณเกี่ยวกับชื่อเต็มของคลาส - คุณรู้อยู่แล้วว่าคลาสอยู่ในแพ็คเกจ ดังนั้น ชื่อคลาสแบบเต็มคือชื่อที่ครอบคลุมแพ็คเกจทั้งหมดโดยคั่นด้วยคะแนน และชื่อคลาส
ตัวอย่าง: ![ระดับเก่า 02 - 19]()
- หากต้องการใช้คลาสในรหัสของคุณเอง คุณต้องระบุชื่อเต็มของคลาส อย่างไรก็ตาม คุณสามารถใช้ชื่อย่อ - ชื่อคลาสเท่านั้น ในการทำเช่นนี้ คุณต้อง "นำเข้า" คลาสนี้โดยระบุชื่อคลาสโดยเพิ่มคำว่า
importก่อนที่คุณจะประกาศคลาส คลาสของ แพ็คเกจ
java.lang (String, Integer,...) ถูกอิมพอร์ตโดยค่าเริ่มต้น คุณไม่จำเป็นต้องระบุ ตัวอย่าง:
![ระดับเก่า 02 - 20]()
- ตัวอย่างการใช้ชื่อย่อ:
- เข้าใจแล้ว - ดี.
10 อาจารย์บรรยายเกี่ยวกับชั้นเรียนและวัตถุ
![ระดับเก่า 02 - 22]()
- เฮ้ อามีโก้ หวังว่าคุณจะเข้าใจทุกสิ่งที่ Elly และ Risha บอกคุณในวันนี้ เพื่อความปลอดภัย ตามที่ฉันสัญญาไว้ นี่คือลิงก์ไปยังเนื้อหาเพิ่มเติม: 1 บันทึกย่อของฉัน 2 การคิดใน Java หนังสือที่ยอดเยี่ยมที่ฉันเคยบอกคุณไปแล้ว มันจะดีมากถ้าคุณอ่านมัน - ฉันหวังว่าคุณจะหาเวลาทบทวนมัน
- อะแฮ่ม. แน่นอนฉันจะ!
11 ฮูลิโอ
- เฮ้ อามีโก้! หวังว่าคุณจะพักผ่อนอย่างหนักและเหน็ดเหนื่อย?
GO TO FULL VERSION