T.M. SoftStudio

feci quod potui, faciant meliora potentes

Купить полную версию курса "Введение в вычисления с Java" (русскоязычная версия, лекции, тесты, лабораторные работы)

Введение в вычисления с Java. Циклы, вложенные циклы, сочетания операторов, подклассы

Неделя 5

Лекция 23

Введение

На прошлой неделе мы обсуждали темы области видимости и выражений ветвления.

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

Это особенно важно, когда разные команды участвуют в разработке различных частей одной комплексной программы.

Трудно полностью избежать использования идентификаторов с одним и тем же именем в разных частях программы разными программистами.

Даже в реальной жизни, вы не можете заставить разные города, чтобы не использовать одни и те же популярные названия улиц.

Мы начнем обсуждение циклов в этой лекции.

Давайте сначала обсудим, чем являются циклы и почему циклы полезны в программировании.

Для программ, которые мы написали до сих пор, мы должны перезапустить программу каждый раз, когда мы хотим, чтобы запустить программу на другом наборе входных данных.

Я уверен, что вы не довольны такими ограничениями.

Например, в программе CourseGrade, вы можете захотеть вычислить оценки для разных студентов, при одном выполнении программы.

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

Вместо того чтобы создавать только одно единственное трехмерное изображение, вы можете захотеть создать последовательность трехмерных изображений.

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

Такого рода управляющие структуры называются циклами.

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

Java поддерживает три различных типа циклов, а именно while цикл, do-while цикл и for цикл. Я буду обсуждать каждый из них в деталях.

Подобно if else выражениям, циклы также могут быть вложенными.

Я буду использовать примеры для иллюстрации некоторых полезных применений циклов.

Давайте сначала взглянем на while цикл.

Цикл while начинается с ключевого слова while, а затем следует выражение условия.

Цикл while выполняется, если выражение условия возвращает true, тогда действие в теле while цикла выполняется.

Действие цикла будет повторяться до тех пор, пока выражение условия не вернет false.

Действием внутри тела цикла может быть группа выражений, или только одно выражение.

Поток управления while циклом может быть проиллюстрирован на блок-схеме.

Давайте взглянем на эту блок-схему более подробно.

Когда программа входит в цикл, она сначала оценивает выражение условия.

Помните, что выражение условия может быть оценено как истина или ложь.

Если условие истинно, блок кода, представляющий действие, будет выполнено.

Действие может быть представлено одним выражением или несколькими выражениями. Это может быть даже еще ​​один цикл.

Я поговорю больше о вложенном цикле позже.

После окончания выполнения действия, контролируемый поток будет возвращаться в начало цикла, чтобы оценить условие снова.

Обратите внимание, что что-то должно быть изменено, когда действие выполнялось.

В противном случае, условие всегда будет оценено в то же значение, как и раньше.

Если предположить, что условие по-прежнему возвращает true, действие будет выполнено снова, и процесс будет повторяться.

Вы можете видеть, что структура выделена желтым цветом и здесь сформирован цикл.

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

Примеры

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

Рассмотрим пример вычисления n! факториала.

n! прогоняет ряд способов упорядочить n различных объектов.

Он также называется перестановкой n различных объектов.

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

После того, как у нас есть победитель, только две машины могут конкурировать за второе место.

После того, как второе место определяется, только единственный оставшийся автомобиль станет третьим.

Итак, мы имеем 3 * 2 * 1, что равно 6 различных исходов. Вот все возможные результаты. Они перечислены здесь на картинке.

В общем, n! вычисляется путем умножения один, два, три, и так далее, пока не достигнем n.

Также можно записать итеративную форму (n - 1)! * n.

Отметим также, что 0! имеет значение 1.

Так 5! расписывается как 1 * 2 * 3 * 4 * 5, и результат будет 120.

n! растет очень быстро.

На самом деле, вы обнаружите, что 13! переполнит 32-битный int, и даже long тип может обрабатывать только до 20 факториала.

Мы говорили о том, что n! предполагает вычислить, но не о том, как n! может на самом деле быть вычислен.

Вот краткий обзор алгоритма для вычисления n факториала.

Вы можете начать с начального случая 0!, который имеет результат 1.

Обратите внимание, что в примере 5!, мы должны получить пять промежуточных результатов, а именно: 1!, 2!, 3!, 4!, а затем 5!, который будет результатом.

