เหตุใดโค้ด Java นี้จึงคอมไพล์

ในขอบเขตของวิธีการหรือคลาสบรรทัดด้านล่างคอมไพล์ (พร้อมคำเตือน):

int x = x = 1;

ในขอบเขตระดับที่ตัวแปรได้รับค่าเริ่มต้นสิ่งต่อไปนี้ทำให้เกิดข้อผิดพลาด 'การอ้างอิงที่ไม่ได้กำหนด':

int x = x + 1;

x = x = 1ข้อผิดพลาด "การอ้างอิงที่ไม่ได้กำหนด" เป็นครั้งแรกไม่ใช่หรือ หรือบรรทัดที่สองint x = x + 1ควรรวบรวม? หรือมีบางอย่างที่ฉันขาดหายไป?

tl; dr

สำหรับสาขา , int b = b + 1เป็นสิ่งผิดกฎหมายเพราะคือการอ้างอิงไปข้างหน้าผิดกฎหมายb bคุณสามารถแก้ไขได้จริงโดยการเขียนint b = this.b + 1ซึ่งรวบรวมโดยไม่มีข้อร้องเรียน

สำหรับตัวแปรท้องถิ่น , int d = d + 1เป็นสิ่งผิดกฎหมายเพราะdไม่ได้เริ่มต้นก่อนการใช้งาน นี่ไม่ใช่กรณีสำหรับฟิลด์ซึ่งมักจะเริ่มต้นเป็นค่าเริ่มต้น

คุณสามารถเห็นความแตกต่างได้โดยพยายามรวบรวม

int x = (x = 1) + x;

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

บทนำ

ก่อนอื่นกฎสำหรับตัวเริ่มต้นของฟิลด์และตัวแปรโลคัลนั้นแตกต่างกันมาก ดังนั้นคำตอบนี้จะจัดการกับกฎเป็นสองส่วน

เราจะใช้โปรแกรมทดสอบนี้ตลอด:

public class test {
    int a = a = 1;
    int b = b + 1;
    public static void Main(String[] args) {
        int c = c = 1;
        int d = d + 1;
    }
}

การประกาศbไม่ถูกต้องและล้มเหลวด้วยillegal forward referenceข้อผิดพลาด
การประกาศdไม่ถูกต้องและล้มเหลวด้วยvariable d might not have been initializedข้อผิดพลาด

ความจริงที่ว่าข้อผิดพลาดเหล่านี้แตกต่างกันควรบอกเป็นนัยว่าสาเหตุของข้อผิดพลาดก็แตกต่างกันเช่นกัน

ฟิลด์

ตัวเริ่มต้นฟิลด์ใน Java ถูกควบคุมโดยJLS §8.3.2การเริ่มต้นฟิลด์

ขอบเขตของเขตข้อมูลที่กำหนดไว้ในJLS §6.3 , ขอบเขตของการประกาศ

กฎที่เกี่ยวข้อง ได้แก่ :

• ขอบเขตของการประกาศของสมาชิกที่mประกาศหรือสืบทอดโดยคลาสประเภท C (§8.1.6) คือเนื้อความทั้งหมดของ C รวมถึงการประกาศประเภทที่ซ้อนกัน
• นิพจน์การเริ่มต้นสำหรับตัวแปรอินสแตนซ์อาจใช้ชื่อง่าย ๆ ของตัวแปรคงที่ที่ประกาศในหรือสืบทอดโดยคลาสแม้กระทั่งคำประกาศที่เกิดขึ้นในภายหลัง
• การใช้ตัวแปรอินสแตนซ์ที่การประกาศปรากฏเป็นข้อความหลังจากการใช้งานบางครั้งถูก จำกัด แม้ว่าตัวแปรอินสแตนซ์เหล่านี้จะอยู่ในขอบเขตก็ตาม ดู§8.3.2.3สำหรับกฎที่แม่นยำซึ่งควบคุมการอ้างอิงไปข้างหน้ากับตัวแปรอินสแตนซ์

§8.3.2.3พูดว่า:

