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


ตอนนี้เรามาพูดถึงการซ่อนข้อมูล
เราใช้กลไกที่ซับซ้อนทุกประเภทโดยไม่เข้าใจว่ามันถูกสร้างขึ้นมาอย่างไรหรือทำงานอย่างไร ง่ายมาก: ผู้สร้างของพวกเขามีอินเทอร์เฟซที่ง่ายและสะดวก ในเครื่องทำโซดา อินเทอร์เฟซคือปุ่มต่างๆ ที่แผงด้านหน้า ปุ่มเดียวช่วยให้คุณเลือกขนาดถ้วยได้ คุณเลือกน้ำเชื่อมด้วยปุ่มที่สอง หนึ่งในสามมีหน้าที่เติมน้ำแข็ง และนั่นคือทั้งหมดที่คุณต้องทำ ไม่สำคัญว่าภายในเครื่องจะเป็นอย่างไร สิ่งสำคัญคือมันถูกออกแบบมาให้ผู้ใช้ดื่มน้ำอัดลมได้โดยการกดสามปุ่ม สิ่งเดียวกันนี้ใช้กับรถยนต์ ไม่สำคัญว่าเกิดอะไรขึ้นข้างใน สิ่งสำคัญคือเมื่อคุณเหยียบแป้นขวา รถจะเคลื่อนที่ไปข้างหน้า และเมื่อคุณเหยียบแป้นซ้าย รถจะช้าลง นี่คือสาระสำคัญของการซ่อนข้อมูล ทุกโปรแกรม' 'อวัยวะภายใน' ถูกซ่อนจากผู้ใช้ ข้อมูลดังกล่าวไม่จำเป็นสำหรับผู้ใช้ ผู้ใช้ต้องการผลลัพธ์สุดท้าย ไม่ใช่กระบวนการภายใน ตัวอย่างเช่น ลองดูที่ประเภทของ ยานพาหนะ :
public class Vehicle {
public void gas() {
/* Some complicated things happen inside a car.
As a result, it moves forward */
}
public void brake() {
/* Some complicated things happen inside a car.
As a result, it slows down */
}
public static void main(String[] args) {
Vehicle vehicle = new Vehicle();
// How everything looks to the user
// Press one pedal, the car moves
vehicle.gas();
// Press the other pedal, the car brakes
vehicle.brake();
}
}
นี่คือวิธีการใช้งานที่ซ่อนอยู่ในโปรแกรม Java เช่นเดียวกับในชีวิตจริง: ผู้ใช้จะได้รับอินเทอร์เฟซ (วิธีการ) ในโปรแกรม ถ้าคุณต้องการรถเพื่อดำเนินการ คุณเพียงแค่เรียกวิธีการที่ต้องการ สิ่งที่เกิดขึ้นภายในวิธีการเหล่านี้เป็นสิ่งที่ไม่จำเป็น สิ่งที่สำคัญคือทุกอย่างทำงานได้ตามที่ควร ที่นี่เรากำลังพูดถึงการซ่อนการใช้งาน Java ยังมีการซ่อนข้อมูล เราเขียนเกี่ยวกับเรื่องนี้ในบทเรียนเกี่ยวกับตัวรับและตัวตั้งแต่เตือนความจำก็ไม่เสียหาย ตัวอย่างเช่น เรามี คลาส Cat :
public class Cat {
public String name;
public int age;
public int weight;
public Cat(String name, int age, int weight) {
this.name = name;
this.age = age;
this.weight = weight;
}
public Cat() {
}
public void sayMeow() {
System.out.println("Meow!");
}
}
บางทีคุณอาจจำบทเรียนที่ผ่านมาได้ว่าปัญหาของชั้นเรียนนี้คืออะไร ถ้าไม่ลองนึกดู ปัญหาคือข้อมูล (ฟิลด์) เปิดให้ทุกคน โปรแกรมเมอร์อีกคนสามารถสร้างแมวนิรนามที่มีน้ำหนัก 0 และอายุ -1,000 ปีได้อย่างง่ายดาย:
public static void main(String[] args) {
Cat cat = new Cat();
cat.name = "";
cat.age = -1000;
cat.weight = 0;
}
ในสถานการณ์นี้ คุณสามารถติดตามได้อย่างรอบคอบว่าเพื่อนร่วมงานคนใดคนหนึ่งของคุณกำลังสร้างออบเจ็กต์ที่มีสถานะไม่ถูกต้องหรือไม่ แต่จะเป็นการดีกว่ามากที่จะกำจัดแม้กระทั่งความเป็นไปได้ในการสร้างออบเจ็กต์ที่ไม่ถูกต้องเหล่านี้ 
- ตัวดัดแปลงการเข้าถึง ( ส่วนตัว, ป้องกัน, แพ็คเกจเริ่มต้น );
- ผู้รับและผู้ตั้งค่า
การห่อหุ้มทำให้เรามีข้อได้เปรียบที่สำคัญหลายประการ:
- ตรวจสอบสถานะวัตถุที่ถูกต้อง เราได้ยกตัวอย่างข้างต้น: ขอบคุณ setter และ ตัวดัดแปลง ส่วนตัวทำให้โปรแกรมของเราปลอดภัยจากแมวที่มีน้ำหนักเป็น 0
- ส่วนต่อประสานที่ใช้งานง่าย เราปล่อยให้วิธีการเปิดเผยต่อผู้ใช้เท่านั้น ผู้ใช้เพียงแค่ต้องโทรหาพวกเขาเพื่อรับผลลัพธ์ และไม่จำเป็นต้องลงลึกในรายละเอียดว่าทำงานอย่างไร
- การเปลี่ยนแปลงรหัสไม่ส่งผลกระทบต่อผู้ใช้ เราทำการเปลี่ยนแปลงทั้งหมดภายในวิธีการ สิ่งนี้ไม่ส่งผลกระทบต่อผู้ใช้: พวกเขาเขียนvehicle.gas()เพื่อใช้แก๊ส และนั่นคือสิ่งที่พวกเขาจะทำต่อไป ความจริงที่ว่าเราเปลี่ยนบางอย่างใน เมธอด gas()นั้นยังคงมองไม่เห็น: เหมือนเมื่อก่อน พวกมันเพียงแค่ได้รับผลลัพธ์ที่ต้องการ
อ่านเพิ่มเติม: |
---|
GO TO FULL VERSION