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

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

public class Auto {

   public void gas() {

       /*some complicated things are happening inside the car
       as a result of which it goes forward*/
   }

   public void brake() {

       /*some complicated things are happening inside the car
       as a result of which it slows down*/
   }

   public static void main(String[] args) {

       Auto auto = new Auto();

       // How everything looks to the user

       //pressed one pedal - went
       auto.gas();

       //pressed another pedal - braked
       auto.brake();
   }
}

นี่คือลักษณะการซ่อนการใช้งานในโปรแกรม Java ทุกอย่างเหมือนในชีวิตจริง: ผู้ใช้ได้รับอินเทอร์เฟซ (วิธีการ) หากเขาต้องการให้รถในโปรแกรมดำเนินการ เขาก็ต้องเรียกวิธีการที่ต้องการ และสิ่งที่เกิดขึ้นภายในวิธีการเหล่านี้คือข้อมูลที่ไม่จำเป็น สิ่งสำคัญคือทุกอย่างทำงานได้ตามปกติ ที่นี่เราพูดคุยเกี่ยวกับการซ่อนการดำเนินการ นอกจากนี้ Java ยังมีการซ่อนข้อมูลด้วย เราเขียนเกี่ยวกับเรื่องนี้ในการบรรยายเกี่ยวกับ getters และ settersแต่การเตือนคุณก็ไม่เสียหาย ตัวอย่างเช่น เรามีคลาส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 และ private modifier ที่ทำให้เราปกป้องโปรแกรมของเราจากแมวที่มีน้ำหนัก 0


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


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