Чи може змінна Java відрізнятися від самої себе?

Мені цікаво, чи можна це питання вирішити на Java (я новачок у мові). Це код:

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

У моїй лабораторії я отримав таке запитання: Як можна пропустити перший випадок (тобто зробити x == xумову помилковою), не змінюючи саму умову?

Одним із простих способів є використання Float.NaN:

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

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

Не добре

Ви можете зробити те ж саме і з Double.NaN.

З JLS §15.21.1. Оператори чисельної рівності ==та!= :

Тестування рівності з плаваючою комою проводиться відповідно до правил стандарту IEEE 754:

• Якщо будь-який операнд - NaN, то результат ==є, falseале результат !=є true.

  Дійсно, тест x!=x- це trueтоді і лише тоді, коли значення xNaN.

...

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

За специфікаціями мови Java NaN не дорівнює NaN.

Тому будь-який рядок, який викликав xрівність NaN, спричинив би це, наприклад

double x=Math.sqrt(-1);

Із специфікацій мови Java:

Оператори з плаваючою комою не створюють винятків (§11). Операція, що переповнює, створює підписану нескінченність, операція, що перетікає, виробляє денормалізоване значення або підписаний нуль, а операція, яка не має математично визначеного результату, виробляє NaN. Усі числові операції з NaN як операндом дають NaN як результат. Як уже було описано, NaN є не упорядкованим, тому чисельна операція порівняння, що включає один або два NaN, повертає помилкові і будь-які! = Порівняння, що включає NaN, повертає істинне, включаючи x! = X, коли x - NaN.

Не впевнений, що це варіант, але зміна xз локальної змінної на поле дозволить іншому потоку змінити своє значення між лівою та правою стороною читання у ifоператорі.

Ось коротка демонстрація:

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

Вихід:

⋮
Ok
Ok
Ok
Ok
Ok
Ok
Ok
Ok
Not ok

Замінений рядок міг прочитати.

double x = Double.NaN;

Це призведе до друку ґутчі.

Специфікація мови Java (JLS) говорить:

Оператори з плаваючою комою не створюють винятків (§11). Операція, що переповнює, створює підписану нескінченність, операція, що перетікає, виробляє денормалізоване значення або підписаний нуль, а операція, яка не має математично визначеного результату, виробляє NaN. Усі числові операції з NaN як операндом дають NaN як результат. Як уже було описано, NaN є не упорядкованим, тому чисельна операція порівняння, що включає один або два NaN, повертає помилкові і будь-які! = Порівняння, що включає NaN, повертає істинне, включаючи x! = X, коли x - NaN.

Мені вдалося отримати Gotcha!таке:

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

Є так багато рішень:

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

Одне просте рішення:

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

Але я не знаю всіх правил цієї загадки ...

:) Я знаю, що це чіт, але не знаючи всіх правил, це найпростіший варіант вирішення питання :)

Створіть свій власний клас Systemу тому ж пакеті з Condition.
У цьому випадку ваш Systemклас приховає java.lang.Systemклас

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

Використовуючи той же підхід пропуску / зміни виводу з інших відповідей:

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