Il test di buon rientro, di cui vi ho svelato ieri sera i vincitori (purtroppo solo due) con le loro soluzioni, ha, come vi ho già accennato, comportamenti e spegazioni diversi in C# rispetto a Java. In un commento, Flavio mi ha chiesto come stanno le cose in Java - magari anche altri hanno la stessa curiosità (il confronto fra C# e Java fa, secondo me, sempre bene).
Mary Smaragdis, una dipendente di Sun, ospita nel suo blog un simpatico concorso di quiz chiamato "Friday Free Stuff" con piccoli premi sponsorizzati dalla sua tenera generosità - eh sì, qui siamo diversi... :-) Da quanto si capisce, i test non li compone lei ma due bei nomi nel mondo Java: Joshua Bloch e Neal M. Gafter (ovvero Click and Hack, the type-it brothers). Il test l'ho preso da questo post del Friday Free Stuff, scritto come dialogo tra i due:
Josh: Yesterday I gave you a Puzzler in which you were asked to provide definitions for x and i so that:
x += i; // (1)
is a legal statement, but
x = x + i; // (2)
is not.
Neal: Isn't statement (1) just a shorthand for statement (2)?
Josh: Not quite. Statement (2) is an ordinary assignment; statement (1) uses +=, which is a compound assignment operator. If you look at JLS 15.26.2, you'll see that compound assignments automatically cast the expression on their right-hand side to the type of the expression on their left-hand side. That's what's known as an implicit narrowing cast.
Neal: Aha! So if I were to declare:
short x = 0;
int i = 1;
the first statement would be legal, but the second would be illegal because it's attempting to assign an int to a short.
Josh: Exactly.
Neal: But isn't that dangerous?
Josh: Yep; it can lead to silent loss of precision. For example, you might expect this program to print out 123456:
short x = 0;
x += 123456;
System.out.println(x);
You'd be wrong. It prints out -7616. To avoid this sort of rude surprise, don't use compound assignment operators (such as +=, -=, and *=) on variables of type byte, short, char, or float.
Neal: Sound advice.
Nella tabella qui sotto vi presento le differeneze di comportamento fra C# e Java per praticamente lo stesso snippet:
| C# |
Java |
class Foo
{
public static void Main(string[] args)
{
short x = 0;
int i = 1;
x += i; // ERROR: Cannot implicitly convert type 'int' to 'short'
x = x + i; // ERROR: Cannot implicitly convert type 'int' to 'short'
}
} |
class foo
{
public static void main(String[] args)
{
short x = 0;
int i = 1;
x += i; // OK
x = x + i; // ERROR: possible loss of precision
}
} |
Il punto di differenza sta nell'OK per l'assegnazione composta x += i in Java. Entriamo un po' nei dettagli di questa differenza:
In Java, come in C#, si inizia con la somma dei valori di x e di i, ma subito dopo le cose cambiano. In Java il valore della somma si converte nel tipo di x e il risultato della conversione si salva in x, mentre in C# il compilatore nota il fatto che i (un int) non è convertibile implicitamente nel tipo di x (short), l'assegnazione perciò non è valida e otteniamo errore.
Se volete indagare di più, stanno sempre a vostra disposizione le specifiche C# e Java.