Методические указания к лабораторной работе №2 «Условные операторы»
Оглавление
1. Теоретические основы 3
2. Постановка задачи 9
3. Варианты заданий 10
Задание 1 10
Задание 2 13
Приложение А. Операции Java 14
Список источников 15
Теоретические основы
Помимо изученных в прошлой лабораторной работе арифметических операций (+, -, *, /, %) и операции присваивания (=) существуют также операции сравнения.
Существуют следующие операции сравнения:
== равно
!= не равно
> больше
>= больше или равно
< меньше
<= меньше или равно
Обратите внимание, что для сравнения необходимо использовать операцию «==», а не «=». Приведенные операции выполняют сравнение двух частей выражения и возвращают значение типа boolean, то есть true или false.
Существуют еще логические операции:
&& операция И
|| операция ИЛИ
! операция НЕ
Логические операции позволяют объединять несколько операций сравнения, к примеру, если a = 10 и b = 4, то следующее выражение:
(a > b) && (a != 10)
вернет false, так как второе условие не выполнено.
В приложении А можно посмотреть список операций Java.
Мы уже знаем о существовании различных операторов, к примеру:
// оператор объявления
int a;
// оператор присваивания
a = 1;
// оператор вызова метода
System.out.println("Hello World!");
Операторы могут объединяться в блоки. Блок, или составной оператор, это группа из нуля или более операторов, заключенных в фигурные скобки:
Формат:
{
<оператор>
<оператор>
…
<оператор>
}
Составной оператор определяет область видимости переменных. Переменные, объявленные в рамках составного оператора видны только внутри этого блока. К примеру:
public static void main(String[] args) {
int a = 2;
{
int x = 15;
x = x + 2; // ошибки не возникает, переменная доступна внутри блока
}
System.out.println(x); // ошибка! переменная не видна вне блока
}
Блок операторов, заключенных в фигурные скобки, воспринимается как единое целое и может находиться в любом месте программы, где синтаксис языка допускает наличие составного оператора, к примеру, в управляющих операторах.
Управляющие операторы используются в языках программирования для того, чтобы продвигать и разветвлять поток выполнения программы. Операторы управления Java можно разделить на следующие категории: ветвление, повторение (итерация) и переход. Темой данной лабораторной работы будут операторы ветвления, или условные операторы.
Java поддерживает два оператора выбора if и switch. Эти операторы позволяют управлять потоком выполнения программы, основываясь на условиях, проверяемых во время выполнения. Они обеспечивают выполнение (или невыполнение) некоторого оператора или блока (составного оператора) в зависимости от заданных условий.
Оператор IF
Простейшая форма этого оператора говорит программе выполнять некоторый оператор или блок, только если некоторое условие истинно. Его форма:
if (<условие>)
<блок операторов>
или
if (<условие>)
<оператор>
< условие > - это выражение, возвращающее результат типа boolean,чаще всего с операциями сравнения и логическими операциями. К примеру, a<5. Или переменная типа boolean.
Пример. Код, выводящий в консоль сообщение только если переменная a больше 10:
public static void main(String[] args) {
int a = 20;
// ... производим какие-то действия с a
if (a > 10) {
System.out.println("Переменная a больше чем 10!");
}
}
Так как в блоке операторов только один оператор, то можно было записать вот так:
if (a > 10)
System.out.println("Переменная a больше чем 10!");
Некоторые программисты находят удобным включать фигурные скобки, даже когда в ветви if имеется только один оператор. Это облегчает последующее добавление операторов в ветви if, и не нужно волноваться относительно пропуска фигурных скобок. Их пропуск при определении блока, когда они необходимы – частая причина ошибок.
Более сложная форма это оператор if-else. Он направляет выполнение по двум разным маршрутам:
if (<условие>)
<оператор1 или блок операторов1>
else
<оператор2 или блок операторов2>
Если <условие> имеет значение true, то выполняется <оператор1 или блок операторов1>, иначе – выполняется <оператор2 или блок операторов2>. К примеру, программа, определяющая максимальное из двух чисел:
public static void main(String[] args) {
int a = 20, b = 30;
int max;
if (a > b) {
System.out.println("Переменная a больше чем b!");
max = a;
} else {
System.out.println("Переменная b больше чем a!");
max = b;
}
System.out.println("Значение максимального числа = " + max);
}
Вывод в консоль:
Переменная b больше чем a!
Значение максимального числа = 30
Пример сложного условия, образованного из нескольких операций сравнения, соединенных логическими операциями:
if (a > 0 && b > 0) {
c = Math.sqrt(a) + Math.sqrt(b);
System.out.println(c);
} else
System.out.println("Некорректные значения a, b");
Также существует такая форма оператора: if-else-if. К примеру, программа, определяющая оценку в зависимости от баллов за тест:
public static void main(String[] args) {
int testscore = 76;
char grade;
if (testscore >= 90) {
grade = 'A';
} else if (testscore >= 80) {
grade = 'B';
} else if (testscore >= 70) {
grade = 'C';
} else if (testscore >= 60) {
grade = 'D';
} else {
grade = 'F';
}
System.out.println("Оценка = " + grade);
}
Вывод в консоль:
Оценка = C
Программа последовательно проверяет выполнение условий. При невыполнении очередного условия переходит к проверке следующего. Если какое либо условие выполнилось, выполняется соответствующий блок операторов, и далее проверка оставшихся условий не производится.
Оператор SWITCH
Это оператор множественного ветвления. Он переключает выполнение на различные части кода программы, основываясь на значении выражения, и часто обеспечивает лучшую альтернативу, чем длинный ряд операторов if-else-if. Общая форма оператора switch:
switch (<выражение>) {
case <значение_1>:
< последовательность операторов 1>
break;
case <значение_2>:
< последовательность операторов 2>
break;
...
case <значение_n>:
< последовательность операторов n>
break;
default:
< последовательность операторов по умолчанию>
}
Здесь <выражение> должно иметь тип byte, short, int, char. Также он работает со строками, перечислениями, и некоторыми классами. Каждое <значение> должно быть уникальной константой (а не переменной). Дублирование не допустимо.
Оператор switch работает следующим образом. Значение выражения сравнивается с каждым из указанных значений в case-операторах. Если соответствие найдено, то выполняется последовательность операторов, следующая после этого оператора case. Если ни одно из значений не соответствует значению выражения, то выполняется последовательность операторов по умолчанию после default. Однако оператор default не обязателен. Если его нет, и ни одно из значений не совпало, то никаких дальнейших действий не требуется. Оператор break используется внутри switch, чтобы закончить последовательность операторов. Когда встречается break, выполнение программы переходит к первой строке кода, которая следует за закрывающей скобкой оператора switch.
Простой пример, использующий оператор switch:
public static void main(String[] args) {
int mark = 3;
switch (mark) {
case 1:
System.out.println("Кол!");
break;
case 2:
System.out.println("Неуд!");
break;
case 3:
System.out.println("Удовлетворительно!");
break;
case 4:
System.out.println("Хорошо!");
break;
case 5:
System.out.println("Отлично!");
break;
default:
System.out.println("Такой оценки нет !");
}
}
Вывод в консоль:
Удовлетворительно!
Оператор break не обязательный. Если он пропускается, выполнение будет продолжаться со следующей case-метки. К примеру:
public static void main(String[] args) {
int x = 3;
switch (x) {
case 1: case 2: case 3:
case 4:
System.out.println("x меньше пяти!");
break;
case 5: case 6: case 7: case 8:
case 9:
System.out.println("x меньше десяти!");
break;
default:
System.out.println("x равно или больше десяти!");
}
}
Вывод в консоль:
x меньше пяти!