การห่อหุ้มใน Java

สวัสดี! เราจะอุทิศบทเรียนของวันนี้ให้กับ 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;

}

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

1. ตัวดัดแปลงการเข้าถึง ( ส่วนตัว, ป้องกัน, แพ็คเกจเริ่มต้น );
2. ผู้รับและผู้ตั้งค่า

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

การห่อหุ้มทำให้เรามีข้อได้เปรียบที่สำคัญหลายประการ:

1. ตรวจสอบสถานะวัตถุที่ถูกต้อง เราได้ยกตัวอย่างข้างต้น: ขอบคุณ setter และ ตัวดัดแปลง ส่วนตัวทำให้โปรแกรมของเราปลอดภัยจากแมวที่มีน้ำหนักเป็น 0


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


3. การเปลี่ยนแปลงรหัสไม่ส่งผลกระทบต่อผู้ใช้ เราทำการเปลี่ยนแปลงทั้งหมดภายในวิธีการ สิ่งนี้ไม่ส่งผลกระทบต่อผู้ใช้: พวกเขาเขียนvehicle.gas()เพื่อใช้แก๊ส และนั่นคือสิ่งที่พวกเขาจะทำต่อไป ความจริงที่ว่าเราเปลี่ยนบางอย่างใน เมธอด gas()นั้นยังคงมองไม่เห็น: เหมือนเมื่อก่อน พวกมันเพียงแค่ได้รับผลลัพธ์ที่ต้องการ