ฉันถามคำถามนี้เพราะฉันเชื่อว่าพวกเขาทำมันด้วยเหตุผลที่ดีมากและคนส่วนใหญ่ไม่ได้ใช้อย่างถูกต้องดีจากประสบการณ์ในอุตสาหกรรมจนถึงตอนนี้ แต่ถ้าทฤษฎีของฉันเป็นจริงฉันก็ไม่แน่ใจว่าทำไมพวกเขาถึงรวมตัวแก้ไขการเข้าถึงส่วนตัว ... ?

ฉันเชื่อว่าหากใช้การเข้าถึงเริ่มต้นอย่างเหมาะสมจะช่วยเพิ่มความสามารถในการทดสอบในขณะที่ยังคงการห่อหุ้ม และยังทำให้ตัวแก้ไขการเข้าถึงส่วนตัวซ้ำซ้อน

ตัวดัดแปลงการเข้าถึงเริ่มต้นสามารถใช้เพื่อให้ผลกระทบแบบเดียวกันโดยใช้แพคเกจเฉพาะสำหรับวิธีการที่ต้องซ่อนจากส่วนอื่น ๆ ของโลกและทำได้โดยไม่กระทบต่อความสามารถในการทดสอบเป็นแพคเกจในโฟลเดอร์ทดสอบ สามารถเข้าถึงวิธีการเริ่มต้นทั้งหมดที่ประกาศในโฟลเดอร์ต้นทาง

ฉันเชื่อว่านี่เป็นสาเหตุที่ Java ใช้การเข้าถึงแพคเกจเป็น 'ค่าเริ่มต้น' แต่ฉันไม่แน่ใจว่าทำไมพวกเขาถึงรวมการเข้าถึงส่วนตัวฉันแน่ใจว่ามีกรณีการใช้ที่ถูกต้อง ...

ฉันเดาว่าพวกเขามีความคิดที่ดีว่าโปรแกรมเมอร์ทั่วไปจะทำอะไร และโดยเฉลี่ยโปรแกรมเมอร์ฉันหมายถึงคนที่ไม่เก่งในการเขียนโปรแกรม แต่ได้งานมาแล้วเพราะมีคนไม่ดีพอและมีราคาแพง

หากพวกเขาทำให้ "สาธารณะ" เข้าถึงค่าเริ่มต้นโปรแกรมเมอร์ส่วนใหญ่จะไม่รำคาญที่จะใช้สิ่งอื่น ผลลัพธ์จะเป็นรหัสสปาเก็ตตี้มากมายในทุกที่ (เพราะถ้าคุณได้รับอนุญาตทางเทคนิคให้โทรหาอะไรจากทุกที่ทำไมต้องสนใจที่จะสรุปเหตุผลบางอย่างในเมธอด?)

การทำให้ "ส่วนตัว" การเข้าถึงเริ่มต้นจะดีขึ้นเล็กน้อยเท่านั้น โปรแกรมเมอร์เริ่มต้นส่วนใหญ่จะประดิษฐ์ (และแบ่งปันในบล็อกของพวกเขา) กฎง่ายๆที่ "คุณต้องเขียน 'สาธารณะ' ทุกที่" แล้วพวกเขาก็จะบ่นว่าทำไม Java แย่มากจนบังคับให้พวกเขาเขียน "สาธารณะ" ทุกที่ และพวกเขาก็จะผลิตสปาเก็ตตี้โค้ดจำนวนมาก

การเข้าถึงแพ็คเกจเป็นสิ่งที่อนุญาตให้โปรแกรมเมอร์ใช้เทคนิคการเขียนโปรแกรมที่เลอะเทอะในขณะที่เขียนโค้ดภายในแพ็คเกจเดียว แต่ต้องพิจารณาอีกครั้งเมื่อสร้างแพ็คเกจเพิ่มเติม เป็นการประนีประนอมระหว่างการดำเนินธุรกิจที่ดีกับความเป็นจริงที่น่าเกลียด ไลค์: เขียนโค้ดสปาเก็ตตี้ถ้าคุณยืนยัน แต่โปรดทิ้งความยุ่งเหยิงไว้ในแพ็คเกจ; อย่างน้อยสร้างอินเตอร์เฟสที่ดีกว่าระหว่างแพ็คเกจ

