Constructor Chaining ใน Java พร้อมตัวอย่างและการใช้งาน

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

ตัวสร้างใน Java มีชื่อเดียวกับคลาสและมีลักษณะดังต่อไปนี้:

myProgram คลาสสาธารณะ{

// นี่คือตัวสร้าง

โปรแกรมของฉัน (){

}

..

}

เมื่อ Constructor ถูกเรียกจากภายใน Constructor อื่น นั่นคือเมื่อ Constructor Chaining เกิดขึ้นใน Java อย่างไรก็ตาม ก่อนที่เราจะเจาะลึกลงไปใน Constructor Chaining อันดับแรก เรามาดูว่า Constructors ทำงานอย่างไรใน Java ก่อน พร้อมกับตัวอย่างบางส่วนเพื่อเสริมความเข้าใจของคุณ

ตัวสร้างใน Java ทำงานอย่างไร

เพื่อให้เข้าใจวิธีการทำงานของคอนสตรัคเตอร์ เรามาดูตัวอย่างกัน สมมติว่าเรามีคลาสชื่อ myProgram ทีนี้ เมื่อเราสร้าง object ของคลาสนี้ เราจะต้องเขียนคำสั่งต่อไปนี้:

myProgram obj = ใหม่ myProgram()

อย่างที่คุณเห็น คีย์เวิร์ดใหม่ที่ใช้ในตัวอย่างข้างต้นจะสร้างอ็อบเจกต์ของ myProgram และเรียกใช้คอนสตรัคเตอร์เพื่อเริ่มต้นอ็อบเจกต์ที่สร้างขึ้นใหม่นี้

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

โปรแกรมสร้างพื้นฐานในภาษาจาวา

ดูโค้ด Java ต่อไปนี้ที่ใช้ Constructors:

การทดสอบในชั้นเรียนสาธารณะ{

หนังสือสตริง;

//คอนสตรัคเตอร์

ทดสอบ(){

this.book = "ผู้จับในข้าวไรย์";

}

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

ทดสอบ obj = ทดสอบใหม่ ();

System.out.println(obj.book);

}

}

เอาท์พุต:

ผู้จับในไรย์

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

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

ด้วยพื้นฐานของ Constructor ใน Java เรียบร้อยแล้ว เรามาต่อกันที่ Constructor Chaining ใน Java และวิธีการทำงานกัน!

การผูกมัดของตัวสร้างภายในคลาสเดียว

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

ตัวสร้างการผูกมัดจากคลาสพื้นฐาน/พาเรนต์

คลาสใน Java สามารถสืบทอดมาจากคลาสอื่น คลาสที่ได้รับจะเรียกว่าคลาสย่อย และคลาสที่ได้รับมาจะเรียกว่าซูเปอร์คลาส คลาสย่อยสามารถมีคอนสตรัคเตอร์ของตัวเองและเรียกใช้คลาสย่อยเหล่านั้นได้

ตัวสร้าง superclass ใช้คำว่า super() ตามด้วยอินพุตที่จำเป็น คำหลัก super() ต้องอยู่ในบรรทัดแรกของตัวสร้างคลาสย่อยเสมอ

โทรจากตัวสร้างที่แตกต่างกัน ตัวสร้าง

การใช้คีย์เวิร์ด this() ตัวสร้างใน Java สามารถเรียกตัวสร้างตัวอื่นจากคลาสเดียวกันได้ คีย์เวิร์ดแรกในตัวสร้างต้องเป็นคีย์เวิร์ด this() เสมอ ซึ่งสามารถใช้เรียกคอนสตรัคเตอร์อื่นที่เป็นประเภทเดียวกันได้เท่านั้น

ตัวสร้าง Superclass โทรศัพท์

คำหลัก super() ใน Java อนุญาตให้ตัวสร้างคลาสย่อยเรียกตัวสร้างของ superclass คีย์เวิร์ด super() ซึ่งสามารถใช้เรียกตัวสร้างของคลาสย่อยของคลาสย่อยเท่านั้น จะต้องอยู่บรรทัดแรกของตัวสร้างคลาสย่อยเสมอ

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

วิธีอื่นในการเชนตัวสร้างโดยใช้ Init Block

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

สิ่งจำเป็นของ Constructor Chaining ใน Java

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

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

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

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

มีสองสิ่งหลักที่คุณควรจำไว้เกี่ยวกับ Constructor Chaining เพื่อให้แน่ใจว่ามีความชัดเจนสูงสุด:

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

ดังที่คุณเห็นในตัวอย่างก่อนหน้านี้ เราใช้คีย์เวิร์ดนี้เพื่อเข้าถึงพารามิเตอร์ของตัวสร้าง ในทำนองเดียวกัน Constructor Chaining ยังต้องการคำหลักสองคำเป็นหลัก นี่คือคำหลักสองคำนั้น:

• นี้ – การแทนเมธอดของมันเรียกตัวสร้างคลาสปัจจุบัน
• ซุปเปอร์ – การแทนเมธอดของมันเรียกคอนสตรัคเตอร์ superclass หรือพาเรนต์ superclass ในทันที

นอกจากนี้ คุณควรทราบคำศัพท์และคำจำกัดความที่สำคัญอีกสองสามข้อในแง่ของ Constructor Chaining ใน Java:

• Constructor Invocation: เมื่อคุณเรียกใช้ Constructor และ Constructor นั้นถูกเรียกใช้สำเร็จ จะเรียกว่า Constructor Invocation
• Constructor Execution: หากเรียกใช้ Constructor ตัวควบคุมจะเริ่มดำเนินการคำสั่งในเนื้อหา Constructor เป็นที่รู้จักกันว่าการดำเนินการคอนสตรัคเตอร์

