methodichkaA5

//Необходимо преобразовать строку в целое число. int age = Integer.parselnt(input);

// Вывод результата на консоль. System.out.println("Здравствуй, " + name

+". В следующем году тебе, возможно, исполнится "

+(age + 1) );

System.exit(0) ;

}

}

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

Заметим, что программа завершает свою работу вызовом метода

System.exit(0);

Каждый раз, когда программа вызывает метод JOptionPane.showsInputDialog, ее работу необходимо завершать вызовом метода System.exit(0). В основном это вызвано техническими причинами. Вывод на экран диалогового окна запускает новый поток управления. При завершении работы метода main этот новый поток управления не прекращает свою работу автоматически. Чтобы закрыть все потоки, нужно вызвать метод System.exit.

Метод System.exit получает целочисленный параметр, представляющий собой "код выхода" из программы. По умолчанию, если работа программы завершилась нормально, ее код выхода равен 0, в противном случае этот код не равен нулю. Для индикации разных ошибочных ситуаций можно использовать разные коды выхода.

В заключение необходимо обратить внимание на строку i

mport javax. swing.* ;

расположенную в начале программы. Класс JOptionPane определен в пакете javax.swing. Используя класс, не определенный в основном пакете java.lang, нужно применять директиву import.

5.Функции

5.1.Основы использования функций в JAVA

Впредыдущих примерах программ использовалась только одна функция

–функция main, с нее всегда начинается выполнение программы. На самом

41

деле, в рамках одного класса программы может быть несколько функций. Функции также можно называть подпрограммами. Они имеют свои собственные переменные и свою собственную логику.

Работу с функцией можно разделить на два этапа: описание (объявление) функции и использование (вызов). Причем описание функции выполняется один раз, а вызывать ее можно любое необходимое количество раз.

Описывают функции в любом порядке подряд в рамках класса, либо перед функцией main, либо после нее, этот факт не существенный. Независимо от количества функций в программе и порядка их объявления всегда первой будет выполняться функция main, внутри которой надо организовать вызов других функций класса.

public static void main(String[] a){

Оператор 1;

Оператор 2;

MyFuction(список входных параметров);

Оператор N;

MyFuction(список входных параметров);

………………..

}

public static void MyFunction(список входных параметров){

Блок операторов 1;

}

В данном примере помимо функции main описывается другая функция – MyFunction, в задачи которой входит выполнение какого-то блока операторов, при некотором условии, задаваемом в списке входных параметров. После запуска программы начинается последовательное выполнение операторов функции main. После выполнения первого и второго оператора происходит вызов MyFuction с какими-то заданными параметрами, и программа переключается на выполнение Блока операторов 1. После отработки функция MyFuction передает работу функции main, которая продолжает выполнение операторов, следующих за первым вызовом MyFuction. Далее выполняется оператор N, после которого следует второй вызов функции MyFuction. Следовательно, опять выполняется Блок операторов 1, которые находятся внутри MyFuction.. Выполнив свои операторы, MyFuction опять передает работу функции main, которая продолжает работу. Таким образом, некий текст программы, написанный один раз в рамках функции MyFuction может быть выполнен несколько раз.

42

При объявлении функции сначала указывается модификатор доступа, в данном примере это public static. Через пробел указывается тип выдаваемого параметра. В данном примере тип выдаваемого параметра – void, т.е. выдаваемого параметра нет. Затем пишется имя функции, которое формируется по принципу формирования имен переменных. В примере это – MyFunction. После чего в круглых скобках через запятую указывается список принимаемых переменных с указанием их типов. Например:

Описана функция, которая принимает два входящих параметра целого типа, выполняет какие-то расчеты и выдает значение типа float.

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

После круглых скобок в фигурных скобках размещается внутренний текст функции, это те блоки операторов, которые будут выполнены при вызове функции. Функции могут иметь или не иметь выходной параметр. Тип выходного параметра описывается перед названием функции. Если он равен void, то это значит, что функция не выдает никаких результатов. В противном случае, если перед названием функции указан какой-то тип данных (float, double, int и т.п.), то это значит, что выдаваемые результаты будут иметь указанный тип, а также делает обязательным наличие в конце функции оператора return, который осуществляет выдачу выходного значения функции и прекращает ее выполнение.

Пример.

Программа рассчитывает квадрат трех чисел и выводит на экран пары чисел число-квадрат. Для расчета квадрата любого числа создается функция Kva с одним входным параметром. В функции Kva значение входной переменной умножается само на себя, а затем выдается оператором return. Функцию Kva вызываем в методе main для каждого из трех чисел.

package ftest;

