Como uma variável Java pode ser diferente de si mesma?

Estou me perguntando se essa questão pode ser resolvida em Java (eu sou novo na linguagem). Este é o 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");
        }
    }
}

Recebi a seguinte pergunta em meu laboratório: Como você pode ignorar o primeiro caso (ou seja, tornar a x == xcondição falsa) sem modificar a própria condição?

Uma maneira simples é usar Float.NaN:

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

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

Não está tudo bem

Você pode fazer o mesmo com Double.NaN.

De JLS §15.21.1. Operadores de igualdade numérica ==e!= :

O teste de igualdade de ponto flutuante é realizado de acordo com as regras do padrão IEEE 754:

• Se qualquer operando for NaN, o resultado de ==é, falsemas o resultado de !=é true.

  Na verdade, o teste x!=xé truese e somente se o valor de xfor NaN.

...

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

Pelas especificações da linguagem Java NaN não é igual a NaN.

Portanto, qualquer linha que causasse xser igual a NaNcausaria isso, como

double x=Math.sqrt(-1);

Nas especificações da linguagem Java:

Operadores de ponto flutuante não produzem exceções (§11). Uma operação que estourou produz um infinito com sinal, uma operação que estourou produz um valor desnormalizado ou um zero com sinal e uma operação que não teve nenhum resultado matematicamente definido produz NaN. Todas as operações numéricas com NaN como operando produzem NaN como resultado. Como já foi descrito, NaN não é ordenado, portanto, uma operação de comparação numérica envolvendo um ou dois NaNs retorna falso e qualquer comparação! = Envolvendo NaN retorna verdadeiro, incluindo x! = X quando x é NaN.

Não tenho certeza se esta é uma opção, mas mudar xde variável local para um campo permitiria que outro segmento alterasse seu valor entre a leitura do lado esquerdo e direito na ifinstrução.

Aqui está uma breve demonstração:

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

Resultado:

⋮
Ok
Ok
Ok
Ok
Ok
Ok
Ok
Ok
Not ok

A linha substituída pode ler.

double x = Double.NaN;

Isso faria com que o pegadinha fosse impresso.

Especificação da linguagem Java (JLS) diz:

Operadores de ponto flutuante não produzem exceções (§11). Uma operação que estourou produz um infinito com sinal, uma operação que estourou produz um valor desnormalizado ou um zero com sinal, e uma operação que não tem resultado matematicamente definido produz NaN. Todas as operações numéricas com NaN como operando produzem NaN como resultado. Como já foi descrito, NaN não é ordenado, portanto, uma operação de comparação numérica envolvendo um ou dois NaNs retorna falso e qualquer comparação! = Envolvendo NaN retorna verdadeiro, incluindo x! = X quando x é NaN.

Consegui obter um Gotcha!deste:

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

Existem tantas soluções:

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

Uma solução fácil é:

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

Mas eu não sei todas as regras para este enigma ...

:) Eu sei que isso é uma trapaça, mas sem conhecer todas as regras, essa é a solução mais fácil para a questão :)

Crie sua própria classe Systemno mesmo pacote com Condition.
Neste caso, sua Systemclasse irá esconder a 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

Usando a mesma abordagem de salto / alteração de saída de outras respostas:

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