Czym zmienna Java może się różnić od siebie?

Zastanawiam się, czy to pytanie można rozwiązać w Javie (jestem nowy w tym języku). To jest kod:

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

W moim laboratorium otrzymałem następujące pytanie: Jak można pominąć pierwszy przypadek (tj. Uczynić x == xwarunek fałszywym) bez modyfikowania samego warunku?

Jednym prostym sposobem jest użycie Float.NaN:

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

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

Nie w porządku

Możesz zrobić to samo z Double.NaN.

Z JLS §15.21.1. Liczbowe operatory równości ==i!= :

Testowanie zmiennoprzecinkowe równości wykonywane jest zgodnie z zasadami normy IEEE 754:

• Jeśli którykolwiek z operandów jest NaN, to wynik ==jest, falseale wynik !=jest true.

  Rzeczywiście, test x!=xjest truewtedy i tylko wtedy, gdy wartość xwynosi NaN.

...

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

Według specyfikacji języka Java NaN nie jest równa NaN.

Dlatego każda linia, która spowodowała, że xbyłaby równa NaN, spowodowałaby to, na przykład

double x=Math.sqrt(-1);

Ze specyfikacji języka Java:

Operatory zmiennoprzecinkowe nie powodują żadnych wyjątków (§11). Operacja, która się przepełnia, tworzy nieskończoność ze znakiem, operacja, która powoduje niedomiar, wytwarza zdenormalizowaną wartość lub zero ze znakiem, a operacja, która nie ma matematycznie określonego wyniku, daje NaN. Wszystkie operacje numeryczne z NaN jako operandem dają wynik NaN. Jak już wspomniano, NaN jest nieuporządkowany, więc operacja numerycznego porównania obejmująca jeden lub dwa NaN zwraca fałsz, a każde! = Porównanie obejmujące NaN zwraca prawdę, w tym x! = X, gdy x jest NaN.

Nie jestem pewien, czy jest to opcja, ale zmiana xzmiennej lokalnej na pole umożliwiłaby innemu wątkowi zmianę wartości między odczytem lewej i prawej strony ifinstrukcji.

Oto krótkie 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++;
    }
}

Wynik:

⋮
Ok
Ok
Ok
Ok
Ok
Ok
Ok
Ok
Not ok

Zastąpiona linia mogła czytać.

double x = Double.NaN;

Spowodowałoby to wydrukowanie gotcha.

Specyfikacja języka Java (JLS) mówi:

Operatory zmiennoprzecinkowe nie powodują żadnych wyjątków (§11). Operacja, która się przepełnia, tworzy nieskończoność ze znakiem, operacja, która powoduje niedomiar, wytwarza zdenormalizowaną wartość lub zero ze znakiem, a operacja, która nie ma matematycznie określonego wyniku, daje NaN. Wszystkie operacje numeryczne z NaN jako operandem dają wynik NaN. Jak już wspomniano, NaN jest nieuporządkowany, więc operacja numerycznego porównania obejmująca jeden lub dwa NaN zwraca fałsz, a każde! = Porównanie obejmujące NaN zwraca prawdę, w tym x! = X, gdy x jest NaN.

Udało mi się uzyskać Gotcha!z tego:

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

Rozwiązań jest tak wiele:

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

Jednym prostym rozwiązaniem jest:

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

Ale nie znam wszystkich zasad tej zagadki ...

:) Wiem, że to oszustwo, ale bez znajomości wszystkich zasad to najłatwiejsze rozwiązanie na pytanie :)

Utwórz własną klasę Systemw tym samym pakiecie z Condition.
W takim przypadku Twoja Systemklasa ukryje java.lang.Systemklasę

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

Używając tego samego podejścia pomiń / zmień dane wyjściowe z innych odpowiedzi:

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