public class FunctionTest{

public static void main(String[] a){

System.out.print(“1 ”);

System.out.println(Kva(1));

System.out.print(“2 ”);

System.out.println(Kva(2));

System.out.print(“3 ”);

43

System.out.println(Kva(3));

}

public static int Kva(int x){ int z = x*x;

return z;

}

}

Результат.

11

24

39

Нужно отметить, что Kva работает независимо от того, какое число будет подано на ее вход в качестве параметра, она является универсальной для всех целых чисел. Ее задача – рассчитывать квадрат того числа, которое будет подставлено ей как входной параметр. При первом вызове функции Kva на вход поступает единица, т.е. единица помещается в х, Kva выполняет расчет, результат которого записывается в z. Затем значение z выдается как результат работы функции с помощью оператора return z, после чего работа передается функции main, которая выводит его на экран, используя оператор

System.out.println(Kva(1));.

Пример.

Программа должна выдавать на консоль 15 строк, содержащих случайное количество звездочек от 0 до 30. В программе необходимо реализовать функцию PrintStars, которая бы выводила на экран только одну строку со случайным количеством звездочек. Затем необходимо вызывать PrintStars 15 раз из функции main.

package MyPackage; public class MyClass {

//========================= public static void PrintStars(int x) { for (int i = 0; i < x; i++) {

System.out.print("*");

}

System.out.println();

}

//========================= public static void main(String[] arg) { for (int i = 0; i < 15; i++) {

double z = 30 * Math.random(); int y = (int) Math.round(z);

44

PrintStars(y);

}

}

}

В функции main 15 раз выполняется цикл, на каждом шаге которого выполняются следующие действия. В переменную z записывается случайное число от 0 до 30, после чего оно округляется до целого и записывается в y. Эту манипуляцию необходимо выполнять потому, что функция PrintStars требует входящим параметром переменную целого типа (public static void PrintStars(int x)). Затем значение y подается на вход функции PrintStars, следовательно, подставляется во входной параметр x функции PrintStars. Таким образом, ранее сгенерированное случайное число от 0 до 30 будет записано и в переменной x. Внутри функции PrintStars выполняется цикл, количество шагов которого равно х. т.е. х-раз выводится на экран звездочка, можно также сказать, что цикл выводит на экран х звездочек. После выполнении цикла происходит переход на следующую строку. Затем, по окончании PrintStars, управление возвращается функции main для выполнения следующих шагов цикла.

Пример.

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

package sssssssss; public class www{

//---------------------------------------------------------------------------------------------------

public static double y1(int x) {

double z = (Math.exp(x) + (Math.exp( -x))) / 2; return z;

}

45

//---------------------------------------------------------------------------------------------------

public static double y2(int x) {

double z = (Math.pow(x, 2) + (Math.pow(x, 3))) / 4; return z;

}

//---------------------------------------------------------------------------------------------------

public static void main(String[] args) { double sum1 = 0;

double sum2 = 0;

for (int x = 1; x < 11; x++) { double z = y1(x); double q = y2(x); sum1 += z;

sum2 += q;

}

System.out.println(sum2);

System.out.println(sum1); if (sum1 > sum2) {

System.out.println("Sum1>Sum2");

}

if (sum1 < sum2) { System.out.println("Sum1<Sum2");

}

if (sum1 == sum2) { System.out.println("Sum1=Sum2");

}

}

}

5.2. Рекурсия

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

Прямой (непосредственной) рекурсией является вызов функции внутри тела этой же функции.

int a()

{.....a().....}

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

46

Например:

Все функции a,b,c являются рекурсивными, так как при вызове одной из них, осуществляется вызов других и самой себя.

Пример.

Необходимо написать программу, которая бы вычисляла сумму цифр в числе. Затем в получившемся числе опять вычисляла сумму цифр. Эти действия необходимо выполнять до тех пор, пока не останется число, состоящее из одной цифры. Например, если ввести число 555, то, посчитав сумму цифр в нем, получим 5+5+5=15. Так как получившееся число 15 состоит не из одной цифры, то необходимо посчитать сумму цифр в нем, т.е. 1+5=6. Теперь было получено число 6, состоящее из одной цифры, значит 6 - это и есть ответ.

package prg1; import java.lang.*; class Recursia {

//главная функция вызывает функцию Estimate public static void main (String args[]) {

System.out.println(Estimate("555"));

}

// функция Estimate вызывает сама себя

String Estimate(String st){ long sum = 0;

for(int i=0;i<st.length();i++){ String c = st.substring(i,i+1); sum+= Integer.parseInt(c);

}

String newSt = String.valueOf(sum); if(newSt.length()>1)

newSt = Estimate(newSt); return newSt;

}

}

