Tại sao toán tử + =, - =, * =, / = toán tử gán ghép của Java yêu cầu truyền?

Cho đến hôm nay, tôi nghĩ rằng ví dụ:

i += j;

Chỉ là một phím tắt cho:

i = i + j;

Nhưng nếu chúng ta thử điều này:

int i = 5;
long j = 8;

Sau đó i = i + j;sẽ không biên dịch nhưng i += j;sẽ biên dịch tốt.

Có nghĩa là trên thực tế i += j;là một lối tắt cho một cái gì đó như thế này i = (type of i) (i + j)?

Như mọi khi với những câu hỏi này, JLS giữ câu trả lời. Trong trường hợp này §15.26.2 Toán tử chuyển nhượng hợp chất . Trích:

Một biểu thức gán tổng hợp của biểu mẫu E1 op= E2tương đương với E1 = (T)((E1) op (E2)), trong đó Tlà loại E1, ngoại trừ chỉ E1được đánh giá một lần.

Một ví dụ được trích dẫn từ §15.26.2

[...] đoạn mã sau là chính xác:

short x = 3;
x += 4.6;

và kết quả là x có giá trị 7 vì nó tương đương với:

short x = 3;
x = (short)(x + 4.6);

Nói cách khác, giả định của bạn là chính xác.

Một ví dụ điển hình của việc truyền này là sử dụng * = hoặc / =

byte b = 10;
b *= 5.7;
System.out.println(b); // prints 57

hoặc là

byte b = 100;
b /= 2.5;
System.out.println(b); // prints 40

hoặc là

char ch = '0';
ch *= 1.1;
System.out.println(ch); // prints '4'

hoặc là

char ch = 'A';
ch *= 1.5;
System.out.println(ch); // prints 'a'

Câu hỏi rất hay. Đặc tả ngôn ngữ Java xác nhận đề xuất của bạn.

Ví dụ: đoạn mã sau là chính xác:

short x = 3;
x += 4.6;

và kết quả là x có giá trị 7 vì nó tương đương với:

short x = 3;
x = (short)(x + 4.6);

Đúng,

về cơ bản khi chúng ta viết

i += l; 

trình biên dịch chuyển đổi nó thành

i = (int)(i + l);

Tôi chỉ kiểm tra .classmã tập tin.

Thực sự là một điều tốt để biết

bạn cần truyền từ longđến int explicitlytrong trường hợp i = i + l sau đó nó sẽ biên dịch và đưa ra đầu ra chính xác. giống

i = i + (int)l;

hoặc là

i = (int)((long)i + l); // this is what happens in case of += , dont need (long) casting since upper casting is done implicitly.

nhưng trong trường hợp +=nó chỉ hoạt động tốt bởi vì toán tử hoàn toàn thực hiện việc truyền kiểu từ loại biến phải sang loại biến trái nên không cần truyền rõ ràng.

Vấn đề ở đây liên quan đến việc đúc kiểu.

Khi bạn thêm int và dài,

1. Đối tượng int được truyền thành dài & cả hai được thêm vào và bạn nhận được đối tượng dài.
2. nhưng đối tượng dài không thể được ngầm định chuyển sang int. Vì vậy, bạn phải làm điều đó một cách rõ ràng.

Nhưng +=được mã hóa theo cách mà nó thực hiện kiểu đúc.i=(int)(i+m)

Trong các chuyển đổi loại Java được thực hiện tự động khi loại biểu thức ở phía bên phải của một hoạt động gán có thể được thăng cấp một cách an toàn thành loại biến ở phía bên trái của phép gán. Do đó chúng ta có thể gán một cách an toàn:

 byte -> ngắn -> int -> dài -> float -> double. 

Điều tương tự sẽ không làm việc theo cách khác. Ví dụ, chúng ta không thể tự động chuyển đổi một khoảng dài thành một int vì lần đầu tiên yêu cầu lưu trữ nhiều hơn lần thứ hai và do đó thông tin có thể bị mất. Để buộc chuyển đổi như vậy, chúng tôi phải thực hiện một chuyển đổi rõ ràng.
Loại - Chuyển đổi

Đôi khi, một câu hỏi như vậy có thể được hỏi tại một cuộc phỏng vấn.

Ví dụ: khi bạn viết:

int a = 2;
long b = 3;
a = a + b;

không có typecasting tự động. Trong C ++ sẽ không có bất kỳ lỗi nào khi biên dịch mã ở trên, nhưng trong Java bạn sẽ nhận được một cái gì đó như thế Incompatible type exception.

Vì vậy, để tránh nó, bạn phải viết mã của bạn như thế này:

int a = 2;
long b = 3;
a += b;// No compilation error or any exception due to the auto typecasting

Sự khác biệt chính là với a = a + b, không có lỗi đánh máy đang diễn ra, và vì vậy trình biên dịch tức giận với bạn vì không đánh máy. Nhưng với a += b, những gì nó thực sự làm là đánh máy bkiểu tương thích a. Vì vậy, nếu bạn làm

int a=5;
long b=10;
a+=b;
System.out.println(a);

Những gì bạn đang thực sự là:

int a=5;
long b=10;
a=a+(int)b;
System.out.println(a);

Điểm tinh tế ở đây ...

Có một kiểu chữ ngầm cho i+jkhi nào jlà một đôi và ilà một int. Java LUÔN chuyển đổi một số nguyên thành gấp đôi khi có một hoạt động giữa chúng.

Để làm rõ i+=jvị trí của imột số nguyên và jmột số kép có thể được mô tả là

i = <int>(<double>i + j)

Xem: mô tả về đúc ngầm

Bạn có thể muốn định kiểu jđể (int)trong trường hợp này cho rõ ràng.

Đặc tả ngôn ngữ Java định nghĩa E1 op= E2tương đương với E1 = (T) ((E1) op (E2))nơi Tlà một loại E1và E1được đánh giá một lần .

Đó là một câu trả lời kỹ thuật, nhưng bạn có thể tự hỏi tại sao đó là một trường hợp. Vâng, hãy xem xét các chương trình sau đây.

public class PlusEquals {
    public static void main(String[] args) {
        byte a = 1;
        byte b = 2;
        a = a + b;
        System.out.println(a);
    }
}

Chương trình này in cái gì?

Bạn có đoán được 3 không? Quá tệ, chương trình này sẽ không được biên dịch. Tại sao? Vâng, điều đó xảy ra rằng việc thêm byte trong Java được định nghĩa để trả về mộtint . Điều này, tôi tin là bởi vì Máy ảo Java không định nghĩa các hoạt động byte để lưu trên mã byte (rốt cuộc, có một số lượng hạn chế), sử dụng các hoạt động số nguyên thay vì là một chi tiết triển khai được thể hiện bằng ngôn ngữ.

Nhưng nếu a = a + bkhông hoạt động, điều đó có nghĩa là a += bsẽ không bao giờ hoạt động đối với byte nếu nó E1 += E2được xác định là E1 = E1 + E2. Như ví dụ trước đây cho thấy, đó thực sự là trường hợp. Là một hack để làm cho +=toán tử hoạt động cho byte và quần short, có một diễn viên ngầm liên quan. Nó không phải là một hack tuyệt vời, nhưng trở lại trong quá trình Java 1.0, trọng tâm là bắt đầu phát hành ngôn ngữ. Bây giờ, vì khả năng tương thích ngược, bản hack được giới thiệu trong Java 1.0 này không thể bị xóa.