คู่มือฉบับสมบูรณ์เกี่ยวกับ Getters และ Setters ใน Java: ศิลปะแห่งการเข้าถึงแบบควบคุม

อินฟอร์เมเทค ดิจิตอล » การเขียนโปรแกรม » คู่มือฉบับสมบูรณ์เกี่ยวกับ Getters และ Setters ใน Java: ศิลปะแห่งการเข้าถึงแบบควบคุม

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

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

Getters และ setters ใน Java คืออะไร?

ในภาษา Java หลักการห่อหุ้ม (encapsulation) นำเราไปสู่การปกป้องคุณสมบัติของคลาสโดยการกำหนดให้เป็นprivate ซึ่งจะป้องกันไม่ให้บุคคลภายนอกเข้าถึงหรือแก้ไขคุณสมบัติเหล่านั้นได้อย่างอิสระ ทำให้ระบบมีความปลอดภัยและสอดคล้องกันมากขึ้น อย่างไรก็ตาม คุณสมบัติเหล่านี้มักจำเป็นต้องถูกสอบถามหรือแก้ไขจากภายนอก นี่คือจุดที่เมธอดgetter และ setter เข้ามามี บทบาท ซึ่งเป็นเมธอดสาธารณะที่ออกแบบมาโดยเฉพาะเพื่อรับ (get) หรือแก้ไข (set) ค่าของฟิลด์ส่วนตัวเหล่านี้

รูปแบบนี้พบได้ทั่วไปมากจนสภาพแวดล้อมการพัฒนาแบบบูรณาการ (IDE) เช่น IntelliJ IDEA หรือ Eclipse ช่วยให้คุณสร้างรูปแบบดังกล่าวได้โดยอัตโนมัติ ตัวอย่างเช่น สำหรับคลาสธรรมดา:

ตัวอย่างคลาสพื้นฐานที่มี getters และ setters

คลาสสาธารณะ Person { ชื่อสตริงส่วนตัว; อายุส่วนตัว int; สาธารณะ String getName() { กลับชื่อ; } สาธารณะ void setName(ชื่อสตริง) { this.name = ชื่อ; } สาธารณะ int getAge() { กลับอายุ; } สาธารณะ void setAge(อายุ int) { this.age = อายุ; } }

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

เหตุใดจึงต้องใช้ getters และ setters การห่อหุ้มและการควบคุมการเข้าถึง

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

ลองมาดู คลาส Catที่มีแอตทริบิวต์สาธารณะกันเป็นตัวอย่าง:

คลาสสาธารณะ Cat { public String name; public int age; public int weight; }

ในกรณีนี้ โค้ดภายนอกใด ๆ ก็สามารถดำเนินการดังต่อไปนี้:

แมว cat = แมวใหม่(); cat.name = ""; cat.age = -1000; cat.weight = 0;

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

public void setAge(int age) { if (age >= 0) { this.age = age; } else { System.out.println("Error! อายุไม่สามารถเป็นค่าลบได้!"); } }

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

ข้อดีของ getters และ setters ใน Java

รูปแบบนี้มีข้อดีหลายประการ:

• การป้องกันข้อมูล:การทำให้แอตทริบิวต์เป็นส่วนตัว จะช่วยป้องกันการเข้าถึงและการแก้ไขแบบไม่เลือกปฏิบัติ
• การตรวจสอบแบบรวมศูนย์:ผู้ตั้งค่าสามารถรวมการตรวจสอบก่อนที่จะกำหนดค่า เพื่อให้แน่ใจว่าเป็นไปตามกฎทางธุรกิจหรือความซื่อสัตย์
• ความยืดหยุ่นในอนาคต- หากเมื่อใดก็ตามคุณต้องการเปลี่ยนแปลงการแสดงภายในของข้อมูลชิ้นหนึ่ง (เช่น คำนวณอายุจากวันเกิด) คุณสามารถทำได้ภายในตัวรับข้อมูลโดยไม่ต้องเปลี่ยนแปลงส่วนอื่นๆ ของโค้ดที่ใช้ข้อมูลนั้นอยู่
• ความเข้ากันได้ของกรอบงานเฟรมเวิร์กและไลบรารี Java จำนวนมาก (เช่น Hibernate, Spring, ตัวซีเรียลไลเซอร์/ดีซีเรียลไลเซอร์ JSON) ต้องมีตัวรับและตัวกำหนดจึงจะทำงานได้อย่างถูกต้อง

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

ตัวอย่างการปฏิบัติจริงและโครงสร้างทั่วไป

กลับมาที่ตัวอย่างที่เว็บไซต์ยอดนิยมหลายแห่งนำเสนอ คลาส Accountมักปรากฏในบทเรียนเพื่ออธิบายแนวคิดนี้:

คลาส Account { private double balance; private double limit; public double getBalance() { return balance; } public void setBalance(double balance) { this.balance = balance; } public double getLimite() { return limit; } public void setLimite(double limit) { this.limit = limit; } }