อาจมีเหตุผลอื่นเช่นกัน แต่ฉันจะไม่ประมาทสิ่งนี้

การเข้าถึงเริ่มต้นไม่ได้ทำให้ตัวดัดแปลงการเข้าถึงส่วนตัวซ้ำซ้อน

ตำแหน่งนักออกแบบภาษาที่ปรากฏในบทช่วยสอนอย่างเป็นทางการ - การควบคุมการเข้าถึงสมาชิกของชั้นเรียนและค่อนข้างชัดเจน (เพื่อความสะดวกของคุณคำสั่งที่เกี่ยวข้องในเครื่องหมายคำพูดทำให้เป็นตัวหนา ):

เคล็ดลับในการเลือกระดับการเข้าถึง:

หากโปรแกรมเมอร์คนอื่นใช้คลาสของคุณคุณต้องการให้แน่ใจว่าข้อผิดพลาดจากการใช้ผิดประเภทจะไม่เกิดขึ้น ระดับการเข้าถึงสามารถช่วยคุณทำสิ่งนี้ได้

• ใช้ระดับการเข้าถึงที่ จำกัด ที่สุดที่เหมาะสมสำหรับสมาชิกบางราย ใช้ส่วนตัวเว้นแต่คุณจะมีเหตุผลที่ดีที่จะไม่
• หลีกเลี่ยงช่องสาธารณะยกเว้นค่าคงที่ (ตัวอย่างมากมายในบทช่วยสอนใช้เขตข้อมูลสาธารณะซึ่งอาจช่วยให้เห็นบางจุดที่ชัดเจน แต่ไม่แนะนำสำหรับรหัสการผลิต) เขตข้อมูลสาธารณะมักจะเชื่อมโยงคุณกับการใช้งานเฉพาะและจำกัดความยืดหยุ่นในการเปลี่ยนรหัสของคุณ

การอุทธรณ์ของคุณต่อความสามารถในการทดสอบเพื่อเป็นเหตุผลในการทำให้ตัวดัดแปลงส่วนบุคคลสมบูรณ์นั้นไม่ถูกต้องตามหลักฐานที่เห็นได้จากคำตอบในใหม่ถึง TDD ฉันควรหลีกเลี่ยงวิธีการส่วนตัวตอนนี้หรือไม่

แน่นอนคุณสามารถมีวิธีส่วนตัวและแน่นอนคุณสามารถทดสอบได้

ทั้งสองมีบางวิธีที่จะได้รับวิธีการส่วนตัวถึงระยะซึ่งในกรณีนี้คุณสามารถทดสอบมันเป็นอย่างนั้นหรือมีไม่มีทางที่จะได้รับส่วนตัวในการทำงานซึ่งในกรณี: ทำไม heck คุณพยายามที่จะทดสอบเพียง ลบสิ่งแช่ง ...

ตำแหน่งของนักออกแบบภาษากับวัตถุประสงค์การใช้งานและการเข้าถึงระดับแพ็กเกจจะมีการอธิบายในอีกอย่างเป็นทางการกวดวิชา, การสร้างและการใช้แพคเกจและมีอะไรที่เหมือนกันกับความคิดของการวางปรับเปลี่ยนเอกชน (เพื่อความสะดวกของคำสั่งที่เกี่ยวข้องในใบเสนอราคาที่ทำตัวหนา ) :

คุณควรรวมคลาสเหล่านี้และอินเทอร์เฟซในแพคเกจด้วยเหตุผลหลายประการรวมถึงต่อไปนี้:

• คุณและโปรแกรมเมอร์คนอื่น ๆ สามารถระบุได้อย่างง่ายดายว่าประเภทเหล่านี้เกี่ยวข้อง ...
• คุณสามารถอนุญาตประเภทภายในแพ็คเกจให้เข้าถึงแบบไม่ จำกัด ซึ่งกันและกัน แต่ยัง จำกัด การเข้าถึงประเภทนอกแพ็คเกจ ...

_{<พูดจาโผงผาง "ฉันคิดว่าฉันได้ยินเสียงครวญครางพอเดาว่าถึงเวลาที่จะพูดเสียงดังและชัดเจน ... ">}

