การส่งผ่านพารามิเตอร์ใน Java

ตัวแปรใน Java คือคอนเทนเนอร์ที่มีค่าอยู่ในนั้น แล้วการ "ผ่าน" ตัวแปรหมายความว่าอย่างไร? และความแตกต่างระหว่างประเภทข้อมูลดั้งเดิมและข้อมูลอ้างอิงคืออะไร เราจะพูดถึงเรื่องนี้ในภายหลัง มาเริ่มกันที่งานง่ายๆ ก่อน รหัสนี้ทำอะไร:

int х = 3;
int у = х;

ในบรรทัดที่ 1 ตัวแปรxประเภท int จะถูกสร้างขึ้นและกำหนดค่าของตัวแปร x ในบรรทัดที่ 2 ตัวแปรy ประเภท int จะถูกสร้างขึ้นและ กำหนดค่าของตัวแปรx ใน อนาคตตัวแปรxจะไม่ส่งผลต่อy แต่อย่างใด Java คัดลอกค่าของx (3) และวางที่คัดลอกลงในy นี่คือการส่งพารามิเตอร์ตามค่า คุณไม่ได้เขียนตัวแปรหนึ่งไปยังอีกตัวแปรหนึ่ง ค่าจะถูกคัดลอกและกำหนดให้กับตัวแปรใหม่ นิพจน์y = x; ไม่ได้หมายความว่า "เขียนxถึงy " หมายความว่า "คัดลอกค่าภายในxแล้วเขียนสำเนานั้นไปที่y " ถ้าภายหลังฉันเปลี่ยนy :

у = 34;

สิ่งนี้จะส่งผลต่อxหรือไม่? ไม่แน่นอน xยังคงมีค่า 3 ถ้าฉันเปลี่ยนx ในภายหลัง :

х = 90;

สิ่งนี้จะส่งผลต่อ y อย่างไร? ไม่มีทาง. ไม่มีความเกี่ยวข้องกันในทางใดทางหนึ่งหลังจากการมอบหมายงานแล้ว (การคัดลอกค่า) แล้วประเภทการอ้างอิงล่ะ? พวกเขาทำงานอย่างไร? ไม่ยากขนาดนั้น จริงๆ แล้วกฎก็เหมือนกัน ลิงก์ทำสิ่งเดียวกัน - คุณจะได้รับสำเนาของลิงก์ ดังนั้นถ้าฉันพูดว่า:

Cat A = new Cat ();
Cat B = A;

ลิงค์Aถูกคัดลอกไปยังลิงค์B สิ่งนี้ใช้ไม่ได้กับวัตถุ - คุณยังมีวัตถุเพียงอันเดียวเท่านั้น แต่ตอนนี้คุณมีการอ้างอิงที่แตกต่างกันสองรายการซึ่งควบคุม วัตถุ Catเดียวกัน ตอนนี้เรามาดูการส่งพารามิเตอร์ไปยังเมธอดต่างๆ Java ส่งผ่านพารามิเตอร์ตามค่า เสมอ. ซึ่งหมายความว่า "คัดลอกค่าและส่งสำเนา" สำหรับประเภทดั้งเดิม เป็นเรื่องง่าย:

int х = 5;
doStuff (х); / / Передать копию х (meaning 5) в метод doStuff

วิธีการdoStuffมีลักษณะดังนี้:

void doStuff (int у) {

   / / Действия с 'y'
}

สำเนาของค่าxเช่น 5 จะถูกส่งผ่านไปยัง เมธอด doStuff ( ) เมธอดdoStuff()มีตัวแปรของตัวเองที่เรียกว่าy ตัวแปรyเป็นตัวแปรใหม่ที่แตกต่างออกไป พร้อมสำเนาสิ่งที่อยู่ในxณ เวลาที่ส่งต่อให้กับเมธอด จากนี้ไปyและxจะไม่มีผลกระทบต่อกัน เมื่อคุณเปลี่ยนyคุณจะไม่ส่งผลกระทบต่อ x

void doStuff (int у) {

   у = 27; / / Это не влияет на 'х'
}

และในทางกลับกัน - ถ้าคุณเปลี่ยนxคุณจะไม่เปลี่ยนy สิ่งเดียว ที่ xทำในกรณีนี้คือคัดลอกค่าของมันและส่งผ่านไปยังเมธอดdoStuff() "ส่งผ่านค่า" ทำงานอย่างไรกับข้อมูลอ้างอิง มีคนจำนวนมากพูดว่า "Java ส่งผ่านประเภทดั้งเดิมตามค่าและอ็อบเจ็กต์โดยการอ้างอิง" ไม่ใช่สิ่งที่พวกเขาพูด Java ส่งผ่านทุกอย่างตามค่า ด้วยพื้นฐาน คุณจะได้รับสำเนาของเนื้อหา ด้วยลิงก์คุณจะได้รับสำเนาของเนื้อหาด้วย แต่เนื้อหาของลิงค์คืออะไร? รีโมท. สิ่งอำนวยความสะดวกสำหรับการจัดการ/การเข้าถึงสิ่งอำนวยความสะดวก เมื่อคุณส่งการอ้างอิงไปยังวัตถุไปยังวิธีการ คุณกำลังส่งสำเนาของการอ้างอิง โคลนการควบคุมระยะไกล วัตถุยังคงนั่งอยู่ในกองที่ถูกสร้างขึ้น กำลังรอใครสักคนใช้รีโมตคอนโทรล สิ่งอำนวยความสะดวกไม่สนใจว่าจะมีการ "ตั้งโปรแกรม" รีโมทจำนวนเท่าใดเพื่อควบคุม คนเดียวที่สนใจเรื่องนี้คือคนเก็บขยะและคุณซึ่งเป็นโปรแกรมเมอร์ ดังนั้นเมื่อคุณพูดว่า:

Cat A = new Cat ();
doStuff (А);

void doStuff (Cat B) {

   / / Использование B
}

มี วัตถุ Cat เพียงอัน เดียว แต่ตอนนี้รีโมทคอนโทรล (ลิงก์) สองตัวสามารถเข้าถึง วัตถุ Cat เดียวกัน ได้ ดังนั้นตอนนี้อะไรก็ตามที่Bทำกับ วัตถุ Catจะส่งผลต่อCat ที่ Aชี้ไปแต่จะไม่ส่งผลกระทบต่อเนื้อหาของA ! คุณสามารถเปลี่ยนCat ได้ โดยใช้ลิงก์ใหม่B (คัดลอกโดยตรงจากA ) แต่คุณไม่สามารถเปลี่ยนA ได้ นี่มันหมายความว่ายังไงเนี่ย? คุณ สามารถเปลี่ยนวัตถุที่A อ้างถึงได้ แต่คุณไม่สามารถเปลี่ยน การอ้างอิง ของ Aได้ - เปลี่ยนเส้นทางไปยังวัตถุอื่นหรือnull ดังนั้น หากคุณเปลี่ยนการอ้างอิงของB (ไม่ใช่วัตถุ Catจริงที่B อ้างอิง แต่เป็นค่าของการอ้างอิงนั้นเอง) คุณ จะไม่เปลี่ยนค่าของA และในทางกลับกัน. ดังนั้น:

Cat A = new Cat ();
doStuff (А);

void doStuff (Cat B) {

   B = new Cat (); / / Не повлияет на ссылку A
}

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