Class primer13
{
static Scanner reader=new Scanner(System.in);
public static void main(String[] args)
{
int x,dig1,dig2,dig3,dig4;
x=reader.nextInt();
dig1=x/1000;
dig2=(x/100)%10;
dig3=(x/10)%10;
dig4=x%10;
System.out.println(x+”=”+dig1*1000+"+"+dig2*100+"+"+dig3*10+"+"+dig4);
}
}
Разумеется, аналогичным образом можно «расчленять» числа с большим количеством цифр, можно «вычленять» из одного числа другие, «внутренние» ему числа (из трехзначного, например, двузначные), а также придумывать разные иные "игры с числами". Надо сказать, что это целый класс довольно интересных и далеко не всегда простых задач.
Раздел №8.
Команда выбора (ветвления)
Возможно, перед началом знакомства с этим разделом, стоит сначала прочитать материал из раздела №18, поскольку именно там рассматриваются так называемые логические, или булевы, выражения, являющиеся неотъемлемой частью команд выбора.
Все примеры, которые мы решали и разбирали до сих пор, были построены по так называемому "линейному принципу". Этот принцип означает, что команды в классе были "выстроены в линию" и с точки зрения их расположения в теле главного метода класса ("первая команда, за ней вторая, третья, четвертая…"), и в смысле их исполнения ("сначала исполняется первая команда, за ней вторая, третья, четвертая…").
"Линейный класс" построен по принципу "как пишется, так и работает": выполняются все до одной команды и строго в том порядке, в каком они записаны в главном методе.
Однако это – совершенно не обязательное правило! Более того – в большинстве классов содержатся так называемые "команды ветвления", которые, в зависимости от данных и результатов проверки данных, направляют исполнение класса либо по одной группе команд ("ветке"), либо – по другой.
Поскольку то, по какой из "веток" направляется исполнение класса, зависит от проверки каких-то условий, команда ветвления часто называется еще и "условным оператором".
Есть у нее и еще одно, также популярное название – "команда выбора": это связано с тем, что она, проверяя данные в условии, выбирает вариант исполнения ("ветку").
Вот об этой команде ветвления, она же – команда выбора, она же – условный оператор, и будет идти речь и в этой теме, и в нескольких следующих.
Следует иметь в виду, что команда выбора относится к числу наиболее часто встречающихся, наиболее широко употребляемых инструментов языка Java (да и вообще практически любого языка – невозможно себе представить, что нет в языке необходимости проверки данных).
Это – одна из самых важных команд в любом языке, потому что с ее помощью становится возможным «различать» разные значения, разные соотношения между значениями, направлять исполнение программы по разным ветвям.
Важно начать изучение команды выбора с самых простых вариантов, постепенно усложняя возможности записи и исполнения этой команды. Дело тут в том, что «мощность» команды выбора скрывает в себе опасность для недостаточно опытного, особенно в формальной логике, программиста (а школьник – это как раз это случай и есть). Опасность эта – риск запутаться не в технике написания команды, а именно в понимании логики, которой должна следовать эта команда.
На начальной стадии изучения команды выбора (ветвления) во всех примерах мы будем использовать только одно условие. Разумеется, что возможна проверка сразу нескольких условий (это когда речь идет о так называемом "составном условии"), но мы займемся правилами записи составных условий позже.
Раздел №9.
Короткий оператор выбора (if без else)
Суть работы такого оператора выглядит следующим образом: если некое условие выполняется (является правильным, истинным), то надо выполнить некоторое действие.
А если это условие не выполняется? Что ж, в этом случае класс просто переходит к исполнению следующей команды.
Таким образом, распределение в таком операторе "по веткам" выглядит так:
· одной "веткой" в таком операторе является команда или группа команд (блок), записанные как часть самой команды выбора (ветвления);
· второй "веткой" является следующая (по порядку) команда класса.
| Короткий оператор выбора (на языке Java) | Смысл оператора (перевод на «нормальный» язык) |
| if (a>0) System.out.println(“positive”); | Если значение переменной а больше нуля (переменная а хранит положительное значение), то на экран выводится слово positive |
| if (a>b) System.out.println(a-b); | Если значение переменной а больше значения переменной b, то на экран выводится разница между значение переменной а и значением переменной b |
| if (a==0) a=4; | Если значение переменной а равно нулю, то переменной а присваивается новое значение, равное 4 |
| if (a!=b) c=a*b; | Если значение переменной а не равно значению переменной b, то переменная с получает значение, равное произведению значений переменных а и b |
Важно соблюдать одно техническое требование языка Java: проверяемое в операторе выбора условие обязательно(!) должно быть заключено в скобки.
И обратите внимание, что в приведенных выше примерах "ветка" внутри команды выбора (ветвления) содержит только одну-единственную команду.
Таблица сравнений, используемых в командах выбора языка Java
| Оператор сравнения | Смысл |
| > | Больше |
| >= | Больше или равно (≥) |
| == | Действительно равно |
| != | Не равно (≠) |
| < | Меньше |
| <= | Меньше или равно (≤) |
В случае, если требуется, чтобы эта исполняемая "ветка" содержала две команды или больше, то ее, эту "ветку", необходимо заключить в фигурные скобки. Приведем примеры таких команд.
| Короткий оператор выбора (на языке Java) | Смысл оператора (перевод на «нормальный» язык) |
| if (a>0) { a++; System.out.println(“positive”); } | Если значение переменной а больше нуля (переменная а хранит положительное значение), то надо сначала увеличить значение этой переменной на 1, а затем вывести на экран слово positive |
| if (a>b) { a++; b-=2; System.out.println(a-b); } | Если значение переменной а больше значения переменной b, то сначала значение переменной а увеличивается на 1, затем значение переменной b уменьшается на 2, а потом на экран выводится разница между новыми значениями переменных а и b |
| if (a==0) { a=4; System.out.println("Ok"); } | Если значение переменной а и в самом деле равно нулю, то сначала переменной а присваивается новое значение, равное 4, а затем на экран выводится сообщение Ok |
| if (a!=b) { c=a*b; a=b; b=0; } | Если значение переменной а не равно значению переменной b, то сначала переменная с получает значение, равное произведению значений переменных а и b, потом переменная а получает значение, хранящееся в переменной b, а после этого значение переменной b устанавливается равным 0 |
Раздел №10.
Стандартная команда выбора (if…else)
В предыдущем разделе мы рассмотрели команду выбора, которая содержала только одну "ветку" – ту, которая исполнялась в случае, если оказывалось правильным условие, записанное в команде. Второй "веткой" при этом была следующая за командой выбора часть класса (точнее – главного метода).
Однако у команды выбора есть вариант, который позволяет записать в самой команде выбора сразу обе "ветки": первую, которая исполняется, когда выполняется содержащееся в команде условие, и вторую – ту, что исполняется, когда записанное в команде условие не выполняется (неверно, не является истинным).
В этом варианте вторая "ветка" начинается со служебного слова else. Такую команду выбора (ветвления) часто называют стандартной командой выбора.
Иными словами, стандартная команда выбора в языке Java состоит из двух частей:
- первая часть: начинается с if, содержит условие и ту группу команд, которая выполняется, если условие оказывается верным;
- вторая часть: начинается с else, содержит только ту группу команд, которая выполняется, если условие оказывается неверным.
В качестве "группы команд" может выступать и одна команда, а в редких, почти не встречающихся случаях – вообще "пустая группа"; хотя очень трудно представить, для чего такое может понадобиться, теоретически существует и такая возможность.
Приведем несколько примеров таких стандартных команд выбора – с пояснениями.
| if (a>5) t=a+7; else t=a-3; | Если значение переменной а больше 5, то переменная t получает значение, на 7 большее значения переменной а; в противном случае переменная t получает значение, на 3 меньшее значения переменной а. |
| if (a>b) c=a+b; else System.out.println(“No”); | Если значение переменной а больше значения переменной b, то переменная с получает значение, равное сумме значений переменных а и b; в противном случае на экран выводится сообщение No |
Разумеется, каждая ветка может содержать не одну-единственную команду, как это показано в приведенных в таблице примерах, а несколько команд. Их в этом случае надо будет объединить в блоки, то есть заключить в фигурные скобки. Более подробно об этом - в следующем разделе.
Раздел №11.
Простая команда выбора с блоком (блоками)
Часто бывает необходимость, чтобы в команде выбора одна или обе "ветки" (и та, что выполняется, когда условие верно, и та, которая выполняется, когда условие не соблюдено) содержали не одну-единственную команду, а несколько команд.
Например, если проверяемое в условии команды выбора значение (переменная) отрицательно, то следует выполнить несколько условий:
· Сначала превратить значение переменной в положительное
· Затем вывести на экран текстовое сообщение Значение изменено на положительное
· Затем увеличить это значение в 4 раза
· И в итоге вывести новое значение на экран в дополнительной строке
Для того, чтобы в команде выбора можно было выполнить все эти действия, в той последовательности, как они описаны, их объединяют в так называемый "блок", то есть группу команд, которые класс воспринимает как единое целое.
Для этого используются уже знакомые нам фигурные скобки (пара фигурных скобок), в которых и записывают нужные для включения в блок команды.
Для нашего примера это будет выглядеть следующим образом:
if (x<0)
{
x=-1*x;
System.out.println("Значение изменено на положительное ");
x=4*x;
System.out.println(x);
}
Точно так же можно использовать блок и после else – следует только обязательно обратить внимание, что в конце первого блока (после закрывающей фигурной скобки, после которой идет else), ни в коем случае не ставится знак "точка с запятой"!
Вот как будет выглядеть команда выбора с двумя блоками:
if (x<0)
{
x=-1*x;
System.out.println("Значение изменено на положительное ");
x=4*x;
System.out.println(x);
}
Else
{
x=2+x;
System.out.println("Новое значение "+x);
}
Мы приводим в качестве примеров словесного описания класса два алгоритма, которые можно "перевести" на язык Java, то есть написать соответствующий алгоритму класс.
Обратите внимание на нумерацию действий в алгоритмах: с ее помощью легко выделить то, что мы только что описывали как "блоки". В частности, в алгоритме №2 таких блоков нет, а в алгоритме №1 – есть: это действия, пронумерованные как (3.1) и (3.2).
Алгоритм №1
1. Введи с клавиатуры целое число для переменной num
2. Если в переменной num находится четное число, то
2.1. Выведи на экран значение переменной num
3. Иначе
3.1. Увеличь значение переменной num на 1
3.2. Выведи на экран значение переменной num
4. Выведи на экран сообщение Работа завершена
Алгоритм №2
1. Введи с клавиатуры две цифры – в переменные dig1 и dig2
2. Если dig1>dig2, то
2.1. numß dig1*10+dig2
3. иначе
3.1. numß dig2*10+dig1
4. Выведи на экран значение переменной num
Раздел №12.
Команда if со сложным условием
До сих пор мы рассматривали задачи, в которых, по сути дела, достаточно было проверить одно условие – или несколько раз разные условия, но, все же, каждое из этих условий проверялось отдельно от остальных.
"…если введенное значение положительно…"
"…если значение первой переменной больше или равно значению второй переменной…"
"…для четного числа… а для нечетного…"
Однако очень часто встречаются ситуации, в которых необходимо проверять не одно-единственное условие, а два; а иногда и больше; что самое главное – проверять их не каждое в независимости от остальных, а все вместе, "в одной связке". В этом случае, команда выбора (ветвления) позволяет использовать сложное (составное) условие.
Сложное (составное) условие состоит из нескольких условий, связанных между собой логическими отношениями, например :
· "и…и…", то есть условия должны выполняться оба, одновременно;
· "или… или…", то есть достаточно выполнение хотя бы одного из условий.
Таблица логических сравнений (для простых условий)
| Пример | Запись сравнения в языке JAVA | Форма записи, принятая в математике | Описание смысла логического сравнения |
| (a==3) | == | = | Равно |
| (a!=0) | != | ≠ | не равно |
| (a<b) | < | > | Меньше |
| (a<=b) | <= | ≤ | меньше или равно |
| (a+b>c) | > | < | Больше |
| (a+b>c*2) | >= | ≥ | больше или равно |
Таблица логических связей между условиями (для составного условия)
| Запись логической связи в языке JAVA | Пример | Описание смысла логической связи в составном условии |
| & | (a<100)&(a>9) | и… и… )AND, И( |
| | | (a==0) | (b==0) | или… или… (OR, ИЛИ) |
| ! | !(a<10) | не |
| && | (a<100)&&(a>9) | "краткое", "быстрое" и (short circuit AND) |
| || | (a==0) || (b==0) | "краткое", "быстрое" или (short circuit OR) |
Таблица истинности
| a | b | a & b a && b | a | b a || b |
| true | true | true | true |
| false | false | false | false |
| true | false | false | true |
| false | true | false | true |
Одной из особенностей языка Java является использование так называемых "быстрых" (иногда их еще называют "краткими") форм логических связей между условиями. На них следует остановиться подробнее, поскольку они и широко распространены, и имеют определенные преимущества и специфику по сравнению со "стандартными" формами записи логических связей между условиями.
Операторы быстрой (краткой) оценки логических выражений (short circuit logical operators &&и ||)
В языке Java существуют два интересных дополнения к набору логических операторов.
Это — альтернативные версии операторов AND и OR, служащие для быстрой оценки логических выражений. Строго говоря, сегодня эти операторы уже давно перестали быть альтернативными, а является как раз наиболее широко применяемыми вариантами записи логических связей в составном условии.
Как видно из таблицы истинности, составное условие с "и… и…" возвращает результат true, если каждое из условий возвращает true – и возвращает результат false, если хотя бы одно из условий возвращает false. При этом, если уже первое условие (в составе сложного условия) возвращает false, то нет никакой, строго говоря, необходимости проверять второе условие – ведь все равно в результате будет возвращено false.
Вот по такой "краткой", "быстрой" схеме и работает оператор "быстрое и… и…", обозначаемый двойным символом "и" – &&. Это означает, что если первое условие возвращает false, то значение второго условия вообще не вычисляется, потому что на общий результат оно уже все равно не повлияет — результат все равно в этом случае будет равен false!
Аналогично обстоит дело и с оператором ||: если первое условие возвращает значение true, то независимо от того, что возвращает второе условие, общим результатом все равно же будет величина true. А посему – второе условие просто вообще не проверяется…
Если вы используете операторы && и || вместо обычных форм & и |, то Java не производит оценку правого (стоящего после знака логической связи) выражения, если ответ ясен из значения левого (стоящего перед знаком логической связи) выражения. Общепринятой практикой является использование операторов && и || практически во всех случаях оценки булевых логических выражений.
Приведем пример, демонстрирующий разницу в применении операторов && и &:
Даны две команды выбора:
if (b!=0 && a/b >1) System.out.println ("a>b");
if (b!=0 & a/b >1) System.out.println ("a>b");
В случае, когда значение переменной b равно 0, использование второй записи приведет к сообщению об ошибке (во время выполнения программы!), так как деление на 0 является запрещенной операцией.
А вот в первом примере этого сбоя не произойдет, так как класс определит, что условие b!=0 не выполняется, и после этого вообще не будет проверять второе условие (a/b >1).
Важно помнить, что составное выражение обязательно должно быть заключено в скобки (круглые), в то время как внутренние логические выражения (условия), входящие в его состав, можно и не заключать в скобки (каждое по отдельности), а можно и заключать.