¿Cómo declaras xey de modo que x + = y da un error de compilación y x = x + y no?

Question

Me encontré con esta pregunta en una entrevista y no pude encontrar una solución. Sé que el viceversa se puede hacer como se muestra en What does the "+=" operator do in Java?

Así que la pregunta era como a continuación.

..... x = .....; 
..... y = .....; 

x += y; //compile error 
x = x + y; //works properly 

Answer 1

Prueba este código

Object x = 1; 
String y = ""; 

x += y; //compile error 
x = x + y; //works properly 

no del todo seguro de por qué esto funciona, pero el compilador dice

El operador + = no está definido para el tipo de argumento (s) Object, String

y supongo que para la segunda línea, toString es ca llenó el Objeto.

EDIT:

Tiene sentido ya que el operador += no tiene sentido en un objeto general. En mi ejemplo, yo echo un int a un objeto, pero sólo depende de x ser del tipo de objeto:

Object x = new Object(); 

Sólo funciona si x es objeto, sin embargo, lo que en realidad creo que es más que la cadena es una directa subclase de Object. Esto se producirá un error de x + y:

Foo x = new Foo(); 

para otros tipos que he probado.

Answer 2

No es posible.

X x = ...; 
Y y = ...; 

x += y;   //1 
//equivalent to 
x = (X) (x+y); //2 

x = x+y;  //3 

Supongamos que el tipo de x+y es Z. # 2 requiere una conversión de colada de la Z a X; # 3 requiere una conversión de asignación de Z a X. "las conversiones de conversión son más inclusivas que las conversiones de asignación" (1). Por lo tanto, siempre que el # 3 sea legal, el # 2 es legal y el # 1 es legal.

En el reverso, es posible que # 1 es legal, pero # 3 es ilegal, por ejemplo

byte x = 0; 
    int y = 1; 
    x+=y;  // ok, x=(byte)(x+y), cast int to byte is allowed. 
    x = x+y; // error, assign int to byte 

Esta información no es útil en absoluto; es un defecto de Java que hace tales diferencias sorprendentes.

(1) http://java.sun.com/docs/books/jls/third_edition/html/conversions.html#5.5

Answer 3

int i = 5; 
String s = "a"; 
System.out.println(i+=s); //Error 
System.out.println(i+s); // No error 

Básicamente, funciona para cualquier objeto o cualquier combinación no sea una cadena primitiva y de cadena.

Me pregunto de qué compañía era?:)

Answer 4

Esta cosa no siempre te dará error de compilación

Si usted está haciendo smoething así:

class A{ 
public static void main(String args[]){ 
    String x = "10"; 
    String y = "s"; 
    x += y; 
    System.out.println(x); 
} 
} 

no tendrán ningún problema

incluso si lo hace

class A{ 
public static void main(String args[]){ 
    int x = 10; 
    float y = 11.5F; 
    x += y; 
    System.out.println(x); 
} 
} 

funcionará correctamente.

pero si se toma x e y de dos tipos de variables como:

class X{ 
} 
class A{ 
public static void main(String args[]){ 
    X x = new X(); 
    float y = 11.5F; 
    x += y; 
    System.out.println(x); 
} 
} 

En tales casos, se producirá un error al compilar.

* Incluso puede concatinar cualquier int, flotar, etc. con String.