Vraag Waarom vereisen Java + =, - =, * =, / = samengestelde toewijzingsoperators casten?


Tot vandaag dacht ik dat bijvoorbeeld:

i += j;

is slechts een snelkoppeling voor:

i = i + j;

Maar wat als we dit proberen:

int i = 5;
long j = 8;

Dan i = i + j; zal niet compileren maar i += j; zal goed compileren.

Betekent het dat in feite i += j; is een snelkoppeling voor zoiets als dit i = (type of i) (i + j)?


3283
2018-01-03 10:10


oorsprong


antwoorden:


Zoals altijd met deze vragen, houdt de JLS het antwoord. In dit geval §15.26.2 Samengestelde toewijzingsoperatoren. Een uittreksel:

Een samengestelde toewijzingsuitdrukking van het formulier E1 op= E2 is gelijk aan E1 = (T)((E1) op (E2)), waar T is het type E1, behalve dat E1 wordt slechts eenmaal geëvalueerd.

Een voorbeeld geciteerd uit §15.26.2

[...] de volgende code is correct:

short x = 3;
x += 4.6;

en resulteert in x met de waarde 7 omdat het equivalent is aan:

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

Met andere woorden, uw aanname is correct.


2210
2018-01-03 10:15



Een goed voorbeeld van deze casting is het gebruik van * = of / =

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

of

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

of

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

of

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

442
2018-01-03 10:20



Zeer goede vraag. De Java-taalspecificatie bevestigt uw suggestie.

De volgende code is bijvoorbeeld correct:

short x = 3;
x += 4.6;

en resulteert in x met de waarde 7 omdat het equivalent is aan:

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

223
2018-01-03 10:17



Ja,

eigenlijk als we schrijven

i += l; 

de compiler converteert dit naar

i = (int)(i + l);

Ik heb net de .class bestandscode.

Echt een goede zaak om te weten


163
2018-01-03 10:19



je moet casten van long naar int  explicitly in het geval van i = i + l  dan zal het compileren en de juiste uitvoer geven. graag willen

i = i + (int)l;

of

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

maar in het geval van += het werkt gewoon goed, omdat de operator impliciet het type casting van het type rechter variabele naar type linkervariabele hoeft dus niet expliciet te casten.


85
2018-01-03 10:15



Het probleem hier betreft type casting.

Wanneer je int en lang toevoegt,

  1. Het int-object is te lang gecast en beide worden toegevoegd en je krijgt een lang object.
  2. maar een lang object kan niet impliciet naar int worden gegoten. Dus je moet dat expliciet doen.

Maar += is gecodeerd op een zodanige manier dat het type cast. i=(int)(i+m)


56
2018-01-03 10:20



In Java-type worden conversies automatisch uitgevoerd wanneer het type expressie aan de rechterkant van een toewijzingsbewerking veilig kan worden gepromoveerd tot het type variabele aan de linkerkant van de toewijzing. Zo kunnen we veilig toewijzen:

 byte -> kort -> int -> lang -> zwevend -> dubbel. 

Hetzelfde werkt niet andersom. We kunnen bijvoorbeeld niet automatisch een long naar een int converteren omdat de eerste meer opslagruimte nodig heeft dan de tweede en daarom kan informatie verloren gaan. Om een ​​dergelijke conversie te forceren, moeten we een expliciete conversie uitvoeren.
Type - Conversie


47
2018-01-23 05:50



Soms kan een dergelijke vraag worden gesteld tijdens een interview.

Bijvoorbeeld wanneer u schrijft:

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

er is geen automatische typecasting. In C ++ zal er geen fout zijn bij het compileren van bovenstaande code, maar in Java krijg je zoiets als Incompatible type exception.

Dus om dit te voorkomen, moet je je code als volgt schrijven:

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

37
2017-12-02 10:40