Частые ошибки и подводные камни

Ключевой момент: общие ошибки элементарного программирования часто включают необъявленные переменные, неинициализированные переменные, переполнение целого числа, непреднамеренное целочисленное деление и ошибки округления.

Частая ошибка 1: Необъявленные/неинициализированные переменные и неиспользуемые переменные

Переменная должна быть объявлена с типом и её должно быть присвоено значение перед ее использованием. Общей ошибкой является не объявление переменной или не инициализация переменной. Рассмотрим следующий код:

double interestRate = 0.05;
double interest = interestrate * 45;

Этот код неверен, потому что InterestRate присваивается значение 0,05; Но interestrate не была объявлена и инициализирована. Java чувствительна к регистру, поэтому интересRate и interestrate – это две разные переменные.

Если переменная объявлена, но не используется в программе, это может быть потенциальная ошибка программирования. Таким образом, вы должны удалить неиспользуемую переменную из своей программы. Например, в следующем коде taxRate никогда не используется. Она должен быть удалена из кода.

double interestRate = 0.05;
double taxRate = 0.05;
double interest = interestRate * 45;
System.out.println("Interest is " + interest);

Если вы используете IDE, например Eclipse и NetBeans, вы получите предупреждение о неиспользуемых переменных.

Частая ошибка 2: Переполнение целых чисел

Числа хранятся с ограниченным количеством разрядов. Когда переменной присваивается значение, которое слишком велико (по размеру) для хранения, оно вызывает переполнение. Например, выполнение следующей инструкции вызывает переполнение, поскольку наибольшее значение, которое может быть сохранено в переменной типа int, равно 2147483647. 2147483648 будет слишком большим для значения int.

int value = 2147483647 + 1;
// фактическим значением будет -2147483648

Аналогично, выполнение следующего оператора вызывает переполнение, поскольку наименьшее значение, которое может быть сохранено в переменной типа int, равно -2147483648. -2147483649 — слишком большой размер для хранения в переменной int.     

int value = -2147483648 - 1;
// фактическим значением будет 2147483647

Java не сообщает о предупреждениях или ошибках при переполнении, поэтому будьте осторожны при работе с числами, близкими к максимальному или минимальному диапазону заданного типа.

Когда число с плавающей запятой слишком мало (т. е. слишком близко к нулю), которое должно быть сохранено, это приводит к переполнению. Java аппроксимирует его до нуля, поэтому обычно вам не нужно беспокоиться о нижнем уровне.

Частая ошибка 3: Ошибки округления

Ошибка округления является разницей между рассчитанной аппроксимацией числа и его точным математическим значением. Например, 1/3 составляет приблизительно 0,333, если вы сохраняете три десятичных знака, и составляет 0,3333333, если вы сохраняете семь знаков после запятой. Поскольку количество цифр, которые могут быть сохранены в переменной, ограничено, ошибки округления неизбежны. Расчеты с использованием чисел с плавающей запятой аппроксимируются, поскольку эти числа не сохраняются с полной точностью. Например,

System.out.println(1.0 - 0.1 - 0.1 - 0.1 - 0.1 - 0.1);

Отображает 0,5000000000000001, а не 0,5, и

System.out.println(1.0 - 0.9);

Отображает 0.09999999999999998, а не 0,1. Целые числа хранятся точно. Поэтому вычисления с целыми числами дают точный целочисленный результат.

Частая ошибка 4: Непреднамеренное деление целых чисел

Java использует один и тот же оператор деления, а именно /, для выполнения как целочисленного, так и деления с плавающей запятой. Когда два операнда являются целыми числами, оператор / выполняет целочисленное деление. Результатом операции является целое число. Дробная часть усечена. Чтобы заставить два целых числа выполнить деление с плавающей запятой, сделайте одно из целых чисел числом с плавающей запятой. Например, код в (a) показывает, что среднее значение равно 1, а код в (b) показывает, что среднее значение равно 1,5.

Распространённый подводный камень 1: Избыточные объекты ввода

Новые программисты часто пишут код для создания нескольких входных объектов для каждого входа. Например, следующий код читает целое число и двойное значение.

Scanner input = new Scanner(System.in);
System.out.print("Enter an integer: ");
int v1 = input.nextInt();
Scanner input1 = new Scanner(System.in);
System.out.print("Enter a double value: ");
double v2 = input1.nextDouble();

Код не ошибочен, но неэффективен. Он создает два входных объекта без необходимости и может привести к некоторым небольшим ошибкам. Вы должны переписать код следующим образом:

Scanner input = new Scanner(System.in);
System.out.print("Enter an integer: ");
int v1 = input.nextInt();
System.out.print("Enter a double value: ");
double v2 = input.nextDouble();

Проверь себя:

1. Можете ли вы объявить переменную как int, а затем переопределить ее как double?
2. Что такое переполнение целого числа? Может ли операция с плавающей запятой вызывать переполнение?
3. Будет ли переполнение причиной ошибки во время выполнения?
4. Что такое ошибка округления? Могут ли целые операции вызывать ошибки округления? Могут ли операции с плавающей запятой вызывать ошибки округления?