Вопросы
Задача
В этом упражнении вы должны завершить свою собственную реализацию метода powerN(int, int) в классе PowerCalculator.
Этот метод вычисляет неотрицательную целую степень целого числа.
Метод принимает два десятичных параметра, число и степень.
Затем он вычисляет результат как степень числа и возвращает вычисленный результат.
Если отрицательная степень дана, метод просто возвращает 1.
Для этого упражнения предоставляется проект Java (https://github.com/novts/java-base).
И нужно организовать ввод значений для параметров – число и степень – в консоли.
Рассчитанный результат также нужно показать в консоли.
Ответ:
long result = 1;
while (power > 0) {
result *= number;
power–;
}
return result;
Статические методы
Как мы видели ранее, оба метода factorial и powerTwo были объявлены как статические методы.
И мы видели статические переменные раньше, когда мы говорили о переменных класса, используя ключевое слово static.
Переменные класса являются общими для всех объектов класса, и могут быть использованы без необходимости создания экземпляра и объекта.
Java поддерживает также статические методы.
Похожие на статические переменные, статические или методы класса объявляются с помощью ключевого слова static.
В то время как методы экземпляра связаны с объектом, статические методы связаны с классом, в котором они определены.
И подобно переменным класса, методы класса могут вызываться без необходимости создания экземпляра класса.
Они могут использоваться за пределами класса, с именем класса с помощью оператора точки, как показано здесь.
Обратите внимание, что в то время, как методы экземпляра могут сделать ссылку на переменные экземпляра или методы, а также статические переменные или методы без явной ссылки на объект с помощью оператора точка, статические методы не могут сделать прямую ссылку на переменные экземпляра.
Тем не менее, они могут сделать ссылку на статическую переменную или другие статические методы.
Статические методы обычно используются для общих расчетов, которые применяются ко всем объектам.
Например, все методы в библиотеке Math, объявлены как статические методы класса Math, и ссылка на метод в библиотеке Math производится с использованием имени класса Math.
Например, абсолютный метод, Math.abs(n), который мы использовали в классе автомобиля, если бы он не был объявлен как статический, мы должны были бы сначала создать объект класса Math перед вызовом метода.
Некоторые из вас, возможно, уже столкнулись с сообщением об ошибке, когда вы сделали ссылку на переменную экземпляра или метода внутри метода, который объявлен как статический.
Давайте откроем среду IDEA, чтобы посмотреть на статические методы factorial и powerTwo.
Здесь я загрузил два метода factorial и powerTwo, которые мы только что обсуждали.
Давайте посмотрим, что произойдет, если мы уберем ключевое слово "static".
И здесь, я также написал метод main, с помощью которого можно воспользоваться двумя методами, которые мы описали.
Вы можете видеть, что здесь есть еще один while цикл, чтобы мы могли проверить эти методы на разных входных данных.
Даже не компилируя программу, вы увидите, что появится замечание о неверном использовании factorial и powerTwo методов, потому что вы не можете использовать не статические методы в методе main, так как он объявлен как статический.
И еще один способ использовать не статический метод в статическом методе, это на самом деле создать экземпляр объекта.
Например, здесь, если мы определяем объект lp с помощью оператора new, тогда вы можете обратиться к методу factorial с помощью оператора точки.
В этом случае метод компилируется, но тогда lp здесь бессмысленный объект.
Так что давайте вернемся назад и изменим метод обратно в статический. И программа скомпилируется без проблем.
Давайте теперь попробуем запустить программу.
Программа попросит входные данные. И давайте попробуем вычислить факториал и 2 в n степени.
Я хочу проиллюстрировать, что если у вас есть 12!, вы получите результат, который должен быть правильным.
Но как только мы вводим большее число, скажем 13!, вы обнаружите, что результат здесь не 13!.
Или даже если вы попытаетесь ввести еще большее число, можно увидеть, что для 40! который, как предполагается намного больше, чем 13!, результат будет явно неправильным.
И мы можем ввести 0 здесь, чтобы остановить выполнение программы.
Как вы можете здесь видеть, в методе main условием является проверка, является ли число не равным 0.
Сочетания операторов
Прежде чем мы перейдем к обсуждению двух других структур цикла, рассмотрим сначала пару опций, предоставляемых Java, которые часто полезны в циклах.
Первая опция, это операторы увеличения и уменьшения, представленные двумя последовательными знаками «++» и двумя последовательными знаками «–».
Операторы увеличения и уменьшения были введены в язык программирования C. Это одна из причин, почему более поздняя версия С называется C ++.
Оператор инкремента, ++, увеличивает значение целого числа на 1, а оператор декремента, – -, приведет к уменьшению числа на 1.
В случае оператора инкремента, для целого а, выражение ++a увеличит значение а на 1, и полученное значение приращения будет передано как значение выражения ++a.
Что касается выражения a++, то здесь разница в том, чтобы поставить оператор ++ после целой переменной а, и выражение a++ будет использовать начальное значение а как значение выражения, и это значение будет увеличено на 1.
Давайте используем таблицу, чтобы суммировать значение и эффект операторов увеличения и уменьшения.
Первое выражение, ++a, сначала будет увеличивать а на 1.
Если выражение используется вместе с оператором присваивания, увеличенное значение затем будет использоваться в присваивании.
Заметим, что это процесс в два этапа, во-первых, увеличиваем, а затем присваиваем полученное значение у.
Второе выражение, a++, которое представляет собой оператор пост-инкремента.
Это выражение будет сначала использовать начальное значение а в присвоении до увеличения на 1.
Обратите внимание на разницу между этим и предыдущим выражением, значение у будет отличаться в них, в то время как результирующее значение а будет таким же, в обоих случаях.
Третье выражение, –a, которое представляет собой оператор пре-декремента подобно оператору пре-инкремента.
–-a сначала уменьшает а на 1, и результат будет затем передан у.
Последнее выражение, a–, является оператором пост-декремента.
Здесь в первую очередь используется начальное значение а в присвоении перед уменьшением на 1.
Таким образом, эти два указанные здесь префикс операторы, которые стоят перед а, сначала увеличивают или уменьшают значение, а затем уменьшенное или увеличенное значение используется в случае необходимости в присвоении.
И эти два постфиксные операторы, которые стоят после переменной а, сначала будут использовать начальное значение в присвоении до приращения, а затем увеличивают или уменьшают значение.
Пример здесь показывает разницу между префиксным и постфиксным оператором.
Здесь объявляются две целых переменные а и у, с инициализацией а = 4.
Первый вывод достаточно простой.
Оператор присваивания будет пытаться присвоить а++ плюс 5 в у.
Подумайте, каким будет результат для этого выражения.
Обратите внимание, что а++ это постфиксный оператор приращения.
Начальное значение а будет использоваться в выражении до увеличения значения, таким образом, а++ даст значение 4, как начальное значение.
Это значение затем будет добавлено к 5, и результат 9 будет затем передан у.
Побочным эффектом а++ будет увеличение значения на 1. Таким образом, значение а будет изменено на 5.
Так что это будет результат, который вы получите от блока кода, о котором мы только что говорили.
Следующая половина кода инициализирует а обратно в 4. Теперь подумайте о том, что произойдет с присвоением здесь.
++а является префиксным оператором приращения.
Здесь будет сначала выполняться приращение, то есть значение а будет увеличено на 1, и мы получим значение 5.
Увеличенное значение а будет использоваться в качестве значения выражения ++а.
То есть 5 будет добавлено к целому 5, и результат 10 будет передан у.
Таким образом, вы можете видеть, что эти данные были бы выведены во второй половине программы.
Разница здесь в том, что в первой половине кода, значение у равно 9.
Во второй половине программного блока, значение у равно 10.
В дополнение к операторам увеличения и уменьшения, Java также предоставляет набор сокращенных операторов присваивания.
Эти сочетания операторов применяют соответствующие арифметические операции к переменной, а затем присваивают результат обратно в переменную.
Вот пять таких операторов.
Они начинаются с арифметической операции с последующим знаком =.
Обратите внимание, что порядок символа важен, так как нет соответствующего сочетания операторов в обратном порядке.
Смысл a *= b точно такой же, как а равно а умножить на b, или а * b.
И остальные операторы имеют тот же принцип.
Вот несколько маленьких примеров.
Первый сокращенный оператор + = в выражении i + = 4, точно такой же, как i = i + 4, так что значение i будет изменено на 7.
Второй сокращенный оператор * = имеет точно такой же смысл, что и a = а * 2, то есть, 3.2 * 2, таким образом, значение теперь становится 6,4.
Обратите внимание, что сокращенный оператор применяется также к числам с плавающей точкой.
Последний сокращенный оператор для оператора остатка.
Таким образом, b %= 10 является таким же, как принимать оставшуюся часть от деления 15 на 10, и результат 5 будет присвоен b.
Вы можете спросить, зачем Java предоставляет такого рода сокращенные операторы, а также операторы увеличения и уменьшения?
Это опции, которые обеспечивают некоторые удобства для программистов.
Эти особенности действительно не добавляют никакой силы языку программирования, в том смысле, что все, что можно сделать с этими операторами также может быть сделано без использования любого из них.
Однако, поскольку многие Java программисты любят использовать сокращения, вы должны быть в состоянии понять, что они означают.