โครงสร้างนี้แม้จะใช้งานได้จริง แต่ได้รับการวิพากษ์วิจารณ์เมื่อไม่นานมานี้ว่าส่งเสริมการแพร่กระจายของวิธีการต่างๆ ซึ่งในหลายๆ กรณีไม่มีจุดประสงค์ ปัญหาที่พบบ่อยที่สุดประการหนึ่งคือการสร้าง getter และ setter อย่างไม่เลือกปฏิบัติโดยไม่ได้ประเมินว่าสิ่งเหล่านี้จำเป็นต่อการออกแบบหรือตรรกะทางธุรกิจหรือไม่

ความเสี่ยงและแนวทางปฏิบัติที่ไม่ดี: เมื่อใดที่ไม่ควรใช้งาน getters และ setters มากเกินไป?

การสร้าง getter และ setter ทั้งหมดโดยอัตโนมัติอาจนำไปสู่สิ่งที่เรียกว่าคลาสที่อ่อนแอ หรือ "คลาสหุ่นเชิด " ซึ่งทำหน้าที่เป็นเพียงที่เก็บข้อมูลโดยไม่มีตรรกะของตัวเอง ซึ่งอาจส่งผลเสียหลายประการ:

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

ตัวอย่างเช่น การตั้งยอดเงินในบัญชีธนาคารโดยใช้ `setBalance()` อาจไม่เหมาะสม: ควรใช้วิธีการเฉพาะเจาะจง เช่น `deposit()` หรือ `withdraw()` ที่ครอบคลุมกฎเกณฑ์ที่เกี่ยวข้อง (เช่น การตรวจสอบวงเงินในบัญชีเมื่อทำการถอนเงิน) ซึ่งจะทำให้โค้ดชัดเจนและแข็งแกร่งยิ่งขึ้น

สาธารณะ void ฝาก (double x) { this.balance += x; } สาธารณะ void รับ (double x) { ถ้า this.balance + this.limit >= x) { this.balance -= x; } อื่น ๆ { โยน IllegalArgumentException ใหม่ ("เกินขีดจำกัด!"); } }

วิธีนี้ช่วยป้องกันการจัดการสมดุลจากภายนอก และช่วยรักษาความสมบูรณ์ของระบบ

แนวทางปฏิบัติที่ดีเมื่อนำ getters และ setters มาใช้

จากประสบการณ์ที่แบ่งปันกันในบทความทางเทคนิคและบล็อกต่างๆ มากมาย มีคำแนะนำหลายประการสำหรับการใช้ getters และ setters อย่างสมเหตุสมผล:

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

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

ทางเลือกและรูปแบบที่ทันสมัย

วิวัฒนาการของ Java และรูปแบบการออกแบบเสนอทางเลือกที่น่าสนใจสำหรับการใช้ getters และ setters แบบดั้งเดิม:

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

ตัวอย่างเช่น สำหรับเอนทิตีที่ไม่เปลี่ยนแปลง คุณสามารถดำเนินการเช่นนี้ได้:

คลาสสาธารณะ Person { ส่วนตัว สุดท้าย String name; ส่วนตัว สุดท้าย int age; สาธารณะ Person(String name, int age) { this.name = Objects.requireNonNull(name); this.age = Objects.requireNonNull(age); } สาธารณะ String getName() { return name; } สาธารณะ int getAge() { return age; } }

มีเพียงวิธี getter เท่านั้น และอ็อบเจ็กต์จะไม่สามารถเปลี่ยนสถานะหลังจากสร้างได้ นี่เป็นเทคนิคที่แนะนำอย่างยิ่งสำหรับเอนทิตีที่ไม่ควรปรับเปลี่ยน

Getters และ setters ในบริบทของเฟรมเวิร์กและไลบรารี

เมธอด getter และ setter ไม่ได้ถูกใช้เพื่อเหตุผลด้านการออกแบบเสมอไป บางครั้งมันก็เป็นสิ่งที่จำเป็นตามข้อกำหนดของเฟรมเวิร์กบางอย่าง ตัวอย่างเช่น ไลบรารี ORM อย่าง Hibernate หรือเครื่องมือสำหรับการแปลงข้อมูลเป็นอ็อบเจ็กต์และการแปลงกลับ (เช่นBLOB ) ต้องการให้เอนทิตีมีเมธอดสาธารณะสำหรับการเข้าถึงแอตทริบิวต์ ดังนั้น นักพัฒนาจำนวนมากจึงถูกบังคับให้รวมเมธอดเหล่านี้ แม้ว่าจะเพื่อตอบสนองข้อกำหนดทางเทคนิคเหล่านี้ก็ตาม

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

คุณควรสร้างตัวรับและตัวกำหนดเสมอหรือไม่ ความคิดสุดท้าย

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

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

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