В Java можем да използваме числа с плаваща запетая, които ни позволяват да смятаме с приближена точност реалните числа от математиката. Например при следната програма ще видим коректно отпечатан резултат 3.5:

 double a = 7;
 double b = 2;
 double result = a/b;
 System.out.println(result);

Сега обаче ще го пресметнем на един ред – без да заделяме специални променливи за 7 и 2:

 double result = 7/2;
 System.out.println(result);

Странно, но факт – резултатът от изпълнението ще е 3.0. Защо се получи така?

И в двата примера има имплицитно превръщане на типове данни от целочислен към плаваща запетая. В лявата част на равенствата имаме променливи от тип double, но в дясната част на равенствата имаме тип int, който се превръща в double. В първият пример 7 се превръща в 7.0 и тогава се присвоява на “a”, след това 2 се превръща в 2.0 и се присвоява на “b”. Така делението a/b всъщност е 7.0/2.0, което е деление на две числа с плаваща запетая и дава резултат 3.5. Във втория пример имаме директно деление на целочисленото 7 с целочисленото 2, което дава целочислен резултат 3 – едва тогава той се превръща в числото с плаваща запетая 3.0 и се присвоява на “result”. Коректен резултат би се получил ако експлицитно зададем, че работим с числа с плаваща запетая:

 double result = 7.0/2.0;
 System.out.println(result);

или

 double result = 7d/2d; 
 System.out.println(result);

В тази задача се тренира не само имплицитното превръщане на типовете от данни, но и приоритета на операциите. Поради тази причина вероятно ще е по-добре първо да се покажат по-прости примери за имплицитно превръщане на типове и едва след това да се подходи с този софизъм.