กฎหลักของ Constructor Chaining ใน Java

ด้วยพื้นฐานของ Constructor Chaining เรียบร้อยแล้ว เรามาดูกฎสำคัญบางประการในการทำงานกับ Constructor Chaining ใน Java:

• this() สามารถเรียกใช้พารามิเตอร์ที่เป็นของ Constructor เดียวกันเท่านั้น
• super() สามารถเรียก superclass Constructor ทันทีเท่านั้น
• this() และ super() ควรเป็นคำสั่งแรกในตัวสร้าง
• ไม่สามารถใช้ this () และ super() ภายใน Constructor เดียวกันได้ เนื่องจากทั้งสองคนจำเป็นต้องเป็นคำสั่งแรก ซึ่งไม่สามารถทำได้จริง
• คุณไม่สามารถเพิ่ม this() ในตัวสร้างทั้งหมดของคลาสเดียวกันได้ เนื่องจากควรมีตัวสร้างอย่างน้อยหนึ่งตัวที่ไม่มีคำสั่ง this()
• การเรียกใช้และเรียกใช้งาน Constructors ใน Java นั้นตรงกันข้าม ดังนั้น หากคอนสตรัคเตอร์ถูกเรียกในลำดับ A, B, C การดำเนินการก็จะอยู่ในลำดับ C, B, A

ตัวอย่างเช่น ที่นี่ เรามีสองคลาสที่แยกจากกันซึ่งทำงานโดยการโอเวอร์โหลดตัวสร้างที่แตกต่างกัน เราต้องการดำเนินการคอนสตรัคเตอร์ในลำดับที่ 2, 1, 4, 3, 5

ในการดำเนินการคอนสตรัคเตอร์ตามลำดับ เราจำเป็นต้องเรียกคอนสตรัคเตอร์ในลำดับตรงกันข้าม เช่น 5, 3, 4, 1, 2 ดูตัวอย่างด้านล่าง

ชั้นเรียนผู้ปกครอง

{

ผู้ปกครอง()// 1

{

นี่ (“สวัสดี”);

System.out.println (“ใน Parent 0 arg ตัวสร้าง 1”);

}

ผู้ปกครอง(ข้อความสตริง)// 2

{

System.out.println(“ในตัวสร้าง Parent(String) 2”);

}

}

ตัวสร้างคลาสขยาย Parent

{

ตัวสร้าง () // 3

{

this(10); // เรียกตัวสร้างตัวเลข 5 ตัว

System.out.println (“ในตัวสร้าง 0 หาตัวสร้าง 3”);

}

ตัวสร้าง(ข้อความสตริง)//4

{

super();//เรียกตัวสร้างคลาสพาเรนต์ 1 หมายเลข

System.out.println (“ในตัวสร้าง (ข้อความสตริง) ตัวสร้างหาเรื่อง 4”);

}

ตัวสร้าง(int i)// 5

{

this("hello");//เรียกตัวสร้างตัวเลข 4 ตัว

System.out.println (“ในตัวสร้าง (int i) ตัวสร้าง 5”);

}

// เมธอด main()

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

{

ตัวสร้าง cobj = ตัวสร้างใหม่ (); // เรียกตัวสร้างตัวเลข 3 ตัว

}

}

เอาท์พุต:

ในตัวสร้าง Parent(String) 2

ใน Parent 0 ตัวสร้าง arg 1

ในตัวสร้าง (ข้อความสตริง) arg ตัวสร้าง 4

ในตัวสร้าง (int i) ตัวสร้าง 5

ในตัวสร้าง 0 arg ตัวสร้าง 3

สรุปแนวคิดทั้งหมดของ Constructors และ Constructor Chaining ใน Java ด้วยตัวอย่างสุดท้าย:

คลาส Emp

{

Ename สตริงสาธารณะ;

สาธารณะ int EEarnings;

ที่อยู่สตริงสาธารณะ

Emp สาธารณะ ()

{

นี่ (“ราหุล”);

}

Emp สาธารณะ (ชื่อสตริง)

{

นี่(ชื่อ 140035);

}

Emp สาธารณะ (ชื่อสตริง, int sal)

{

this(ชื่อ, sal, “นิวเดลี”);

}

พนักงานสาธารณะ (ชื่อสตริง, int sal, เพิ่มสตริง)

{

this.Ename=ชื่อ;

this.EEarnings=sal;

this.address=เพิ่ม;

}

เป็นโมฆะ disp () {

System.out.println(“ชื่อ:“+EName);

System.out.println(“เงินเดือน:“+EEarnings);

System.out.println(“ที่อยู่:“+ที่อยู่);

}

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

{

พนักงาน obj = พนักงานใหม่ ();

obj.disp();

}

}

เอาท์พุต:

ชื่อพนักงาน: ราหุล

เงินเดือนพนักงาน: 140035

ที่อยู่พนักงาน: นิวเดลี

บทสรุป

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

หนึ่งในหลักสูตรดังกล่าวคือการรับรอง PG ที่เชื่อมโยงกับงานของ upGrad ในวิศวกรรมซอฟต์แวร์ ซึ่งออกแบบมาโดยเฉพาะสำหรับผู้หางานครั้งแรก ตรวจสอบเนื้อหาหลักสูตรและลงทะเบียนเรียนวันนี้! เรียนรู้ทักษะวิศวกรรมซอฟต์แวร์ที่เกี่ยวข้องทั้งหมด เช่น Java, DSA, OODAP, JavaScript, MERN, AWS ฯลฯ จากผู้เชี่ยวชาญในอุตสาหกรรมและผู้เชี่ยวชาญชั้นนำ