Come può una variabile Java essere diversa da se stessa?

Mi chiedo se questa domanda possa essere risolta in Java (sono nuovo nel linguaggio). Questo è il codice:

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");
        }
    }
}

Ho ricevuto la seguente domanda nel mio laboratorio: come puoi saltare il primo caso (cioè rendere x == xfalsa la condizione) senza modificare la condizione stessa?

Un modo semplice è usare Float.NaN:

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

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

Non bene

Puoi fare lo stesso con Double.NaN.

Da JLS §15.21.1. Operatori di uguaglianza numerica ==e!= :

Il test di uguaglianza in virgola mobile viene eseguito in conformità con le regole dello standard IEEE 754:

• Se uno degli operandi è NaN, il risultato di ==è falsema il risultato di !=è true.

  In effetti, il test x!=xè truese e solo se il valore di xè NaN.

...

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

Dalle specifiche del linguaggio Java NaN non è uguale a NaN.

Pertanto qualsiasi linea che ha causato xessere uguale a NaNcauserebbe questo, come

double x=Math.sqrt(-1);

Dalle specifiche del linguaggio Java:

Gli operatori in virgola mobile non producono eccezioni (§11). Un'operazione che ha un overflow produce un infinito con segno, un'operazione che un underflow produce un valore denormalizzato o uno zero con segno e un'operazione che non ha un risultato matematicamente definito produce NaN. Tutte le operazioni numeriche con NaN come operando producono NaN come risultato. Come è già stato descritto, NaN non è ordinato, quindi un'operazione di confronto numerico che coinvolge uno o due NaN restituisce false e qualsiasi! = Confronto che coinvolge NaN restituisce true, incluso x! = X quando x è NaN.

Non sono sicuro che questa sia un'opzione, ma il passaggio xda una variabile locale a un campo consentirebbe ad un altro thread di modificare il suo valore tra la lettura a sinistra ea destra ifnell'istruzione.

Ecco una breve demo:

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++;
    }
}

Produzione:

⋮
Ok
Ok
Ok
Ok
Ok
Ok
Ok
Ok
Not ok

La riga sostituita potrebbe leggere.

double x = Double.NaN;

Ciò causerebbe la stampa del gotcha.

Java Language Specification (JLS) dice:

Gli operatori in virgola mobile non producono eccezioni (§11). Un'operazione che eccede produce un infinito con segno, un'operazione che genera un valore insufficiente produce un valore denormalizzato o uno zero con segno e un'operazione che non ha un risultato matematicamente definito produce NaN. Tutte le operazioni numeriche con NaN come operando producono NaN come risultato. Come è già stato descritto, NaN non è ordinato, quindi un'operazione di confronto numerico che coinvolge uno o due NaN restituisce false e qualsiasi! = Confronto che coinvolge NaN restituisce true, incluso x! = X quando x è NaN.

Sono riuscito a ottenere un Gotcha!da questo:

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;
    }
  }
}

Ci sono tante soluzioni:

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 semplice soluzione è:

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

Ma non conosco tutte le regole di questo indovinello ...

:) So che questo è un trucco, ma senza conoscere tutte le regole, è questa la soluzione più semplice alla domanda :)

Crea la tua classe Systemnello stesso pacchetto con Condition.
In questo caso la tua Systemclasse nasconderà la java.lang.Systemclasse

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");
        }
    }
}  

Ideone DEMO

Utilizzando lo stesso approccio salta / modifica l'output da un'altra risposta:

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");
        }
    }
}