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

Encapsulation คืออะไร Java?

การห่อหุ้มใน Java เป็นกลไกในการรวมตัวแปร (ข้อมูล) และเมธอด (โค้ด) เข้าด้วยกันเป็นหน่วยเดียว เป็นกระบวนการซ่อนรายละเอียดข้อมูลและปกป้องข้อมูลและพฤติกรรมของอ็อบเจ็กต์ เป็นหนึ่งในแนวคิด OOP ที่สำคัญสี่ประการ คลาส encapsulate นั้นทดสอบได้ง่าย จึงเหมาะสำหรับการทดสอบยูนิตด้วย

คลิก Good Farm Animal Welfare Awards หากไม่สามารถเข้าถึงวิดีโอได้

เรียนรู้การห่อหุ้มใน Java พร้อมตัวอย่าง

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

class Account {
    private int account_number;
    private int account_balance;

    public void show Data() {
        //code to show data 
    }

    public void deposit(int a) {
        if (a < 0) {
            //show error 
        } else
            account_balance = account_balance + a;
    }
}

สมมติว่าแฮกเกอร์สามารถเข้าถึงรหัสบัญชีธนาคารของคุณได้ ตอนนี้เขาพยายามฝากเงินจำนวน -100 เข้าบัญชีของคุณโดยใช้สองวิธี มาดูวิธีแรกหรือแนวทางของเขากัน

แนวทางที่ 1: เขาพยายามฝากเงินจำนวนที่ไม่ถูกต้อง (เช่น -100) เข้าบัญชีธนาคารของคุณโดยจัดการรหัส

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

หากข้อมูลสมาชิกเป็นแบบส่วนตัว แสดงว่าสามารถเข้าถึงได้เฉพาะภายในคลาสเดียวกันเท่านั้น คลาสภายนอกไม่สามารถเข้าถึงข้อมูลสมาชิกส่วนตัวหรือตัวแปรของคลาสอื่นได้ ดังนั้นในกรณีของเรา แฮกเกอร์ไม่สามารถฝากเงิน -100 เข้าบัญชีของคุณได้

แนวทาง 2:วิธีการแรกของแฮกเกอร์ล้มเหลวในการฝากเงินจำนวนดังกล่าว ต่อมาเขาพยายามฝากเงินจำนวน -100 โดยใช้วิธีการ "ฝากเงิน"

แต่การนำวิธีการไปใช้นั้นมีการตรวจสอบค่าลบ ดังนั้นแนวทางที่สองก็ล้มเหลวเช่นกัน

ดังนั้นคุณจะไม่เปิดเผยข้อมูลของคุณแก่บุคคลภายนอก ซึ่งทำให้ใบสมัครของคุณปลอดภัย

รหัสทั้งหมดสามารถคิดได้ว่าเป็นแคปซูล และคุณสามารถสื่อสารได้ผ่านทางข้อความเท่านั้น ดังนั้นจึงเรียกว่าการห่อหุ้ม

ข้อมูลที่ซ่อนอยู่ใน Java

ข้อมูลที่ซ่อนอยู่ใน Java คือการซ่อนตัวแปรของคลาสจากคลาสอื่น ซึ่งสามารถเข้าถึงได้ผ่านเมธอดของคลาสปัจจุบันเท่านั้น เป็นการซ่อนรายละเอียดการใช้งานจากผู้ใช้ แต่นอกจากการซ่อนข้อมูลแล้ว ยังมีจุดประสงค์เพื่อการจัดการหรือการจัดกลุ่มข้อมูลที่เกี่ยวข้องที่ดีขึ้น เพื่อให้บรรลุระดับการห่อหุ้มที่น้อยลง Javaคุณสามารถใช้ตัวปรับแต่ง เช่น “protected” หรือ “public” ได้ ด้วยการห่อหุ้ม นักพัฒนาสามารถเปลี่ยนแปลงส่วนหนึ่งของโค้ดได้อย่างง่ายดายโดยไม่ส่งผลกระทบต่อส่วนอื่น

Getter และ Setter ใน Java

Getter และ Setter ใน Java เป็นสองวิธีทั่วไปที่ใช้ในการดึงและอัพเดตค่าของตัวแปร ส่วนใหญ่จะใช้เพื่อสร้าง แก้ไข ลบ และดูค่าตัวแปร เมธอด setter ใช้สำหรับอัพเดตค่า และเมธอด getter ใช้สำหรับอ่านหรือดึงค่า พวกมันยังเป็นที่รู้จักในชื่อ accessor และ mutator

โค้ดต่อไปนี้เป็นตัวอย่างของวิธี getter และ setter:

class Account{ 
private int account_number;
private int account_balance; 
    // getter method
	public int getBalance() {
        return this.account_balance;
    }
    // setter method
	public void setNumber(int num) {
        this.account_number = num;
    }
}

ในตัวอย่างข้างต้น เมธอด getBalance() คือเมธอด getter ที่อ่านค่าของตัวแปร account_balance และเมธอด setNumber() คือเมธอด setter ที่ตั้งค่าหรืออัพเดตค่าสำหรับตัวแปร account_number

สิ่งที่เป็นนามธรรมกับการห่อหุ้ม

การห่อหุ้มมักถูกเข้าใจผิดด้วย สิ่งที่เป็นนามธรรม- มาเรียนกันเถอะ-

• การห่อหุ้มเป็นเรื่องเกี่ยวกับ "วิธีการ" เพื่อให้ได้ฟังก์ชันการทำงานมากกว่า
• นามธรรมเป็นเรื่องเกี่ยวกับ "อะไร" ที่ชั้นเรียนสามารถทำได้มากกว่า

ตัวอย่างง่ายๆ ในการทำความเข้าใจความแตกต่างนี้คือโทรศัพท์มือถือ ซึ่งตรรกะที่ซับซ้อนในแผงวงจรจะถูกห่อหุ้มไว้ในหน้าจอสัมผัส และมีอินเทอร์เฟซที่จัดเตรียมไว้เพื่อแยกตรรกะเหล่านี้ออกมา

ข้อดีของการห่อหุ้มใน Java

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