В Java имена могут включать
• Символы алфавита (латиница A-Z кириллица А-Я)
• цифры
• знак подчеркивания _, знак $
Имена НЕ могут включать
• пробелы
• скобки, знаки +, =,!,? и др.
Ключевые (abstract, continue, for, new, switch, assert, default, goto, package, synchronized, boolean, do, if, private, this, break, double, implements, protected, throw, byte, else, import, public, throws, case, еnum, instanceof, return, transient, catch, extends, int, short, try, char, final, interface, static, void, class, finally, long, strictfp, volatile, const, float, native, super, while) и зарезервированные слова (true, false, null) в сочетании с синтаксисом операций и разделителями образуют основу языка Java. Ключевые и зарезервированные слова нельзя использовать в качестве имен переменных, классов, методов.
Простые типы данных:
char { символьный (один символ) }
byte, short, int, long {целые типы}
float, double { вещественные типы }
boolean { логический }
Оператор присваивания служит для изменения значения переменной.
Порядок выполнения операций:
• вычисление выражений в скобках
• умножение, деление, % слева направо
• сложение и вычитание слева направо
7. Целые типы данных. Операции над величинами целого типа. Сокращенная запись арифметических операций. Особенность деления в Java. Определение цифр числа. Целочисленные константы.
В Java 4 целых типа данных: byte (8 бит), short (16 бит), int (32 бита) и long (64 бита).
Операции над величинами целого типа:
+ –сложение
- –вычитание
* –умножение
/ –делениенацело
% –получениеостаткаотделения
Сокращенная запись арифметических операций:
а = а + 1; а++;
а = a + b; a+=b;
a = a – 1; a--;
a = a – b; a-=b;
a = a * b; a*=b;
a = a / b; a/=b;
a = a % b; a%=b;
Особенность деления в Java: при делении целых чисел остаток отбрасывается.
Определение цифр числа:
int one = x % 10;
int dec = (x / 10) % 10;
int hun = (x / 100) % 10;
Целочисленные константы:
В числовых константах используются 3 вида представления:
• десятичное;
• восьмеричное;
• шестнадцатеричное;
8. Инкремент и декремент. Префиксная и постфиксная формы. Примеры.
Инкремент: а = а + 1;
Декремент: a = a – 1;
???
Инкремент - это оператор (++), который увеличивает число на 1.
Декремент - это оператор (--), который уменьшает число на 1.
Постфиксный - это означает то, что сначала над операндом (переменной) делаются какие-то операции и только после всех этих операций, действует оператор инкремента или декремента. То есть, если у нас такая строчка: A = 5 * B--;, то это будет читаться так: умножить 5 на B и присвоить полученный результат переменной A, после чего уменьшить переменную B на единицу.
Префиксный - это противоположность постфиксному. Сначала оператор инкремента или декремента увеличивает или уменьшает операнд (переменную) и только после этого над ним производятся остальные операции, если они есть. То есть, если у нас такая строчка: A = 5 * —B;, то это будет читаться так: уменьшить значение переменной B на единицу, после чего умножить 5 на B (а в это время в переменной B уже будет хранится значение, которое на единицу меньше изначального) и присвоить результат переменной A.
9. Типы данных с плавающей точкой. Константы с плавающей точкой.
Константы класса Math. Методы класса Math: прямые трансцендентные, обратные трансцендентные, гиперболические, экспоненциальные. Примеры.
Числа с плавающей точкой, называемые действительными, используются при вычислениях, которые требуют получения результата с точностью до определенного десятичного знака. float (32 бита) и double (64 бита).
Константы с плавающей точкой: Числа с плавающей точкой представляют десятичные значения с дробной частью. Стандартная форма записи десятичного числа состоит из: целого числа; десятичной точки; дробной части.Научная форма записи десятичного числа состоит из: мантиссы; символа E, суффикса,
Константы класса Math типа double:
Math.PI – число π с точностью в 15 десятичных знаков.
Math.E – основание натурального логарифма с точностью в 15 десятичных знаков.
Методы класса Math:
• Прямые трансцендентные:
double sin(double arg) - Возвращает синус угла arg, переданного в радианах
double cos(double arg) - Возвращает косинус угла arg, переданного в радианах
double tan(double arg) - Возвращает тангенс угла arg, переданного в радианах
• Обратные трансцендентные:
double asin(double arg) - Возвращает угол, синус которого равен arg.
double acos(double arg) - Возвращает угол, косинус которого равен arg.
double atan(double arg) - Возвращает угол, тангенс которого равен arg.
double atan2(double x, double y) - Возвращает угол, тангенс которого равен x/y.
• Гиперболические:
double sinh(double arg) - Возвращает гиперболический синус угла arg, переданного в радианах.
double cosh(double arg) - Возвращает гиперболический косинус угла arg, nepeдaннoro в радианах.
double tanh(double arg) - Возвращает гиперболический тангенс угла arg, переданного в радианах.
• Экспоненциальные:
double ехр(double arg) - Возвращает экспоненту arg.
double log(double arg) - Возвращает натуральный логарифм arg.
double log10(double arg) - Возвращает логарифм по основанию 10 от arg.
double pow(double y, double x) - Возвращает y в степени x.
double sqrt(double arg) - Возвращает квадратный корень из arg.
10. Типы данных с плавающей точкой. Константы с плавающей точкой.
Константы класса Math. Методы класса Math: функции округления.
Генерация псевдослучайных чисел. Генерация целых и вещественных
чисел в заданном интервале. Примеры.
См. 9.
Методы класса Math:
• Функции округления:
int abs(int arg) - Возвращает абсолютное значение arg.
long abs(long arg) - Возвращает абсолютное значение arg.
float abs(float arg) - Возвращает абсолютное значение arg.
double abs(double arg) - Возвращает абсолютное значение arg.
double ceil(double arg) - Возвращает наименьшее целое число, которое больше arg.
double floor(double arg) - Возвращает наибольшее целое число, которое меньше или равно arg.
int round(float arg) - Возвращает arg, округленное до ближайшего int.
long round(double arg) - Возвращает arg, округленное до ближайшего long.
int max(int x, int y) - Возвращает большее из двух чисел х и у.
long max(long x, long y) - Возвращает большее из двух чисел х и у.
float max(float x, float y) - Возвращает большее из двух чисел х и у.
double max(double x, double y) - Возвращает большее из двух чисел х и у.
int min(int x, int y) - Возвращает меньшее из двух чисел х и у.
long min(long x, long y) - Возвращает меньшее из двух чисел х и у
float min(float x, float y) - Возвращает меньшее из двух чисел х и у.
double min(double x, double y) - Возвращает меньшее из двух чисел х и у.
• Генерация псевдослучайных чисел:
Метод Math.random()возвращает псевдослучайное вещественное число из промежутка [0;1).
• Генерация целых и вещественных чисел в заданном интервале:
x = (int)(Math.random ()*(b – a + 1)) + a; // [a,b]
11. Форматный вывод. Спецификаторы формата. Форматирование целых чисел. Форматирование вещественных чисел. Указание минимальной ширины поля.
Форматный вывод – вывод в различные потоки значений разных типов, отформатированных согласно заданному формату (шаблону).
Спецификатор формата начинается со знака процента с последующим спецификатором преобразования.
Форматирование целых чисел: System.out.printf ("Результат: %d", c);
Форматирование вещественных чисел: System.out.printf ("%f", x);
Спецификатор минимальной ширины – целое число, помещенное между символом % и кодом преобразования формата.
Спецификатор минимальной ширины дополняет вывод пробелами, обеспечивая заданную минимальную длину.
12. Форматный вывод. Спецификаторы формата. Указание точности.
Флаги формата. Использование индекса аргументов.
См. 11.
Указание точности: Спецификатор точности может быть применен к спецификаторам формата %f, %e, %g и %s. Спецификатор точности следует за спецификатором минимальной ширины поля (если таковой имеется) и состоит из точки с последующим целым числом.
Флаги формата: позволяют управлять различными аспектами преобразования. Все флаги формата – одиночные символы, которые следуют за знаком % в спецификаторе формата.
- - выравнивание влево
0 – вывод дополняется нулями вместо пробелов
Пробел – положительным числам предшествует пробел
+ - положительным числам предшествует знак +
, - числовые значения, включающие групповые разделители
(- отрицательные числовые значения заключены в скобки
Использование индекса аргументов: Обычно порядок аргументов и спецификаторов совпадает (слева направо), т.е. первый спецификатор относится к первому аргументу, второй – ко второму и т.д. Индекс аргумента следует за % в спецификаторе формата и имеет вид n$, где n – индекс нужного аргумента, начиная с 1.
13. Разветвляющиеся алгоритмы. Условный оператор и его особенности.
Пример программы с блок-схемой.
Разветвляющиеся алгоритмы – алгоритмы, в которых последовательность шагов зависит от выполнения некоторых условий.
Условный оператор:
if (<условие>) {
<что делать, если условие верно>
}
else {
<что делать, если условие неверно>
}
Особенности:
• вторая часть (else …) может отсутствовать (неполная форма)
• если в блоке один оператор, можно убрать фигурные скобки
14. Сложные условия. Порядок выполнения логических операций. При-
мер программы с блок-схемой.
Сложное условие – это условие, состоящее из нескольких простых условий (отношений), связанных с помощью логических операций:
•! – НЕ (отрицание, инверсия)
• && – И (логическое умножение, конъюнкция,
одновременное выполнение условий)
• || – ИЛИ (логическое сложение, дизъюнкция,
выполнение хотя бы одного из условий)
Порядок выполнения (приоритет = старшинство)
• выражения в скобках
•! (НЕ, отрицание)
• <, <=, >, >=,
• ==,!=
• && (И)
• || (ИЛИ)
15. Оператор выбора и его особенности. Выполнение оператора выбора.
Вложенные операторы выбора.
Операторы выбора.
В языке Java существует всего 2 оператора выбора: оператор if и оператор switch. Они позволяют управлять выполнением той или иной программы в зависимости от некоторых условий. В этом уроке мы рассмотрим оператор If.
Оператор if.
Оператор if позволяет направить выполнение программы по одному из 2-х возможных путей в зависимости от какого-либо условия. Конструкция с этим оператором имеет вид:
if (условие) оператор_1;
else оператор_2;
В этой конструкции "условие" – это значение типа "boolean". Если вы помните, то значение типа "boolean" является результатом операций сравнения или логических операций. Чаще всего, оператор "if" используется именно в операциях сравнения.
"Оператор_*" в данной конструкции – это любой из операторов, которые присутствуют в языке Java. Причем они могут быть одиночным, а могут быть составным (несколько операторов). Составной оператор необходимо заключать в фигурные скобки. После ключевого слова "if" записывается условие и оператор(ы), которые выполняются, если условие верно. После "else" записывается оператор(ы), которые выполняются, если условие ложно.
Всю конструкцию можно расшифровать следующим образом: Если (if) условие истинно, то выполняется "оператор_1", если же оно "ложно", то (else) выполняется "оператор_2". Вторая строка в данной конструкции не обязательна. Если ее не будет, то в случае если условие ложно, ни один из операторов не будет выполнен.
Рассмотрим пример.
class prog_10{
public static void main(String[] args){
int a=30;
int b=20;
if (a>b) {
System.out.println("Переменная a больше переменной b");
}
}
}
Строка №3-№4. Объявляем 2 целочисленные переменные "a" и "b" и присваиваем им значения.
Строка №5. Записываем конструкцию с оператором выбора if. В круглых скобках записывается условие (a>b). Если это условие верно, то будут выполняться операторы, находящиеся в фигурных скобках {}. У нас в фигурных скобках стоит один оператор " System.out.println", который выводит на экран сообщение.
Пример написан так, что условие (a>b) окажется верным (30>20), поэтому сработает оператор вывода на экран.
Операторы выбора в Java.
Теперь изменим пример, поменяв условие в строке №5.
class prog_10{
public static void main(String[] args){
int a=30;
int b=20;
if (a<b) {
System.out.println("Переменная a больше переменной b");
}
}
}
Строка №5. Теперь условие (a<b). Это условие ложно, так как 30 не меньше 20. Учитывая тот факт, что условие ложно, оператор "System.out.println" не будет выполнен и сообщение на экран не будет выведено.
Оператор if в Java.
Следующий пример демонстрирует действие оператора "if" с оператором "else".
class prog_10{
public static void main(String[] args){
int a=30;
int b=20;
if (a<b) {
System.out.println("Переменная a больше переменной b");
}
else {
System.out.println("b меньше a");
}
}
}
В данном примере условие ложно, поэтому оператор в строке №6 не будет выполнен. Но, здесь также присутствует оператор "else"(строка №8). После него записываются альтернативные операторы, которые выполняются только в тех случаях, если условие является ложным.
Оператор выбора if...else.
Обратите внимание, что операторы заключаются в фигурные скобки, хотя здесь это не обязательно, ведь фигурные скобки нужны при использовании составного оператора. Однако это не является ошибкой, более того, многие программисты заключают в фигурные скобки даже один оператор, чтобы исключить возможные ошибки, например, при добавлении еще одного или нескольких операторов.
Например, посмотрим на следующий пример.
class prog_10{
public static void main(String[] args){
int a=30;
int b=20;
if (a>b) {
System.out.println("Переменная a больше переменной b");
}
else
System.out.println("b меньше a");
int c=a+b;
System.out.println("Сумма чисел="+c);
}
}
После оператора "else" мы добавили еще 2 оператора:
Строка №10. Оператор присваивания, который записывает в переменную "c" значение суммы переменных "a" и "b".
Строка №11. Выводим эту сумму на экран.
В этой программе условие является истинным, т.е. выполнится оператор в строке №6, а операторы после "else" (строка №9-№11) не выполниться. Однако если посмотрим на результат, то увидим, что операторы в строке №10 и №11 тоже выполнились.
Использование составных операторов.
Переменная "c" была создана и ее значение выведено на экран. Почему так произошло?
Все дело как раз в фигурных скобках. Операторы после "else" не заключены в фигурные скобки, поэтому компилятор считает, что к "else" относится только один оператор в строке №9. Поэтому он не будет выполняться, а остальные выполняются. Чтобы компилятор считал, что все 3 оператора относятся к "else" необходимо заключить их в фигурные скобки.
class prog_10{
public static void main(String[] args){
int a=30;
int b=20;
if (a>b) {
System.out.println("Переменная a больше переменной b");
}
else {
System.out.println("b меньше a");
int c=a+b;
System.out.println("Сумма чисел="+c);
}
}
}
Вложенные операторы if.
Иногда после оператора "if" или "else" может быть записан еще один (или несколько) операторов "if", либо конструкций "if…else".
class prog_10{
public static void main(String[] args){
int a=30;
int b=20;
if (a>b) {
if (a==30) {
System.out.println("Переменная a="+a);
}
}
else {
System.out.println("a меньше b");
}
}
}
Строка №6. Здесь используется вложенный оператор "if". Фактически, он добавляет к программе еще одно условие. Сначала проверяется первое условие в строке №5 (a больше b). Если оно истинно, то проверяется второе условие в строке №6 (a равно 30). Если оно тоже истинно, то выполняется оператор в строке №7.
Вложенный оператор if.
Важно помнить: Оператор "else" всегда относится к ближайшему оператору "if", который находится с ним в одном блоке и не связан с другим оператором "if".
Пример:
class prog_10{
public static void main(String[] args){
int a=30;
int b=20;
if (a==30) {
if (b>a){
System.out.println("a меньше b");
}
if (b<a){
System.out.println("a больше b");
}
else {
System.out.println("Переменная a="+a);
}
}
else {
System.out.println("a меньше b");
}
}
}
Фигурная скобка в строке №5 открывает блок, который заканчивается в строке №15. Если кликнуть мышкой в редакторе NetBeans по любой фигурной скобке он подсветит 2-ую фигурную скобку, относящуюся к этому блоку.
Вложенный оператор if...else.
Оператор "else" внутри этого блока (строка №12) относится к ближайшему оператору "if" (строка №9).
Оператор "else" в строке №16 не может быть связан с "if" в строке №6 или №9, поскольку не находится с ними в одном блоке. Он связан с оператором "if" в строке №5.
Тернарный оператор??? (пр.12-13)
16. Операторы перехода и их особенности: break, continue, return.
Break
Применение:
• Завершение последовательности операторов в операторе switch;
• Завершение работы цикла.
• Форма оператора безусловного перехода (goto)
Особенности:
• В цикле можно использовать более одного оператора break, НО, как правило большое число этих операторов приводит к деструктуризации кода.
• Оператор break, который завершает последовательность операторов в операторе switch, оказывает влияние только на данный оператор switch, а не на какие-либо содержащие его циклы.
• Оператор break нельзя использовать в качестве обычного средства выхода из цикла, его нужно использовать для выхода из цикла в определенных особых ситуациях.
Continue
Оператор continue применяется, когда в текущей итерации цикла необходимо пропустить все команды до конца тела цикла.
При этом сам цикл не прерывается, условия продолжения или выхода вычисляются обычным образом.
В циклах while и do-while оператор continue вызывает передачу управления управляющему условному выражению цикла.
В цикле for управление передается вначале итерационной части цикла for, а потом условному выражению.
return:
Оператор return используется для выполнения явного возврата управления из метода.
17. Цикл с известным числом шагов и его особенности. Пример программы с блок-схемой.
Цикл – это многократное выполнение одинаковой последовательности действий.
for (начальные значения; условие продолжения цикла; изменение на каждом шаге) { тело цикла }
Особенности:
• условие проверяется в начале очередного шага цикла, если оно ложно цикл не выполняется;
• изменения (третья часть в заголовке) выполняются в конце очередного шага цикла;
• если условие никогда не станет ложным, цикл может продолжаться бесконечно (зацикливание)
18. Цикл с условием (постусловием) и его особенности. Пример программы с блок-схемой.
Цикл с условием: while (<условие>) { тело цикла }
Особенности:
• условие пересчитывается каждый раз при входе в цикл;
• если условие на входе в цикл ложно, цикл не выполняется ни разу:
• если условие никогда не станет ложным, программа зацикливается
Цикл с постусловием – это цикл, в котором проверка условия выполняется в конце цикла.
do {
System.out.print(“Введите положит. число”);
n = in.nextInt(); }
while (n <= 0);
Особенности:
• тело цикла всегда выполняется хотя бы один раз
• после слова while ставится условие ПРОДОЛЖЕНИЯ цикла
19. Вложенные циклы. Примеры.
Вложенный цикл – цикл расположенный внутри тела другого цикла.
20. Применение циклов. Численный метод решения уравнений.
Язык Java предусматривает три различных оператора цикла: while, do-while и for. Первый из них обычно используют в ситуации, когда тело цикла нужно выполнить нуль или более раз, а второй применяется, если его выполнение хотя бы раз обязательно. Третий из операторов является наиболее универсальным и используется в различных ситуациях.
21. Применение циклов. Численные методы вычисления площади.
22. Применение циклов. Численный метод вычисления длины кривой.
PASCAL!!
const
stp = 0.001;
var
x0, x1, x, xt, s: double;
...
function myF(ax: double):double;
begin
result:= ax*ax;
end;
...
//получим x0 и x1
x:= x0;
s:= 0;
while x <=x1 do
begin
xt:= x + stp;
s:= s+sqrt(sqr(xt-x)+sqr(myf(xt)-myf(x)));
x:= xt;
end;
...
writeln('длина = ',s);
23.Статические методы. Примеры методов. Виды методов. Определение статического метода. Вызов статического метода. Статические методы не возвращающие значения.
Статические методы
Статическим методом называется фрагмент программы, которому присвоено некоторое уникальное имя, и который по этому имени можно вызывать из остальных частей программы. В момент, когда происходит вызов, выполняются действия, перечисленные внутри метода (в его описании или теле).
В объектно-ориентированном программировании основная задача методов заключается в том, чтобы изменять текущее состояние объекта, но до тех пор, когда в программе объекты ещё не используются, методы уже могут вводиться. Метод, который описан внутри некоторого класса, но вызывается без приложения к конкретному объекту этого класса, называется статическим.
Кроме имени и описания, о которых сказано выше, у метода есть ряд других характеристик:
Набор модификаторов.
Тип возвращаемого значения.
Набор аргументов (параметров).
Модификаторы метода
Для того чтобы создать статический метод, перед его именем надо указать модификатор static. Если этого не сделать, то метод можно будет вызывать только в приложении к конкретному объекту данного класса (будет нестатическим).
Модификатор public отвечает за уровень доступа к описываемому методу. Вместо public могут указываться уровни доступа private или protect, а также может не указываться ничего, тогда будет действовать уровень доступа по умолчанию.
С уровнями доступа мы познакомимся подробнее, когда будем создавать свои классы, а пока отметим, что доступ по умолчанию разрешает обращаться к методу из любой части того пакета, в котором метод описан. А уровень public открывает доступ к методу откуда угодно. В том числе и из других пакетов и программ.
Метод main обязан иметь уровень доступа public как раз потому, что к нему обращается виртуальная машина Java, не являющаяся частью какого-либо пакета.
Кроме этого, существуют другие модификаторы, которые, например, позволяют регулировать работу методов в процессе параллельных (многопоточных) вычислений.
Тип возвращаемого значения
Методы в Java условно можно разделить на 2 группы: функции и процедуры. К первой группе относятся методы, очень похожие на функции в математическом смысле. В результате своей работы такие методы возвращают в то место программы, из которого они были вызваны, некоторый конкретный результат существующего типа, то есть это может быть целое или вещественное число или логическое значение (int, double, boolean), массив (ссылка на него), объект (ссылка на него). Возвращаемое значение должно присваиваться переменной подходящего типа или же передаваться какому-либо другому методу в роли аргумента.
В отличие от функций, методы процедурного типа производят какие-либо полезные действия, но не дают законченного результата, который мог бы выражаться в одном конкретном значении или объекте.
Примеры:
double r = Math.random();
/* random относится к функциям */
System.out.println(r);
/* println относится к процедурам */
Если бы мы создали метод, который так же, как и println, печатал бы текст на экран, но при этом подсчитывал бы количество пробелов в тексте, и возвращал бы этот результат, то получили бы функцию. При этом функция продолжала бы выполнять полезные действия, характерные для процедуры println. Соответственно, функция более универсальна, чем процедура, но не всегда необходима.
При создании метода в первую очередь надо определить, будет ли он функцией или процедурой. Для промежуточных вычислений, как правило, используются функции. Для сокращения однотипных фрагментов кода могут подходить и процедуры.
После модификаторов, но также слева от имени метода, указывается тип возвращаемого им значения (если метод является функцией, например: int[] или double) или же слово void (если метод является процедурой).
Если метод является функцией, то в нём обязательно должна встречаться команда return после которой через пробел указывается то выражение, значение которого должно быть возвращено в качестве результата работы метода.
Все команды, указанные в описании метода после return, выполняться уже не будут, return без аргумента можно использовать внутри процедур. Он будет просто досрочно завершать процедуру (аналог break для цикла).
Аргументы (параметры)
При вызове метода в него из основной программы может передаваться набор некоторых значений. Для того чтобы научить метод их принимать (и внутри метода их обрабатывать), в круглых скобках после имени метода должны быть перечислены пары вида: тип_аргумента имя_аргумента через запятую.
Тогда при вызове метода можно будет указать набор значений, соответствующих по типам, описанным аргументам.
Значение, которые передаются методу в момент вызова, называются фактическими параметрами, а имена аргументов, которые фигурируют в описании метода — формальными параметрами.
Каждый формальный параметр является внутри метода локальной переменной, то есть он недоступен за пределами метода (вне блока его описания). В момент вызова метода фактическое значение копируется в формальный параметр.
В частности, это означает, что, передавая какую-либо переменную базового типа как параметр методу при его вызове, мы не сможем изменить значение этой переменной в основной программе. Если в метод через аргумент передаётся какого-либо объекта или массива, то внутрь метода копируется только ссылка на объект или массив (т. е. их адрес в памяти). Действия, которые мы совершим с массивом или объектом внутри метода, отразятся на состоянии этого массива или объекта в основной программе даже после того, как метод завершит свою работу. Внутри метода мы обращались по тому же адресу и работали с теми же данными в памяти, что доступны в основной программе.
Если имя фактического параметра совпадает с именем формального параметра, то это не влечёт никакой проблемы: внутри метода имеется локальная переменная, в которую при вызове копируется значение одноимённой глобальной переменной. Обращаясь по этому имени внутри метода, будем попадать на локальную переменную и никак не сможем добраться до глобальной.
Описание метода
Метод должен описываться внутри класса, но при этом один метод не описывают внутри другого, то есть метод должен вкладываться непосредственно в блок класса.
Общая схема описания метода:
модификаторы тип_возвращаемого_значения имя_метода (формальные аргументы) {
// действия, выполняемые методом
// возможно, return
}
Имя метода по традиции должно начинаться с маленькой буквы. Если оно состоит из нескольких слов, каждое следующее слово начинают с заглавной буквы. Имя для метода выбирают так, чтобы было понятно, что он делает.
Рассмотрим несколько примеров:
Пример 1.
public static double kvadk (double) {
double t;
t = Math.pow(a, 0.5);
return t;
}
Теперь внутри метода main мы сможем использовать наш метод. Например, так:
int a = 25;
System.out.println(kvadk(a));
// 5.0
System.out.println(a)
// 25
При передаче фактических параметров в метод действует автоприведение. Если аргумент фактический не соответствует типу формального, то Java пробует привести фактический аргумент к более универсальному типу (в данном случае int был приведён к double).
Перегрузка методов
Сигнатурой метода называется совокупность его имени и набора формальных параметров.
Java позволяет создавать несколько методов с одинаковыми именами, но разными сигнатурами. Создание метода с тем же именем, но с другим набором параметров называется перегрузкой. Какой из перегруженных методов должен выполняться при вызове, Java определяет на основе фактических параметров.
void pr(double a) {
System.out.println(a);
}
void pr (String a) {
System.out.println(a);
}
void pr(int[] a) {
for (int i=0; i<a.length; i++) {
System.out.print(a[i]+" ")
}
System.out.println();
}
Пример использования метода.
int a = 5;
int [] m = {1, 2, 8, 3}
String s = "Мир";
pr (a) //работает исходный метод
pr (a+s); // 5 мир, работает первая перегрузка
pr (m); // 1 2 8 3
pr (m+a); // ошибка
Переменная а не относится к типу double, но её обрабатывает исходный метод, поскольку возможно автоприведение из int в double. В обратном направлении оно невозможно. Если бы метод имел аргумент типа int, то с его помощью вещественные числа выводить не получилось бы.
Перегрузка методов реализует такое важное свойство в программировании, как полиморфизм. Полиморфным называется программный код, который связан с одним общим именем, но имеет разные реализации. Какая из реализаций будет работать, выбирается на основе контекста, в котором имя было упомянуто. Конкретно для методов полиморфными являются их перегрузки, а выбор исполняемой перегрузки происходит по параметрам.
Полиморфизм: одно имя, много форм.
Примеры использования методов
Следующая программа ищет и выводит на экран все простые нетривиальные делители числа, введённого пользователем с клавиатуры, начиная с наибольшего из делителей, либо сообщает, что введённое число — является простым.
import java.util.Scanner;
public class Main {
public static boolean isPrime(int n) {
for(int i = 2; i <= Math.sqrt(n); i++) {
if(n%i == 0) {
return false;
}
}
return true;
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("Введите натуральное число: ");
if(sc.hasNextInt()) {
int u = sc.nextInt();
if(u > 0) {
if(isPrime(u)) {
System.out.println("Вы ввели простое число");
} else {
System.out.print("Простые делители числа: ");
for(int i = (int)Math.sqrt(u); i >= 2; i--) {
if(u%i == 0 && isPrime(i)) {
System.out.print(i+" ");
}
}
System.out.println();
}
} else {
System.out.println("Вы ввели не положительное число");
}
} else {
System.out.println("Вы ввели не целое число");
}
}
}
В следующем примере за счёт перегрузки будет создано несколько одноимённых методов.
Первый вариант метода будет просто переводить строку, т. е. фактически являться боле коротким синонимом встроенного метода System.out.println(). Параметров у этого варианта не будет.
Второй вариант метода (его первая перегрузка), проверяет, есть ли у числового аргумента дробная часть, если её нет, то аргумент приводится к целым и выводится на экран без нулевой дробной части (3 вместо 3.0). В этот метод смогут в качестве единственного аргумента передаваться не только переменные типа double, но и переменные любого другого типа, для которого возможно автоприведение к double (например, любые целочисленные переменные).
Третий метод с одним параметром просто вызывает четвёртый метод, передавая в качестве параметров ему полученный массив, а также пробел в качестве второго параметра. Обратите внимание, что мы вызываем метод, который будет описан далее по ходу программу, это вполне допустимо.
Четвёртый метод выводит числовой массив, обрабатывая каждый элемент уже существующим методом. После каждого выведенного элемента добавляется переданный в параметре разделитель.
public class Main {
public static void pr() {
System.out.println();
}
public static void pr(double d) {
if((int)d == d) {
System.out.print((int)d);
} else {
System.out.print(d);
}
}
public static void pr(double[] m) {
pr(m, " ");
}
public static void pr(double[] m, String s) {
for(int i = 0; i < m.length; i++) {
pr(m[i]);
System.out.print(s);
}
}
public static void main(String[] args) {
double[] arrn = {1, 2.71, 3.14, 15, -5, 92, 0.5};
double p = 3.0;
int k = 13;
pr(p); // вывод числа, без дробной части при возможности
pr(); // переводит строку
pr(arrn); // вывод числового массива в строку
pr(); // переводит строку
pr(arrn,", "); // вывод числового массива в строку через запятую
pr(); // переводит строку
pr(k); // вывод целого числа через автоприведение
}
}
В результате работы программы на экран будет выведено:
1 2.71 3.14 15 -5 92 0.5
1, 2.71, 3.14, 15, -5, 92, 0.5,
24.Статические методы. Локальные переменные. Формальные и фактические параметры. Статические методы, не возвращающие значения и их особенности. Логические методы.
Формальные параметры подпрограммы указывают, с какими аргументами следует обращаться к этой подпрограмме (количество аргументов, их последовательность, типы). Они задаются в заголовке подпрограммы в виде списка, разбитого на группы. Разделителем групп является знак точка с запятой (;). В каждую группу включаются параметры одного типа, принадлежащие к одной категории.
Все формальные параметры можно разбить на четыре категории:
параметры-значения;
параметры-переменные;
параметры-константы (используются только в версии 7.0);
параметры-процедуры и параметры-функции.
Локальная переменная - любая переменная примитивного или ссылочного типа, объявленная внутри любого метода. Память для локальной переменной не выделяется в куче (heap) a выделяется в стеке (call stack) метода, который создаётся при вызове метода, по завершении работы метода стек уничтожается вместе с локальными переменными. Для локальных переменных не существует дефолтных значений, как это происходит для переменных экземпляров, например. При попытке использовать явно неинициализированную локальную переменную выдаётся ошибка компиляции - variable <your local var> might not have been initialized.
Формальные параметры – данные, с которыми работает подпрограмма (ПП). Это внутренние данные для ПП. Они перечисляются в заголовке ПП и связаны с фактическими параметрами. Фактические параметры – данные, передаваемые в ПП и возвращаемые из нее. Это внешние для ПП данные, с которыми имеет дело вызывающая часть программы. В ПП им соответствуют формальные параметры. Указываются в списке фактических параметров при обращении к ПП. Синонимы:
Параметры = формальные параметры.
Аргументы = фактические параметры.
Для формальных и фактических параметров необходимо соблюдать соответствия:
одинаковое количество,
одинаковый порядок следования,
совместимость типов по присвоению.
Категории формальных параметров
Параметры-значения (в списке формальных параметров не имеют атрибута). Передаются ПП через стек, как копии, и не изменяются ею.
Параметры-переменные (в списке формальных параметров имеют атрибут var). Передаются ПП через адреса, и могут изменяться ею. Используются для возврата результатов в вызывающую программу.
Выходные параметры-переменные (в списке формальных параметров имеют атрибут out). Подобны параметрам-переменным, но передаются только из ПП в программу.
Параметры-константы (в списке формальных параметров имеют атрибут const). Передаются ПП через адреса, но не могут изменяться ею. Применяются вместо параметров-значений, когда стек может перепол