วิธีการแบบส่วนตัวมีประโยชน์ต่อการทดสอบหน่วย

หมายเหตุด้านล่างอนุมานว่าคุณมีความคุ้นเคยกับความคุ้มครองรหัส ถ้าไม่ใช้เวลาในการเรียนรู้เนื่องจากมันค่อนข้างมีประโยชน์สำหรับผู้ที่สนใจในการทดสอบหน่วยและในการทดสอบเลย

เอาล่ะดังนั้นฉันจึงมีวิธีส่วนตัวและการทดสอบหน่วยและการวิเคราะห์ความครอบคลุมบอกฉันว่ามีช่องว่างวิธีส่วนตัวของฉันไม่ได้รับการทดสอบ ตอนนี้ ...

ฉันจะได้อะไรจากการรักษาความเป็นส่วนตัว

เนื่องจากเมธอดเป็นไพรเวตวิธีเดียวที่จะดำเนินการต่อคือการศึกษาโค้ดเพื่อเรียนรู้วิธีใช้งานผ่าน API ที่ไม่ใช่ไพรเวต โดยทั่วไปแล้วการศึกษาดังกล่าวแสดงให้เห็นว่าเหตุผลของช่องว่างคือสถานการณ์การใช้งานเฉพาะที่ขาดหายไปในการทดสอบ

    void nonPrivateMethod(boolean condition) {
        if (condition) {
            privateMethod();
        }
        // other code...
    }

    // unit tests don't invoke nonPrivateMethod(true)
    //   => privateMethod isn't covered.

^{เพื่อความสมบูรณ์เหตุผลอื่น ๆ (ไม่บ่อย) สำหรับช่องว่างการรายงานข่าวดังกล่าวอาจเป็นข้อบกพร่องในสเปค / การออกแบบ ฉันจะไม่ดำดิ่งลึกลงไปในสิ่งเหล่านี้ที่นี่เพื่อให้สิ่งต่าง ๆ เรียบง่าย; พอเพียงที่จะบอกว่าถ้าคุณอ่อนแอข้อ จำกัด การเข้าถึง "เพียงเพื่อให้วิธีการทดสอบ" คุณจะพลาดโอกาสที่จะเรียนรู้ว่าข้อบกพร่องเหล่านี้มีอยู่ทั้งหมด}

ได้ดีเพื่อแก้ไขช่องว่างฉันเพิ่มการทดสอบหน่วยสำหรับสถานการณ์ที่ขาดหายไปการวิเคราะห์ความครอบคลุมซ้ำและยืนยันว่าช่องว่างหายไป ตอนนี้ฉันมีอะไร ฉันได้รับการทดสอบหน่วยใหม่สำหรับการใช้งานเฉพาะของ API ที่ไม่ใช่ส่วนตัว

1. การทดสอบใหม่ช่วยให้มั่นใจได้ว่าพฤติกรรมที่คาดหวังสำหรับการใช้งานนี้จะไม่เปลี่ยนแปลงหากไม่มีการแจ้งให้ทราบเนื่องจากมีการเปลี่ยนแปลงการทดสอบจะล้มเหลว

2. ผู้อ่านภายนอกอาจตรวจสอบการทดสอบนี้และเรียนรู้ว่าควรใช้และประพฤติตัวอย่างไร (ที่นี่ผู้อ่านภายนอกจะรวมตัวตนในอนาคตของฉันด้วยเนื่องจากฉันมักจะลืมรหัสหนึ่งหรือสองเดือนหลังจากที่ฉันทำเสร็จ)

3. การทดสอบใหม่มีความทนทานต่อการปรับโครงสร้างใหม่ (ฉันจะปรับวิธีส่วนตัวหรือไม่คุณเดิมพัน!) ไม่ว่าฉันจะทำอะไรprivateMethodฉันจะต้องทดสอบnonPrivateMethod(true)เสมอ ไม่ว่าฉันจะทำอะไรprivateMethodจะไม่จำเป็นต้องแก้ไขการทดสอบเพราะวิธีการไม่ได้ถูกเรียกใช้โดยตรง

ไม่เลว? พนันได้เลย.

ฉันทำอะไรหลวมจากข้อ จำกัด การเข้าถึงที่ลดลง

