รู้เกี่ยวกับตัวสร้างพารามิเตอร์ใน Java พร้อมตัวอย่าง

บทความนี้ครอบคลุมถึงวิธีที่เราสามารถใช้ตัวสร้างพารามิเตอร์ใน java พร้อมตัวอย่างต่างๆและความแตกต่างระหว่างตัวสร้างเริ่มต้นและตัวสร้างพารามิเตอร์

Java เป็นหนึ่งในภาษาโปรแกรมต่างๆที่ตามมา . นั่นหมายความว่าในขณะที่เขียนโปรแกรมใน Java เรามีคุณสมบัติที่มีประสิทธิภาพทั้งหมดของ Data Abstraction, Polymorphism, Inheritance เป็นต้นหลักของคุณสมบัติ OOP ทั้งหมดคือการใช้งาน Classes และ Objects และการโต้ตอบระหว่างกัน ในบทความนี้เราจะดูวิธีการเริ่มต้นวัตถุโดยใช้ตัวสร้างพารามิเตอร์ใน . โปรดทราบว่าความเข้าใจพื้นฐานของ จำเป็นก่อนที่คุณจะดำเนินการก่อสร้างต่อไป



วิธีจัดการหน้าต่างป๊อปอัปในเว็บไขควงซีลีเนียม

ตัวสร้างคืออะไร?

ตัวสร้างเป็นวิธีการที่เรียกโดยอัตโนมัติเมื่อมีการสร้างวัตถุ (อินสแตนซ์) ของคลาสนั้น ใช้เพื่อเริ่มต้นสมาชิกข้อมูลของออบเจ็กต์

คลาสสาธารณะ Edureka {Edureka () {System.out.println ('constructor is made')}}

คุณสมบัติบางอย่างของตัวสร้าง ได้แก่ :

  1. มันมีชื่อเดียวกับชื่อชั้น
  2. ไม่มีประเภทผลตอบแทน

ประเภทของตัวสร้าง

  1. ตัวสร้างเริ่มต้น
  2. ตัวสร้างพารามิเตอร์

ประเภทของตัวสร้างที่กำหนดพารามิเตอร์ตัวสร้างใน java-edureka



ตัวสร้างเริ่มต้นเทียบกับตัวสร้างพารามิเตอร์

ตัวสร้างเริ่มต้น - ตัวสร้างที่ไม่ยอมรับพารามิเตอร์เรียกว่า Default Constructor ไม่จำเป็นต้องมีคอนสตรัคเตอร์บล็อกในนิยามคลาสของคุณ หากคุณไม่ได้เขียนตัวสร้างอย่างชัดเจนคอมไพลเลอร์จะแทรกตัวสร้างให้คุณโดยอัตโนมัติ

ตัวอย่างการแสดง Default Constructor ใน Java:

คลาสสาธารณะ Edureka {Edureka () {System.out.println ('I am a constructor')} public static void main (String args []) {Edureka obj = new Edureka ()}}
 เอาท์พุต: ฉันเป็นคนสร้าง

ตัวสร้างพารามิเตอร์ - ตัวสร้างเรียกว่า Parameterized Constructor เมื่อยอมรับพารามิเตอร์จำนวนหนึ่ง เพื่อเริ่มต้นข้อมูลสมาชิกของคลาสด้วยค่าที่แตกต่างกัน



ตัวอย่างที่แสดงให้เห็นถึงตัวสร้างพารามิเตอร์:

คลาสสาธารณะ Edureka {String studentName int studentAge // constructor Edureka (String name, int age) {studentName = name studentAge = age} void display () {System.out.println (studentName + '' + studentAge)} public static void main ( สตริง args []) {Edureka myObj = new Edureka ('Manan', 19) myObj.display ()}}
 เอาท์พุต: มาแนน -19

ในตัวอย่างข้างต้นเรากำลังส่งสตริงและจำนวนเต็มไปยังวัตถุ จากนั้นตัวสร้างเริ่มต้น studentName และ studentAge โดยใช้ค่าที่ผ่าน วิธีการแสดงผลจะให้ผลลัพธ์ที่ต้องการ

ด้วยตัวสร้างพารามิเตอร์สำหรับคลาสหนึ่งต้องระบุค่าเริ่มต้นเป็นอาร์กิวเมนต์มิฉะนั้นคอมไพเลอร์จะรายงานข้อผิดพลาด

การส่งผ่านวัตถุเป็นอาร์กิวเมนต์

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

ตัวอย่างที่แสดงการส่งผ่านวัตถุเป็นอาร์กิวเมนต์:

คลาสสาธารณะ Edureka {String studentName Edureka (String name) {studentName = name} Edureka (Edureka myObj) {this.studentName = myObj.studentName} void display () {System.out.println ('Student:' + studentName)} public Static void main (String args []) {Edureka obj1 = new Edureka ('Manan') / * ส่งผ่านวัตถุเป็นอาร์กิวเมนต์สำหรับตัวสร้าง * สิ่งนี้จะเรียกตัวสร้างการคัดลอก * / Edureka obj2 = ระบบ Edureka (obj1) ใหม่ out.println ('การพิมพ์ obj1 -') obj1.display () System.out.println ('การพิมพ์ obj2 -') obj2.display ()}}
 เอาท์พุต: 
วัตถุการพิมพ์ 1 -มานวัตถุการพิมพ์ 2 -มาน

ในตัวอย่างข้างต้นเราเริ่มต้น obj1 โดยใช้สตริง จากนั้นเราส่ง obj1 เป็นอาร์กิวเมนต์ในขณะที่สร้าง obj2 สุดท้ายเมื่อเราพิมพ์ตัวแปร studentName ของออบเจ็กต์ทั้งสองโดยใช้ฟังก์ชันการแสดงผลเราจะได้รับ“ Manan”

การเรียกใช้ Default Constructor จากตัวสร้างพารามิเตอร์ใน Java

บางครั้งจำเป็นต้องเรียกใช้ตัวสร้างเริ่มต้นจากตัวสร้างอื่นในคลาสเดียวกัน คำหลักนี้ บรรลุวัตถุประสงค์นี้

ตัวอย่างการแสดงการเรียกใช้ตัวสร้างเริ่มต้นจากตัวสร้างพารามิเตอร์:

คลาสสาธารณะ Edureka {String studentName int studentAge String member Edureka () {member = 'YES'} Edureka (String name, int age) {this () / * ซึ่งใช้สำหรับการเรียกตัวสร้างเริ่มต้น * จากตัวสร้างพารามิเตอร์ * / studentName = name studentAge = age} void display () {System.out.println (studentName + '-' + studentAge + '-' + 'Member' + member)} public static void main (String args []) {Edureka obj = new Edureka ('มาน', 21) obj.display ()}}

เอาท์พุต: Manan - 21 - สมาชิกใช่

ในตัวอย่างข้างต้นเมื่อสร้างพารามิเตอร์ในการเรียกใช้ตัวสร้างพารามิเตอร์จะเรียกตัวสร้างเริ่มต้นด้วยความช่วยเหลือของคีย์เวิร์ดนี้ () ตัวสร้างดีฟอลต์เริ่มต้นตัวแปร 'member' เป็น 'YES' จากนั้นดำเนินการตัวสร้างพารามิเตอร์ต่อไป

ตัวสร้างโอเวอร์โหลด

Constructor รองรับวิธีการโอเวอร์โหลดเช่นเดียวกับคลาสอื่น ๆ ตามประเภทหรือจำนวนอาร์กิวเมนต์ที่แตกต่างกันตัวสร้างที่แตกต่างกันจะถูกเรียก

ตัวอย่างที่แสดงให้เห็นถึงการโอเวอร์โหลด Constructor:

คลาสสาธารณะสี่เหลี่ยมผืนผ้า {int ความยาว int ความกว้างสตริงสี // ตัวสร้าง 1 สี่เหลี่ยมผืนผ้า (int l, int b) {length = l breadth = b color = 'Green'} // ตัวสร้าง 2 สี่เหลี่ยมผืนผ้า (int l, int b, สตริง c) {length = l breadth = b color = c} void display () {System.out.println ('Length-' + length + 'Breadth-' + breadth + 'Color' + color)} public static void main (String args [ ]) {Rectangle obj1 = new Rectangle (2,4) Rectangle obj2 = new Rectangle (2,4, 'Green') obj1.display () obj2.display ()}}
 เอาท์พุต: ความยาว - 2 ความกว้าง - 4 สี - สีเขียวความยาว - 2 ความกว้าง - 4 สี - สีแดง

ตอนนี้คุณได้เข้าใจว่าคอนสตรัคเตอร์คืออะไรและจะทำงานกับพวกมันได้อย่างไรคุณก็เข้าใกล้การเดินทางเพื่อเรียนรู้ Java มากขึ้นอีกขั้น แนวคิดเช่นคอนสตรัคเตอร์นั้นเรียบง่าย แต่มีความสำคัญอย่างยิ่งเนื่องจากเกี่ยวข้องกับคลาสและอ็อบเจ็กต์ สำหรับหัวข้อเชิงลึกเพิ่มเติมและการอ่านสนุก ๆ ลงทะเบียนกับ Edureka’s . อย่าลังเลที่จะชำระเงินของเรา เพื่อเริ่มต้นการเรียนรู้ของคุณ

มีคำถามสำหรับเรา? โปรดระบุสิ่งนี้ในส่วนความคิดเห็นของบทความ 'Parameterized Constructor ใน Java' และเราจะติดต่อกลับโดยเร็วที่สุด