Constructor Overloading ใน Java คืออะไร

ความต้องการใช้งานเว็บเพิ่มขึ้นทั่วโลก Java กลายเป็นตัวเลือกยอดนิยมสำหรับนักพัฒนาที่ต้องการการเขียนโปรแกรมขนาดใหญ่ ความนิยมของ Java ขึ้นอยู่กับคุณสมบัติไดนามิก ส่วนต่อประสานที่ใช้งานง่าย และความเข้ากันได้สูงกับระบบปฏิบัติการชั้นนำ ภาษานี้มี API ที่สมบูรณ์ ข้อดีอีกอย่างของ Java คือมันให้การสนับสนุนชุมชนที่แข็งแกร่งและบริการเอกสารที่ยอดเยี่ยม อย่าลืมชุดเครื่องมือการพัฒนาที่นำเสนอโดย Java

คุณหมายถึงอะไรโดยตัวสร้างใน Java?

ตัวสร้างใน Java ส่วนใหญ่ใช้สำหรับการเริ่มต้นสถานะของวัตถุ คล้ายกับเมธอด ตัวสร้างประกอบด้วยกลุ่มคำสั่งหรือคำสั่งที่ต้องดำเนินการเมื่อวัตถุถูกสร้างขึ้น

สิ่งที่จำเป็นสำหรับตัวสร้างใน Java คืออะไร

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

คุณหมายถึงอะไรโดย Constructor Overloading ใน Java?

ในการโอเวอร์โหลดคอนสต รัคเตอร์ มีการกำหนดคอนสตรัคเตอร์หลายตัวในคลาสเดียวกัน อย่างไรก็ตาม ตัวสร้างทุกตัวควรมีลายเซ็นเฉพาะหรือพารามิเตอร์อินพุตเฉพาะ โปรแกรม โอเวอร์โหลดตัวสร้างใน Java ทำให้คลาสเดียวมีตัวสร้างมากกว่าหนึ่งตัว ซึ่งแตกต่างกันตามรายการอาร์กิวเมนต์ที่ส่งผ่าน คอนสตรัคเตอร์ที่โอเวอร์โหลดทุกตัวถูกใช้เพื่อทำงานคลาสต่างๆ

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

ตัวอย่างของการโอเวอร์โหลดตัวสร้าง

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

StudentData.java

คลาส StudentData

{

int stuID ส่วนตัว ;

สตริง ส่วนตัว stuName;

int stuAge ส่วนตัว ;

ข้อมูลนักเรียน ()

{

// ตัวสร้างเริ่มต้น

สตูไอดี = 100 ;

stuName = “นักศึกษาใหม่” ;

สตูอายุ = 18 ;

}

StudentData ( int num1, สตริง str, int num2)

{

// ตัวสร้างพารามิเตอร์

สตูไอดี = num1;

stuName = str;

สตูเอจ = num2;

}

// เมธอด Getter และ setter

int สาธารณะ getStuID () {

ส่งคืน stuID;

}

โมฆะ สาธารณะ setStuID ( int stuID) {

นี้ .stuID = stuID;

}

สตริง สาธารณะ getStuName () {

กลับ stuName;

}

โมฆะ สาธารณะ setStuName ( String stuName) {

นี่ .stuName = stuName;

}

int สาธารณะ getStuAge () {

กลับ stuAge;

}

โมฆะ สาธารณะ setStuAge ( int stuAge) {

นี้ .stuAge = stuAge;

}

โมฆะ สาธารณะ คงที่ main ( String args [])

{

// การสร้างวัตถุนี้จะเรียกตัวสร้างเริ่มต้น

StudentData myobj = ใหม่ StudentData ();

ระบบ . ออก .println( “ชื่อนักศึกษาคือ: “ +myobj.getStuName());

ระบบ . ออก .println( “อายุนักเรียนคือ: “ +myobj.getStuAge());

ระบบ . ออก .println( “รหัสนักศึกษาคือ: “ +myobj.getStuID());

/* การสร้างวัตถุนี้จะเรียกพารามิเตอร์

* ตัวสร้าง StudentData(int, String, int)*/

StudentData myobj2 = StudentData ใหม่ ( 555 , “ไชยธัญญา” , 25 );

ระบบ . ออก .println( “ชื่อนักศึกษาคือ: “ +myobj2.getStuName());

ระบบ . ออก .println( “อายุนักเรียนคือ: “ +myobj2.getStuAge());

ระบบ . ออก .println( “รหัสนักศึกษาคือ: “ +myobj2.getStuID());

}

}

เอาท์พุต:

ชื่อ นักศึกษา คือ : นักศึกษา ใหม่

อายุ นักเรียน คือ : 18

รหัส นักศึกษา คือ : 100

ชื่อ นักศึกษา : ชัย ธัญ ญา

อายุ นักเรียน คือ : 25

รหัส นักศึกษา คือ : 555

อ้างอิง: https://beginnersbook.com/2013/05/constructor-overloading/

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

ทำความเข้าใจกับฟังก์ชันนี้ () ในตัวสร้างโอเวอร์โหลด