В общем, для n!, будет n шагов.

Давайте установим счетчик для подсчета количества шагов и инициализируем счетчик на 1.

Условие для расчета установим меньше, чем или равно n, из числа шагов n.

Затем мы повторим умножение промежуточного результата t на счетчик.

Этот процесс проиллюстрирован ниже.

Первый шаг состоит в вычислении 1!, который является t, или 0! * 1.

Затем мы должны увеличить счетчик на 1. То есть, счетчик становится 2.

Второй шаг состоит в вычислении 2! умножением t на 2 или значения счетчика.

Третий шаг состоит в вычислении 3! умножением t на 3. Снова, 3 это обновленное значение счетчика.

Процесс продолжается до тех пор, пока счетчик не больше, меньше или равен пяти, и конечный результат n!, будет сохранен в t.

Вот реализация n! используя while цикл.

После того, как у нас есть алгоритм, перевод алгоритма в программу Java является простым.

Метод получил название факториал, который принимает один аргумент целого типа.

Имя параметра number представляет n, для которого n! должен быть вычислен.

Метод, возвращает значение десятичного типа как результат.

Как упоминалось ранее, вы можете изменить тип возвращаемого значения на long, если метод, как ожидается, будет вычислять факториал числа больше, чем 12.

Отметим также, что я объявляю метод как статический. Я вернусь к статическим методам немного позже.

Первые два выражения внутри метода являются инициализацией, соответствующей первой стадии алгоритма.

В то время как while цикл соответствует второму шагу алгоритма.

Обратите внимание, что условие проверяет счетчик на меньше или равно n, или параметра number.

Внутри тела while цикла, промежуточный результат t, обновляется путем умножения t на счетчик, который фактически является счетчиком факториала.

Счетчик затем увеличивается на единицу. Процесс повторяется до тех пор, пока счетчик не больше, чем number, или параметр.

А значение t затем будет возвращено в качестве результата вычислений.

Давайте взглянем на второй пример.

В этом примере, мы хотим разработать метод вычисления 2 в n степени.

В информатике, мы должны вычислять 2 в n степени очень часто, потому что все в компьютере представлено ​​в двоичном виде.

Например, байт это 2 в восьмой степени, а 32 бит это 2 в 32-й степени.

В общем, 2 в n степени состоит в умножении:

Обратите внимание, что так же, как другие числа, два в нулевой степени равно 1.

Далее 2 в 1-й степени является 2, 2 во второй степени это 4 и т.д.

Таким образом, чтобы вычислить 2 в n степени, мы должны разработать алгоритм, чтобы определить, как он должен быть вычислен.

Процесс на самом деле очень похож на n!.

Первый шаг состоит в том, чтобы посмотреть на первоначальный случай для первой инициализации промежуточного результата t в исходное состояние, в этом случае, 2 в нулевой степени, которая равна 1.

И установить счетчик, чтобы считать количество шагов в вычислении.

Следующий шаг будет также очень похож на n!, за исключением того, что здесь мы обновляем промежуточный результат путем умножения t на 2 вместо t на счетчик.

Вот шаги для вычисления 2 в 4-й степени.

t сначала инициализируется 1.

Следующим шагом является вычисление 2 в 1-й степени, затем 2 во 2-й, 2 в третьей степени, и на последнем этапе вычисляется 2 в 4-й степени.

Вот реализация 2 в n степени, используя while цикл.

Опять же, так как у нас есть хорошо разработанный алгоритм, легко преобразовать алгоритм в программу Java.

Метод получит имя powerTwo, с одним параметром десятичного типа.

Параметр number это n, для которого 2 в n степени должен быть вычислен.

Первые два оператора внутри метода являются инициализацией, соответствующей первой стадии алгоритма.

В то время как цикл соответствует второму шагу алгоритма.

Если условие счетчика меньше или равно n, условие возвращает true, тело while цикла будет умножать промежуточный результат t на 2, а затем счетчик увеличивается на единицу.

Процесс повторяется, пока счетчик не станет больше чем number, и значение t будет затем возвращаться как результат.

Вы можете думать о том, как сделать метод более гибким для вычисления степени любого числа.

Например, 3 в седьмой степени, или 7 в пятой степени, и т.д.