Object-Oriented Programming หรือที่รู้จักกันดีในชื่อ OOPs เป็นหนึ่งในเสาหลักของ Java ที่ใช้ประโยชน์จากพลังและความสะดวกในการใช้งาน ในการเป็นนักพัฒนา Java มืออาชีพคุณต้องได้รับการควบคุมอย่างไร้ที่ติสำหรับสิ่งต่างๆ ชอบ , สิ่งที่เป็นนามธรรม , Encapsulation และ Polymorphism จากสื่อของบทความนี้ฉันจะให้ข้อมูลเชิงลึกที่สมบูรณ์เกี่ยวกับแนวคิดที่สำคัญที่สุดประการหนึ่งของ OOPs นั่นคือการห่อหุ้มใน Java และวิธีการบรรลุผล
ด้านล่างนี้เป็นหัวข้อที่ฉันจะพูดถึงในบทความนี้:
- รู้เบื้องต้นเกี่ยวกับการห่อหุ้ม
- ทำไมเราต้อง Encapsulation ใน Java?
- ประโยชน์ของการห่อหุ้ม
- ตัวอย่างแบบเรียลไทม์
คุณสามารถดูการบันทึกนี้ของไฟล์ ซึ่งคุณสามารถทำความเข้าใจหัวข้อโดยละเอียดพร้อมตัวอย่าง
สถาปัตยกรรม mvc ใน java พร้อมตัวอย่าง
รู้เบื้องต้นเกี่ยวกับการห่อหุ้ม
Encapsulation หมายถึงการรวมข้อมูลภายใต้หน่วยเดียว เป็นกลไกที่ผูกรหัสและข้อมูลที่จัดการ อีกวิธีหนึ่งในการคิดเกี่ยวกับการห่อหุ้มคือมันเป็นเกราะป้องกันที่ป้องกันไม่ให้รหัสเข้าถึงข้อมูลภายนอกโล่นี้ ในสิ่งนี้ตัวแปรหรือข้อมูลของไฟล์ ถูกซ่อนจากคลาสอื่น ๆ และสามารถเข้าถึงได้ผ่านฟังก์ชันสมาชิกของคลาสของตัวเองที่ประกาศไว้เท่านั้น
ตอนนี้เรามาดูตัวอย่างของแคปซูลทางการแพทย์ซึ่งยาจะปลอดภัยเสมอในแคปซูล ในทำนองเดียวกันวิธีการและตัวแปรของคลาสจะถูกซ่อนไว้อย่างดีและปลอดภัยผ่านการห่อหุ้ม
การห่อหุ้มใน Java สามารถทำได้โดย:
- การประกาศตัวแปรของคลาสเป็นส่วนตัว
- ให้ public setter และ getter method เพื่อปรับเปลี่ยนและดูค่าตัวแปร
ตอนนี้เรามาดูโค้ดเพื่อทำความเข้าใจเกี่ยวกับการห่อหุ้มให้ดีขึ้น:
คลาสสาธารณะ Student {private String name public String getName () {return name} public void setName (String name) {this.name = name}} class Test {public static void main (String [] args) {Student s = new Student () s.setName ('แฮร์รี่พอตเตอร์') System.out.println (s.getName ())}} ดังที่คุณเห็นในรหัสด้านบนฉันได้สร้างชั้นเรียน Student ที่มีส่วนตัว ชื่อ . ต่อไปฉันได้สร้าง getter และ setter เพื่อรับและตั้งชื่อนักเรียน ด้วยความช่วยเหลือของวิธีการเหล่านี้คลาสใด ๆ ที่ต้องการเข้าถึงตัวแปร name จะต้องทำโดยใช้วิธี getter และ setter เหล่านี้
ตอนนี้เรามาดูอีกหนึ่งตัวอย่างและทำความเข้าใจเกี่ยวกับ Encapsulation ในเชิงลึก ในตัวอย่างนี้คลาส Car มีสองช่องชื่อและ topSpeed ที่นี่ทั้งสองประกาศว่าเป็นส่วนตัวหมายความว่าไม่สามารถเข้าถึงได้โดยตรงจากภายนอกชั้นเรียน เรามีเมธอด getter และ setter บางอย่างเช่น getName, setName, setTopSpeed เป็นต้นและจะประกาศเป็นสาธารณะ วิธีการเหล่านี้เปิดเผยต่อ 'บุคคลภายนอก' และสามารถใช้เพื่อเปลี่ยนแปลงและดึงข้อมูลจากวัตถุรถยนต์ เรามีวิธีการหนึ่งในการตั้งค่าความเร็วสูงสุดของยานพาหนะและวิธี getter สองวิธีในการดึงค่าความเร็วสูงสุดไม่ว่าจะเป็น MPH หรือ KMHt โดยพื้นฐานแล้วนี่คือสิ่งที่การห่อหุ้มทำ - มันซ่อนการใช้งานและให้ค่าที่เราต้องการ ตอนนี้เรามาดูโค้ดด้านล่างนี้
package Edureka public class Car {private String name private double topSpeed public Car () {} public String getName () {return name} public void setName (String name) {this.name = name} public void setTopSpeed (double speedMPH) {topSpeed = speedMPH} public double getTopSpeedMPH () {return topSpeed} public double getTopSpeedKMH () {return topSpeed * 1.609344}}ที่นี่โปรแกรมหลักจะสร้างวัตถุรถยนต์ด้วยชื่อที่กำหนดและใช้วิธีการ setter เพื่อจัดเก็บความเร็วสูงสุดสำหรับอินสแตนซ์นี้ ด้วยการทำเช่นนี้เราสามารถรับความเร็วเป็น MPH หรือ KMH ได้อย่างง่ายดายโดยไม่ต้องสนใจว่าจะแปลงความเร็วอย่างไรในคลาสรถยนต์
package Edureka public class ตัวอย่าง {public static void main (String args []) Car car = new Car () car.setName ('Mustang GT 4.8-litre V8') car.setTopSpeed (201) System.out.println (car. getName () + 'ความเร็วสูงสุดใน MPH คือ' + car.getTopSpeedMPH ()) System.out.println (car.getName () + 'ความเร็วสูงสุดใน KMH คือ' + car.getTopSpeedKMH ())สo นี่คือวิธีที่ Encapsulation สามารถทำได้ใน Java ตอนนี้เรามาดูกันว่าทำไมเราจึงต้องใช้ Encapsulation
ทำไมเราต้อง Encapsulation ใน Java?
การห่อหุ้มเป็นสิ่งสำคัญใน Java เนื่องจาก:
- ควบคุมวิธีการเข้าถึงข้อมูล
- แก้ไขรหัสตามข้อกำหนด
- ช่วยให้เราบรรลุคู่หลวม
- บรรลุความเรียบง่ายของแอปพลิเคชันของเรา
- นอกจากนี้ยังช่วยให้คุณสามารถเปลี่ยนส่วนของรหัสโดยไม่รบกวนฟังก์ชันหรือรหัสอื่น ๆ ที่มีอยู่ในโปรแกรม
ตอนนี้เรามาดูตัวอย่างเล็ก ๆ ที่แสดงให้เห็นถึงความจำเป็นในการห่อหุ้ม
class Student {int id String name} public class Demo {public static void main (String [] args) {Student s = new Student () s.id = 0 s.name = '' s.name = null}}ในตัวอย่างข้างต้นประกอบด้วยตัวแปรอินสแตนซ์สองตัวเป็นตัวปรับการเข้าถึง ดังนั้นคลาสใด ๆ ภายในแพ็กเกจเดียวกันสามารถกำหนดและเปลี่ยนแปลงค่าของตัวแปรเหล่านั้นได้โดยการสร้างอ็อบเจกต์ของคลาสนั้น ดังนั้นเราจึงไม่สามารถควบคุมค่าที่เก็บไว้ในชั้นเรียนของนักเรียนเป็นตัวแปรได้ เพื่อแก้ปัญหานี้เราได้สรุปชั้นนักเรียน
ดังนั้นนี่คือตัวชี้บางส่วนที่แสดงถึงความต้องการของ Encapsulation ตอนนี้เรามาดูประโยชน์ของการห่อหุ้มกัน
ประโยชน์ของการห่อหุ้ม
- การซ่อนข้อมูล: ที่นี่ผู้ใช้จะไม่มีความคิดเกี่ยวกับการนำชั้นเรียนไปใช้งานภายใน แม้แต่ผู้ใช้จะไม่ทราบว่าคลาสนั้นเก็บค่าในตัวแปรอย่างไร เขา / เธอจะทราบเพียงว่าเรากำลังส่งผ่านค่าไปยังเมธอด setter และตัวแปรจะเริ่มต้นด้วยค่านั้น
- เพิ่มความยืดหยุ่น: ที่นี่เราสามารถทำให้ตัวแปรของคลาสเป็นแบบอ่านอย่างเดียวหรือเขียนอย่างเดียวขึ้นอยู่กับความต้องการของเรา ในกรณีที่คุณต้องการทำให้ตัวแปรเป็นแบบอ่านอย่างเดียวเราต้องละเว้นเมธอด setter เช่น setName ()setAge() เป็นต้นหรือหากเราต้องการให้ตัวแปรเป็นแบบเขียนอย่างเดียวเราต้องละเว้นเมธอด get เช่น getName (), getAge () เป็นต้นจากโปรแกรมด้านบน
- การนำกลับมาใช้ใหม่: นอกจากนี้ยังปรับปรุงการใช้งานซ้ำและเปลี่ยนแปลงได้ง่ายตามข้อกำหนดใหม่ ๆ
เมื่อเราเข้าใจพื้นฐานของการห่อหุ้มแล้วเรามาเจาะลึกหัวข้อสุดท้ายของบทความนี้และทำความเข้าใจเกี่ยวกับการห่อหุ้มโดยละเอียดด้วยความช่วยเหลือของตัวอย่างแบบเรียลไทม์
ตัวอย่างการห่อหุ้มแบบเรียลไทม์
ลองพิจารณาตัวอย่างทางโทรทัศน์และทำความเข้าใจว่ารายละเอียดการใช้งานภายในถูกซ่อนจากชั้นเรียนภายนอกอย่างไรโดยทั่วไปในตัวอย่างนี้เรากำลังซ่อนข้อมูลโค้ดภายในเช่นวงจรจากโลกภายนอกโดยฝาครอบ ตอนนี้ใน ซึ่งสามารถทำได้ด้วยความช่วยเหลือของตัวปรับแต่งการเข้าถึง ตัวปรับแต่งการเข้าถึงตั้งค่าการเข้าถึงหรือระดับของคลาสตัวแปรคอนสตรัคเตอร์เป็นต้นดังที่คุณเห็นในโค้ดด้านล่างฉันได้ใช้ตัวปรับการเข้าถึงส่วนตัวเพื่อ จำกัด ระดับการเข้าถึงของคลาส ตัวแปรที่ประกาศว่าเป็นส่วนตัวสามารถเข้าถึงได้ภายในคลาสโทรทัศน์เท่านั้น
โทรทัศน์ระดับสาธารณะ {private double width private double height private double Screensize private int maxVolume print int volume private boolean power public Television (double width, double height, double screenSize) {this.width this.height this.screenSize = ScreenSize} public double channelTuning (int channel) {switch (channel) {case1: return 34.56 case2: return 54.89 case3: return 73.89 case1: return 94.98} return 0} public int reductionVolume () {if (0volume) volume ++ return volume}} class test {public static เป็นโมฆะ main (String args []) {Television t = new Television (11.5,7,9) t.powerSwitch () t.channelTuning (2) t.decreaseVolume () t.increaseVolume () Television. // เกิดข้อผิดพลาดเนื่องจากตัวแปรเป็นส่วนตัวและไม่สามารถเข้าถึงนอกคลาสได้}}ในตัวอย่างข้างต้นฉันได้ประกาศตัวแปรทั้งหมดเป็นส่วนตัวและวิธีการตัวสร้างและคลาสเป็นสาธารณะ ที่นี่ผู้สร้างวิธีการสามารถเข้าถึงได้นอกชั้นเรียน เมื่อฉันสร้างวัตถุของคลาสโทรทัศน์สามารถเข้าถึงวิธีการและตัวสร้างที่มีอยู่ในคลาสได้ในขณะที่ตัวแปรที่ประกาศด้วยตัวปรับการเข้าถึงส่วนตัวจะถูกซ่อนไว้ นั่นคือเหตุผลที่เมื่อคุณพยายามเข้าถึง ตัวแปรความกว้าง ในตัวอย่างข้างต้นมันพ่นข้อผิดพลาด. นั่นคือรายละเอียดการใช้งานภายในที่ซ่อนจากคลาสอื่น ๆ นี่คือวิธีการบรรลุการ Encapsulation ใน Java
เป็นระดับสูงกว่าปริญญาตรีเช่นเดียวกับปริญญาโท
เรามาถึงตอนท้ายของบทความเรื่อง“ Encapsulation in Java” หวังว่าคุณจะพบว่ามันให้ข้อมูลและช่วยเพิ่มมูลค่าให้กับความรู้ของคุณ หากคุณต้องการเรียนรู้เพิ่มเติมเกี่ยวกับ Java คุณสามารถอ้างถึงไฟล์
เมื่อคุณเข้าใจแล้ว“ Encapsulation ใน Java คืออะไร” ลองดูไฟล์ โดย Edureka บริษัท การเรียนรู้ออนไลน์ที่เชื่อถือได้ซึ่งมีเครือข่ายผู้เรียนที่พึงพอใจมากกว่า 250,000 คนกระจายอยู่ทั่วโลก หลักสูตรการฝึกอบรมและการรับรอง Java J2EE และ SOA ของ Edureka ออกแบบมาสำหรับนักเรียนและผู้เชี่ยวชาญที่ต้องการเป็น Java Developer หลักสูตรนี้ออกแบบมาเพื่อให้คุณเริ่มต้นการเขียนโปรแกรม Java และฝึกอบรมแนวคิด Java ทั้งหลักและขั้นสูงพร้อมกับเฟรมเวิร์ก Java ต่างๆเช่น Hibernate & Spring
มีคำถามสำหรับเรา? โปรดระบุไว้ในส่วนความคิดเห็นของบล็อก 'Encapsulation in Java' และเราจะติดต่อกลับโดยเร็วที่สุด