Результат.

6

В программе в главной функции вызывается метод

System.out.println(Estimate("555")), т.е. выполняется печать на экран результата

выполнения функции Estimate при заданном в виде строки параметре 555. Внутри функции Estimate, перебирая в цикле посимвольно строку st,

47

вычисляется сумма цифр в заданном числе. Результат помещается в

строковую переменную newSt командой String newSt = String.valueOf(sum); Затем

выполняется проверка if(newSt.length()>1), если количество знаков больше одного, то вызываем эту же функцию Estimate, но с новым параметром, который равен полученной сумме newSt = Estimate(newSt); Этот процесс может повторяться многократно.

6.Объектно-ориентированное программирование

6.1.Введение в объектно-ориентированное программирование

Объектно-ориентированное программирование (ООП) в настоящее время стало доминирующей парадигмой программирования, вытеснив "структурные", процедурно-ориентированные способы программирования, разработанные в начале 1970-х годов. Язык Java представляет собой полностью объектно-ориентированный язык, и на нем невозможно программировать в процедурном стиле.

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

Традиционное структурное программирование заключается в разработке набора функций (или алгоритмов) для решения поставленной задачи. Определив эти функции, программист должен задать подходящий способ хранения данных.

Основной принцип, обеспечивший высокую производительность ООП, заключается в том, что каждый объект предназначен для выполнения определенных задач. Если перед объектом стоит задача, для решения которой он не предназначен, у него должен быть доступ к другому объекту, который может эту задачу решить. Затем первый объект просит второго решить эту задачу. Это – обобщенный вариант вызова функций, применяемого в процедурном программировании.

В частности, объект никогда не должен непосредственно манипулировать внутренними данными другого объекта, а также предоставлять другим объектам прямой доступ к своим данным. Все связи между ними обеспечиваются с помощью вызовов методов. Инкапсуляция (encapsulation) данных объекта максимально повышает возможность его повторного использования, уменьшает их взаимозависимость и минимизирует время отладки программы.

48

Разумеется, как и от модулей в процедурно-ориентированном программировании, от объектов не следует ожидать слишком многого. И разработка, и отладка программы, состоящей из небольших объектов, выполняющих небольшие задачи, намного проще по сравнению с программой, созданной из громадных объектов с крайне сложными внутренними данными и сотнями функций для манипулирования ими.

6.2. Основные термины объектно-ориентированного

программирования

Наиболее важным термином является класс, который был уже использован в предыдущих примерах программ. Класс – это шаблон, или проект, по которому будет сделан объект. Обычно класс сравнивают с формой для выпечки печенья. Объект – это само печенье. Конструирование объекта на основе некоторого класса называется созданием экземпляра (instance) этого класса.

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

Инкапсуляция (иногда называемая сокрытием данных) - это ключевое понятие при работе с объектами. Формально инкапсуляция - это просто объединение данных и операций над ними в одном пакете и сокрытие данных от пользователя объекта. Данные в объекте называются полями экземпляра (instance fields), а функции и процедуры, выполняющие операции над данными, - его методами (methods). В указанном объекте, т.е. экземпляре класса, поля экземпляра имеют определенные значения. Множество этих значений называется текущим состоянием (state) объекта. Применение любого метода к какому-нибудь объекту может изменить его состояние.

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

49

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

Еще один принцип ООП облегчает разработку собственных классов в языке Java: класс можно сконструировать на основе других классов. В этом случае говорят, что вновь созданный класс расширяет класс, на основе которого он построен. Язык Java, по существу, создан на основе "глобального суперкласса", называемого, что вполне естественно, Object. Все остальные объекты расширяют его.

Новый класс содержит все свойства и методы расширяемого класса, а также новые методы и поля данных. Концепция расширения класса для создания нового называется наследованием (inheritance).

6.3 Объекты

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

–Поведение (behavior) объекта - что с ним можно делать и какие методы

кнему можно применять.

–Состояние объекта - как этот объект реагирует на применение методов.

–Сущность (identity) объекта - чем данный объект отличается от других,

характеризующихся таким же поведением и состоянием.

Все объекты, являющиеся экземплярами одного и того же класса, ведут себя одинаково. Поведение объекта определяется методами, которые можно вызвать.

Далее, каждый объект сохраняет информацию о своем состоянии. Со временем состояние объекта может измениться, однако спонтанно это произойти не может. Состояние объекта может изменяться только в результате вызовов методов. (Если состояние объекта изменилось вследствие иных причин, значит, инкапсуляция нарушена.).

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

50