ทีนี้ลองนึกว่าแทนที่จะเป็นเรื่องข้างต้นฉันแค่ จำกัด การเข้าถึง exPrivateMethodฉันข้ามการศึกษาของรหัสที่ใช้วิธีการและดำเนินการตรงกับการทดสอบที่จะเรียกฉัน ที่ดี? ไม่!

1. ฉันจะได้รับการทดสอบสำหรับการใช้งานเฉพาะของ API ที่ไม่ใช่ส่วนตัวดังกล่าวข้างต้นหรือไม่ ไม่: ไม่มีการทดสอบมาnonPrivateMethod(true)ก่อนและไม่มีการทดสอบดังกล่าวในขณะนี้

2. ผู้อ่านภายนอกได้รับโอกาสที่จะเข้าใจการใช้งานของชั้นเรียนดีขึ้นหรือไม่ ไม่"- เฮ้จุดประสงค์ของวิธีทดสอบที่นี่คืออะไร - ลืมมันเป็นวิธีการใช้ภายในอย่างเคร่งครัด - โอ๊ะโอ"

3. ทนต่อการเปลี่ยนโครงสร้างใหม่ได้หรือไม่ ไม่มีทาง: สิ่งที่ฉันเปลี่ยนexPrivateMethodมีแนวโน้มที่จะทำลายการทดสอบ เปลี่ยนชื่อรวมเข้ากับวิธีอื่นเปลี่ยนการโต้แย้งและการทดสอบจะหยุดรวบรวม ปวดหัว? พนันได้เลย!

ข้อสรุปการผสานกับวิธีการส่วนตัวทำให้ฉันได้รับการปรับปรุงที่มีประโยชน์และเชื่อถือได้ในการทดสอบหน่วย ในทางตรงกันข้ามการ จำกัด การเข้าถึง "สำหรับการทดสอบ" นั้นทำให้ฉันมีความคลุมเครือและยากที่จะเข้าใจรหัสการทดสอบซึ่งเป็นความเสี่ยงถาวรที่จะถูกทำลายโดยการปรับเปลี่ยนเล็กน้อย ตรงไปตรงมาในสิ่งที่ผมได้รับมีลักษณะหวาดระแวงเช่นหนี้ทางเทคนิค

_{</ พูดจาโผงผาง>}

เหตุผลที่น่าพอใจที่สุดคือ: มันเกี่ยวข้องกับประวัติศาสตร์ Oak บรรพบุรุษของ Java มีระดับการเข้าถึงสามระดับเท่านั้น: ส่วนตัวได้รับการป้องกันสาธารณะ

ยกเว้นว่า private ใน Oak นั้นเทียบเท่ากับ package private ใน Java คุณสามารถอ่านมาตรา 4.10 ของข้อกำหนดภาษาของ Oak (ระดับความสำคัญ):

โดยค่าเริ่มต้นตัวแปรและวิธีการทั้งหมดในคลาส (รวมถึงตัวสร้าง) เป็นแบบส่วนตัว ตัวแปรและวิธีการส่วนตัวสามารถเข้าถึงได้โดยวิธีการที่ประกาศในชั้นเรียนเท่านั้นและไม่สามารถทำได้โดยคลาสย่อยหรือคลาสอื่น ๆ ( ยกเว้นคลาสที่อยู่ในแพ็คเกจเดียวกัน )

ดังนั้นถึงจุดของคุณการเข้าถึงแบบส่วนตัวที่รู้จักกันใน Java ไม่ได้มีมา แต่เดิม แต่เมื่อคุณมีมากกว่าสองสามคลาสในแพ็กเกจการไม่มีความเป็นส่วนตัวอย่างที่เรารู้ตอนนี้จะนำไปสู่ฝันร้ายของการชนกันของชื่อ (ตัวอย่างเช่น java.until.concurrent มี 60 คลาส) ซึ่งอาจเป็นเหตุผลว่าทำไม แนะนำให้รู้จัก

อย่างไรก็ตามการเข้าถึงแพ็คเกจเริ่มต้น (แต่เดิมเรียกว่าส่วนตัว) ซีแมนทิคส์ไม่ได้เปลี่ยนแปลงระหว่าง Oak และ Java