ตัวอย่างการ โอเวอร์โหลด คลาส สาธารณะ 2

{

int rollNum ส่วนตัว ;

ตัวอย่างการโอเวอร์โหลด2 ()

{

จำนวนม้วน = 100 ;

}

OverloadingExample2 ( int rnum)

{

นี้ ();

/*this() ใช้สำหรับเรียกค่าเริ่มต้น

* ตัวสร้างจากตัวสร้างพารามิเตอร์

* ควรเป็นคำสั่งแรกเสมอ

* ภายในตัวสร้าง

*/

rollNum = จำนวนม้วน+ rnum;

}

int สาธารณะ getRollNum () {

ม้วน กลับ Num;

}

โมฆะ สาธารณะ setRollNum ( int rollNum) {

นี้ .rollNum = rollNum;

}

โมฆะ สาธารณะ คงที่ main ( String args [])

{

OverloadingExample2 obj = ใหม่ OverloadingExample2 ( 12 );

ระบบ . ออก .println(obj.getRollNum());

}

}

เอาต์พุต

112

อ้างอิง: https://beginnersbook.com/2013/05/constructor-overloading/
การสัมมนาผ่านเว็บการพัฒนาซอฟต์แวร์สุดพิเศษของ upGrad สำหรับคุณ -
การสัมมนาผ่านเว็บการพัฒนาซอฟต์แวร์สุดพิเศษของ upGrad สำหรับคุณ -

ธุรกิจ SAAS – แตกต่างอย่างไร?

ในโปรแกรมที่กล่าวถึงข้างต้น ตัวสร้างพารามิเตอร์จะถูกเรียกในระหว่างการสร้างวัตถุ ตัวสร้างเริ่มต้นถูกเรียกใช้เนื่องจาก () ถูกวางไว้ในตัวสร้างพารามิเตอร์ ตัวแปร rollNum ถูกเตรียมใช้งาน

ตัวอย่างอื่น:

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

การ สาธิต ระดับ สาธารณะ

{

int rollNum ส่วนตัว ;

// เราไม่ได้กำหนดตัวสร้าง no-arg ที่นี่

สาธิต ( int rnum)

{

rollNum = จำนวนม้วน+ rnum;

}

// เมธอด Getter และ Setter

โมฆะ สาธารณะ คงที่ main ( String args [])

{

// คำสั่งนี้จะเรียกใช้ตัวสร้าง no-arg

การ สาธิต obj = การ สาธิต ใหม่ ();

}

}

เอาท์พุต:

ข้อยกเว้น ใน เธรด "หลัก" java.lang ข้อผิดพลาด : การรวบรวมที่ ไม่ได้แก้ไข

ปัญหา: ตัว สร้างการ สาธิต () ไม่ได้ ถูก กำหนด

หลักสูตรและบทความยอดนิยมเกี่ยวกับวิศวกรรมซอฟต์แวร์

อธิบายการใช้คอนสตรัคโอเวอร์โหลด

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

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

ข้อดีของ Constructor Overloading ใน Java

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

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

บทสรุป

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

โปรแกรมใบรับรองการพัฒนาแบบ Full Stack ของ upGrad สำหรับนักพัฒนาซอฟต์แวร์และผู้เชี่ยวชาญด้านเทคโนโลยี

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

upGrad เสนอ โปรแกรมผู้บริหารในการพัฒนาซอฟต์แวร์ ให้กับผู้สมัครที่สนใจ ซึ่งออกแบบมาเฉพาะสำหรับผู้เชี่ยวชาญด้านไอที นักพัฒนาซอฟต์แวร์ ผู้เชี่ยวชาญด้านการสนับสนุนด้านเทคนิค นักวิเคราะห์ และผู้สำเร็จการศึกษาล่าสุดที่ต้องการเข้าร่วมในเวทีการพัฒนาซอฟต์แวร์

คุณจะมีทักษะสูงใน JavaScript และเรียนรู้ Microservices และ MERN Stack ในหลักสูตรนี้ นอกเหนือจากการเรียนรู้ภาษาโปรแกรมและเครื่องมือเกือบ 10+ รายการแล้ว คุณจะได้เรียนรู้เครื่องมือต่างๆ ที่ใช้กันอย่างแพร่หลายบน Facebook, Walmart, Netflix และ LinkedIn โปรแกรมมอบประสบการณ์การเรียนรู้ที่ดื่มด่ำบน Cloud Labs

นักเรียนที่เข้าร่วมโปรแกรมประกาศนียบัตรนี้จะมีโอกาสออกแบบ พัฒนา ทดสอบ และปรับใช้เว็บแอปพลิเคชันในโครงการ Capstone ผู้เรียนจะได้รับการให้คำปรึกษาด้านอาชีพแบบตัวต่อตัวกับที่ปรึกษาชั้นนำในอุตสาหกรรมพร้อมสิทธิประโยชน์เหล่านี้ เมื่อจบหลักสูตร คุณสามารถทำงานเป็นนักพัฒนาแบบ full-stack, นักพัฒนา UI, front-end และ back-end developer

สมัคร เรียนคอร์สได้เลย!