การประกาศสมาชิกจะต้องปรากฏเป็นข้อความก่อนที่จะใช้เฉพาะในกรณีที่สมาชิกเป็นฟิลด์อินสแตนซ์ (ตามลำดับคงที่) ของคลาสหรืออินเตอร์เฟส C และเงื่อนไขทั้งหมดต่อไปนี้มีไว้

• การใช้งานเกิดขึ้นในตัวเริ่มต้นตัวแปรอินสแตนซ์ (ตามลำดับคงที่) ของ C หรือในอินสแตนซ์ (ตามลำดับคงที่) ตัวเริ่มต้นของ C
• การใช้งานไม่ได้อยู่ทางด้านซ้ายมือของงาน
• การใช้งานผ่านชื่อธรรมดา
• C คือคลาสหรืออินเทอร์เฟซด้านในสุดที่ปิดล้อมการใช้งาน

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

int j = i;
int i = j;

จากการรวบรวม ข้อมูลจำเพาะของ Java ระบุว่า "ข้อ จำกัด ข้างต้นได้รับการออกแบบมาเพื่อตรวจจับในเวลาคอมไพล์การเริ่มต้นแบบวงกลมหรือผิดรูปแบบ"

กฎเหล่านี้มีผลต่ออะไร?

โดยทั่วไปแล้วกฎจะบอกว่าคุณต้องประกาศเขตข้อมูลล่วงหน้าของการอ้างอิงไปยังฟิลด์นั้นหาก (a) การอ้างอิงอยู่ในตัวเริ่มต้น (b) การอ้างอิงไม่ได้ถูกกำหนดให้ (c) การอ้างอิงคือ a ชื่อธรรมดา (ไม่มีคุณสมบัติเช่นthis.) และ (d) ไม่สามารถเข้าถึงได้จากภายในคลาสภายใน ดังนั้นการอ้างอิงไปข้างหน้าที่ตรงตามเงื่อนไขทั้งสี่จึงผิดกฎหมาย แต่การอ้างอิงไปข้างหน้าที่ล้มเหลวอย่างน้อยหนึ่งเงื่อนไขก็ใช้ได้

int a = a = 1;รวบรวมเนื่องจากละเมิด (b): a มีการกำหนดข้อมูลอ้างอิงให้ดังนั้นจึงเป็นเรื่องถูกกฎหมายที่จะอ้างถึงaล่วงหน้าก่อนการaประกาศฉบับสมบูรณ์

int b = this.b + 1ยังรวบรวมเพราะละเมิด (c): การอ้างอิงthis.bไม่ใช่ชื่อธรรมดา (มีคุณสมบัติด้วยthis.) โครงสร้างแปลก ๆ นี้ยังคงมีการกำหนดไว้อย่างสมบูรณ์เนื่องจากthis.bมีค่าเป็นศูนย์

ดังนั้นโดยพื้นฐานแล้วข้อ จำกัด ในการอ้างอิงฟิลด์ภายใน initializers ป้องกันไม่ให้int a = a + 1คอมไพล์สำเร็จ

สังเกตว่าการประกาศเขตข้อมูลint b = (b = 1) + bจะไม่สามารถรวบรวมได้เนื่องจากขั้นสุดท้ายbยังคงเป็นการอ้างอิงไปข้างหน้าที่ผิดกฎหมาย

ตัวแปรท้องถิ่น

การประกาศตัวแปรท้องถิ่นอยู่ภายใต้JLS §14.4คำชี้แจงการประกาศตัวแปรท้องถิ่น

ขอบเขตของตัวแปรท้องถิ่นถูกกำหนดไว้ในJLS §6.3ขอบเขตของประกาศ:

• ขอบเขตของการประกาศตัวแปรโลคัลในบล็อก (§14.4) คือส่วนที่เหลือของบล็อกที่การประกาศปรากฏขึ้นโดยเริ่มจากตัวเริ่มต้นของตัวเองและรวมถึงตัวประกาศอื่น ๆ ทางด้านขวาในคำสั่งการประกาศตัวแปรโลคัล

