¿Cómo puede una variable de Java ser diferente de sí misma?

Me pregunto si esta pregunta se puede resolver en Java (soy nuevo en el idioma). Este es el código:

class Condition {
    // you can change in the main
    public static void main(String[] args) { 
        int x = 0;
        if (x == x) {
            System.out.println("Ok");
        } else {
            System.out.println("Not ok");
        }
    }
}

Recibí la siguiente pregunta en mi laboratorio: ¿Cómo se puede omitir el primer caso (es decir, hacer que la x == xcondición sea falsa) sin modificar la condición en sí?

Una forma sencilla es utilizar Float.NaN:

float x = Float.NaN;  // <--

if (x == x) {
    System.out.println("Ok");
} else {
    System.out.println("Not ok");
}

No está bien

Puedes hacer lo mismo con Double.NaN.

De JLS §15.21.1. Operadores de igualdad numérica ==y!= :

La prueba de igualdad de punto flotante se realiza de acuerdo con las reglas del estándar IEEE 754:

• Si cualquiera de los operandos es NaN, entonces el resultado de ==es falsepero el resultado de !=es true.

  De hecho, la prueba x!=xes truesi y solo si el valor de xes NaN.

...

int x = 0;
if (x == x) {
    System.out.println("Not ok");
} else {
    System.out.println("Ok");
}

Según las especificaciones del lenguaje Java NaN no es igual a NaN.

Por lo tanto, cualquier línea que cause xser igual a NaNcausaría esto, como

double x=Math.sqrt(-1);

De las especificaciones del lenguaje Java:

Los operadores de coma flotante no producen excepciones (§11). Una operación que se desborda produce un infinito con signo, una operación que se desborda produce un valor desnormalizado o un cero con signo, y una operación que no tiene un resultado matemáticamente definido produce NaN. Todas las operaciones numéricas con NaN como operando producen NaN como resultado. Como ya se ha descrito, NaN no está ordenado, por lo que una operación de comparación numérica que involucra uno o dos NaN devuelve falso y cualquier comparación! = Que involucre NaN devuelve verdadero, incluyendo x! = X cuando x es NaN.

No estoy seguro de si esta es una opción, pero cambiar xde variable local a un campo permitiría que otro hilo cambie su valor entre la lectura del lado izquierdo y derecho en la ifdeclaración.

Aquí hay una breve demostración:

class Test {

    static int x = 0;

    public static void main(String[] args) throws Exception {

        Thread t = new Thread(new Change());
        t.setDaemon(true);
        t.start();

        while (true) {
            if (x == x) {
                System.out.println("Ok");
            } else {
                System.out.println("Not ok");
                break;
            }
        }
    }
}

class Change implements Runnable {
    public void run() {
        while (true)
            Test.x++;
    }
}

Salida:

⋮
Ok
Ok
Ok
Ok
Ok
Ok
Ok
Ok
Not ok

La línea reemplazada podía leer.

double x = Double.NaN;

Esto haría que se imprimiera el gotcha.

La especificación del lenguaje Java (JLS) dice:

Los operadores de coma flotante no producen excepciones (§11). Una operación que se desborda produce un infinito con signo, una operación que se desborda produce un valor desnormalizado o un cero con signo, y una operación que no tiene un resultado matemáticamente definido produce NaN. Todas las operaciones numéricas con NaN como operando producen NaN como resultado. Como ya se ha descrito, NaN no está ordenado, por lo que una operación de comparación numérica que involucra uno o dos NaN devuelve falso y cualquier comparación! = Que involucre NaN devuelve verdadero, incluyendo x! = X cuando x es NaN.

Me las arreglé para obtener una Gotcha!de esto:

volatile Object a = new Object();

class Flipper implements Runnable {
  Object b = new Object();

  public void run() {
    while (true)  {
      Object olda = a;
      a = b;
      a = olda;
    }
  }

}

public void test() {
  new Thread(new Flipper()).start();

  boolean gotcha = false;
  while (!gotcha) {
    // I've added everything above this - I would therefore say still legal.
    if (a == a) {
      System.out.println("Not yet...");
    } else {
      System.out.println("Gotcha!");
      // Uncomment this line when testing or you'll never terminate.
      //gotcha = true;
    }
  }
}

Hay tantas soluciones:

class A extends PrintStream {
    public A(PrintStream x) {super(x);}
    public void println(String x) {super.println("Not ok");}
    public static void main(String[] args) {
        System.setOut(new A(System.out));
        int x = 0;
        if (x == x) {
            System.out.println("Ok");
        } else {
            System.out.println("Not ok");
        }
    }
}

Una solución sencilla es:

System.out.println("Gotcha!");if(false)
if( a == a ){
  System.out.println("Not yet...");
} else {
  System.out.println("Gotcha!");
}

Pero no conozco todas las reglas de este acertijo ...

:) Sé que esto es una trampa, pero sin conocer todas las reglas, ¿es esta la solución más fácil a la pregunta :)

Crea tu propia clase Systemen el mismo paquete con Condition.
En este caso, su Systemclase ocultará la java.lang.Systemclase.

class Condition
{
    static class System
    {
        static class out
        {
            static void println(String ignored)
            {
                java.lang.System.out.println("Not ok");
            }
        }
    }

    public static void main (String[] args) throws java.lang.Exception
    {
        int x = 0;
        if (x == x) 
        {
           System.out.println("Not ok");
        } 
        else 
        {
           System.out.println("Ok");
        }
    }
}  

DEMO de Ideone

Usando el mismo enfoque de salida de salto / cambio de otras respuestas:

class Condition {
    public static void main(String[] args) {
        try {
            int x = 1 / 0;
            if (x == x) {
                System.out.println("Ok");
            } else {
                System.out.println("Not ok");
            }
        } catch (Exception e) {
            System.out.println("Not ok");
        }
    }
}