เมื่อใดควรใช้คลาส wrapper และประเภทดั้งเดิม

เมื่อใดที่ฉันควรเลือกคลาส Wrapper มากกว่าประเภทดั้งเดิม หรือในกรณีใดฉันควรเลือกระหว่าง wrapper / Primitive types?

คนอื่น ๆ ได้กล่าวว่าโครงสร้างบางอย่างเช่นCollectionsต้องใช้วัตถุและวัตถุนั้นมีค่าใช้จ่ายมากกว่าวัตถุดั้งเดิม (หน่วยความจำและการชกมวย)

ข้อควรพิจารณาอีกประการหนึ่งคือ:

การเตรียมใช้งานออบเจ็กต์nullหรือส่งnullพารามิเตอร์ไปยังเมธอด / คอนสตรัคเตอร์เพื่อระบุสถานะหรือฟังก์ชันได้อย่างสะดวก สิ่งนี้ไม่สามารถทำได้โดยใช้แบบดั้งเดิม

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

นอกจากนี้ยังจะจัดฉากNullPointerExceptionเมื่อมีการใช้บางสิ่งอย่างไม่ถูกต้องซึ่งเป็นมิตรกับโปรแกรมเมอร์มากกว่าข้อผิดพลาดบางอย่างตามอำเภอใจ

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

ในความคิดของฉันถ้าสมาชิกชั้นเรียนของฉันเป็นตัวแปร Wrapper จะไม่ขึ้นอยู่กับค่าเริ่มต้นซึ่งเป็นพฤติกรรมที่เป็นมิตรกับนักพัฒนา

1.

class Person {
   int SSN ; // gets initialized to zero by default 
}

2.

class PersonBetter {
  Integer SSN; //gets initialized to null by default
}

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

ในกรณีที่สองคุณสามารถเริ่มต้น SSN ด้วย null ได้ ซึ่งสามารถนำไปสู่ ​​NullPointerException แต่จะดีกว่าการแทรกค่าเริ่มต้น (ศูนย์) เป็น SSN ลงในฐานข้อมูลโดยไม่รู้ตัวเมื่อใดก็ตามที่คุณพยายามใช้งานโดยไม่ต้องเริ่มต้นฟิลด์ SSN

ฉันจะใช้ประเภทกระดาษห่อหุ้มเท่านั้นถ้าคุณต้อง

ในการใช้พวกเขาคุณจะไม่ได้รับมากนักนอกจากความจริงที่ว่าพวกเขา Objectsในการใช้พวกเขาที่คุณไม่ได้รับมากนอกเหนือจากความจริงที่ว่าพวกเขา

และคุณสูญเสียค่าใช้จ่ายในการใช้หน่วยความจำและเวลาที่ใช้ในการชกมวย / แกะกล่อง

ในทางปฏิบัติฉันเคยเจอสถานการณ์ที่สามารถอธิบายการใช้คลาส wrapper ได้

ฉันสร้างคลาสบริการที่มีlongตัวแปรประเภท

1. หากตัวแปรเป็นประเภทlong- เมื่อไม่ได้เริ่มต้นจะถูกตั้งค่าเป็น 0 - สิ่งนี้จะทำให้ผู้ใช้สับสนเมื่อแสดงใน GUI
2. หากตัวแปรเป็นประเภทLong- เมื่อไม่ได้เริ่มต้นตัวแปรจะถูกตั้งค่าเป็นnull- ค่าว่างนี้จะไม่ปรากฏใน GUI

สิ่งนี้ใช้ได้กับBooleanค่าที่อาจทำให้สับสนได้มากขึ้นเมื่อเราใช้แบบดั้งเดิมboolean(เนื่องจากค่าเริ่มต้นเป็นเท็จ)

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

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

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

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

ประเภทดั้งเดิมหนึ่งใช้ตัวดำเนินการ == แต่สำหรับ wrapper ตัวเลือกที่ต้องการคือการเรียกใช้เมธอด equals ()

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

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

หากคุณต้องการใช้ Collections คุณต้องใช้คลาส Wrapper

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

ตั้งแต่การทำ autoboxing พรมแดน "เมื่อใดควรใช้แบบดั้งเดิมหรือ Wrapper" ก็ค่อนข้างคลุมเครือ

แต่จำไว้ว่า Wrappers เป็นวัตถุดังนั้นคุณจะได้รับคุณสมบัติ Java ที่น่าสนใจทั้งหมด ตัวอย่างเช่นคุณสามารถใช้การสะท้อนกลับเพื่อสร้างอ็อบเจ็กต์จำนวนเต็ม แต่ไม่ใช่ค่า int คลาส Wrapper ยังมีเมธอดเช่น valueOf

หากคุณต้องการสร้างประเภทค่า บางอย่างเช่น ProductSKU หรือ AirportCode

เมื่อประเภทดั้งเดิม (สตริงในตัวอย่างของฉัน) กำหนดความเท่าเทียมกันคุณจะต้องลบล้างความเท่าเทียมกัน

ค่าดั้งเดิมใน Java ไม่ใช่วัตถุ ในการจัดการค่าเหล่านี้เป็นอ็อบเจ็กต์แพ็กเกจ java.lang จะจัดเตรียมคลาส wrapper สำหรับแต่ละประเภทข้อมูลดั้งเดิม

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

แม้ว่าคลาสโมฆะถือเป็นคลาสของ wrapper แต่ไม่ได้รวมค่าดั้งเดิมใด ๆ และไม่สามารถเริ่มต้นได้ ไม่มีตัวสร้างสาธารณะ แต่หมายถึงคลาสอ็อบเจ็กต์ที่แทนคีย์เวิร์ด void

เมื่อใดควรใช้ประเภทดั้งเดิม

• เมื่อทำการคำนวณจำนวนมากประเภทดั้งเดิมจะเร็วกว่าเสมอ - มีค่าโสหุ้ยน้อยกว่ามาก
• เมื่อคุณไม่ต้องการให้ตัวแปรเป็นโมฆะ
• เมื่อคุณไม่ต้องการให้ค่าเริ่มต้นเป็นโมฆะ
• ถ้าเมธอดต้องส่งคืนค่า

เมื่อใดควรใช้ Wrapper Class

• เมื่อคุณใช้ Collections หรือ Generics - จำเป็น
• หากคุณต้องการ MIN_SIZE หรือ MAX_SIZE ประเภท
• เมื่อคุณต้องการให้ตัวแปรเป็นโมฆะ
• เมื่อคุณต้องการให้ค่าเริ่มต้นเป็นค่าว่าง
• หากบางครั้งเมธอดสามารถคืนค่าว่างได้

จากhttps://medium.com/@bpnorlander/java-understand-primitive-types-and-wrapper-objects-a6798fb2afe9