โปรดทราบว่าตัวเริ่มต้นอยู่ในขอบเขตของตัวแปรที่ประกาศ แล้วทำไมไม่int d = d + 1;คอมไพล์ล่ะ?

สาเหตุเนื่องมาจากกฎของ Java เกี่ยวกับการกำหนดที่แน่นอน ( JLS §16 ) การกำหนดที่ชัดเจนโดยทั่วไปกล่าวว่าการเข้าถึงตัวแปรโลคัลทุกครั้งจะต้องมีการกำหนดก่อนหน้านี้ให้กับตัวแปรนั้นและคอมไพลเลอร์ Java จะตรวจสอบลูปและกิ่งก้านเพื่อให้แน่ใจว่าการกำหนดจะเกิดขึ้นก่อนการใช้งานใด ๆเสมอ (นี่คือเหตุผลที่การกำหนดที่แน่นอนมีส่วนข้อกำหนดเฉพาะทั้งหมด ไปเลย). กฎพื้นฐานคือ:

• สำหรับการเข้าถึงของตัวแปรท้องถิ่นหรือสนามสุดท้ายว่างเปล่าทุกx, xต้องกำหนดแน่นอนก่อนที่จะเข้าถึงหรือรวบรวมข้อผิดพลาดเกิดขึ้นเวลา

ในint d = d + 1;การเข้าถึงdได้รับการแก้ไขให้กับตัวแปรโลคัลได้ดี แต่เนื่องจากdไม่ได้ถูกกำหนดก่อนที่dจะเข้าถึงคอมไพลเลอร์จึงแสดงข้อผิดพลาด ในint c = c = 1, c = 1เกิดขึ้นครั้งแรกที่ได้รับมอบหมายcและจากนั้นcจะเริ่มต้นได้จากผลของการกำหนดว่า (ซึ่งก็คือ 1)

หมายเหตุว่าเพราะกฎการกำหนดแน่นอนการประกาศตัวแปรท้องถิ่นint d = (d = 1) + d; จะรวบรวมประสบความสำเร็จ ( ซึ่งแตกต่างจากการประกาศเขตint b = (b = 1) + b) เพราะdได้รับมอบหมายแน่นอนตามเวลาที่สุดท้ายdจะมาถึง

int x = x = 1;

เทียบเท่ากับ

int x = 1;
x = x; //warning here

ขณะที่อยู่ใน

int x = x + 1; 

ก่อนอื่นเราต้องคำนวณx+1แต่ไม่ทราบค่าของ x ดังนั้นคุณจึงได้รับข้อผิดพลาด (คอมไพเลอร์รู้ว่าไม่ทราบค่าของ x)

เทียบเท่ากับ:

int x;
x = 1;
x = 1;

ประการแรกint <var> = <expression>;จะเทียบเท่ากับ

int <var>;
<var> = <expression>;

ในกรณีนี้นิพจน์ของคุณคือx = 1ซึ่งเป็นคำสั่งเช่นกัน x = 1เป็นคำสั่งที่ถูกต้องเนื่องจากxมีการประกาศvar แล้ว นอกจากนี้ยังเป็นนิพจน์ที่มีค่า 1 ซึ่งจะถูกกำหนดให้xอีกครั้ง

ในจาวาหรือภาษาสมัยใหม่การมอบหมายงานจะมาจากทางขวา

สมมติว่าคุณมีสองตัวแปร x และ y

int z = x = y = 5;

คำสั่งนี้ถูกต้องและนี่คือวิธีที่คอมไพลเลอร์แยกออก

y = 5;
x = y;
z = x; // which will be 5

แต่ในกรณีของคุณ

int x = x + 1;

คอมไพเลอร์ให้ข้อยกเว้นเพราะมันแยกแบบนี้

x = 1; // oops, it isn't declared because assignment comes from the right.

int x = x = 1; ไม่เท่ากับ:

int x;
x = 1;
x = x;

javap ช่วยเราอีกครั้งนี่คือคำสั่ง JVM ที่สร้างขึ้นสำหรับรหัสนี้:

0: iconst_1    //load constant to stack
1: dup         //duplicate it
2: istore_1    //set x to constant
3: istore_1    //set x to constant

