Neden Java'nın + =, - =, * =, / = bileşik atama işleçleri döküm gerektirmez?

Bugüne kadar şöyle düşündüm:

i += j;

Sadece bir kısaydı:

i = i + j;

Ama bunu denersek:

int i = 5;
long j = 8;

O i = i + j;zaman derlenmeyecek ama i += j;iyi derlenecektir.

Aslında i += j;böyle bir şey için bir kısayol olduğu anlamına mı geliyor i = (type of i) (i + j)?

Her zaman olduğu gibi, bu sorularda JLS cevabı tutar. Bu durumda §15.26.2 Bileşik Atama Operatörleri . Bir özü:

Şeklinde olan bir bileşik atama ifade E1 op= E2eşdeğerdir E1 = (T)((E1) op (E2)), burada Ttürüdür E1dışında, E1sadece bir kere elde edildi.

§15.26.2'den alıntı yapılan bir örnek

[...] aşağıdaki kod doğrudur:

short x = 3;
x += 4.6;

ve x'in 7 değerine sahip olmasıyla sonuçlanır, çünkü şuna eşdeğerdir:

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

Başka bir deyişle, varsayımınız doğrudur.

Bu dökümün iyi bir örneği * = veya / = kullanmaktır

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

veya

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

veya

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

veya

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

Çok güzel bir soru. Java Dil şartname önerinizi doğruluyor.

Örneğin, aşağıdaki kod doğrudur:

short x = 3;
x += 4.6;

ve x'in 7 değerine sahip olmasıyla sonuçlanır, çünkü şuna eşdeğerdir:

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

Evet,

temelde yazdığımızda

i += l; 

derleyici bunu

i = (int)(i + l);

Az önce .classdosya kodunu kontrol ettim .

Gerçekten bilmek iyi bir şey

Eğer gelen döküm gerekir longetmek int explicitlydurumunda i = i + l o zaman derlemek ve doğru çıktı verecektir. sevmek

i = i + (int)l;

veya

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

ancak bu durumda +=iyi çalışır çünkü operatör dolaylı olarak sağ değişken türünden sol değişken türüne döküm türünü dolaylı olarak dökmek zorunda değildir.

Buradaki sorun tip dökümü içerir.

İnt ve long eklediğinizde,

1. İnt nesnesi uzun süre dökülür ve her ikisi de eklenir ve uzun nesne elde edersiniz.
2. ancak uzun nesneler dolaylı olarak int. Yani, bunu açıkça yapmalısınız.

Ancak +=döküm yapacağı şekilde kodlanmıştır.i=(int)(i+m)

Java türünde, bir atama işleminin sağ tarafındaki ifadenin türü, atamanın sol tarafındaki değişkenin türüne güvenli bir şekilde yükseltilebildiğinde, dönüşümler otomatik olarak gerçekleştirilir. Böylece güvenle atayabiliriz:

 bayt -> kısa -> int -> uzun -> şamandıra -> çift. 

Aynı şey ters yönde çalışmaz. Örneğin, birinciyi otomatik olarak uzun bir int'e dönüştüremeyiz çünkü ilki ikincisinden daha fazla depolama alanı gerektirir ve sonuç olarak bilgiler kaybolabilir. Böyle bir dönüşümü zorlamak için açık bir dönüşüm gerçekleştirmeliyiz.
Tür - Dönüşüm

Bazen böyle bir soru röportajda sorulabilir.

Örneğin, yazarken:

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

otomatik tipleme yoktur. C ++ 'da yukarıdaki kodu derlerken herhangi bir hata olmayacak, ancak Java'da böyle bir şey alacaksınız Incompatible type exception.

Bundan kaçınmak için kodunuzu şu şekilde yazmalısınız:

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

Temel fark, devam eden bir a = a + btiplemenin olmamasıdır ve bu nedenle derleyici, tiplemelemediğiniz için size kızar. Ancak bununla a += bgerçekten yaptığı şey, buyumlu bir tipe yazmaktır a. Yani eğer yaparsan

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

Gerçekten yaptığınız şey:

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

Burada ince bir nokta ...

i+jWhen jbir double ve iint olduğunda örtük bir typecast vardır . Java DAİMA aralarında bir işlem olduğunda bir tamsayıyı ikiye dönüştürür.

i+=jNerede ibir tam sayı ve jbir çift olduğunu açıklığa kavuşturmak

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

Bkz: örtük dökümün bu açıklaması

Sen typecasting isteyebilirsiniz jiçin (int)netlik için bu durumda.

Java Dil Şartname tanımlar E1 op= E2eşdeğer olduğu E1 = (T) ((E1) op (E2))yerde Ttürüdür E1ve E1bir kez değerlendirilir .

Bu teknik bir cevap, ama bunun neden böyle olduğunu merak ediyor olabilirsiniz. Peki, aşağıdaki programı ele alalım.

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

Bu program ne yazdırıyor?

3'ü tahmin ettin mi? Çok kötü, bu program derlenmeyecek. Neden? Java'da bayt eklemenin birint . Bunun nedeni, Java Sanal Makinesi'nin bayt kodlarını kaydetmek için bayt işlemlerini tanımlamamış olmasından kaynaklanmaktadır (sonuçta sınırlı sayıda vardır), bunun yerine tamsayı işlemlerini bir dilde açıklanmış bir uygulama detayı kullanmaktır.

Fakat eğer a = a + bişe yaramazsa, a += bbu E1 += E2, tanımlandığı takdirde baytlar için asla işe yaramayacağı anlamına gelir E1 = E1 + E2. Önceki örnekte gösterildiği gibi, bu gerçekten de durum böyle olurdu. Yapmak için bir hack olarak +=bayt ve şort operatör çalışmaları, ilgili örtük dökme yoktur. Bu bir hack büyük değil, ama Java 1.0 çalışması sırasında, odak noktası dili başlamak için başladı. Artık geriye dönük uyumluluk nedeniyle Java 1.0'da tanıtılan bu saldırı kaldırılamadı.