คลาส Wrapper ใน Java

สวัสดี! คุณคุ้นเคยกับประเภทดึกดำบรรพ์ดีอยู่แล้ว และเคยทำงานกับพวกมันมาบ้างแล้ว ในการเขียนโปรแกรม (และโดยเฉพาะอย่างยิ่ง Java) แบบดั้งเดิมมีข้อดีหลายประการ: พวกมันใช้หน่วยความจำเพียงเล็กน้อย (และทำให้โปรแกรมมีประสิทธิภาพมากขึ้น) และมีขอบเขตของค่าที่ชัดเจน อย่างไรก็ตาม ในขณะที่เรียนรู้ Java เราได้ท่องมนต์ที่ว่า "ทุกอย่างใน Java เป็นวัตถุ" ซ้ำแล้วซ้ำอีก แต่ดั้งเดิมขัดแย้งกับคำเหล่านั้นโดยตรง พวกเขาไม่ใช่วัตถุ หลักการ "ทุกสิ่งทุกอย่างเป็นวัตถุ" ของเราเป็นเท็จหรือไม่? จริงๆแล้วมันไม่ใช่ ใน Java ทุกประเภทดั้งเดิมมีพี่น้องฝาแฝดซึ่งเป็นคลาส wrapper

คลาส Wrapper คืออะไร?

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

public static void main(String[] args) {

   Integer i = new Integer(682);
  
   Double d = new Double(2.33);
  
   Boolean b = new Boolean(false);
}

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

public static void main(String[] args) {

   Integer i = new Integer(432);
  
   String s = i.toString();
}

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

public static void main(String[] args) {

   String s = "1166628";

   Integer i = Integer.parseInt(s);

   System.out.println(i);
}

เอาท์พุต:

1166628

เราแยกตัวเลขจากสตริง สำเร็จ และกำหนดให้กับตัวแปรอ้างอิงจำนวนเต็มi โดยวิธีการเกี่ยวกับการอ้างอิง คุณรู้อยู่แล้วว่าอาร์กิวเมนต์ถูกส่งผ่านไปยังเมธอดด้วยวิธีต่างๆ: ดั้งเดิมตามค่า และออบเจกต์โดยการอ้างอิง คุณสามารถใช้ความรู้นี้ในการสร้างเมธอดของคุณเอง ตัวอย่างเช่น ถ้าเมธอดของคุณใช้ตัวเลขที่เป็นเศษส่วน แต่คุณต้องการให้ลอจิกผ่านการอ้างอิง คุณสามารถส่ง อาร์กิวเมนต์ Double / Floatไปยังเมธอดแทนdouble / float นอกจากเมธอดของคลาส wrapper แล้ว ฟิลด์สแตติกของพวกมันยังสะดวกอีกด้วย ตัวอย่างเช่น สมมติว่าคุณมีงานต่อไปนี้: แสดงจำนวนสูงสุดที่เป็นไปได้ค่า intตามด้วยค่าต่ำสุดที่เป็นไปได้ ปัญหานี้ดูเหมือนค่อนข้างพื้นฐาน แต่ถ้าไม่มี Google คุณก็ไม่น่าจะทำได้ แต่เครื่องห่อหุ้มช่วยให้คุณจัดการกับ "งานทางโลก" ดังกล่าวได้อย่างง่ายดาย:

public class Main {
   public static void main(String[] args) {

       System.out.println(Integer.MAX_VALUE);
       System.out.println(Integer.MIN_VALUE);
   }
}

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

public static void main(String[] args) {

   Integer a = new Integer(0);
   Integer b = new Integer(0);

   b = a;
   a = 1;
   System.out.println(b);
}

เอาท์พุต:

0

สถานะของวัตถุที่a ชี้ไปในตอนแรก ไม่เปลี่ยนแปลง (เพราะค่าของbก็จะเปลี่ยนไปด้วย) เช่นเดียวกับString s แทนที่จะเปลี่ยนสถานะของวัตถุห่อหุ้ม วัตถุใหม่ทั้งหมดจะถูกสร้างขึ้นในหน่วยความจำ เหตุใดผู้สร้าง Java จึงตัดสินใจทิ้งประเภทดั้งเดิมไว้ในภาษาในท้ายที่สุด เนื่องจากทุกอย่างควรเป็นอ็อบเจกต์ และเรามีคลาส wrapper ที่สามารถแสดงทุกอย่างที่ภาษาดั้งเดิมแสดงออก ทำไมไม่เพียงแค่เก็บ wrapper ไว้ในภาษาและลบสิ่งดั้งเดิมออก คำตอบนั้นง่าย: ประสิทธิภาพ ประเภทดึกดำบรรพ์เรียกว่าดั้งเดิมเพราะขาดคุณสมบัติ "หนัก" หลายอย่างของวัตถุ ใช่ วัตถุมีวิธีการที่สะดวกมากมาย แต่คุณไม่จำเป็นต้องใช้มันเสมอไป บางครั้งสิ่ง ที่คุณต้องมีคือตัวเลข 33 หรือ 2.62 หรือtrue / false ในสถานการณ์ที่ข้อดีของอ็อบเจกต์ไม่สำคัญและไม่จำเป็นสำหรับการทำงานของโปรแกรม ไพรเมตจะเหมาะสมกับงานมากกว่า