ฉันเชื่อว่าหากใช้การเข้าถึงเริ่มต้นอย่างเหมาะสมจะช่วยเพิ่มความสามารถในการทดสอบในขณะที่ยังคงการห่อหุ้ม และยังทำให้ตัวแก้ไขการเข้าถึงส่วนตัวซ้ำซ้อน

มีสถานการณ์ที่เราต้องการให้สองชั้นแยกจากกันซึ่งถูกผูกไว้แน่นกว่าการเปิดเผยทุกอย่างกับสาธารณะ สิ่งนี้มีความคิดคล้ายกันกับ 'เพื่อน' ใน C ++ ซึ่งคลาสอื่นที่ประกาศเป็น 'เพื่อน' ของอีกคนหนึ่งสามารถเข้าถึงสมาชิกส่วนตัวของพวกเขาได้

ถ้าคุณมองเข้าไปในเครื่องในของคลาสเช่นBigIntegerคุณจะพบจำนวนการป้องกันค่าเริ่มต้นของแพ็คเกจบนฟิลด์และวิธีการ (ทุกอย่างที่เป็นสามเหลี่ยมสีน้ำเงินในรายการ) นี้จะช่วยให้ชั้นเรียนอื่น ๆ ในแพคเกจ java.math ที่จะมีการเข้าถึงที่เหมาะสมมากขึ้นในอวัยวะภายในของพวกเขาสำหรับการดำเนินงานที่เฉพาะเจาะจง (คุณสามารถหาวิธีการเหล่านี้เรียกว่าในBigDecimal - BigDecimal มีการสนับสนุนจาก BigInteger และบันทึก reimplementing BigInteger อีกครั้ง . ว่าเหล่านี้เป็น ISN ระดับแพ็กเกจ' ไม่มีปัญหาสำหรับการป้องกันเนื่องจาก java.math เป็นแพคเกจที่ปิดสนิทและไม่สามารถเพิ่มคลาสอื่นได้

ในทางกลับกันมีหลายสิ่งที่เป็นส่วนตัวอย่างที่ควรจะเป็น แพ็คเกจส่วนใหญ่ไม่ได้ปิดผนึก หากไม่มีความเป็นส่วนตัวเพื่อนร่วมงานของคุณสามารถเพิ่มคลาสอื่นลงในแพ็คเกจนั้นและเข้าถึงฟิลด์ (ไม่) อีกต่อไปและหยุดการสรุปแค็ปซูล

จากการสังเกตการทดสอบหน่วยไม่ใช่สิ่งที่คิดย้อนกลับไปเมื่อขอบเขตการป้องกันถูกสร้างขึ้น JUnit (เฟรมเวิร์กการทดสอบ XUnit สำหรับ Java) ไม่ได้คิดมาจนกระทั่งปี 1997 (มีคนบอกเล่าเรื่องราวที่สามารถอ่านได้ที่http://www.martinfowler.com/bliki/Xunit.html ) JDK รุ่นอัลฟ่าและเบต้าอยู่ในปี 1995 และ JDK 1.0 เป็นในปี 1996 แม้ว่าระดับการป้องกันจะไม่ได้รับการตอกย้ำจนกระทั่ง JDK 1.0.2 (ก่อนหน้านั้นคุณจะมีprivate protectedระดับการป้องกัน)

บางคนยืนยันว่าค่าเริ่มต้นไม่ควรอยู่ในระดับแพ็คเกจ แต่เป็นแบบส่วนตัว คนอื่นอ้างว่าไม่ควรมีการป้องกันเริ่มต้นแต่ทุกอย่างควรมีการระบุไว้อย่างชัดเจน - ผู้ติดตามบางส่วนของสิ่งนี้จะเขียนโค้ดเช่น:

public class Foo {
    /* package */ int bar = 42;
    ...
}

หมายเหตุความคิดเห็นที่นั่น

เหตุผลที่แท้จริงที่ว่าทำไมการป้องกันระดับแพ็คเกจเป็นค่าเริ่มต้นอาจหายไปจากบันทึกการออกแบบของ Java (ฉันขุดแล้วและไม่สามารถหาบทความใด ๆ ได้ทำไมผู้คนมากมายอธิบายความแตกต่าง แต่ไม่มีใครพูดว่า "นี่คือเหตุผล ")

ดังนั้นฉันจะเดา และนั่นคือทั้งหมดที่ - เดา

ก่อนอื่นผู้คนยังคงพยายามออกแบบภาษา ภาษาตั้งแต่นั้นมาได้เรียนรู้จากความผิดพลาดและความสำเร็จของ Java นี่อาจเป็นรายการที่ผิดพลาดเพื่อไม่ให้มีบางสิ่งที่จำเป็นต้องกำหนดสำหรับฟิลด์ทั้งหมด

• นักออกแบบมองเห็นความต้องการ 'ความสัมพันธ์' ของ C ++ เป็นครั้งคราว
• นักออกแบบต้องการคำแถลงที่ชัดเจนสำหรับpublicและprivateเนื่องจากสิ่งเหล่านี้มีผลกระทบที่ใหญ่ที่สุดในการเข้าถึง

ดังนั้นความเป็นส่วนตัวจึงไม่ใช่ค่าเริ่มต้นและทุกอย่างก็เข้าที่ ขอบเขตเริ่มต้นถูกปล่อยไว้เป็นค่าเริ่มต้น มันอาจจะเป็นคนแรกที่ขอบเขตที่ถูกสร้างขึ้นและอยู่ในความสนใจของข้างหลังอย่างเข้มงวดเข้ากันได้กับรหัสเก่าถูกทิ้งวิธีการที่

ที่ผมกล่าวว่าเหล่านี้เป็นทุกการคาดเดา

Encapsulation เป็นวิธีการพูดว่า "คุณไม่ต้องคิดเกี่ยวกับเรื่องนี้"

                 Access Levels
Modifier    Class   Package  Subclass   World
public        Y        Y        Y        Y
protected     Y        Y        Y        N
no modifier   Y        Y        N        N
private       Y        N        N        N

การใส่สิ่งเหล่านี้เป็นคำศัพท์ที่ไม่ใช้เทคนิค

1. สาธารณะ: ทุกคนต้องคิดเรื่องนี้
2. ได้รับการป้องกัน: ค่าเริ่มต้นและคลาสย่อยต้องทราบ
3. ค่าเริ่มต้นหากคุณกำลังทำงานกับแพคเกจคุณจะรู้เกี่ยวกับมัน (มันอยู่ตรงหน้าสายตาของคุณ) อาจช่วยให้คุณได้รับประโยชน์จากมัน
4. ส่วนตัวคุณเพียงแค่ต้องรู้เกี่ยวกับสิ่งนี้หากคุณกำลังทำงานในชั้นเรียนนี้

ฉันไม่คิดว่าพวกเขามุ่งเน้นไปที่การทดสอบเพียงเพราะการทดสอบไม่ได้เป็นเรื่องธรรมดามากในตอนนั้น

สิ่งที่ฉันคิดว่าพวกเขาต้องการบรรลุคือการห่อหุ้มในระดับแพ็คเกจ ชั้นเรียนตามที่คุณรู้มีวิธีการภายในและสาขาและเปิดเผยบางส่วนผ่านสมาชิกสาธารณะ ในทำนองเดียวกันแพคเกจสามารถมีคลาสภายในวิธีการและเขตข้อมูลและเปิดเผยบางส่วนเท่านั้น หากคุณคิดว่าวิธีนี้แพคเกจจะมีการนำไปใช้ภายในในชุดชั้นเรียนวิธีการและเขตข้อมูลพร้อมกับส่วนต่อประสานสาธารณะในส่วนอื่น (อาจทับซ้อนกันบางส่วน) ชุดชั้นเรียนวิธีการและเขตข้อมูล

นักเขียนโค้ดที่มีประสบการณ์มากที่สุดที่ฉันรู้จักคิดแบบนี้ พวกเขาใช้การห่อหุ้มและนำไปใช้กับระดับนามธรรมสูงกว่าคลาส: แพคเกจหรือส่วนประกอบหากคุณต้องการ ดูเหมือนว่าสมเหตุสมผลสำหรับฉันที่นักออกแบบของ Java นั้นเป็นผู้ใหญ่ในการออกแบบของพวกเขาพิจารณาว่า Java ยังคงดีขึ้น