Roadmap ของ Java Developer
เพื่อนของฉันสงสัยว่าทำไมนักพัฒนาซอฟต์แวร์จึงมีความสุขอยู่เสมอ คำตอบที่เธอได้รับนั้นเรียบง่ายและน่าประหลาดใจ พวกเขาทำในสิ่งที่ชอบและได้เงินก้อนโต ยินดีต้อนรับสู่โลกของนักพัฒนาซอฟต์แวร์เงินเดือนของนักพัฒนาซอฟต์แวร์
ฉันอยากจะบอกคุณเกี่ยวกับเงินเดือนของนักพัฒนา ที่ดินอยู่กับเงินเดือนอย่างไร ที่ไหนควรไปทำงาน ที่ไหนไม่ควร หากคุณไม่ใช่นักพัฒนาซอฟต์แวร์และพยายามไขปริศนาด้วยตัวคุณเอง คุณอาจได้รับข้อมูลที่ค่อนข้างขัดแย้ง ประเด็นหลักคือปัจจัยสำคัญที่มีอิทธิพลต่อเงินเดือนของนักพัฒนาไม่ใช่คุณสมบัติ แต่เป็นสถานที่ทำงาน บางครั้ง ด้วยระดับคุณสมบัติที่เท่ากัน ความแตกต่างระหว่างสถานที่ทำงานที่ดีและไม่ดีอาจเป็น 2 ถึง 10 เท่า (!) ในแต่ละช่วงเวลา คุณสมบัติของคุณจะคงที่ คุณไม่สามารถมีคุณสมบัติเป็นสองเท่าในหนึ่งเดือนและรับเงินสองเท่าได้ แต่คุณสามารถเปลี่ยนที่ทำงานได้ในหนึ่งเดือนและรับเงินเดือนมากขึ้นสองเท่า เมื่อสองเดือนเงินเดือนของฉันคูณด้วยสาม (!) – ประสบการณ์ที่น่าจดจำ มาดูกันดีกว่าว่าที่ไหนดี- ไม่ว่าจะเป็นธุรกิจหลักของบริษัทคือการพัฒนาซอฟต์แวร์
- ไม่ว่าบริษัทจะมุ่งเน้นไปที่ตลาดโลกหรือตลาดท้องถิ่น
- สำนักงานใหญ่ตั้งอยู่ที่ใด: ประเทศที่พัฒนาแล้วหรือประเทศกำลังพัฒนา
จำนวนเฉพาะ
เนื่องจากเงินเดือนแตกต่างกันในแต่ละส่วนของโลก ฉันเสนอว่าให้ใช้เงินเดือนของ Senior Java Developer ที่มีประสบการณ์ 5 ปีเป็นจุดเริ่มต้นและเรียกว่า "สูงสุด 5 ปี" ตัวเลขทั้งหมดด้านล่างจะได้รับเป็นเปอร์เซ็นต์ของจำนวนเงินนี้ ต่อไปนี้คือตัวอย่างบางส่วนของเงินเดือน "สูงสุด 5 ปี" ในเมืองต่างๆ ของโลก: ด้านล่างจะแสดงให้เห็นว่า Java Senior Developer ที่มีประสบการณ์ 5 ปีอาจได้รับรายได้เท่าใดขึ้นอยู่กับบริษัทที่เขาทำงาน: อะไรคือสิ่งที่แปลกประหลาดที่สุดเกี่ยวกับสถานการณ์ปัจจุบัน ครึ่งหนึ่งของโปรแกรมเมอร์ทั้งหมดทำงานในบริษัทระดับ 1 และ 2 คุณอยากรู้ไหม จับอะไร มีตำแหน่งงานว่างหลายร้อยตำแหน่งในบริษัทระดับ 3 และ 4 บริษัทเหล่านี้ยินดีที่จะเสนอเงินเดือนที่สูงขึ้นและโดยปกติแล้วจะมีสภาพการทำงานที่ดีกว่า ฉันรู้จัก Java Junior สองคน คนหนึ่งได้งานโดยจ่ายประมาณ 3% ของ "สูงสุด 5 ปี" (บริษัทระดับ 1) และอีกคนหนึ่งได้งานที่ 30% ของเงินเดือน "สูงสุด 5 ปี" (ระดับ 4) แล้วทำไมได้น้อยลง? ความต้องการโปรแกรมเมอร์มีมากเกินข้อเสนอ – อย่าไปทำงานที่คุณได้รับค่าจ้างน้อยลง! สรุป 1:เงินเดือนเฉลี่ยสำหรับนักพัฒนา Java (ที่มีประสบการณ์) คือ 40%-50% ของเงินเดือน "สูงสุด 5 ปี" สรุป 2:เงินเดือนเฉลี่ยของคุณใน 5 ปีจะอยู่ที่ประมาณ 90%-110% ของเงินเดือน "สูงสุด 5 ปี" หากคุณไม่ได้ทำงานในบริษัทระดับ 1 และ 2 และทำงานให้กับบริษัทระดับ 3 และ 4คุณจะประสบความสำเร็จอะไรได้ถ้าคุณไม่ทำอะไรโง่ๆ
หากคุณเริ่มทำงานด้านการศึกษาด้วยตนเองในการเขียนโปรแกรมตอนนี้ เงินเดือนของคุณสามารถมีลักษณะดังนี้:วางแผน
0-3 เดือน (นักเรียน)
คุณรู้เรื่องการเขียนโปรแกรมน้อยมาก คุณอาจเคยเรียนที่โรงเรียนหรือในวิทยาลัยในระดับพื้นฐาน สิ่งที่คุณต้องทำคือเรียนรู้วิธีการเขียนโปรแกรมและเรียนรู้ Java เป้าหมายของคุณคือการได้งานเป็น Java Junior Developer ในบริษัทระดับ 3 ขึ้นไป ในช่วงสามเดือนแรกของแผน คุณจะไม่ได้รับอะไรเลย เพราะคุณเพิ่งเรียนรู้วิธีการตั้งโปรแกรม แต่ยิ่งคุณเริ่มต้นเร็วเท่าไหร่ก็ยิ่งดีเท่านั้น เวลาที่ดีที่สุดคือตอนนี้ ในอนาคต เมื่อคุณมีครอบครัวและมีเงินกู้ยืมมากมาย การปรับคุณสมบัติใหม่จะยากขึ้นมาก เพื่อแก้ไขข้อผิดพลาดของคุณ คุณจะต้องกันเงินไว้จ่ายอย่างน้อยหนึ่งปีของชีวิตปกติ อย่าทำผิดพลาดโง่ๆ3-15 เดือน (Java Junior Developer)
คุณทำงานเป็นนักพัฒนาซอฟต์แวร์อยู่แล้ว และประสบการณ์ของคุณก็เพิ่มขึ้นทุกวัน อย่าผ่อนคลาย คุณมีหลายสิ่งที่ต้องทำก่อนที่จะพักผ่อนบนพาย สิ่งที่คุณต้องทำคือ – ศึกษาเทคโนโลยีที่จำเป็นสำหรับนักพัฒนาระดับกลาง เหล่านี้คืออะไร? โลกมีการเปลี่ยนแปลงตลอดเวลา ฉันจะโหลดคำแนะนำให้คุณ แล้วชีวิตจะเปลี่ยนทุกอย่าง ค้นหาตำแหน่งงานว่างสองสามแห่งบนเว็บและดูว่าคุณต้องสมัครอะไรบ้าง อย่าลืมอ่านหนังสือของ Bruce Eckel เรื่อง “Thinking in Java” เป้าหมายของคุณในปีแรกของการทำงานเป็น Java Junior Developer คือการไปถึงระดับของ Java Middle Developer ไม่มีใครบอกว่าจะง่าย แต่เป็นไปได้สำหรับคนที่มีเป้าหมาย มันจะเพิ่มเงินเดือนของคุณในทันทีสูงถึง 40% ของ "สูงสุด 5 ปี" ($50K สำหรับ SF และลอนดอน, $6K สำหรับบังกาลอร์)การเขียนโปรแกรม 2 ปี (Java Middle Developer ระดับ 1)
คุณทำงานได้ดีในปีที่แล้ว และตอนนี้คุณเป็น Java Middle Developer คุณสามารถใช้ชีวิตได้ค่อนข้างดีโดยมีรายได้ 50% ของเงินเดือน Senior Java Developer คุณได้รับงานที่จริงจังบางอย่างในที่ทำงานและประสบการณ์ของคุณก็เพิ่มขึ้นอย่างมาก คุณจะไปถึงระดับ Java Senior Developer ในสองหรือสามปี ไม่ต้องรีบร้อน คุณจะไม่ได้เงินเดือนสูงลิ่วอยู่ดี สิ่งที่คุณต้องทำคือเรียนรู้รูปแบบการออกแบบ อ่าน – McConnell's Code Complete ปรับปรุงคุณภาพของรหัสและทักษะทีมของคุณให้สมบูรณ์แบบ สร้างกฎการอ่านหนังสือเกี่ยวกับการเขียนโปรแกรมคอมพิวเตอร์เดือนละ 1 เล่ม จากนั้นใน 4 ปี คุณจะฉลาดกว่าหนังสืออื่นๆ ถึง 50 เล่ม อย่าเลื่อนออกไป: คุณจะไม่มีเวลาว่างมากขึ้น นอกจากนี้ เป็นไปได้มากว่าคุณจะได้เริ่มต้นครอบครัว หรือถ้ามี มันก็จะใหญ่ขึ้น เป้าหมายของคุณคือการเลือกเทคโนโลยีสองสามอย่างเพื่อให้เชี่ยวชาญในฐานะ Senior Java Developer คุณไม่สามารถเรียนรู้ได้ทั้งหมด คุณรู้ไหม และเป็นการตัดสินใจที่ดีเสมอในการเป็นกูรูในสาขาเฉพาะทางการเขียนโปรแกรม 3 ปี (Java Middle Developer ระดับ 2)
ตอนนี้คุณเป็น Middle Developer ที่มีประสบการณ์แล้ว และคุณกำลังคิดที่จะเป็น Senior Developer มันน่ายินดีและน่าเกรงขาม คุณเงินเดือนเกิน 60% ของ “สูงสุด 5 ปี” ($10K ในบังกาลอร์, $25K ในเคียฟ, $40K ในเบอร์ลิน, $80K ในนิวยอร์ก) จากนี้ไป ความต้องการสำหรับมืออาชีพเช่นคุณเพิ่มขึ้นข้อเสนอ คุณจะสามารถหางานได้ภายในสองสามวัน และแทบจะไม่ได้รายได้น้อยกว่าที่เป็นอยู่ตอนนี้เลย แน่นอนว่าถ้าคุณไม่ทำอะไรโง่ๆ สิ่งที่คุณต้องทำคือศึกษาเทคโนโลยีที่คุณเลือกต่อไป ทำงานได้ดีขึ้น ไม่ใช่เพื่อประโยชน์ของนายจ้างเพื่อตัวคุณเอง สมัครเข้าร่วมโครงการที่เกี่ยวข้องกับเทคโนโลยีที่น่าสนใจ (เช่น BigData ที่กำลังเขียนบทความนี้) อย่างไรก็ตาม คุณต้องใช้เวลา 8 ชั่วโมงต่อวันในสำนักงาน ดังนั้นทำไมไม่หาเงินเพิ่มสักหน่อย และสิ่งที่สำคัญกว่านั้นคือประสบการณ์อันมีค่าที่สุดที่คุณต้องการในอนาคต เป้าหมายของคุณคือการหางานใหม่ ทีมที่ดีมักจะพบ คุณจะต้องเผชิญกับโครงการและเทคโนโลยีใหม่ๆ คุณไม่จำเป็นต้องหยั่งรากถึงเก้าอี้ของคุณ หากคุณยังทำงานในบริษัทระดับที่สาม ให้นึกถึงการจ้างงานในบริษัทระดับที่สี่การเขียนโปรแกรมปีที่ 5 (Java Senior Developer ระดับ 1
ตอนนี้คุณเป็นนักพัฒนาอาวุโสแล้ว บางทีคุณอาจไม่สมควรได้รับมัน และคุณรู้สึกได้ ยังไงก็ขอแสดงความยินดีด้วย ไม่สำคัญว่าตอนนี้คุณคู่ควรกับตำแหน่งของคุณหรือไม่ สิ่งสำคัญคือคุณจะคู่ควรกับตำแหน่งนั้นในอนาคต ฉันคิดว่าคุณจะเห็นด้วยว่ามันดีกว่าที่จะได้งานที่ดีและหลังจากเติบโตถึงระดับที่ต้องการแล้ว ในทางกลับกัน ฉันหวังว่าคุณจะยังไม่ลืมคำแนะนำของฉันในการอ่านหนังสือหนึ่งเล่มต่อเดือน? ตอนนี้นักเรียนคนใดจะอิจฉาความรู้และทักษะของคุณ ถ้าจะให้เจาะจงมากขึ้น เขาจะอธิษฐานเผื่อพวกเขา ลองคิดดูสิ: คุณมีรายได้ที่จริงจัง เกือบ 90% ของเงินเดือน "สูงสุด 5 ปี" คุณน่าจะยังเด็กอยู่ โลกอยู่ที่เท้าของคุณ สิ่งที่คุณต้องทำคือเพื่อประเมินเทคโนโลยีที่คุณเลือกใหม่ บางทีคุณอาจต้องเปลี่ยนความเชี่ยวชาญ โลกเปลี่ยนไป เทคโนโลยีเปลี่ยนไป และคุณได้รับความรู้ค่อนข้างมากในช่วงสองปีที่ผ่านมา สิ่งที่คุณเลือกตอนนี้จะกลายเป็นหัวข้อข่าวในอีกไม่กี่ปีข้างหน้าสำหรับคุณ ได้เวลาเลือกเทคโนโลยีที่คุณชื่นชอบแล้ว เป้าหมายของคุณคือการเลือกทิศทางการเติบโตของคุณ มีจำนวนมาก ไม่มีใครสามารถตั้งชื่อได้ทั้งหมด แต่คุณต้องเลือกตัวเลือกของคุณตอนนี้ หากคุณทำการเปลี่ยนแปลงเล็กน้อยในวันนี้ คุณจะได้รับการเปลี่ยนแปลงครั้งใหญ่ในอนาคตการเขียนโปรแกรมปีที่ 6 (Java Senior Developer ระดับ 2)
คุณได้ตัดสินใจเกี่ยวกับอนาคตของคุณและกำลังทำความฝันให้เป็นจริง ทิศทางที่เลือกอย่างถูกต้องพร้อมกับความปรารถนาที่จะก้าวไปข้างหน้า – และผลลัพธ์จะไม่นาน ยินดีด้วย. ดีใจที่มีคนทำความฝันสำเร็จอีกหนึ่งคน มีความจริงอันลึกซึ้งประการหนึ่ง ผู้คนมักประเมินค่าสูงเกินจริงในสิ่งที่พวกเขาสามารถทำได้ในหนึ่งปี และประเมินสิ่งที่พวกเขาสามารถทำได้ภายในห้าปีต่ำเกินไป ดูย้อนหลังไปห้าปี มันเป็นอย่างนั้น สิ่งที่คุณต้องทำคือหลีกเลี่ยงการตัดสินใจที่ไม่ฉลาดและไม่เกียจคร้าน เป้าหมายของคุณคือการเลือกทิศทางและก้าวไปข้างหน้า หรือคุณคิดว่ามันจบลงที่นี่? จดจำการสำเร็จการศึกษาของคุณ มันไม่ใช่จุดจบ มันเป็นแค่จุดเริ่มต้นคุณเชี่ยวชาญในอนาคต
คุณสามารถเติบโตเป็นผู้เชี่ยวชาญทางเทคนิค (สาขาบน) เป็นผู้บริหาร (สาขาล่าง) หรือจ้างมืออาชีพ/ที่ปรึกษาอิสระ (สาขาขนาดกลาง) ทุกอย่างขึ้นอยู่กับสิ่งที่คุณต้องการอาชีพของ Java Developer
อาชีพนักพัฒนานั้นแตกต่างจากอาชีพอื่นๆ คุณไม่จำเป็นต้องเป็นผู้จัดการเพื่อรับเงินที่ดี บ่อยครั้งเกิดขึ้นที่ Senior Developer มีรายได้มากกว่าผู้จัดการ-หัวหน้า ยิ่งคุณมีประสบการณ์มากขึ้นความสัมพันธ์ในการทำงานกับเจ้านายของคุณก็จะยิ่งแน่นแฟ้นมากขึ้นจาก "เจ้านาย-ลูกน้อง" เป็น "ดาราและผู้จัดการ"นักพัฒนาอายุสองร้อยปี
หากคุณชอบการเขียนโปรแกรมเป็นส่วนใหญ่ นี่คือวิธีของคุณ: นักพัฒนาอาวุโส จากนั้นเป็นหัวหน้านักพัฒนาเทคโนโลยีและสถาปนิก วิธีนี้ทำให้คุณสามารถทำงานเป็นนักพัฒนาได้นานถึง 50 ปีหรือมากกว่านั้น ในกรณีส่วนใหญ่เงินเดือนของ Senior Developers และ Tech Lead Developers จะสูงกว่าเงินเดือนของผู้จัดการ ดังนั้นรับเงินของคุณให้คุ้มค่าผู้จัดการ. คุณโชคดีที่ไม่เหมือนคนอื่น
คุณไปหาศัตรู ผมล้อเล่น. หากคุณค้นพบทักษะการจัดการที่ยอดเยี่ยม วิธีการของคุณก็คือ หัวหน้าทีม และผู้จัดการโครงการ มันจะทำให้คุณมีโอกาสเป็นหัวหน้าแผนกและเปิดธุรกิจของคุณเอง นั่นคือสิ่งที่คุณต้องการใช่ไหมบ้านคือที่ที่หัวใจอยู่
หากคุณได้เริ่มสร้างครอบครัวแล้ว บางทีคุณอาจปรารถนาที่จะมีชีวิตที่ดีและเงียบสงบในประเทศที่มีเศรษฐกิจแข็งแกร่ง บางทีคุณอาจพิจารณาย้ายไปแคนาดา สหรัฐอเมริกา สวิตเซอร์แลนด์ หรือแม้แต่ออสเตรเลีย คุณมีทักษะที่ยอดเยี่ยมและอาชีพที่ต้องการ คุณจะไม่ต้องเริ่มจากการล้างจาน คุณจะเริ่มต้นในฐานะ Java Senior Developer อาจมีรายได้มาก ไม่เลวฮะ?ดูเนเปิลส์และไม่ตาย
คุณยังไม่มีครอบครัวและ คุณ ชอบท่องเที่ยว oDesk คือทั้งหมดของคุณ หาลูกค้า ตกลงอัตรา $20-$50 ต่อชั่วโมง นำแล็ปท็อปติดตัวไปได้เลย! เงินเดือนของคุณจะเพียงพอสำหรับการใช้ชีวิตทุกที่ในโลก ทำไมไม่เริ่มทำความฝันของคุณให้เป็นจริงในทันทีล่ะ?ฉันไม่ต้องการโปรแกรม ฉันเป็นผู้หญิง..
หากคุณเป็นผู้หญิง คุณ อาจจำเป็นต้องลาคลอดบุตร ฟังดูเป็นเรื่องตลกเรื่องเพศซึ่งก็คือ ยังคงมีสามัญสำนึกมากมายอยู่ในนั้น เป็นไปได้มากว่า การลาคลอดบุตรจะทำให้คุณได้รับเงินจำนวนมากสำหรับการลาคลอดบุตร (ในประเทศที่มีการคุ้มครองทางสังคมสูง) มีบริษัทที่ไม่จ่ายอะไรเลย และก็มีบริษัทที่จ่ายดี นักเรียนของฉันคนหนึ่งได้หนึ่งในสามของเงินเดือนประจำปีจากการลาคลอด และสิ่งนี้เกิดขึ้นในฤดูใบไม้ผลิปี 2009 ระหว่างการเลิกจ้างงาน และในหนึ่งปีครึ่ง คุณอาจกลับมาได้ อย่างน้อยก็ในฐานะ Middle Developerระดับ 6
1 เอลลี่ การมองเห็นวัตถุ โมฆะ
- เฮ้ อามีโก้! - สวัสดี เอลลี่! คุณจะบอกสิ่งที่น่าสนใจในวันนี้ให้ฉันฟังไหม - วันนี้ฉันจะบอกคุณเกี่ยวกับ อายุการใช้ งานของวัตถุ หลังจากสร้างวัตถุแล้ว จะมีอยู่ (มีชีวิต) จนกว่าตัวแปรอย่างน้อยหนึ่งตัวจะจัดเก็บที่อยู่ของมัน (มีการอ้างอิงวัตถุอย่างน้อยหนึ่งรายการ) หากไม่มีการอ้างอิงอีกต่อไป วัตถุนั้นจะตาย ตัวอย่าง: - วัตถุ «cat Tommy» มีอยู่ในบรรทัดเดียวตั้งแต่ตอนที่ถูกสร้างขึ้น ในบรรทัดถัดไป ตัวแปรที่เก็บการอ้างอิงเท่านั้นที่ถูกตั้งค่าเป็น null และ Java virtual machine ทำลายอ็อบเจกต์ - วัตถุ «cat Sammy» หลังจากสร้างจะถูกเก็บไว้ในตัวแปร cat1 หรือค่อนข้าง cat1 เก็บการอ้างอิงถึงวัตถุ จากนั้นสองสามบรรทัดด้านล่างการอ้างอิงนี้จะถูกคัดลอกไปยังตัวแปร cat2 หลังจากนั้นการอ้างอิงถึงวัตถุอื่นจะถูกเก็บไว้ใน cat1 และการอ้างอิงถึง «cat Sammy» จะยังคงอยู่ใน cat2 เท่านั้น สุดท้าย ในบรรทัดสุดท้ายของเมธอด main การอ้างอิงสุดท้ายไปยังอ็อบเจกต์จะถูกตั้งค่าเป็น null - วัตถุ «แมว Maisy» มีอยู่ในบรรทัดเดียวตั้งแต่ตอนที่มันถูกสร้างขึ้น ในบรรทัดถัดไป ตัวแปร cat2 ถูกกำหนดเป็นค่าอื่น และการอ้างอิงถึง «cat Maisy» จะหายไป วัตถุไม่สามารถเข้าถึงได้และถือว่าเป็นขยะ (ตายแล้ว) - วัตถุ «cat Ginger» มีอยู่ตั้งแต่ตอนที่ถูกสร้างขึ้นจนถึงจุดสิ้นสุดของวิธีการ ที่รันไทม์เมื่อเมธอดออก ตัวแปร cat1 จะถูกทำลาย และหลังจากออบเจกต์ «cat Ginger» ก็จะถูกทำลายเช่นกัน - ก็เป็นที่ชัดเจน. - อย่างไรก็ตาม หากคุณสร้างวัตถุ Cat ในบางเมธอดและจัดเก็บการอ้างอิงไว้ในตัวแปรคลาส Cat ก็จะมีอยู่ตราบเท่าที่มีการอ้างอิงถึงวัตถุนั้นจากวัตถุอื่นที่มีอยู่ - โดยปกติแล้ว วัตถุจะไม่ถูกทำลายทันที เครื่องเสมือน Java เปิดใช้งานการรวบรวมขยะเป็นครั้งคราวเพื่อลบวัตถุที่ไม่ได้ใช้ ฉันจะบอกคุณในภายหลัง - หากคุณต้องการให้ตัวแปรบางตัวหยุดการจัดเก็บการอ้างอิงวัตถุ คุณสามารถกำหนดค่าว่างหรือการอ้างอิงไปยังวัตถุอื่น2 อาจารย์, การเก็บขยะ
- เฮ้ อามีโก้! นี่คือลิงค์ที่มีประโยชน์เกี่ยวกับการรวบรวมขยะใน Java แน่นอนว่านั่นไม่ใช่การบรรยายที่ยอดเยี่ยมของฉัน แต่นั่นก็เพียงพอแล้ว: Java Garbage Collection Basics3 Elly จบ
- สวัสดีอีกครั้ง! ตอนนี้ฉันจะแนะนำสั้น ๆ เกี่ยวกับวิธี การสุดท้าย ( ) วิธีการนี้เรียกโดยเครื่องเสมือน Java บนวัตถุก่อนที่วัตถุจะถูกทำลาย ในความเป็นจริงวิธีนี้ตรงข้ามกับตัวสร้าง ในวิธีนี้ เป็นไปได้ที่จะปล่อยทรัพยากรที่ใช้โดยวัตถุ - คลาส Object มีเมธอดนี้ ดังนั้นทุกคลาสจึงมีเมธอดนี้ ( คลาสทั้งหมดใน Java ถือว่าสืบทอดมาจากคลาส Object และมีสำเนาของเมธอดของมันอยู่ ) หากคุณเขียนเมธอด Finalize() ในคลาสของคุณ และมันจะถูกเรียกใช้ก่อนที่ออบเจกต์ของคลาสนี้จะถูกทำลาย ตัวอย่าง: - เข้าใจแล้ว - แต่มีสิ่งหนึ่งที่ เครื่องเสมือน Java ตัดสินใจเองว่าจะเรียกวิธีนี้หรือไม่โดยมากแล้ว ออบเจกต์ที่สร้างในเมธอดและประกาศเป็นขยะหลังจากออกจะถูกทำลายทันทีและไม่มีการเรียกใช้เมธอด finalize() วิธีนี้เป็นอีกเครื่องมือหนึ่งในการควบคุมการจัดสรรทรัพยากรภายนอก (นอก JVM) คุณควรปล่อยทรัพยากรภายนอกที่ใช้ทั้งหมดและรีเซ็ตการอ้างอิงที่เก็บไว้เมื่อคุณต้องการทำลายวัตถุ ฉันจะบอกคุณเกี่ยวกับข้อดีของวิธีนี้และรายละเอียดการทำงานใน 10 หรือ 20 ระดับ ในระหว่างนี้ คุณควรรู้สองสิ่ง: วิธีการดังกล่าวมีอยู่จริง และ ( แปลกใจ! ) ไม่ได้ถูกเรียกใช้เสมอไป4 Elly อายุการใช้งานของวัตถุ
- ฉันอยากจะบอกคุณถึงสิ่งที่น่าสนใจสองสามอย่างเกี่ยวกับอายุการใช้งานของวัตถุ ใน Java เป็นเรื่องยากมากที่จะสูญเสียวัตถุโดยไม่ตั้งใจ หากคุณมีการอ้างอิงวัตถุ หมายความว่าวัตถุนั้นมีชีวิตแน่นอน - ภายในการอ้างอิงวัตถุจะเก็บตัวเลข - ที่อยู่ของวัตถุนี้ไว้ในหน่วยความจำ คุณไม่สามารถเปลี่ยนจำนวน เพิ่ม หรือลดได้ คุณไม่สามารถสร้างการอ้างอิงเมื่อคุณมีที่อยู่ในหน่วยความจำเท่านั้น คุณสามารถสร้างวัตถุใหม่และกำหนดการอ้างอิงให้กับตัวแปรเท่านั้น นี่เป็นวิธีเดียวที่จะได้รับข้อมูลอ้างอิงใหม่ - ฉันเห็น. นั่นคือถ้าฉันตั้งค่าเป็น null (ลบ) การอ้างอิงวัตถุทั้งหมด ฉันจะไม่ได้รับการอ้างอิงวัตถุและเข้าถึงเลย - ใช่. แต่มักจะตรงกันข้าม – มีออบเจกต์สดจำนวนมากเกินไปที่ไม่ได้ใช้งานโปรแกรมส่วนใหญ่สร้างออบเจกต์มากมายและเก็บไว้ในรายการต่างๆ ที่รันไทม์ แต่ไม่เคยล้างรายการเหล่านั้น - ส่วนใหญ่ โปรแกรมเมอร์จะติดป้ายวัตถุที่ไม่ต้องการว่า "ถูกลบ" แค่นั้น ไม่มีใครสนใจที่จะลบออกจากรายการ ดังนั้นโปรแกรม Java ขนาดใหญ่จึงมีแนวโน้มที่จะขยายตัว - วัตถุที่ไม่ได้ใช้จำนวนมากขึ้นเรื่อยๆ ยังคงอยู่ในหน่วยความจำ - นั่นคือทั้งหมด ในอนาคต ฉันจะดึงความสนใจของคุณไปที่วัตถุที่ไม่ได้ใช้และการกำจัดที่เหมาะสม - โอเค ขอบคุณ คุณได้เคลียร์บางอย่างเกี่ยวกับข้อมูลอ้างอิงแล้ว5 ดิเอโก ภารกิจตลอดอายุการใช้งานของอ็อบเจกต์
- เฮ้ อามีโก้! นี่คืองานสองสามอย่างสำหรับคุณ:งาน | |
---|---|
1 | 1. เมธอด Finalize() ของคลาส Cat เขียนเมธอดที่ป้องกัน void finalize() โยน Throwableในคลาส Cat |
3 | 2. Classes Cat and Dog และ Finalize() method สำหรับแต่ละคลาส ในแต่ละคลาส Cat and Dog ให้เขียนFinalize() method ซึ่งแสดงข้อความบนหน้าจอว่าวัตถุถูกทำลาย |
3 | 3. 50,000 ออบเจ็กต์ของคลาส Cat และ 50,000 ออบเจ็กต์ของคลาส Dog สร้างในลูป 50,000 ออบเจ็กต์ของคลาส Cat และ 50,000 ออบเจ็กต์ของคลาส Dog (เครื่องเสมือน Java จะทำลายวัตถุที่ไม่ได้ใช้ ดังนั้นเมธอดfinalize()จะถูกเรียกอย่างน้อยหนึ่งครั้ง) |
4 | 4. Cat counter ในตัวสร้างคลาส Cat [public Cat()] เพิ่ม cat counter (catCount ตัวแปรคงที่ของคลาสเดียวกัน) โดย 1 ในเมธอดfinalize()ลดลง 1 |
6 Elly คลาสสแตติกและเมธอด
- นี่คือหัวข้อใหม่ที่น่าสนใจ ฉันต้องการบอกคุณเกี่ยวกับตัวแปรสแตติกและเมธอด - โอ้ ฉันได้ยินเกี่ยวกับตัวแปรคงที่แล้ว ฉันเดาว่าเกี่ยวกับวิธีคงที่เช่นกัน แต่ฉันอยากได้รายละเอียดมากกว่านี้ - เมื่อประกาศตัวแปรในคลาส เราระบุว่าตัวแปรเหล่านี้ถูกสร้างขึ้นในอินสแตนซ์เดียวที่ใช้ร่วมกัน หรือจำเป็นต้องสร้างสำเนาสำหรับแต่ละอ็อบเจกต์หรือไม่ ตามค่าเริ่มต้น สำเนาใหม่ของตัวแปรคลาสจะถูกสร้างขึ้นสำหรับแต่ละอ็อบเจกต์ของคลาสนี้ มีลักษณะดังนี้: - แม้ว่าตัวแปรcat1.nameและcat2.nameจะถูกประกาศในคลาสเดียวกัน - Cat แต่เก็บค่าต่างกัน เนื่องจากถูกผูกไว้กับออบเจกต์ที่แตกต่างกัน - ก็เป็นที่ชัดเจน. - ตัวแปรคงที่มีอยู่ในอินสแตนซ์เดียว คุณต้องเข้าถึงโดยใช้ชื่อคลาส: - ชัดเจนเช่นกัน - วิธีการเรียนยังแบ่งออกเป็นสองประเภท เมธอดธรรมดาถูกเรียกใช้บนออบเจกต์และมีสิทธิ์เข้าถึงข้อมูลของอ็อบเจ็กต์นี้ วิธีการแบบคงที่ไม่มีการเข้าถึงดังกล่าวเนื่องจากไม่มีการอ้างอิงวัตถุ เมธอดสแตติกสามารถเข้าถึงตัวแปรสแตติกของคลาสนี้หรือเมธอดสแตติกอื่นๆ - วิธีการแบบคงที่ไม่สามารถเข้าถึงวิธีการที่ไม่คงที่หรือตัวแปรที่ไม่คงที่! - ทำไมถึงเป็นเช่นนั้น? - ตัวแปรคลาสธรรมดาทุกตัวจะถูกวางไว้ในวัตถุ เมธอดใดๆ จะเข้าถึงตัวแปรดังกล่าวได้ก็ต่อเมื่อมีการอ้างอิงถึงอ็อบเจกต์นั้น การอ้างอิงดังกล่าวไม่ได้ถูกส่งผ่านไปยังเมธอดแบบสแตติก - แล้ววิธีธรรมดาล่ะ? - วิธีการปกติจะถูกส่งผ่านการอ้างอิงที่ซ่อนอยู่ไปยังวัตถุ วิธีนี้เรียกว่า ตัวแปรที่เก็บการอ้างอิงนี้เรียกว่าthis ดังนั้นเมธอดสามารถรับข้อมูลของออบเจกต์ของตัวเองได้ตลอดเวลา หรือเรียกเมธอดอื่นที่ไม่ใช่สแตติกของออบเจกต์เดียวกันก็ได้ - ค่าnullถูกส่งผ่านไปยังเมธอดแบบคงที่แทนการอ้างอิงวัตถุ ดังนั้นเมธอดแบบสแตติกจึงไม่สามารถเข้าถึงตัวแปรและเมธอดที่ไม่ใช่สแตติกได้ - มันไม่มีการอ้างอิงถึงออบเจกต์ที่ถูกผูกไว้ - ฉันเห็น. - นั่นคือวิธีการทำงานของเมธอดที่ไม่ใช่สแตติกทั่วไป: - และนั่นคือวิธีการทำงานของเมธอดสแตติก: - ตัวแปรหรือเมธอดจะเป็นสแตติกหากประกาศด้วยคีย์เวิร์ดสแตติก - และวิธีการดังกล่าวมีประโยชน์อย่างไร หากมีข้อ จำกัด มาก - วิธีการนี้ยังมีข้อได้เปรียบ - ขั้นแรกคุณไม่จำเป็นต้องส่งการอ้างอิงวัตถุใดๆ เพื่อเข้าถึงเมธอดและตัวแปรแบบสแตติก - ประการที่สอง บาง ครั้งก็จำเป็นที่ตัวแปรจะต้องไม่ซ้ำใคร เช่น ตัวแปร System.out (ตัวแปรสแตติกนอกคลาส System) - และประการที่สามบางครั้งจำเป็นต้องเรียกใช้เมธอดก่อนที่คุณจะสามารถสร้างวัตถุใดๆได้ - เนื่องในโอกาสอะไร? - ทำไมคุณถึงคิดว่าเมธอดmainถูกประกาศแบบสแตติก เพื่อเรียกใช้ทันทีหลังจากโหลดคลาสลงในหน่วยความจำก่อนที่จะสามารถสร้างออบเจกต์ใดๆ ได้7 Risha คลาสสแตติกและเมธอด
- นอกจากวิธีสแตติกแล้วยังมีคลาสสแตติกด้วย เราจะพิจารณากรณีนี้ในภายหลัง ฉันจะแสดงให้คุณเห็นตัวอย่าง: - คุณสามารถสร้างวัตถุของคลาส Cat ได้มากเท่าที่คุณต้องการ ไม่เหมือนกับตัวแปรคงที่ซึ่งมีอยู่ในอินสแตนซ์เดียว - จุด ประสงค์หลักของการแก้ไขแบบคงที่ก่อนการประกาศคลาสคือเพื่อรักษาความสัมพันธ์ระหว่างคลาสCatและคลาสStaticClassExample โดยทั่วไปแล้วคลาส Cat ไม่ได้ถูกผูกไว้ (ไม่มีการอ้างอิงที่ซ่อนอยู่) กับวัตถุ StaticClassExampleและไม่สามารถเข้าถึงตัวแปร StaticClassExample ธรรมดา (ไม่คงที่) - ฉันสามารถสร้างชั้นเรียนภายในชั้นเรียนอื่นได้หรือไม่? - ใช่. Java ทำให้สิ่งนี้เป็นไปได้ ตอนนี้อย่าไปคิดมาก หลังจากนั้นฉันจะอธิบายสิ่งอื่น ๆ และทุกอย่างจะง่ายขึ้นเล็กน้อย - ฉันหวังว่าอย่างนั้น.8 ดิเอโก ภารกิจเกี่ยวกับวิธีสแตติก
- เฮ้ อามีโก้! นี่คืองานที่น่าสนใจเกี่ยวกับวิธีการแบบคงที่:งาน | |
1 | 1. คลาส Cat และตัวแปรสแตติก catCount เขียนตัวแปรสแตติกint catCountในคลาส Cat สร้างตัวสร้าง [ public Cat() ] ซึ่งตัวแปรที่กำหนดควรเพิ่มขึ้น 1 |
2 | 2. วิธีแบบคงที่: int getCatCount() และ setCatCount(int) เพิ่มสองวิธีแบบคงที่ให้กับคลาส Cat: int getCatCount( ) และsetCatCount(int)ซึ่งคุณสามารถรับ / เปลี่ยนจำนวนแมว (ตัวแปร catCount) |
3 | 3. Class Util ใช้เมธอดสแตติก double getDistance(x1, y1 , x2, y2) ควรคำนวณระยะห่างระหว่างจุด ใช้วิธีการdouble Math.sqrt(double a)เพื่อคำนวณค่ารากที่สองของพารามิเตอร์ที่ส่งผ่าน |
4 | 4. Class ConsoleReader เขียนคลาส ConsoleReader ซึ่งจะมี 4 วิธีแบบคงที่: - String readString()เพื่ออ่านสตริงจากแป้นพิมพ์ - int readInt()เพื่ออ่านตัวเลขจากแป้นพิมพ์ - double readDouble()เพื่ออ่านตัวเลขที่เป็นเศษส่วนจากแป้นพิมพ์ - void readLn ()เพื่อรอการกด enter [use readString()] |
5 | 5. Class StringHelper เขียนคลาส StringHelper ซึ่งจะมี 2 วิธีแบบคงที่: - สตริงคูณ (String s, int count)ควรคืนค่าสตริงซ้ำนับครั้ง - สตริงทวีคูณ (สตริง s)ควรส่งคืนสตริงซ้ำ 5 ครั้ง ตัวอย่าง: Amigo → AmigoAmigoAmigoAmigoAmigo |
9 อาจารย์ ขอบเขตคงวัตถุและอายุการใช้งาน
- ฉันอีกแล้ว ขออภัย วันนี้ฉันไม่สามารถให้ลิงก์ใดๆ แก่คุณได้ การบรรยายที่ยอดเยี่ยมเหล่านั้นหายไปที่ไหนสักแห่ง ฉันเกรงว่าวันนี้คุณต้องทำเอง แต่คุณควรฟัง Elly และ Risha ให้มากขึ้น พวกเขาสามารถสอนบางสิ่งให้คุณได้เสมอ ลองใช้อันนี้: Object Lifecycle10 ฮูลิโอ
- เฮ้ อามีโก้! วันนี้คุณทำได้ดีมาก นั่นเป็นเหตุผลที่ฉันไม่สามารถให้คุณได้มากกว่านี้ มานั่งลง การแสดงเริ่มขึ้น:11 กัปตันกระรอก
- สวัสดีทหาร! - สวัสดีตอนเช้าครับท่าน! - ฉันมีข่าวที่ยอดเยี่ยมสำหรับคุณ นี่คือการตรวจสอบอย่างรวดเร็วเพื่อเสริมสร้างทักษะของคุณ ทำทุกวันและคุณจะเพิ่มพูนทักษะของคุณได้อย่างรวดเร็ว งานได้รับการออกแบบมาเป็นพิเศษให้ทำใน Intellij IDEAงานเพิ่มเติมที่ต้องทำใน Intellij Idea | |
---|---|
1 | คลาส Cat และตัวแปรสแตติก catCount เขียนตัวแปรสแตติกpublic int catCountในคลาส Cat สร้างตัวสร้าง [public Cat()] ให้ catCountตัวแปรสแตติกเพิ่มขึ้น 1 ทุกครั้งที่คุณสร้าง cat (วัตถุ Cat ใหม่) สร้าง 10 อ็อบ เจ กต์ Cat และแสดงค่าของตัวแปรcatCount |
2 | 2. แมวคงที่
ในการสร้าง ตัวแปร catให้ใช้โค้ดบรรทัด: public static ArrayList<Cat> cats = new ArrayList<Cat>(); |
3 | 3. ย้ายตัวแก้ไขแบบคงที่หนึ่งตัว ย้ายตัวแก้ไขแบบคงที่หนึ่งตัวเพื่อให้โค้ดคอมไพล์ |
4 | 4. จำนวนคำหลักแบบคงที่ขั้นต่ำ เพิ่มจำนวน คำหลัก แบบคงที่ ขั้นต่ำ เพื่อให้โค้ดคอมไพล์และโปรแกรมเสร็จสมบูรณ์ |
5 | 5. มีไอเดียใหม่ๆ บ้างไหม? ลองคิดดูว่า...
|
6 | 6. KissMyShinyMetalAss เขียนคลาสชื่อ KissMyShinyMetalAss สร้างวัตถุของคลาสนี้ แล้วแสดงบนหน้าจอ |
7 | 7. ชื่อตัวแปรสแตติกสามตัว เขียนตัวแปรสแตติกสาธารณะ 3 ตัว: String Solution.name , String Cat.name , String Dog.name |
GO TO FULL VERSION