2014-02-12
394
Буферизация.
Потоки ввода-вывода
Ввод и вывод данных в компьютере традиционно осуществляется через набор специальных устройств.
Устройством вывода по умолчанию является дисплей компьютера, а устройствами ввода – клавиатура и мышь.
Когда мы создаем программу в режиме командной строки, она привязывается к виртуальному терминалу, на который может выводить текстовые данные и с которого может получать данные, напечатанные на клавиатуре. При этом сам терминал может быть просто окном, запущенным в ОС приложения
СОВРЕМЕННЫЕ ИНТЕРФЕЙСЫ
Современные интерфейсы программ делятся на 3 группы:
1)CLI –(Command Line Interface) – интерфейс командной строки
2)GUI (Graphic User Interface) – графический интерфейс
3)Web GUI – веб-интерфейс
Для пунктов 2 и 3 доступен широкий набор средств ввода и вывода.
Для пункта 1 – только терминальная (дисплей и клавиатура)
Java доступны встроенные объекты, которые позволяют работать с выводом и с вводом (System.out… и System.in…). Эти объекты с потоками ввода и вывода ОС, по умолчанию поток System.out… направляется на дисплей, а поток System.in… читается с клавиатуры, но средствами ОС потоки могут быть перенаправлены, что позволяет например, организовать ввод данных из файла, а вывод на принтер.
|
|
|
При потоковой передаче данных, особенно, когда она происходит по сети, часто возникает ситуация, когда принятый объем не может быть обработан сразу, а требует временного хранения. для того, чтобы в этом случае не возникало ошибки, используется небольшой объем памяти, называемый буфером, в который на принимающей стороне складываются все входящие данные. И уже потом эти данные,нужные программе или устройству, извлекаются из буфера.
Буферизация также страхует от кратковременных задержек при передаче (пока нет входящих данных, информация будет читаться из буфера до его опустошения)
Потоки ввода-вывода в java буферизованы. В частности, это означает, что в буфер ввода может быть положена, например, несколько целых чисел. Но внутри программы из этого буфера можно извлекать их по одному.
System.err - поток, предназначенный для вывода ошибок.
error – поток ошибок
Объекты класса Scanner могут быть связанны с любым потоком ввода и представляют набор методов для обработки этого потока. В частности, далее мы рассмотрим методы, отвечающие за проверку содержания потока и зачтения данных из него.
Для того, чтобы начать работать со стандартным потоком ввода (читать данные с клавиатуры) необходимо подключить к программе класс Scanner, создать его объект и далее через методы объекта проверять и получать данные.
|
|
|
пример:
import java.util.Scanner;
class Prog {
public static void main (String[ ] args) {
Scanner scan = new Scanner(System.in); \\ создали объект scan класса Scanner и связали его со стандартными потоками ввода Sistem.in
String s = “ “;
System.out.println(“Введите ваше имя”); \\ до текущего момента ввода данных не производилось
s=scan.next(); \\ прочитает всю строку, введенную пользователем и запишет в переменную s
System.out.println(“Привет,”+s);
{
{
РАССМОТРИМ НЕКОТОРЫЕ МЕТОДЫ КЛАССА Scanner:
boolean.hasNextInt() – возвращает истинное значение, если в потоке ввода для чтения доступно целое число типа Int
boolean.hasNextByte() – возвращает истинное значение, если в потоке ввода для чтения доступно целое число типа Byte
boolean.hasNextDouble() – возвращает истинное значение, если в потоке ввода для чтения доступно вещественное число типа Double, в том числе вернет истину и для любого целого числа в потоке ввода 5=5.0
Существуют аналогичные методы и других встроенных типов. Все эти проверочные методы инициируют ввод данных и затем обращаются в буфер за этими данными, инициируя необходимые проверки, но данные из буфера не забирают.
Проверочный метод обращается только крайнему значению в строковом буфере, хотя отдельных значений там может быть несколько. Они разделяются пробелом или символом табуляции.
В зависимости от настроек локали на том компьютере, где исполняется программа, в качестве десятичного разделителя может использоваться точка, а не запятая.
String.next() – возвращает целиком строку, введенную пользователем
int.nextInt() – извлекает из буфера и передает в программу переменную типа int, если она в буфере имелась, иначе возникает системная ошибка и аварийное завершение программы, поэтому перед использованием этого метода надо выполнять соответствующий ему проверочный (.hasNextInt)
double.nextDouble() – аналогично для типа double
byte.next.Byte() - аналогично для типа byte
// обязательно включать везде, где используется Scanner
пример:
Scanner sc = new Scanner(Sistem.in);
System.out.println(“Введите ваш возраст ”);
if(sc.hasNextInt) {
int v=sc.nextInt();
if(v=16){
System.out.println(“Вам можно на все сайты”);
} else {
System.out.println(“Позовите родителей”);
}
} else {
System.out.println(“Возраст должен быть целым числом”);
}
Циклы JAVА
Циклом в программировании назв. фрагмент программы, который повторяется несколько раз.
Напр. Можно сформулировать задачку: необходимо на экран вывести 10 случайных чисел из отрезка от 1 до 10. Решение этой задачи возможно без использования цикла можно просто скопировать (вставить) в исходный код программы.
A= (int)(Math. Random()*(0)+1);
System.out.println (a);
……………………….. }10раз
………………………..
…………………………
Но задача не может быть решена, если нужно будет вывести 10000 случайных чисел (это рутинный процесс). Рассмотрим другую задачу: необходимо вывести на экран все элементы последовательности 1,3,5…., которые меньше 10000.в данной задаче требуется выполнить и определить многогранное кол-во повторений, а это возможно не всегда.Например не всегда известно сколько повторений потребуется в задаче: выводить на экран случайные целые числа от 1 до 10 пока не выпадет 5.
Цикл типа «пока».
Данный тип цикла предназначен для повторения некоторый действий в зависимости от указанного условия:
While(условие){
//повторяемые
//действия
}
Условие это некоторое выражение имеющее логическое значения.Например результат сравнения или логический материал. Б>а
True
True// z
Повторяемые действия – это набор из одной или нескольких операций, которые будут многократно повторятся, до тех пор, пока условие истинно.
Если в момент первой проверки условия оказалось что оно ложно, то действия внутри цикла не будут выполнены ни разу. Если условие изначально было истинным и внутри цикла не представлены не одного действия, которые эту истинность могут изменить, то цикл напротив будет повторяться бесконечное кол-во раз.
|
|
|
В реальности в большинстве программ требуется, чтобы цикл выполняется определенное заранее кол-во, раз или не перестал выполняться при наступлении какого-то условия который точно произойдет, поэтому условие цикла обычно как-то изменяется по мере повторения цикла.
Блок, в котором указывается повторяющаяся команда, называется телом цикла.
1)нужно вывести на экран 100 первых натуральных чисел:
Int a=1;
While (a<= 100){
System.out.println (a);
A= a+1;
}
2) вывести на экран все неотрицательные числа последовательности 100, 95, 90,85….
Int s=100;
While (s>=0){
System.out.print(s);
S=s-5;
}
….10,5,0
3) необходимо вывести на экран первые 15 элементов последовательности 2,4,8,16,32,64….
Intn=1; // для подсчета повторений
Inta=2;
White (n<16){
System.out.print (a+””);
a=a*2;
n++; // n=n+1;
}
4) вывести и вычислить на экран сумму всех положительных двухзначных элементов последовательности -15,-10,-5,0,5,10,15,20….
Int a=-15;
Int sum=0;
While(a<100){
If(a>=10){
} Sum = sum+a;
A=a+5;
}
System.out.println (sum);
50 необходимо посчитать квадратный корень числа с клавиатуры до тех пор пока пользователь вводит отрицательное или не число – требовать от пользователя повторного ввода.
ScannerSC=now Scanner (system.in);
Doubleu;
System.out.println(“введите положительное число”);
While (! Sc.hasNextDouble ()){
System.out.println(“вы ввели неподходящее значение. Повторите ввод”);
ВЛОЖЕННЫЕ ЦИКЛЫ
пример 1:
С помощью программы нужно вывести на экран указанный набор чисел. строго в указанном формате.
101 102 103 104 105
201 202 203 204 205
301 302 303 304 305
401 402 403 404 405
for(int i1=100,i<=400;i=i+100;){
for(int j=1;j<=5;j++){
System.out.print(i+j+”_”);
}
System.out.println();
}
У внутреннего и у внешнего цикла должны использоваться разные счетчики, иначе вся конструкция будет вести себя непредсказуемо.
пример 2:
Дано натуральное число n. Необходимо вывести на экран все его простые делители, кроме тривиальных.
простое - то, которое делится на 1 и на само себя. «1 и само себя» и есть тривиальные делители, т.е. 1 и n.
|
|
|
число 63.
в программе выводится 3 и 7, т.к. 63=9*7=3*3*7 (т.к. 9-это составное число)
число 24: делители – 2 и 3.
N(сост. число)=a*b (представимо в виде произведения двух чисел).Например: 21=7*3=3*7
можно поставить условие: а>=b
a2 >= a*b;
a>=(a*b)1/2(корень)
…
int n=24;
for(int i=2; i<= Math.sqrt(n);i++) {
if(n%i==0){ \\ ищем все подряд делители
boolean h= true;
for(int j=2; j<= Math.sqrt()I; j++) { \\ проверяем условие
if(i%j==0) {
h=false;
break;
}
}
if(n) { \\ или if(n==true)
System.out.println(i);
}
}
}
МАССИВЫ
Массив – это конечная последовательность упорядоченных элементов одного типа.
Доступ к каждому элементу массива осуществляется по индексу. Индекс начального элемента массива – 0, индекс следующего за ним – 1 и т.д…индекс последнего элемента на 1 меньше чем общее кол-во элементов в массиве.
Массив в простейшем виде можно представить так:
индекс: 0 1 2 3 4 5
| int | -1 |
номера: 1 2 3 4 5 6
Размером или длиной массива называется общее кол-во элементов в нем. Размер массива задается при его создании и не может быть изменен в дальнейшем: нельзя добавить или удалить элемент из массива, но можно присвоить новое значение в любой из его элементов.
например:
индекс: 0 1 2 3 4 5
| int | -1 |
номера: 1 2 3 4 5 6
индекс: 0 1 2 3 4 5
| int | -1 | -3 |
номера: 1 2 3 4 5 6
Постоянность размера обусловлена тем, что в момент создания массива для него выделяется
область памяти нужной длины.
В частности, в нашем примере, мы имеем массив из 6 элементов, т.е. 4*6=24 (кусочек длинной 24 байта).
Массивы не уменьшаются и не увеличиваются.(!)
В java массивы являются объектами. Это значит, что имя, даваемое каждому массиву, является ссылочной переменной, указывающей на некоторый фрагмент данных в памяти. Кроме адреса в этой переменной ничего не хранится. Индекс массива, по сути, указывает на то, сколько нужно отступить от начального элемента массива в памяти, чтобы добраться до нужного элемента.
Чтобы создать массив, надо объявить для него имя (ссылочную переменную), а потом с этим именем связать фрагмент памяти нужной длинны, куда далее будут помещаться элементы массива.
Возможны следующие схемы объявления имени массивов:
1) тип_имя[ ];
2)тип[ ]_имя
\\ где тип – это тип ВСЕХ элементов будущего массива (также его называют базовым типом массива), а имя – это уникальный, не занятый другими переменными или объектами, идентификатор, состоящий из 2-х символов: $ _, не начинающийся с цифры.
пример:
byte[ ] ar;
double z[ ];
int[ ] ar1;
…
Теперь с объявленными ссылочными переменными мы можем связать области памяти нужной длины. Делается это следующим образом:
ar = new byte[8]; \\ по умолчанию заполнится нулями.
z = {1.3, 4.3, 3.14, 2.71}; \\ в случает явного перечисления элементов массива, его размер будет определен программой автоматически.
int n=15;
ar1 = new int[n];\\ появится массив типа int из 15 элементов
\\ если массив создается с помощью оператора new, то в отличии от переменных инициализируется значениями по умолчанию. Для чисел – это 0 или 0.0, для логических массивов – false.
обращение к элементам созданного массива происходит через индексы. Указав имя массива и после него в квадратных скобках индекс, мы обращаемся к конкретной ячейке массива.
ar [0] = 2;
System.out.println(z[1]); \\ 4.3
ar1 [0] = 5; ar1 [1] = 6; ar1 [3] = ar1 [0] +1;
| 0 … | … |
Поскольку массивы предназначены для хранения последовательности, то для обхода всех элементов массива удобно использовать цикл for, счетчик которого переберет все индексы от начального до последнего.
0 1 2 3 4 5
int[ ] m={3, 6, -7, 0, -1, 9};
for(int i=0; i<=5; i++) {
System.out.print(a[i]+” ”);
}
\\ 3 6 -7 0 -1 9
Если массив устроен, как некая числовая последовательность, где каждый элемент может вычисляться по какой-то формуле, то удобнее массив заполнять также с помощью цикла, не задавая явно его элементы.
Рассмотрим пример цикла, который заполняет массив из 13 элементов последовательностью четных чисел, начиная с двух:
int[ ] m1=new int[13];
m1[0]=2;
for(int i=1; i<=12; i++) {
m1[i]=m1[i-1]+2;
}
for(int i=0; i<=12; i++) {
System.out.print(m1[i]+” “);
}
\\ 2 4 6 8 10 12…26
В данном решении присутствует недостаток в виде двух проходов по одному и тому же массиву, можно было уложиться в один цикл, если заполнять массив по условию.
int[ ] m1=new int[13];
m1[0]=2;
for(int i=0; i<=12; i++) {
if(i!=0){
m1[i]=m1[i-1]+2;
}
System.out.print(m1[i]+” “);
}
Кроме того, что начальный элемент массива с помощью выражения переопределять не требуется по условию, если бы это все таки было сделано, возникла бы ошибка выхода за пределы массива. Она аварийно завершает программу и случается каждый раз при попытке обращения по несуществующему индексу(мы бы попытались обратиться по индексу -1).
Конкретно для этой задачи можно было обойтись и без условного оператора, создавая i-тый элемент не на основании i-1, а опираясь на численное обозначение индекса.
0 1 2 3 4 5…12 формула: i*2+2
2 4 6 8 10 12..26
int[ ] m1=new int[13];
for(int i=0; i<13; i++) {
m1[i]=(i*2)+2;
System.out.print(m1[i]+” “);
}
Такой подход возможен не для любой задачи.(!)
замечание: условие нахождения в цикле может содержать как индекс последнего элемента(с нестрогим неравенством), так и размер массива (со строгим неравенством).
т.о.: (n-натуральные числа) а<n óa<=n-1
Поскольку массив именуется ссылочной переменной, то он, как и объекты, может обладать некоторыми свойствами, к нему могут приниматься некоторые методы. У любого массива имеется встроенное свойство.length, которая содержит длину массива. Её необязательно помнить, поскольку всегда должно получить с помощью названного свойства. Свойство доступно только для чтения, ведь запись у него обозначала бы, что длину, уже существующего массива, можно изменить.
пример:
int[ ] a={3,5,0,7,-1};
int n;
n=a. length;
System.out.print(n);
a. length=4; \\error
Пользуясь свойством, можно описать универсальный цикл для обхода всех элементов массива в независимости от его размера.
for(int i=0; i<a. length; i++)
System.out.print(a[i]);
}
Рассмотрим задачу, в которой необходимо вычислить среднее арифметическое всех элементов числового массива:
Для вычисления среднего арифметического нужно знать количество всех элементов массивов.
int[ ] a= {1,3,7,9,2,0,0};
int sum = 0;
for(int i=0; i< a. length; i++) {
sum=sum+a[i];
}
double sa=(double)sum/a.legth;
System.out.print(sa);
Поместить в цикл 1-ые 10 элементов последовательности Фибоначчи и вывести их на экран:
int[ ] fib=new int[10];
fib[0]=1;
fib[1]=1;
for(int i=0; i< fib. length; i++) {
if(i>=2) {
fib[i]= fib[i-1]+ fib[i-2];
}
System.out.print(fib[i]+” “);
}
Можно было исключить из цикла проверку условия, начав счетчик с двух и организовав отдельно выход
первых элементов до цикла.
Рассмотрим задачу: Заполнить массив из 6-ти элементов случайными целыми числами из отрезка [1;10].
Вывести массив на экран в прямом и обратном порядке.
например: 9 1 3 7 4 5
5 4 7 3 1 9
int[ ] a=new int[6];
for(int i=0; i< a. length; i++) {
a[i]=(int)(Math.random()*10)+1;
System.out.print(a[i]+” “);
}
System.out.println();
for(int i==a.length-1; i>=0; i- -) {
System.out.print(a[i]+” “);
}
В данной задаче нельзя было обойтись одним циклом, поскольку внутри___ до его первого цикла часть элементов оставалась неизвестной
Задача: дан массив целых чисел, необходимо заменить отрицательные элементы на их модули и вывести их на экран.
int[ ] a={1,-2,0,-3,5,6,-1}
for(int i=0; i< a. length; i++) {
if(a[i]<0){
a[i]=(-1)*a[i];
}
System.out.print(a[i]+” “);
}
\\ 1 2 0 3 5 6 1
Дан числовой массив. Необходимо в нем найти и вывести на экран значение наибольшего элемента.
int[ ] a={1,6,0,-3,5,6,-1}
int max=a[0];
for(int i=1; i< a. length; i++) {
if(a[i]>=max){
max= a[i];
}
}
System.out.println(max);
}
Задача: В программе созданы переменные а и b. В них записаны некоторые числа. Необходимо обменять значения в переменных a и b местами.
int a=5;
int b=3;
int t;
t=a;
a=b;
b=t;
System.out.println(a); \\ 3
System.out.println(b); \\ 5
СОРТИРОВКА МАССИВОВ.
Сортировкой называется процесс переставления элементов в массиве, в результате которого числовой массив превращается в возрастающую или убывающую последовательность. Сортировать можно не только числовые массивы, а любые множества, де задано какое-то отношение порядка (> / <).
Существуют разные алгоритмы сортировки (их сотни): одни из них являются универсальными, т.е. позволяют работать с любым множеством, невзирая на его первоначальную упорядоченность и приводят к гарантированно желаемому результату (сортируют множество), другие – являются специальными и эффективно работают на множествах, пребывающих в каком-то определенном состоянии (например, в почти упорядоченных множествах). Зато специальные алгоритмы неэффективно или же совсем не работают для неподходящих множеств.
· Сортировка выбором.
Для простоты будем рассматривать все алгоритмы на примере сортировки по возрастанию, т.е. начальное место в массиве после сортировки должен занять наименьший элемент, а последнее место – наибольший.
В рамках алгоритма рассматриваются фрагменты массива. Сначала весь массив, потом весь массив кроме начального элемента, затем массив без двух начальных элементов, и т.д. При рассмотрении каждого фрагмента в нем находится наименьший элемент и ставится в начало фрагмента. Таким образом, рассматривая каждый следующий фрагмент, мы оставляем слева от него наименьший элемент предыдущего шага.
массив:{ 2 9 1 4 3 5 2} \\ наименьшее число местами меняется с первым членом во множестве
1 шаг: 1 { 9 2 4 3 5 2}
2 шаг: 1 2 { 9 4 3 5 2}
3 шаг: 1 2 2 {4 3 5 9}
4 шаг: 1 2 2 3 {4 5 9}
5 шаг: 1 2 2 3 4 { 5 9}
итог: 1 2 2 3 4 5 9
for(int i=0; i<=a.lenth-2; i++) {
int min=a[i];
int imin=i
for(int j=i+1; j<=a.lenth; j++) {
if(a[j]<min) {
min=a[j];
min = j;
}
}
if(i!=imin) {
int t=a[i];
a[i]=a[min];
a[imin]=t;
}
}
· Сортировка пузырьком.
Суть алгоритма заключается в том, что выполняется многократный проход по массиву и в процессе каждого прохода сравниваются два соседних элемента и между ними устанавливается правильный порядок.
2 9 1 4 3 5 2 -> 2 9 1 4 3 5 2 -> 2 1 9 4 3 5 2 -> 2 1 4 9 3 5 2 -> 2 1 4 3 9 5 2 -> 2 1 4 3 5 9 2 -> 2 1 4 3 5 2 9
…
-> 2 1 4 3 2 5 9 ->
…
-> 2 1 3 2 4 5 9 … и т.д.
for(int i=a.length-1; i>=2; i--) {
boolean sorted=true;
for(int j=0; j<I; j++) {
if(a[j]>…a[j+1]) {
int t = a[j];
a[j] = a[j+1];
a[j+1]=t;
sorted = false;
}
}
if(sorted) {
break;
}
}
Переменная sorted позволяет досрочно завершить повторение данного цикла в случае, когда массив будет отсортирован еще до того как отсортированный фрагмент дойдет до длины 2.
МНОГОМЕРНЫЕ МАССИВЫ.
До текущего момента мы рассматривали массивы, представляющие собой числовую последовательность, их можно визуализировать так:
0 1 2 3 4 5 6
И для адресации каждого элемента массива использовался единственный индекс, показывающий на сколько ячейка с элементом смещена относительно начала массива.
В математике существуют такие объекты как матрицы, которые визуализируются в виде таблицы чисел
m[0][0]=2
m[2][1]=8
m[3][4]=4
…
Для обращения к конкретному элементу подобной таблицы уже не хватит одного индекса, потому что надо указывать и строку и столбец.
Двумерными называются массивы, для адресации элементов которых используются 2 индекса, где 1 индекс указывает на строку где расположен элемент, 2 – на столбец.
Объявляются массивы таким образом: int m[ ][ ]=new int[3][4]; \\ 3 строки, 4 столбца
Для работы с двумерным массивом требуется использовать два вложенных цикла с разными индексами.
1-й цикл будет перебирать строки, вложенный в него 2-ой цикл будет перебирать элементы внутри строки(столбцы).
for(int i=0; i<=3; i++) {
for(int j=0; j<=4; j++) {
System.out.print(m[i][j]+” ”);
}
System.out.println();
}
\\ выводит массив на экран
Существуют 3,4 и более мерные массивы для адресации индексов соответственно.
СТАТИЧЕСКИЕ МЕТОДЫ
Методом в программировании называется фрагмент кода, которому присвоено некоторое уникальное имя, по которому данный код можно многократно вызывать и использовать.
В общем случае в java методы применяются к объектам для того, чтобы менять их состояние, но даже не изучая объектно-ориентированное программирование, можно создавать методы, описывая их в текущем классе и применять методы вне контекста этого класса. Такие методы называются статическими.
Методы можно разделить на две группы: функции и процедуры.
Функции в программировании похожи на функции в математике тем, что при обращении к функции ей могут быть переданы некоторые входящие аргументы и в зависимости от них вычислим итоговый результат, который будет возвращаться в то место программы, откуда вызывалась функция.
Процедура отличается от функции тем, что не возвращает конечного результата, при этом также может принимать аргументы и выполнять какие-то полезные действия (например: выводить на экран, сортировать массив и т.д.), но при этом, не вычисляя результат действий в виде конкретного значения (числа, строки, ссылки на массив, ссылки на какой-либо другой объект…) и не возвращает его в место вызова.
пример:
System.out.print(“abc”); \\ процедура. (System.out – применяется к объекту)
double s = Math.random(); \\ функция. (Math.random – не применяется ни какому объекту. является статическим методом).
Функция более универсальна, чем процедура.
Создание собственного метода происходит внутри существующего класса. При том метод должен описываться непосредственно в блоке класса (нельзя описание одного метода вложить в другой). При описании метода описываются следующие его компоненты:
1. модификаторы
2. имя метода
3. параметры (или аргументы)
4. тело метода
Весь набор этих компонентов называется описанием методов.
пример метода:
class Prog {
public static void main (String[ ] args) { \\ первые 4 слова – модификаторы (указываются перед именем метода и отвечают за разные его характеристики
public –относится к модификаторам доступа, которые позволяют ограничить или предоставить возможность вызова данного метода в разных частях программы (например, в других классах).public дает самый широкий доступ, в частности такие методы может вызывать виртуальная машина java, не являющаяся частью данного класса или даже пакета
static – указывает на то, что метод будет статическим, т.е. не потребуется вызывать его в приложении к объекту.
System.out.println(2+m1(3)); \\ аргумент println
}
public static void int m1(int a) { \\ int – тип возвращаемого методом значения. вместо int может быть любой допустимый тип данных, в том числе и ссылка на объект, массив и прочее. Методы с указанным типом относятся к функциям, в теле таких методов обязательно должна встречаться команда return, после которой через пробел размещают выражение, которое и будет возвращено в качестве значения метода. Команда return - в функциях обязательна.
Вместо типа данных перед именем метода может указываться слово void, которое превратит метод в процедуру и отменит необходимость возвращать из него результат командой return. При этом return без параметров можно использовать в процедурах для их досрочного завершения (аналог break (в циклах)).
int t;
t=a*a;
return t;
}
Имя метода задается по тем же правилам, что и имя переменных, но в классе может существовать несколько методов с одинаковыми именами при условии, что набор параметров у них будет разный. Создание одноименных методов называется перегрузкой, она реализует такое важное свойство программирования, как полиморфизм: одно имя – много форм (под одним именем могут скрываться разные фрагменты кода).
У метода может быть любое количество аргументов, в том числе они могут отсутствовать. Аргументы позволяют связывать метод с основной программой: а том месте, где метод вызовется через аргументы, ему передаются некоторые входящие значения, которые внутри метода обрабатываются.
В рамках описания аргументы метода называются формальными параметрами. Каждый формальный параметр – это локальная переменная в теле метода. В частности, если она совпадает по имени с глобальной переменной, то доступ к глобальной пропадает до завершения метода
Аргумент, передаваемый методу при вызове называется фактическим параметром, это может быть любое выражение совместимое (под совместимостью понимается совпадение типов или возможность автоприведения) по типу с формальных параметром.
При вызове метода значение фактического параметра копируется в формальный и далее начинает выполняться тело метода.
Если в качестве фактического параметра используется ссылка на объект, то переходя по этой ссылке внутри метода, мы будем работать с той же областью памяти, а значит все изменения совершенные в теле метода над объектами, отразятся и в основной программе, откуда метод вызывался.
Тело метода содержит все действия, которые метод должен совершить, в том числе над своими параметрами
Лекции по программированию на Java. 1 курс 2 семестр, Математика с доп. спец. Информатика
команд и включения кода на Ассемблере. С завоевал огромную популярность и позволил
создать целые новые ОС. На базе С был создан ЯП С++, он обратно совместим с С (т.е
программы, написанные на С, являются корректными с точки зрения С++), но при этом
включает новые возможности и позволяет создавать объектно-ориентированные программы.
С++ до сих пор самый популярный язык системного программирования (низкоуровневого).
Но для создания прикладных программ (высокого уровня) он уже не так популярен в силу
сложной переносимости (тоже только на уровне исходного кода) и необходимости
компилировать программу после всякого изменения и под всякую платформу.
В 1995 году появилась первая версия ЯП java, которая была лишена некоторых названных
недостатков.
Подходы к программированию.
Первые программы представляли собой линейный алгоритм, где все действия выполнялись
от начала до конца в строгой последовательности.
Из-за того, что в сложных программах было много однотипных и повторяющихся действий,
их стали выделять в отдельные подпрограммы, которые назвали процедурами. Процедуру
можно было многократно вызывать в разных местах программы, при этом передавая ей
разные параметры. Таким образом, создание сложной программы сводилось к описанию
нужных процедур и их вызову в нужном порядке и с подходящими параметрами. Такой
подход называется процедурным программированием.
Объектно-ориентированное программирование (ООП) – подход к созданию программ,
основанный на использовании классов и объектов, взаимодействующих между собой.
Класс описывает устройство и поведение объектов. Устройство описывается через набор
характеристик (свойств), а поведение – через набор доступных для объектов операций
(методов).
Классы можно создавать на основе уже имеющихся, добавляя или переопределяя свойства и
методы.
Классы можно представлять себе как шаблоны, по которым строятся объекты.
Объекты – это элементы программы, обладающие схожим набором характеристик и
поведением (т.е это элементы, построенные на основе одного класса).
Каждый объект имеет некоторое состояние, оно определяется значением всех его свойств.
В одной программе могут существовать несколько классов, и объекты разных классов могут
взаимодействовать между собой (через методы).
Создание программы в рамках ООП происходит так:
1. Из предметной области задачи выделяются существенные характеристики, с учётом
которых создаются классы.
2. От классов порождаются объекты, обладающие некоторым начальным состоянием
(значениями свойств).
3. Объекты начинают взаимодействовать между собой с помощью методов, изменяя
своё состояние.
4. Так, мы получаем модель некоторого явления или процесса. Чтобы получить
Набрано: Котомина Эмилия aka Eeemilen Asmodea WwwolandiaЛекции по программированию на Java. 1 курс 2 семестр, Математика с доп. спец. Информатика
полезный результат, надо оценить состояние этой модели в нужный момент.
Платформа Java.
ЯП является лишь частью платформы, в состав которой также входят:
1) Набор классов, собранных в библиотеку для решения многих стандартных задач.
(библиотека класса Java),
2) Виртуальная машина Java. Которая исполняет байт-код, полученный в результате
компиляции программ.
Существует несколько редакций платформы:
1) Java SE (Standard Edition) для настольных приложений.
2) Java ME (Micro Edition) для приложений под мобильные и встраиваемые устройства.
3) Java EE (Enterprise Edition) для клиент-серверных приложений корпоративного
назначения.
Процесс создания простейшей программы на Java.
В общем случае новую программу можно начать писать в любом текстовом редакторе, но
удобнее это делать в редакторе с подсветкой синтаксиса языка или в интегрированной среде
разработки (IDE), которая, кроме редактора кода, содержит различные заготовки и полезные
функции для ускоренного создания программы.
После того, как исходный код программы написан, она сохраняется с именем
имя_программы.java, где имя_программы – имя одного из классов, представленных в
исходном коде.
Далее программу необходимо откомпилировать. Это можно сделать командой
javac имя_програмы.java
После запуска этой команды происходят 2 важных процесса:
1) Специальный отладчик ищет возможные ошибки в программе. Например, он
выявляет синтаксические ошибки, но почти не анализирует сам алгоритм.
2) Если отладчик не выявил ошибок, то запускается компилятор, он превращает
исходный код программы в так называемый байт-код – это двоичные данные,
непонятные человеку, но готовые к выполнению на JVM.
Если корректно прошли отладка и компиляция, то появляется файл имя_программы.class
Теперь мы можем запустить полученный байт-код на JVM с помощью команды
java имя_программы
JVM – это программа, которая запускается внутри ОС и создана специально под конкретную
архитектуру (например, для Win и 32-разрядного процессора или для Linux и 64-разрядного
процессора или для мобильного телефона).
В JVM происходят запуск и выполнение байт-кода. Указанная выше команда заставит JVM
искать в текущей директории файл с именем имя_программы.class, в этом файле – класс
имя_программы, а в этом классе – метод Main. Дальше будут выполняться все инструкции,
указанные в методе Main. Если класс был назван неправильно или метод Main в нём
Набрано: Котомина Эмилия aka Eeemilen Asmodea WwwolandiaЛекции по программированию на Java. 1 курс 2 семестр, Математика с доп. спец. Информатика
отсутствует, то программа выполняться не сможет.
Если какие-то изменения были внесены в исходный код, то перед запуском программы её
код необходимо сохранить и перекомпилировать, иначе выполняться будет старая версия
байт-кода.
Переменные и типы данных.
Переменной называется некоторая область памяти, которой присвоена уникальное и
понятное для программиста имя и в которых могут быть записаны данные определённого
рода и объёма. Данные из переменной могут быть также прочитаны, и старые данные могут
заменяться новыми.
В ЯП Java до того, как переменная будет использована (до записи или чтения данных)
необходимо определить её тип – один из возможных вариантов, описывающих, какие данные
могут помещаться в переменную, какова область допустимых значений и какие опреации
смогут применяться к этим данным.
Тип каждой переменной Java задаётся однажды и не может быть изменён по ходу
программы. Такой набор характеристик и называется статической строгой типизацией. В
других ЯП тип переменной может определяться теми значениями, которые в неё
записываются, и даже изменяться по ходу программы (PHP).
Для того. Чтобы объявить переменную, надо указать существующий тип данных и после –
имя данной переменной. Имя может состоять из латинских букв, цифр и некоторых
символов, но начинаться должно с буквы. По традиции имена переменных и методов
начинают с маленькой буквы, а имена классов – с большой. В одной части программы не
может существовать двух и более переменных с одинаковыми именами (в одном блоке).
Имена Primer, primer, PRIMER различны. Имена переменных рекомендуется придумывать
так, чтобы из имени следовало назначение переменной.
Sum – сумма, например, а не произведение.
Логический тип.
Тип может хранить 2 значения в своих переменных: истину (true) и ложь (false). Для
объявления переменной логического типа требуется
boolean a;
После этого можно присваивать и читать значения из переменных.
a=true;
boolean b;
b=a;
Для данного типа применима следующая операция:
a && b – операция пересечения (логическая И), даёт истинный результат <=> оба аргумента
истинны.
a || b — логическое ИЛИ, даёт истинный результат тогда, когда хотя бы один из операндов
Набрано: Котомина Эмилия aka Eeemilen Asmodea WwwolandiaЛекции по программированию на Java. 1 курс 2 семестр, Математика с доп. спец. Информатика
истинен.
!а – отрицание, возвращает результат, противоположный значению переменной а.
a^b – исключающее ИЛИ, возвращает истинный результат <=> один из аргументов истинен,
а другой ложен.
С участием описанных операций, а также операция присваивания, которая обозначается
операцией =, можно составлять и вычислять сложные операции.
boolean a, b, c;
a = true;
b =!a;
c = a || b &&!a;
Приоритет операций таков:
!, &&, ||. но приоритет можно регулировать с помощью (). Выражение в скобках выполняется
в первую очередь. () можно вкладывать друг в друга, первым будет выполняться выражение
во внутренних ().
Операция присваивания (=) работает однозначно по следующему принципу:
Сначала вычисляется выражение, стоящее справа от =, потом оно присваивается переменной,
стоящей слева от =.
Числовые целые типы данных.
Тип Объём Значения по умолчанию Диапазон
byte 1 байт 0 [-128, 127]
char 2 байт \u 0000 \u 0000... \u FFFF
int 2 байт 0 [-2^15;2^15-1]
long 4 байта 0L [-2^31, 2^31-1]
Тип char хранит не просто целые числа, а номера символов по кодовой таблице Unicode,
которая содержит специальные символы, символы псевдографики и буквы различных
национальных алфавитов, в т.ч и кириллицей, а также популярные иероглифы.
Условные операторы
Для организации ветвления в программах на Java моет также использоваться оператор switch.
Он попал в Java по наследству из более старых языков программирования, и любая
конструкция с его использованием может быть заменена с помощью набора связок else if.
Более того, оператор switch позволяет работать только с одной переменной, проверяя её
точное совпадение с некоторым набором констант и потому является менее универсальным,
чем if.
switch (n) {
case 1:
Набрано: Котомина Эмилия aka Eeemilen Asmodea WwwolandiaЛекции по программированию на Java. 1 курс 2 семестр, Математика с доп. спец. Информатика
//n — единица
break;
case 2:
case 8:
//n – не единица
break;
default:
//n – ни 1, ни 2, ни 8
}
Операторы организации цикла.
Циклом в ЯП Java называется некоторый фрагмент программного кода, который
повторяется многократно. При этом цикл может состоять даже из одного выражения или
вообще быть пустым.
Выделяют 2 типа циклов: Цикл типа «пока» и цикл типа «n раз».
Цикл типа «n раз».
Данный вид циклов используется в том случае, когда заранее известно, какое количество
повторений потребуется. Обычно цикл типа «n раз» связан с каким-то счётчиком, который и
отмеряет количество повторений.
Общая схема цикла:
for (инициализация; условие повторения; итерация) {
//Тело цикла
}
Инициализация -- создание некоторого счётчика и указание его начального значения. Для
одного цикла при необходимости может быть создано сразу несколько счётчиков.
Инициализация выполняется один раз до самого первого шага цикла.
Итерация – некоторое выражение, описывающее, каким образом будет изменяться
счётчик/счётчики цикла после каждого его шага.
Условия повторения – некоторое логическое выражение, переменная или константа,
значение которой будет проверяться перед началом каждого шага цикла (в том числе и
самого первого). Если условие истинно, то очередной шаг цикла будет выполняться, иначе
цикл остановится.
Тело цикла – набор каких-то операций ЯП Java, который и будет повторяться на каждом
шаге цикла. Все значения переменных, полученных на текущем шаге, будут переданы в
следующий шаг.
Пример 1:
for (int i=1; i <=10; i++) {
Набрано: Котомина Эмилия aka Eeemilen Asmodea WwwolandiaЛекции по программированию на Java. 1 курс 2 семестр, Математика с доп. спец. Информатика
System.out.println («!»);
}
Пример 2:
for (int j=99; j > 0; j =j-2) {
System.out.println (j + «»);
}
//99 97 95 …
Пример 3:
for (int a = 5; b = 5; a-b>=0; a--, b++) {
System.out.println (a*b);
}
// -25
-16
-9
-4
-1
Пример 4 (вычисление факториала)
int n = 6, f = 1;
for (int i = 2; i <= n, i++) {
f = f*i;
}
System.out.println (f);
Пример 5 (все делители некоторого целого положительного числа)
int n = 24;
for (int i = 1; i<=n; i++) {
if (n%i == 0) {
System.out.println (i+» «);
}
// 1 2 3 4 6 8 12 24
Набрано: Котомина Эмилия aka Eeemilen Asmodea WwwolandiaЛекции по программированию на Java. 1 курс 2 семестр, Математика с доп. спец. Информатика
Цикл типа «пока».
Данный вид циклов используется в том случае, когда набор некоторых действий нужно
повторять до тех пор, пока выполняется определённое условие, при этом заранее можно не
знать, сколько раз выполнится цикл.
Общая схема:
while (условие) {
// тело цикла
}
Условие – некоторое логическая переменная, выражение или константа, истинность которой
проверяется перед каждым шагом цикла, включая первый)
Если условие истинно, то выполняется очередной шаг цикла, иначе происходит выход из
цикла и выполняется та часто программы, которая расположена после него.
Тело цикла – набор операций, повторяемых на каждом шаге цикла.
Таким образом, цикл типа «пока» может не выполняться ни разу. Как правило, условие
повторения цикла составляется таким образом, чтобы после очередного шага цикла оно всё-
таки стало ложным. Если этого не сделать, то получится цикл, повторяющийся бесконечное
число раз.
Существует разновидность цикла типа «пока», в которой условие выполнения следующего
шага цикла проверяется не перед ним, а после него.
Схема:
do {
// тело цикла
} while (условие);
Цикл do while, в отличие от цикла while, выполняется по крайней мере один раз.
Примеры:
Пример 1.
int s = 1;
while (s<11) {
System.out.print(«!»);
s++;
}
Любой цикл for можно свести к циклу while, выполняющему аналогичные действия. Более
того, для цикла for может не указываться первый и последний параметр. Тогда он будет
полностью аналогичен циклу while.
Пример 2.
int s = 1;
Набрано: Котомина Эмилия aka Eeemilen Asmodea WwwolandiaЛекции по программированию на Java. 1 курс 2 семестр, Математика с доп. спец. Информатика
do {
System.out.print («!»);
s++;
} while (s<10);
//!!!!!!!!!!
Пример 3.
int s = 0;
do {
s++;
System.out.print («!»);
} while (s<11);
Пример 4.
Scanner inp = new Scanner(System.in);
double u = inp.nextDouble();
while (u<=0 || u!= Math.Floor(u)) {
u = input.nextDouble();
}
Данный фрагмент кода будет читать значение, введённое пользователем с клавиатуры, до тех
пор, пока не будет введено целое положительное число.
Пример 5.
Scanner inp = new Scanner(System.in);
double u;
do {
u = inp.nextDouble();
} while (!(u>0 && Math.floor(u) == u));
Пример 6.
int kol=0;
int n = 1875;
while (n>0) {
n = n/10;
kol++;
}
System.out.print(kol);
// 4
Набрано: Котомина Эмилия aka Eeemilen Asmodea WwwolandiaЛекции по программированию на Java. 1 курс 2 семестр, Математика с доп. спец. Информатика
Данная программа считает количество цифр в положительном целом числе.
Случайные числа.
Math.random() [0,1)
А надо: [-10, 5]
[-10; 5] ← [-10,6) ← [0;16) ← [0;1)
Math.floor(Math.random()*16-10)
или же
a = Math.random();
a = a*16
a=a-10;
a = Math.floor(a);
Массивы.
Массив – конечная последовательность элементов одного типа.
1. Int [ ] a; – описание массива: описываем, какого типа будет массив, даём описание
double arr [ ]
тип [ ] имя;
тип имя [ ];
2. Выделение памяти под этот массив.
а = new int [5];
arr = new double [10];
В случае, когда мы не знаем наверняка длину массива, то мы можем описать переменную,
присвоить ей какое-либо значение к моменту выделения памяти для массива.
int n = 15;
a = new int [n];
arr = {3.14; 5; 2.16};
Можно и совместить описание массива и выделение памяти под его элементы в одной
строке.
Тип [ ] имя= new тип [размер];
тип [ ] имя = { элемент 1, элемент 2, …, элемент 15 }
float [ ] d = newfloat[5];
Набрано: Котомина Эмилия aka Eeemilen Asmodea WwwolandiaЛекции по программированию на Java. 1 курс 2 семестр, Математика с доп. спец. Информатика
byte [ ] mas = { 1, 3, 8 };
a.length – получить размер массива.
Циклы в массивах.
Для работы с массивами больше всего подходит цикл типа for.
for (int; i=0; i < a.length-1; i++)
{ a[i]=10;
}
Заполнение массива случайными числами от 0 до 9.
int arr[ ];
arr = new int [10];
for (int i=0; i<arr.length; i++)
{
arr[i] = Math.int (Math.random () *10);
System.out.print (arr[i] + «»
Сортировка массива.
Сортировка массива – преобразование массива таким образом, что все элементы
располагаются по убыванию или по возрастанию.
mas
[9] [2] [1] [4] [6]
0 1 2 3 4
min
for (int i=0; i<mas.length; i++) {
int min = mas [i];
int indmin = i
// пусть минимальным является первый элемент из рассматриваемой части массива.
for (int j=i+1; j<mas.length; j++) {
if (mas [j]<min) {
min = mas [j];
indmin = j; }
}
if (i!=indmin) {
int temp=mas[i];
Набрано: Котомина Эмилия aka Eeemilen Asmodea WwwolandiaЛекции по программированию на Java. 1 курс 2 семестр, Математика с доп. спец. Информатика
mas[i] = mas[indmin]
mas[indmin]=temp;
}
}
Метод «Пузырька»
2 9 1 4 3 2
2 9 1 4 3 2
2 1 9 4 3 2
2 1 4 9 3 2
2 1 4 3 9 2
2 1 4 3 2 9
for (int i = a.length -1; i>=2; i - -)
boolean sorted = true;
FOR (int j=0; j<i; j++ {
if (a[j] > a[j+1]) {
int temp = a[j];
a[j]=a[j+1];
a[j+1]=temp;
sorted = false;
}
}
if (sorted) {break;}
Статические методы.
Из математики известно понятие функции. Похожим элементом в программировании
являются методы.
Методом называется фрагмент программы, которому присвоено некоторое уникальное имя
и который по этому имени можно обращаться из остальных частей программы. В момент,
когда происходит такое обращение, выполняются действия, перечисленные внутри метода.
В объектно-ориентированном программировании основная задача методов заключается в
том, чтобы изменять текущее состояние объекта, но до тех пор, когда в программе объекты
ещё не используются, методы уже могут вводиться. Метод, который описан внутри
некоторого класса, но вызывается без приложения к конкретному объекту этого класса,
называется статическим.
Кроме имени и описания, о которых сказано выше, у метода есть ряд других характеристик:
Набрано: Котомина Эмилия aka Eeemilen Asmodea WwwolandiaЛекции по программированию на Java. 1 курс 2 семестр, Математика с доп. спец. Информатика
1) Набор модификаторов,
2) Тип возвращаемого значения,
3) Набор аргументов (параметров)
Модификаторы метода.
Для того, чтобы создать статический метод, перед ним надо указать модификатор static. Если
этого не сделать, то метод можно будет вызывать только в приложении к конкретному
объекту данного класса.
Модификатор public отвечает за уровень доступа к описываемому методу. Вместо public –
private (protect), а также может не указываться ничего, тогда будет действовать уровень
доступа по умолчанию.
С модификаторами познакомимся подробнее, когда будем создавать свои классы, а пока
отметим, что доступ по умолчанию разрешает обращаться к методу из любой части того
пакета, в котором метод описан. А уровень public открывает доступ к методу откуда угодно.
В том числе и из других пакетов.
Метод Main обязан иметь уровень доступа public как раз потому, что к нему обращается ВМ
Java, не являющаяся частью какого-либо пакета.
Кроме этого, существуют другие модификаторы, которые, например, позволяют
регулировать работу методов в процессе параллельных вычислений. Или модификатор
native, позволяющий в java-программе использовать методы, описанные в других ЯП.
Тип возвращаемого значения.
Методы java условно можно разделить на 2 группы: функции и процедуры. К первой группе
относятся методы, очень похожие на функции в математическом смысле. В результате своей
работы такие методы возвращают в то место программы, из которого они были вызваны,
некоторый конкретный результат существующего типа, то есть это может быть целое или
вещественное число, логическое значение (int, double, boolean...), массив (ссылку на него),
объект (ссылку на него). Это значение должно присваиваться переменной подходящего типа
или же передаваться какому-либо другому методу в роли аргумента.
В отличие от функций, методы процедурного типа производят какие-либо полезные
действия, но не дают законченного результата, который мог бы выражаться в одном
конкретном значении или объекте.
Примеры:
double r = Math.random();
/* относится к функциям */
System.out.println(r);
/* процедура */
Если бы мы создали метод, который так же, как и println, печатал бы текст на экран, но при
этом подсчитывал бы количество пробелов в тексте, и возвращал бы этот результат, то мы
получили бы функцию. При этом функция продолжала бы выполнять полезные действия,
Набрано: Котомина Эмилия aka Eeemilen Asmodea WwwolandiaЛекции по программированию на Java. 1 курс 2 семестр, Математика с доп. спец. Информатика
характерные для процедуры println. Соответственно, функция более универсальна, чем
процедура.
При создании метода в первую очередь надо определить, будет ли он функцией или
процедурой. Для промежуточных вычислений, как правило, используются функции. Для
сокращения однотипных кусов кода могут подходить и процедуры.
Все команды, указанные в описании метода после return, выполняться уже не будут.
Return без аргумента а можно использовать внутри процедур. Он будет просто досрочно
завершать процедуру (аналог break для цикла).
Аргументы (параметры)
При вызове метода в него из основной программы может передаваться набор некоторых
значений. Для того, чтобы научить метод их обрабатывать, в круглых скобках после имени
метода в его описаниях должны быть перечислены пары вида: тип_аргумента
имя_аргумента через запятую.
Тогда при вызове метода можно будет указать набор значений, соответствующих по типам,
описанным аргументом.
Значение, которые передаются методу в момент вызова, называются фактическими
параметрами, а имена аргументов, которые фигурируют в описании метода –
формальными параметрами.
Каждый формальный параметр является внутри метода локальной переменной, то есть он
недоступен за пределами метода (вне блока его описания). В момент вызова метода
фактическое значение копируется в формальный параметр.
В частности, это означает, что, передавая какую-либо переменную базового типа как
параметр метода при его вызове, мы не сможем изменить значение этой переменной в
основной программе. Если в метод через аргумент передаётся какого-либо объекта или
массива, то внутрь метода копируется ссылка на объект или массив. Его адрес в памяти
компьютера. Действия, которые мы совершим с массивом или объектом внутри метода,
отразятся на состоянии этого массива или объекта в основной программе даже после того,
как метод завершит свою работу. Внутри метода мы обращались по тому же адресу и
работали с теми же данными в памяти. Если имя фактического параметра совпадает с
именем формального параметра, то это не влечёт никакой проблемы: внутри метода имеется
локальная переменная, в которую при вызове было скопировано значение одноимённой
глобальной. Обращаясь по имени, будем попадать на локальную переменную и никак не
сможем добраться до глобальной.
Описание метода.
Метод должен описываться внутри класса, но при этом один метод не описывают внутри
другого, то есть метод должен вкладываться непосредственно в блок класса.
Общая схема описания метода.
Модификаторы тип_возвращаемого_значения имя_метода (формальные аргументы) {
//действия, выполняемые методом
Набрано: Котомина Эмилия aka Eeemilen Asmodea WwwolandiaЛекции по программированию на Java. 1 курс 2 семестр, Математика с доп. спец. Информатика
//возможно, return
}
Имя метода по традиции должно начинаться с маленькой буквы. Если оно состоит из
нескольких слов, их не разделяют пробелом, но каждое следующее слово начинают с
заглавной. Имя для метода выбирают так, чтобы было понятно, что он делает.
Примеры:
poiskMax
vyvodMassiva
Рассмотрим несколько примеров:
Пример 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) {
Набрано: Котомина Эмилия aka Eeemilen Asmodea WwwolandiaЛекции по программированию на Java. 1 курс 2 семестр, Математика с доп. спец. Информатика
System.out.println(a);
}
pr (5); pr («5»)
void pr(int[ ] a) {
for (int i=0; i<a.length; i++) {
System.out.print(a[i]+»»)
}
}
Пример использования метода.
Int a = 5;
int [ ] m = {1, 2, 8, 3}
String s = «Мир»;
pr (a) //работает исходный метод
pr (a+s); // 5 мир, работает 1 перегрузка
pr (m); // 1 2 8 3
pr (m+a); // ошибка
Переменная а не относится к типу double, но её обрабатывает исходный метод, поскольку
возможно автоприведение из int в double. В обратном направлении оно невозможно. Если бы
метод имел аргумент типа int, то с его помощью вещественные числа выводить не
получилось бы.
Перегрузка методов реализует такое важное свойство в программировании, как
полиморфизм.
Полиморфным называется программный код, который связан с одним общим именем, но
имеет разные реализации. Какая из реализаций будет работать, выбирается на основе
контекста, в котором имя было упомянуто. Конкретно для методов полиморфными являются
их перегрузки, а выбор исполняемой перегрузки происходит по параметрам.
Полиморфизм: одно имя, много форм.
Рекурсия.
Рекурсией называется метод (функция), которая внутри своего тела вызывает сама себя.
Рассмотрим пример – вычисление факториала. Для того, чтобы вычислить n!, достаточно
знать и перемножить между собой (n-1)! и n.
Создадим метод, реализующий описанный способ.
Int fact (int n) {
if (n==1) return 1,
Набрано: Котомина Эмилия aka Eeemilen Asmodea WwwolandiaЛекции по программированию на Java. 1 курс 2 семестр, Математика с доп. спец. Информатика
if (n==2) return 2;
if (n==3) return 6;
return fact (n-1)*n,
}
Указанный метод вычисляет факториал натурального числа.
Рассмотрим пример, вычисляющий через рекурсию n-ое число Фибоначчи.
1 1 2 3 5 8 13
int fib (int n) {
if (n==1 || n == 2) return 1;
return fib (n-2) + fib (n-1);
}
Рассмотрим пример работы метода с аргументом 6.
Рекурсивные вычисления часто приводят к необходимости повторять одни и те же действия,
что существенно замедляет работу программы. Например, алгоритм вычисления числа
Фибоначчи через цикл с хранением 2 предыдущих элементов последовательности намного
эффективнее.
Стек вызовов.
В общем случае в текущий момент времени может исполняться только один единственный
метод из всей программы. Это значит, что, если метод а устроен таким образом, что в своём
теле он вызывает метод b, а сам а вызывается в Main, то при запуске программы управление
сначала будет передано методу Main, затем методу а, затем методу b. Метод b вернёт
результат b управление в а, а вернет результат управления в Main, им только потом будут
Набрано: Котомина Эмилия aka Eeemilen Asmodea Wwwolandia
3 2
2 1
2 1
3 2
2 1Лекции по программированию на Java. 1 курс 2 семестр, Математика с доп. спец. Информатика
выполняться основные инструкции, указанные в методе Main. Вся иерархия (кто кого
вызывал) хранится в специальной области памяти, называемой стек вызовов. Элементы в
этот фрагмент памяти добавляются по следующему принципу: последний добавленный
элемент должен быть извлечён первым. Когда работает метод b, имеем:
В связи с этим в процессе рекурсии существует опасность переполнения стека вызовов.
Существует так называемая сложная рекурсия, при которой функция а вызывает функцию
b, b вызывает с, а с вызывает а.
Объектно – ориентированное программирование.
Объектно – ориентированный подход (парадигма) заключается в следующем:
проанализировав условие задачи, необходимо понять, какие объекты в рамках этой задачи
должны существовать, какой набор характеристик, существенно для решения реальных
объектов и к