ชอบมากขึ้น:

int x = 1;
x = 1;

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

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

ถ้าเราเขียน:

int b, c, d, e, f;
int a = b = c = d = e = f = 5;

เท่ากับ:

f = 5
e = 5
d = 5
c = 5
b = 5
a = 5

นิพจน์ส่วนใหญ่ถูกกำหนดให้กับตัวแปรทีละรายการโดยไม่มีการเรียกซ้ำ เราสามารถยุ่งกับตัวแปรตามที่เราต้องการ:

a = b = c = f = e = d = a = a = a = a = a = e = f = 5;

ในตัวint x = x + 1;คุณเพิ่ม 1 เป็น x ดังนั้นค่าของxมันคืออะไรจึงยังไม่ได้สร้าง

แต่ในint x=x=1;จะรวบรวมข้อผิดพลาดไม่ได้เพราะคุณกำหนด 1 xถึง

โค้ดชิ้นแรกของคุณประกอบด้วยวินาที=แทนที่จะเป็นบวก สิ่งนี้จะรวบรวมที่ใดก็ได้ในขณะที่ส่วนที่สองของโค้ดจะไม่รวบรวมในที่ใดที่หนึ่ง

ในโค้ดชิ้นที่สอง x จะใช้ก่อนการประกาศในขณะที่โค้ดชิ้นแรกจะถูกกำหนดเพียงสองครั้งซึ่งไม่สมเหตุสมผล แต่ใช้ได้

มาแบ่งมันทีละขั้นตอนเชื่อมโยงอย่างถูกต้อง

int x = x = 1

x = 1กำหนด 1 ให้กับตัวแปร x

int x = xกำหนดค่า x ให้กับตัวมันเองเป็น int เนื่องจากก่อนหน้านี้ x ถูกกำหนดให้เป็น 1 จึงยังคงเป็น 1 แม้ว่าจะซ้ำซ้อนก็ตาม

ที่รวบรวมได้ดี

int x = x + 1

x + 1เพิ่มหนึ่งในตัวแปร x อย่างไรก็ตาม x ที่ไม่ได้กำหนดสิ่งนี้จะทำให้เกิดข้อผิดพลาดในการคอมไพล์

int x = x + 1ดังนั้นบรรทัดนี้จะรวบรวมข้อผิดพลาดเนื่องจากส่วนด้านขวาของการเท่ากับจะไม่รวบรวมการเพิ่มหนึ่งในตัวแปรที่ไม่ได้กำหนด

อันที่สองint x=x=1คอมไพล์เนื่องจากคุณกำลังกำหนดค่าให้กับ x แต่ในอีกกรณีหนึ่งint x=x+1ที่นี่ตัวแปร x จะไม่ถูกเตรียมใช้งานโปรดจำไว้ว่าในตัวแปรโลคัลของ java จะไม่เริ่มต้นเป็นค่าเริ่มต้น หมายเหตุถ้ามัน ( int x=x+1) อยู่ในขอบเขตคลาสด้วยก็จะทำให้เกิดข้อผิดพลาดในการคอมไพล์เนื่องจากไม่ได้สร้างตัวแปร

int x = x + 1;

คอมไพล์สำเร็จใน Visual Studio 2008 พร้อมคำเตือน

warning C4700: uninitialized local variable 'x' used`

x ไม่ได้เริ่มต้นในx = x + 1;.

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

ดูประเภทข้อมูลดั้งเดิม

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

int x;
x = (x = 1); // (x = 1) returns 1 so there is no error

อย่างไรก็ตามในส่วนที่สองของคุณของรหัสint x = x + 1ที่+ 1คำสั่งต้องxมีการกำหนดไว้ซึ่งตอนนั้นมันไม่ได้ เนื่องจากคำสั่งมอบหมายหมายถึงรหัสทางด้านขวาของ=รันก่อนเสมอรหัสจะล้มเหลวเนื่องจากxไม่ได้กำหนด Java จะรันโค้ดดังนี้:

int x;
x = x + 1; // this line causes the error because `x` is undefined

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