Мова Java регістро-чутлива. Це значить, що ідентифікатори чутливі до того, у якому регістрі (верхньому або нижньому) набираються символи. Наприклад, імена i1 і I1 відповідають різним ідентифікаторам. Це правило звично для тих, хто вивчав мови C/C++, але може спочатку викликати складності в тих, хто вивчав мову PASCAL, що є регістро-нечутливим.

Довжина ідентифікатора в Java будь яка, принаймні, у межах розумного. Так, навіть при довжині ідентифікатора у всю ширину екрана компілятор NetBeans правильно працює.

Змінна - це іменована комірка пам'яті, уміст якої може змінюватися. Перед тим, як використовувати яку-небудь змінну, вона повинна бути задана в області програми, що передує місцю, де ця змінна використовується. При оголошенні змінної спочатку вказується тип змінної, а потім ідентифікатор задаваємої змінної. Вказівка типу дозволяє компіляторові задавати розмір осередку (обсяг пам'яті, виділюваної під змінну або значення даного типу), а також припустимого правила дій зі змінними й значеннями цього типу. В Java існує ряд визначених типів: int - ціле число, float - речовинне число, boolean - логічне значення, Object - найпростіший об'єктний тип (клас) Java, і т.д. Також є можливість задавати власні об'єктні типи (класи).

Оголошення змінних a1 і b1, що мають якийсь тип MyType1, здійснюється так:

MyType1 a1,b1;

При цьому MyType1 - ім'я типу цих змінних.

Інший приклад - оголошення змінної j типу int :

int j;

Типи бувають визначені й користувальницькі. Наприклад, int - визначений тип, а MyType1- користувальницький. Для оголошення змінної не потрібно ніякого зарезервованого слова, а ім'я типу пишеться перед іменами задаваємих змінних.

Оголошення змінних може супроводжуватися їхньою ініціалізацією - присвоюванням початкових значень. Приведемо приклад такого оголошення цілочисельних змінних i1 і i2 :

int i1=5;

int i2=-78;

або

int i1=5,i2=-78;

Присвоювання виду int i1=i2=5;, характерні для C/C++, заборонені.

Для починаючих програмістів відзначимо, що символ “=” використовується в Java і багатьох інших мовах як символ присвоювання, а не символу рівності, як це прийнято в математиці. Він означає, що значення, що знаходиться із правої сторони від цього символу, копіюється в змінну, що стоїть в лівій частині. Тобто, наприклад, присвоювання b=a означає, що в змінну (осередок) з ім'ям b треба скопіювати значення зі змінної (осередку) з ім'ям a. Тому неправильне з погляду математики вираження

x=x+1

у програмуванні цілком коректно. Воно означає, що треба взяти значення, що зберігається в осередку з ім'ям x, додати до нього 1 (це буде відбуватися десь поза осередком x), після чого результат, що вийшов, записати в осередок x, замінивши їм колишнє значення.

Після оголошення змінних вони можуть бути використані у вираженнях і присвоюваннях:

змінна=значення;

змінна=вираження;

змінна1= змінна2;

і так далі. Наприклад,

i1=i2+5*i1;

Примітивними типами називаються такі, для яких дані втримуються в одній комірці пам'яті, і цей осередок не має підосередків.

Посилальними типами називаються такі, для яких у комірці пам'яті (посилальної змінної) утримуються не самі дані, а тільки адреси цих даних, тобто посилання на дані. При присвоюванні в посилальну змінну заноситься нова адреса, а не самі дані. Але безпосереднього доступу до адреси, що зберігається в посилальних змінних, немає. Це зроблено для забезпечення безпеки роботи з даними - як з погляду усунення ненавмисних помилок, характерних для роботи з даними по їхніх адресах у мовах C/C++/PASCAL, так і для усунення можливості навмисного злому інформації.

Якщо посилальної змінної не привласнено посилання, у ній зберігається нульова адреса, якому дане символічне ім'я null. Посилання можна привласнювати один одному, якщо вони сумісні по типах, а також привласнювати значення null. При цьому з однієї посилальної змінної в іншу копіюється адреса. Посилальні змінні можна порівнювати на рівність, у тому числі на рівність null. При цьому рівняються не дані, а їхньої адреси, що зберігаються в посилальні змінні.

В Java всі типи діляться на примітивні й посилальні. До примітивних типів ставляться наступні визначені типи: цілочисельні типи byte,short,int, long, char, типи даних у форматі із плаваючою крапкою float, double, а також булевий (логічний) тип boolean і типи-перерахування, що повідомляються за допомогою зарезервованого слова enum (скорочення від enumeration - “перерахування”). Всі інші типи Java є посилальними.

В Java діють наступні угоди про регістр букв в ідентифікаторах:

· Імена примітивних типів варто писати в нижньому регістрі (малими літерами). Наприклад, int, float, boolean і т.д.

· Імена посилальних типів варто починати із заголовної (великий) букви, а далі для імен, що складаються з одного слова, писати всі інші букви в нижньому регістрі. Наприклад, Object, Float, Boolean, Collection, Runnable. Але якщо ім'я складене, нову частина імені починають із заголовної букви. Наприклад, JButton, JTextField, JFormattedTextField, MyType і т.д. Зверніть увагу, що типи float і Float, boolean і Boolean різні - мова Java чутлива до регістра букв!

· Для змінних і методів імена, що складаються з одного слова, варто писати в нижньому регістрі. Наприклад, i, j, object1. Якщо ім'я складене, нову частину імені починають із заголовної букви: myVariable, jButton2, jTextField2.getText() і т.д.

· Імена констант варто писати у верхньому регістрі (більшими буквами), розділяючи вхідні в ім'я складові частини символом підкреслення “_”. Наприклад, Double.MIN_VALUE, Double.MAX_VALUE, JOptionPane.INFORMATION_MESSAGE, MY_CHARS_COUNT і т.п.

· Символ підкреслення “_” рекомендується використовувати для поділу складових частин імені тільки в іменах констант і пакетів.

Змінна примітивного типу може бути ототожнена з осередком, у якій зберігаються дані. У неї завжди є ім'я. Присвоювання змінної примітивного типу змінює значення даних. Для посилальних змінних дії виконуються з адресами осередків, у яких зберігаються дані, а не із самими даними.

Для чого потрібні такі ускладнення? Адже людині набагато природніше працювати з комірками пам'яті, у яких зберігаються дані, а не адреси цих даних. Відповідь полягає в тім, що в програмах часто потрібні динамічно створювані й знищувані дані. Для них не можна заздалегідь створити необхідне число змінних, тому що це число невідомо на етапі написання програми й залежить від вибору користувача. Такі дані доводиться поміщати в динамічно створювані й знищувані осередки. А із цими осередками вдається працювати тільки за допомогою посилальних змінних.

Посилальні типи Java використовуються в об'єктному програмуванні. Зокрема, для роботи з рядками, файлами, елементами користувальницького інтерфейсу. Всі користувальницькі типи (задаються програмістом), крім типів-перерахувань, є посилальними. У тому числі - строкові типи.

2.3 Зарезервовані слова мови Java

Це слова, зарезервовані для синтаксичних конструкцій мови, причому їхнє призначення не можна перевизначати усередині програми(див. табл. 2,1).

Таблиця 2.1

Зарезервовані слова мови Java

abstract	boolean	break	byte	case
catch	char	class	const	continue
default	do	double	else	enum
extends	false	final	finally	float
for	goto	if	implements	import
instanceof	int	interface	long	native
new	null	package	private	protected
public	return	short	static	super
switch	synchronized	this	throw	throws
transient	true	try	void	volatile
while

Їх не можна використовувати як ідентифікатори (імен змінних, підпрограм і т.п.), але можна використовувати в строкових вираженнях.

2.4 Керуючі послідовності

2.4.1 Керуючі послідовності - символи формування тексту

Іноді в тексті програми в строкових константах потрібно використовувати символи, які звичайним образом у текст програми ввести не можна. Наприклад, символи лапок (їх треба використовувати усередині лапок, що важко), символ питання (зарезервований для тернарного умовного оператора), а також різні спеціальні символи. У цьому випадку використовують керуючу послідовність - символ зворотної косої риси, після якої слідує один керуючий символ. У таблиці 2.2 наведені керуючі послідовності, що застосовуються в мові Java.

Таблиця 2.2

Символи формування тексту

Символ	Що означає
\a	дзвінок
\b	повернення на один символ назад
\f	перехід на нову сторінку
\n	перехід на новий рядок
\r	повернення до початку рядка
\t	горизонтальна табуляція
\v	вертикальна табуляція
\'	лапки
\”	подвійні лапки
\\	зворотна коса риса
\?	знак питання
\u	початок кодування символу Unicode

2.4.2 Керуючі послідовності - символи Unicode

Керуюча послідовність може містити кілька символів. Наприклад, символи національних алфавітів можуть кодуватися послідовністю “\u”, після якої йде код символу в щістнадцятиричному кодуванню для кодових таблиць UTF-16 або UTF-8. Наприклад:

\u0030 - \u0039 - цифри ISO-LATIN від 0 до 9

\u0024- знак долара $

\u0041 - \u005a - букви від A до Z

\u0061 - \u007a - букви від a до z

2.4.3 Прості спеціальні символи

В мові програмування Java використовуються прості спеціальні символи наведені в таблиці 2.3

Таблиця 2.3

Прості спеціальні символи

+	Оператор додавання		.	Крапка - десятковий роздільник у числовому літерному вираженні; роздільник у складеному імені для доступу до елемента пакета, класу, об'єкта, інтерфейсу
-	Оператор вирахування		(	Продовження таблиці 2,3 Ліва кругла дужка - використовується для відкриття списку параметрів в операторах і для відкриття групуємої частини у вираженнях
*	Оператор множення		)	Права кругла дужка- використовується для закриття списку параметрів в операторах і для закриття групуємої частини у вираженнях
/	Оператор розподілу		[	Ліва квадратна дужка - відкриття індексу масиву
%	Оператор залишку від цілочисельного розподілу		]	Права квадратна дужка - закриття індексу масиву
=	Оператор присвоювання		;	Крапка з комою - закінчення оператора
~	Оператор побітового доповнення (побітове “не”)		'	Апостроф (одиночні лапки) - відкриття й закриття символу
?	Знак питання - частина тернарного ( щоскладається із трьох частин) умовного оператора “? :”		”	Продовження таблиці 2,3 Подвійні лапки - відкриття й закриття рядка символів
:	Двокрапка - частина умовного оператора “? :”. Також використовується для завдання мітки - ставиться після імені мітки.		\	зворотна коса риса (backslash) - використовується для завдання керуючих послідовностей символів
^	Оператор “ щовиключає або” (XOR)			знак пробілу (невидимий)
&	Оператор “побітове й” (AND)			знак табуляції (невидимий)
|	Оператор “побітове або” (OR)		@	Комерційне a (“ет”) - знак початку метаданих
!	Оператор “НЕ”		#	- не має спеціального призначення
>	Більше		¤	- не має спеціального призначення
<	Менше		«	- не має спеціального призначення
{	Ліва фігурна дужка - відкриття блоку коду		»	- не має спеціального призначення
}	Права фігурна дужка - закриття блоку коду		№	Продовження таблиці 2,3 - не має спеціального призначення
,	Кома - роздільник у списку параметрів оператора; роздільник у складеному операторі		§	- не має спеціального призначення

2.4.4 Складені спеціальні символи

В мові програмування Java використовуються складені спеціальні символи наведені в таблиці 2.4

Таблиця 2.4

Складені спеціальні символи

Символ	Що означає
++	Оператор інкремента (збільшення на 1); x++ еквівалентно x=x+1
--	Оператор декремента (зменшення на 1); x-x-- еквівалентно x= x-1
&&	Оператор “логічне І” (AND)
||	Оператор “ логічне АБО” (OR)
<<	Оператор лівого побітового зрушення
>>>	Оператор беззнакового правого побітового зрушення
>>	Оператор правого побітового зрушення зі збереженням знака Продовження таблиці 2.4 негативного числа
==	Дорівнює
! =	не дорівнює
+=	y+=x еквівалентно y=y+x
-=	y-y-=x еквівалентно y= y-x
*=	y*=x еквівалентно y=y*x
/=	y/=x еквівалентно y=y/x
%=	y%=x еквівалентно y=y%x
|=	y|=x еквівалентно y=y|x
^=	y^=x еквівалентно y=y^x
>>=	y>>=x еквівалентно y= y>>x
>>>=	y>>>=x еквівалентно y= y>>>x
<<=	y<<=x еквівалентно y= y<<x
/*	Початок багатострокового коментарю.
/**	Початок багатострокового коментарю, призначеного для автоматичного створення документації по класі.
*/	Кінець багатострокового коментарю ( що відкривається як /* або /**).
//	Однорядковий коментар.

2.5 Складений оператор

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

Складений оператор - блок коду між фігурними дужками {}:

Є два загальноприйнятих способи форматування тексту з використанням фігурних дужок.

У першому з них дужки пишуть друг під другом, а текст, що перебуває між ними, зрушують на 1-2 символу вправо (зрідка - більше). Приклад:

оператор

{

послідовність простих або складених операторів

}

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

оператор{

послідовність простих або складених операторів

}

Саме такий спосіб установлений за замовчуванням у середовищі NetBeans, і саме він використовується у фрагментах програмного коду, що приводяться в, даній книзі. Проте, автор віддає перевагу першому способу форматування програмного коду, тому що він більше читаємий. Для установки такого способу форматування вихідного коду варто перейти в меню Tools/Options, вибрати Editor/Indentation, після чого в діалоговій формі, що з'явилася, відзначити галочкою пункт AddNewLineBeforeBrace.

Після фігурних дужок за правилами Java, як і в /C++, ставити символ ";" не треба.

2.6 Умовний оператор if

В умовного оператора if є дві форми: if і if- else.

По-англійському if означає "якщо", else - "у противному випадку". Таким чином, ці оператори можуть бути переведені як "якщо...те..." і "якщо...те...у противному випадку...".

Перша форма:

if(умова)

оператор1;

Якщо умова дорівнює true, виконується оператор1. Якщо ж умова==false, в операторі не виконується ніяких дій.

Друга форма:

if(умова)

оператор1;

else

оператор2;

У цьому варіанті оператора if якщо умова==false, то виконується оператор2.

Потрібно звернути особливу увагу на форматування тексту. Не можна розташовувати всі частини оператора if на одному рядку - це характерно для новачків!

Приклад:

if(a<b)

a=a+1;

elseif(a==b)

a=a+1;

else{

a=a+1;

b=b+1;

};

Із цього правила є виключення: якщо підряд іде велика кількість операторів if, що вміщаються в один рядок, для підвищення читаності програм буває доцільно не переносити інші частини операторів на окремі рядки.

2.7 Оператор вибору switch

Є аналогом if для декількох умов вибору. Синтаксис оператора наступний:

switch(вираження){

case значення1: оператори1;

……………………………

caseзначение: оператори N;

default: оператори;

}

Правда, украй незручно, що не можна не вказувати діапазон значень, не перераховувати через кому значення, яким відповідають однакові оператори. Тип вираження повинен бути яким-небудь із цілих типів. Зокрема, неприпустимі речовинні типи.

Працює оператор у такий спосіб: спочатку обчислюється вираження. Потім обчислене значення рівняється зі значеннями варіантів, які повинні бути визначені ще на етапі компіляції програми. Якщо знайдено варіант, якому задовольняє значення вираження, виконується відповідному цьому варіанту послідовність операторів, після чого НЕ ВІДБУВАЄТЬСЯ виходу з оператора case, що було б природно. - Для такого виходу треба поставити оператор break.Ця неприємна особливість Java успадкована від мови C.

Частина з default є необов'язковою й виконується, якщо жоден варіант не знайдений.

Приклад:

switch(i/j){

case 1:

i=0;

break;

case 2:

i=2;

break;

case 10:

i=3;

j=j/10;

break;

default:

i=4;

};

В оператора switch є дві особливості:

Можна писати довільне число операторів для кожного варіанта case, що досить зручно, але повністю випадає з логіки операторів мови Java.

Вихід з виконання послідовності операторів здійснюється за допомогою оператора break. Якщо він відсутній, відбувається "провалювання" у блок операторів, що відповідають наступному варіанту за тим, з яким збіглося значення вираження. При цьому ніякої перевірки відповідності черговому значенню не виробляється. І так триває доти, поки не зустрінеться оператор break або не скінчаться всі оператори у варіантах вибору. Такі правила перевірки породжують типову помилку, називану "забутий break".

2.8 Умовне вираження...?... :...

Ця не дуже вдала по синтаксису функція успадкована з мови C. Її синтаксис такий:

умова?значення1:значення2

У випадку, коли умова має значення true, функція повертає значення1, у противному випадку вертається значення2.

Наприклад, ми хочемо привласнити змінної j значення, рівне i+1 при i<5, і i+2 в інших випадках. Це можна зробити в такий спосіб:

j=i<5?i+1:i+2

Іноді при обчисленні громіздких виражень цей оператор доводиться використовувати: без нього програма виявляється ще менш прозорою, чим з ним. Пріоритет роздільників "?" і ":" дуже низький - нижче тільки пріоритет оператора присвоювання (у будь-яких його формах). Тому можна писати вираження без використання дужок. Але краще все-таки використовувати дужки:

j=(i<5)?(i+1):(i+2)

2.9 Оператори інкремента ++ і декремента -і

Оператор "++" називається інкрементным ("збільшуючим"), а "-і" декрементним ("зменшуючим"). У цих операторів є дві форми, постфіксна (найпоширеніша, коли оператор ставиться після операнда) і префіксна (використовується дуже рідко, у ній оператор ставиться перед операндом).

Для будь-якої числової величини x вираження x++ або ++x означає збільшення x на 1, а вираження x-- або -іx означає зменшення x на 1.

Розходження двох форм пов'язане з тим, коли відбувається зміна величини - після обчислення вираження, у якому використовується оператор, для постфіксної форми, або до цього обчислення - для префіксної.

Наприклад, присвоювання j=i++ і j=++i дадуть різні результати. Якщо спочатку i=0, то перше присвоювання дасть 0, тому що i збільшиться на 1 після виконання присвоювання. А друге дасть 1, тому що спочатку виконається інкремент, і тільки потім буде обчислюватися вираження й виконуватися присвоювання. При цьому в обох випадках після виконання присвоювання i стане дорівнювати 1.

2.10 Оператор циклу for

for(блок ініціалізації; умова виконання тіла циклу;

блок зміни лічильників)

оператор;

У блоці ініціалізації через кому перераховуються оператори завдання локальних змінних, область існування яких обмежується оператором for. Також можуть бути привласнені значення змінним, заданим поза циклом. Але ініціалізація може відбуватися тільки для змінних одного типу.

У блоці умови продовження циклу перевіряється виконання умови, і якщо воно виконується, іде виконання тіла циклу, у якості якого виступає оператор. Якщо ж не виконується - цикл припиняється, і йде перехід до оператора програми, що випливає за оператором for.

Після кожного виконання тіла циклу (чергового кроку циклу) виконуються оператори блоку зміни лічильників. Вони повинні розділятися комами.

Приклад:

for(int i=1,j=5; i+j<100; i++,j=i+2*j){

...

};

Кожний із блоків оператора for є необов'язковим, але при цьому розділові ";" потрібно писати.

Найбільш уживане використання оператора for - для перебору значень деякої змінної, що збільшуються або зменшуються на 1, і виконання послідовності операторів, що використовують ці значення. Змінна називається лічильником циклу, а послідовності операторів - тілом циклу.

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

Напишемо цикл, у якому виконується підсумовування всіх чисел від 1 до 100. Результат будемо зберігати в змінної result.

int result=0;

for(int i=1; i<=100; i++){

result=result+i;

};

Цикл (повторне виконання тих самих дій) виконується в такий спосіб:

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

Починається цикл. Спочатку виконується блок ініціалізації - лічильнику циклу i привласнюється значення 1. Блок ініціалізації виконується тільки один раз на самому початку циклу.

Починається перший крок циклу. Перевіряється умова виконання циклу. Значення i порівнюється з 100.

Оскільки порівняння 1<=100 повертає true, виконується тіло циклу. У змінної result зберігається 0, а значення i дорівнює 1, тому присвоювання result=result+i еквівалентно result=1. Таким чином, після першого кроку циклу в змінної result буде зберігатися значення 1.

Після виконання тіла циклу виконується секція зміни лічильника циклу, тобто оператор i++, що збільшує i на 1. Значення i стає рівним 2.

Починається другий крок циклу. Перевіряється умова виконання тіла циклу. Оскільки порівняння 2<=100 повертає true, іде чергове виконання тіла циклу, а потім - збільшення лічильника циклу.

Кроки циклу тривають доти, поки лічильник циклу не стане рівним 101. У цьому випадку умова виконання тіла циклу 101<=100 повертає false, і відбувається вихід із циклу. Останнє присвоювання result=result+i, проведене в циклі, це result=result+100.

Якби нам треба було підсумувати числа від 55 до 1234, у блоці ініціалізації i треба привласнити 55, а в умові перевірки поставити 1234 замість 100.

Приклад 2: обчислення факторіала.

double x=1;

for(i=1;i<=n;i++){

x=x*i;

};

Помітимо, що в наведених прикладах можна зробити деякі вдосконалення - оператори присвоювання записати в такий спосіб:

result+=i; замість result=result+i;

для першого приклада й

x*=i; замість x=x*i;

для другого. На початкових стадіях навчання так краще не робити, оскільки текст програми повинен бути зрозумілий програмістові - всі алгоритми повинні бути "прозорі" для розуміння.

2.11 Оператор циклу while - цикл із передумовою

while(умова)

оператор;

Поки умова зберігає значення true - у циклі виконується оператор, інакше - дія циклу припиняється. Якщо умова із самого початку false, цикл відразу припиняється, і тіло циклу не виконається жодного разу.

Цикл while звичайно застосовують замість циклу for у тому випадку, якщо умови продовження досить складні. На відміну від циклу for у цьому випадку немає формально заданого лічильника циклу, і не відбувається його автоматичної зміни. За це відповідає програміст. Хоча цілком можливе використання як циклу for замість while, так і навпаки. Багато програмістів воліють користуватися тільки циклом for як найбільш універсальним.

Приклад:

i=1;

x=0;

while(i<=n){

x+=i;//еквівалентно x=x+i;

i*=2;//еквівалентно i=2*i;

};

2.12 Оператор циклу do...while - цикл із постумовою

do

оператор;

while(умова);

Якщо умова приймає значення false, цикл припиняється. Тіло циклу виконується до перевірки умови, тому воно завжди виконається хоча б один раз.

Приклад:

int i=0;

double x=1;

do{

i++; // i=i+1;

x*=i; // x=x*i;

}

while(i<n);

Якщо за допомогою оператора do...whileорганізується цикл із речовинним лічильником або іншою перевіркою на рівність або нерівність чисел типу float або double, у нього виникають точно такі ж проблеми, як описані для циклів for і while.

При необхідності організувати нескінченний цикл (з виходом зсередини тіла циклу за допомогою оператора переривання) часто використовують наступний варіант:

do{

…

}

while(false);

2.13 Оператори переривання continue, break, return, System.exit

Досить часто потрібно при виконанні якої-небудь умови перервати цикл або підпрограму й перейти до виконання іншого алгоритму або чергової ітерації циклу. При неструктурному програмуванні для цих цілей служив оператор goto. В Java є більш гнучкі й структурні засоби для рішення цих проблем - оператори continue, break, return, System.exit:

continue; - переривання виконання тіла циклу й перехід до наступної ітерації (перевірці умови) поточного циклу;

continue ім'я мітки; - переривання виконання тіла циклу й перехід до наступної ітерації (перевірці умови) циклу, позначеного міткою (label);

break; - вихід з поточного циклу;

break ім'я мітки; - вихід із циклу, позначеного міткою;

return; - вихід з поточної підпрограми (у тому числі з тіла циклу) без вороття значення;

return значення; - вихід з поточної підпрограми (у тому числі з тіла циклу) з поверненням значення;

System.exit(n) -вихід з додатка з кодом завершення n. Ціле число n довільно задається програмістом. Якщо n=0, вихід уважається нормальним, в інших випадках - аварійним. Додаток перед завершенням повідомляє число n операційній системі для того, щоб програміст міг установити, з якої причини відбувся аварійний вихід.

Оператори continue і break використовуються у двох варіантах - без міток для виходу з поточного (самого внутрішнього по вкладеності) циклу, і з міткою - для виходу з позначеного їй циклу. Міткою є ідентифікатор, після якого стоїть двокрапка. Мітку можна ставити безпосередньо перед ключовим словом, що починає завдання циклу (for, while, do).

Приклад використання continue без мітки:

for(int i=1;i<=10;i++){

if(i==(i/2)*2){

continue;

};

System.out.println("i="+i);

};

У даному циклі не будуть друкуватися всі значення i, для яких i==(i/2)*2. Тобто виводитися у вікно консолі будуть тільки непарні значення i.

Приклад використання break без мітки:

for(int i=1;i<=10;i++){

if( i+6== i*i ){

break;

};

System.out.println("i="+i);

};

Даний цикл зупиниться при виконанні умови i+6== i*i. Тобто вивід у вікно консолі буде тільки для значень i, рівних 1 і 2.

Ще один приклад використання break без мітки:

for(int i=1;i<=20;i++){

for(int j=1;j<=20;j++){

if(i*j==(i*j/2)*2){

break;

};

System.out.println("i="+i+" j="+j+ " 1.0/(i*j-20)="+ (1.0/(i*j-20)) );

};};

У цьому випадку будуть виводитися всі значення i та j доти, поки не найдеться пара i та j, для яких i*j==(i*j/2)*2. Після чого внутрішній цикл припиняється - значення i, j та 1.0/(i*j-20) для даного й наступного значень j при відповідному i не будуть виводитися у вікно консолі. Але зовнішній цикл (по i ) буде тривати, і висновок продовжиться для нових

i та j. Результат буде таким же, як для continue з міткою для зовнішнього циклу.

2.14 Робота з рядками в Java. Рядки як об'єкти. Класи String, StringBuffer і StringBuilder

Клас Stringінкапсулює дії з рядками. Об'єкт типу String - рядок, що складається з довільного числа символів, від 0 до 2*10⁹. Літерні константи типу String являють собою послідовності символів, укладені в подвійні лапки:

”A”, ”abcd”, ”abcd”, ”Мама миє раму”, ” ”.

Це так звані “довгі” рядки. Усередині літерної строкової константи не дозволяється використовувати ряд символів - замість них застосовуються керуючі послідовності.

Усередині рядка дозволяється використовувати переноси на новий рядок. Але літерні константи з такими переносами заборонені, і треба ставити керуючу послідовність “\n”. На жаль, такий перенос рядка не спрацьовує в компонентах.

Дозволено порожні рядки, що не містять жодного символу.

У мові Java строковий і символьний тип несумісні. Тому ”A” - рядок з одного символу, а 'A' - число з ASCII кодом символу ”A”. Це помітно ускладнює роботу з рядками й символами.

Рядки можна складати: якщо s1 і s2 строкові літерні константи або змінні, то результатом операції s1+s2 буде рядок, що є зчепленням (конкатенацією) рядків, що зберігаються в s1 і s2. Наприклад, у результаті операції

Strings=”Це ”+”мій рядок”;

у змінної s буде зберігатися строкове значення ”Це мій рядок”.

Для рядків дозволений оператор ”+=”. Для строкових операндів s1 і s2 вираження

s1+=s2 еквівалентно вираженню s1=s1+s2.

Будь-який рядок (набір символів) є об'єктом - екземпляром класу String. Змінні типу String є посиланнями на об'єкти, що варто враховувати при передачі параметрів строкового типу в підпрограми, а також при багаторазових змінах рядків. При кожній зміні рядка в динамічній області пам'яті створюється новий об'єкт, а колишній перетворюється в “сміття”. Тому при багаторазових змінах рядків у циклі виникає багато сміття, що небажано.

Дуже частою помилкою є спроба порівняння рядків за допомогою оператора “==”. Наприклад, результатом виконання наступного фрагмента

String s1="Рядок типу String";

String s2="Рядок";

s2+=" типи String";

if(s1==s2)

System.out.println("s1 дорівнює s2");

else

System.out.println("s1 не дорівнює s2");

буде вивід у консольне вікно рядка “s1 не дорівнює s2”, тому що об'єкти-рядка мають у пам'яті різні адреси. Порівняння по змісту для рядків виконує оператор equals. Тому якби замість s1==s2 ми написали s1.equals(s2), те одержали б відповідь “s1 дорівнює s2”.

Дивним може здатися факт, що результатом виконання наступного фрагмента

String s1="Рядок";

String s2="Рядок";

if(s1==s2)

System.out.println("s1 дорівнює s2");

else

System.out.println("s1 не дорівнює s2");

буде вивід у консольне вікно рядка “s1 дорівнює s2”. Справа в тому, що оптимізуючий компілятор Java аналізує наявні в коді програми літерні константи, і для однакових по змісту констант використовує ті самі об'єкти-рядки.

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

У класі String є ряд методів. Перелічимо найважливіші з них. Нехай s1 і sub мають тип String, charArray - масив символів char[], ch1 - змінна або значення типу char, а i, index1 і count (“рахунок, кількість”) - цілочисельні змінні або значення. Тоді

String.valueOf(параметр) - повертає рядок типу String, що є результатом перетворення параметра в рядок. Параметр може бути будь-якого примітивного або об'єктного типу.

String.valueOf(charArray, index1,count) - функція, аналогічна попередньої для масиву символів, але перетвориться count символів починаючи із символу, що має індекс index1.

2.15 Робота з масивами

Масив (array) - це впорядкований набір однаково влаштованих осередків, доступ до яких здійснюється по індексу. Наприклад, якщо в масиву ім'я a1, то a1[i] - ім'я осередку цього масиву, що має індекс i.

В Javaмасиви є об'єктами, але особливого роду - їхнє оголошення відрізняється від оголошення інших видів об'єктів. Змінна типу масив є посилальної - у ній утримується адреса об'єкта, а не сам об'єкт, як і для всіх інших об'єктних змінних в Java. Як елементи (осередків) масиву можуть виступати значення як примітивних типів, так і посилальних типів, у тому числі - змінні типу масив.

Тип осередку масиву називається базовим типом для масиву.

Для завдання масиву, на відміну від об'єктів інших типів, не потрібно попередньо задавати клас, і мати спеціальне ім'я для даного об'єктного типу. Замість імені класу при оголошенні змінної використається ім'я базового типу, після якого йдуть порожні квадратні дужки.

Наприклад, оголошення

int[] a1;

задає змінну a1 типу масив. При цьому розмір масиву (число осередків у ньому) заздалегідь не задається й не є частиною типу.

Для того, щоб створити об'єкт типу масив, варто скористатися зарезервованим словом new, після чого вказати ім'я базового типу, а за ним у квадратних дужках число осередків у створюваному масиві:

a1=new int[10];

Можна сполучити оголошення типу змінної й створення масиву :

int[] a1=new int[10];

Після створення масиви Java завжди ініціалізовані - в осередках утримуються нулі. Тому якщо базовий тип масиву примітивний, елементи масиву будуть нулями відповідного типу. А якщо базовий тип посилальний - в осередках будуть значення null.

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

Приклад роботи з масивом:

int[] a=newint[100];

for(int i=0;i<a.length;i++){

a[i]=i+1;};

Якщо в нас є змінна типу масив, і їй зіставлений масив заданої довжини, у будь-який момент цієї змінної можна зіставити новий масив. Наприклад,

a1=new int[20];

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

Змінні типу масив можна привласнювати один одному. Присвоювання змінних типу масив приводить до того, що імена змінних стають синонімами того самого масиву - копіюється адреса масиву. А зовсім не приводить до копіювання елементів з одного масиву в іншій, як це відбувається в деяких інших мовах програмування.

Двовимірний масив являє собою масив осередків, кожна з яких має тип “одномірний масив”. Відповідним чином він і задається. Наприклад, завдання двовимірного масиву цілих чисел буде виглядати так:

int[][] a=newint[10][20];

Буде заданий осередок типу “двовимірний масив”, а також створений і призначений цієї посилальної змінної масив, що має по першому індексі 10 елементів, а по другому 20. Тобто ми маємо 10 осередків типу “одномірний масив”, кожна з яких посилається на масив з 20 цілих чисел. При цьому базовим типом для осередків по першому індексі є int[], а для осередків по другому індексі int.

Розглянемо роботу із двовимірними масивами на прикладі заповнення двовимірного масиву випадковими числами:

int m=10;//10 рядків

int n=20;//20 стовпців

int[][] a=newint[m][n];

for(int i=0;i<m;i++){ //цикл по рядках

for(int j=0;j<n;j++){ //цикл по стовпцях

a[i][j]=(int)(100*Math.random());

System.out.print(a[i][j]+" "); };

System.out.println();//переклад на новий рядок після виводу рядка матриці

};

Після створення масиву потрібно його ініціалізувати - записати потрібні значення в осередки. Дотепер ми робили це шляхом завдання значень у циклі по деякій формулі, однак часто потрібно задати конкретні значення. Дуже зручний наступний варіант синтаксису:

int[] a=newint[] {2,0,0,6};

З об'єктів-масивів можна викликати метод clone(), що дозволяє створювати копію (клон) масиву:

a=newint[] {2,0,0,6};

int[] a1=a.clone();

Копіювання масивів можна здійснювати в циклі, але набагато швидше використати метод System.arraycopy.

int[] b=newint[a.length+10];

System.arraycopy(a,index1a,b, index1b,count);

Швидке заповнення масиву однаковими значеннями може здійснюватися методом Arrays.fill(масив, значення). Клас Arrays розташований у пакеті java.util. Заелементне порівняння масиву варто виконувати за допомогою методу Arrays.equals(a,a1). Сортування (упорядкування за значеннями) масиву a виконуються методами Arrays.sort(a) і Arrays.sort(a,index1,index2). Перший з них упорядковує в порядку зростання весь масив, другий - частина елементів (від індексу index1 до індексу index2).

2.16 Створення Java додатка із графічним інтерфейсом

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

Екранною формою називається область, що видна на екрані у вигляді вікна з різними елементами - кнопками, текстом, що випадають списками й т.д. А самі ці елементи називаються компонентами.

Форма - це об'єкт, звичайно прямокутної форми, якому можна застосовувати для надання інформації користувачеві й для обробки уведення інформації від користувача.

2.17 Редактор екранних форм

Для створення проекту необхідно натиснути File /NewFile. У діалозі, що відкрився, у списку категорій треба вибратиSwing GUI Forms. Обираємо тип файлу JFrameForm. НатискаємоNext>. Після цього введемо назву створюваного класу й пакет, де він буде зберігатися. І натискаємо Finish. IDE створює новий клас. І відкриває його у візуальному редакторі форми. Натиснемо закладкуDesign (“дизайн”) у лівій верхній частині редактора вихідного коду. При цьому ми перемкнемося з режиму редагування вихідного коду (активна закладкаSource - “вихідний код”) у режим редагування екранної форми, як це показано на рисунку 2.1.

Рис. 2.1 Редагування екранної форми.

Замість вихідного коду показується зовнішній вигляд екранної форми й компоненти, що перебувають на ній. Праворуч від вікна, у якому показується екранна форма в режимі редагування, розташовані вікна Palette (“палітра”) палітри компонентів і вікно Properties (“властивості”) показу й редагування властивостей поточного компонента.

Властивість - це поле даних, що після зміни значення може проробити яку-небудь дію. Наприклад, при зміні значення ширини компонента вималювати на екрані компонентів з новою шириною. “Звичайне” поле даних на таке не здатне. Таким чином, властивість - це “розумне поле даних”.

Палітра компонентів призначена для вибору типу компонента, що потрібний програмістові для розміщення на екранній формі. Наприклад, додамо на нашу форму компонентів типу JButton (скорочення від JavaButton - “кнопка Java”). Для цього клацнемо мишею по пунктіJButton на палітрі й пересунемо мишу в потрібне місце екранної форми. При влученні миші в область екранної форми на ній з'являється кнопка стандартного розміру, що пересувається разом з мишею. Клацання в потрібному місці форми приводить до того, що кнопка залишається в цьому місці. Навколо їїпоказуються рамка й маленькі квадратики, що позначають, що наш компонент є виділеним. Для нього здійснюється показ і редагування властивостей у вікні Properties.Крім того, від виділеного компонента виходять лінії, до яких іде прив'язка для завдання положення компонента на формі.

За замовчуванням напису на компонентах задаються як ім'я типу, після якого йде номер компонента. Але замість заголовної букви, на відміну від імені типу, використовується рядкова. Тому перша кнопка буде мати напис jButton1, друга - jButton2, і так далі. Такі ж імена будуть отримувати автоматично створювані у вихідному коді змінні, відповідним кнопкам.

Змінити напис на кнопці можна декількома способами. По-перше, зробивши по ній подвійне клацання, і відредагувавши текст. По-друге, перейшовши у вікно Properties, змінивши значення властивості Text і нажавши<Enter> для завершення уведення. По-третє, змінивши аналогічним образом властивість label. Нарешті, можна у вікні Properties відредагувати текст не в однорядковому полі уведення значень для властивостей Text або label, а відкривши багатостроковий редактор шляхом натискання на кнопку, що перебуває праворуч від пункту редагування значення властивості. Однак багатостроковість редактора не допомагає зробити напис на кнопці багатостроковим.

Введемо на кнопці напис “OK” - використовуємо цю кнопку для виходу із програми.

Рис 2.2 Редагування властивостей компонента

Розмір компонента задається мишею шляхом хапання за рамку й розширення або звуження по відповідних напрямках. Установка на нове місце - перетаскуванням компонента мишею.

Деякі властивості виділеного компонента (його розмір, положення, текст) можна змінювати безпосередньо в області екранної форми. Однак більшість властивостей переглядають і міняють у вікні редагування властивостей(рис 2.2). Воно складається із двох стовпців: у лівому показуються імена властивостей, у правому - їхні значення. Значення, які знаходяться у правому стовпці, у багатьох випадках можуть бути відредаговані безпосередньо в осередках таблиці. При цьому уведеннязакінчується натисканням на <Enter> або виходом з редагуємоїячейки, а скасувати результати незакінченого уведення можна натисканням <Escape>.

У правій частині кожного осередку є кнопка з написом “...” - у сучасних операційних системах прийнято додавати трикрапки в назві пунктів меню й кнопок, після натискання на які відкривається діалогове вікно. У цьому випадку розкривається вікно спеціалізованого редактора відповідної властивості, якщо він існує.

Якщо потрібно переглядати й редагувати велику кількість властивостей компонента, буває зручніше клацнути правою кнопкою миші по потрібному компоненті й у меню що з'явилось вибрати пункт “Properties”. У цьому випадку відкриється окреме вікно редагування властивостей компонента. Можна тримати відкритими одночасно довільну кількість таких вікон.

Булеві властивості в колонці значень властивостей показуються у вигляді кнопок вибору checkbox - квадратиків з можливістю установки галочки усередині. Якщо галочки нема, значення властивості false, якщо є - true.

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

Таблиця 2.5

Властивості компонента JButton

Назва властивості	Що воно задає
background	Колір тла
componentPopupMenu	Дозволяє призначати спливаюче меню, що з'являється по натисканню правою кнопкою миші в області компонента.
font	Шрифт, яким робиться напис на компоненті.
foreground	Колір шрифту, яким робиться напис на компоненті.
icon	Картинка, що рисується на компоненті поруч із текстом.
text	Текст (напис) на компоненті.
toolTipText	Спливаюча підказка, що з'являється через якийсь час при наведенні курсору миші на компонент.
border	Тип рамки навколо компонента.
borderPainted	Чи рисується рамка навколо компонента.
contentAreaFilled	Чи є заповнення кольором внутрішньої області компонента (для кнопок воно створює ефект тривимірності, без заповнення кнопка виглядає плоскою).
defaultCapable	Чи здатна кнопка бути “кнопкою за замовчуванням”: при натисканні <Enter> автоматично відбувається натискання “кнопки за замовчуванням” (така кнопка на екранній формі повинна бути одна).
enabled	Чи доступний компонент. За замовчуванням всі створювані на формі компоненти доступні. Недоступні компоненти рисуються більш бляклими фарбами.

Як приклад додамо спливаючу підказку для нашої кнопки: уведемо текст “Ця кнопка призначена для виходу із програми” у поле, що відповідає властивості toolTipText. На жаль, підказка може бути тільки однорядковою - символи перекладу на новий рядок при виводу підказки ігноруються, навіть якщо вони задані в рядку програмним шляхом.

Нарешті, задамо дію, що буде виконуватися при натисканні на кнопку - оброблювач події (eventhandler) натискання на кнопку. Для цього спочатку виділимо кнопку, після чого клацнемо по ній правою кнопкою миші, і в спливаючому меню що з'явилось (рис 2.3) виберемо пункт Events/Action/actionPerformed.

Рис. 2.3 Призначення оброблювача події

Events означає “Події”, Action - “Дія”, actionPerformed - “виконанадія”.

Після цього відбудеться автоматичний перехід у редактор вихідного коду, і там з'явиться заготівля оброблювача події:

privatevoid jButton1ActionPerformed(java.awt.event.ActionEventevt) {

// TODO addyourhandlingcodehere: }

Аналогічний результат можна одержати й більш швидким способом - після того, як ми виділимо кнопку у вікні редагування форми (Design), у вікні Navigator показується й виділяється ім'я цієї кнопки. Подвійне клацання по цьомуімені у вікні навігатора приводить до створення заготівлі оброблювача події.

Поруч із оброблювачем jButton1ActionPerformed буде розташований уже наявний оброблювач події, що спрацьовує при натисканні на пункт меню “Вихід”:

privatevoidexitMenuItemActionPerformed(java.awt.event.ActionEventevt) {

System.exit(0); }

Замінимо в нашім оброблювачі події рядок з коментарем на код, що викликає вихід із програми:

privatevoid jButton1ActionPerformed(java.awt.event.ActionEventevt) {

System.exit(0); }

Тепер після запуску нашого додатка підведення курсору миші до кнопки приведе до появи спливаючої підказки, а натискання на кнопку - до виходу із програми.

Випадок, що часто зустрічається - показ повідомлення при настанні якої-небудь події, наприклад - натисканні на кнопку. В цьому випадку викликають панель із повідомленням:

javax.swing.JOptionPane.showMessageDialog(null,"Мене натиснули");

Якщо класи пакета javax.swing імпортовані, префікс javax.swing при виклику не потрібний.

3. ПРАКТИЧНА ЧАСТИНА

Програми, створені мовою програмування Java, підрозділяються по своєму призначенню на дві групи.

До першої групи відносяться додатки Java, призначені для локальної роботи під управлінням інтерпретатора (віртуальної машини) Java.

Другу групу програм називають аплетами (aplets). Аплети являють собою невеликі спеціальні програми, що перебувають на вилученому комп'ютері в мережі, з яким користувачі з'єднуються за допомогою браузера. Аплети завантажуються в браузер користувача й інтерпретуються віртуальною машиною Java, убудованої практично в усі сучасні браузери.

Додатки, що відносяться до першої групи, являють собою звичайні локальні додатки. Оскільки вони виконуються інтерпретатором і не містять машинного коду те їхня продуктивність помітно нижче, ніж у звичайних компилируемых програм (З++, Delphi).

Для розробки програм мовою Java нам буде потрібно спеціальне програмне забезпечення. Самі нові версії системного програмного забезпечення, необхідного для підтримки, можна завантажити із сайту компанії Sun (http://java.sun.com/): JRE, JDK. Перший додаток JRE - це програма для запуску й виконання програм (середовище виконання Java) Java Runtime Environment (JRE).

Для розробки програм також потрібен комплект розробки програмного забезпечення - JDK (Java Development Kit). Він містить компілятор, стандартні бібліотеки й т.п.

У цей час є три Java-Платформи:

Java 2 Platform, Standard Edition (J2SE);

Java 2 Platform, Enterprise Edition (J2EE);

Java 2 Platform, Micro Edition (J2ME).

Кожна із цих платформ призначена для розробки певного типу програм.

· Перша платформа J2SE дозволяє розробляти звичайні (desktop) локальні додатки й аплети.

· Друга платформа J2EE призначена для розробки серверних додатків (сервлетів, jsp-сторінок, компонентів JavaBeans).

· Третя платформа (J2ME) застосовується при розробці додатків для мобільних і невеликих пристроїв (стільникових телефонів, кишенькових комп'ютерів і ін.), які мають істотно обмежені апаратні ресурси (ємність оперативної пам'яті, швидкодія процесора й ін.).

3.1 Створення в NetBeans найпростішого додатка Java

Зміст роботи. Розгядається приклад створення найпростішого додатку в середовищі NetBeans.

Створимо за допомогою середовища NetBeans додаток Java. Для цього запустимо інтегроване середовище розробки (IDE) NetBeans, і виберемо в головному меню File/New Project... У діалозі, що відкрився, виберемо General / Java Application / Next>

Рис. 3.1 Створення нового проекту. Крок 1

Після чого можна натискати кнопку Finish - значення за замовчуванням для початку міняти не потрібно. Це можна буде робити потім.

Рис. 3.2. Створення нового проекту. Крок 2

На наступному малюнку показано, як виглядає редагування вихідного коду додатка в середовищі NetBeans.

У лівому верхнім вікні "Projects" показується дерево проектів. У нашім випадку це дерево для проекту JavaApplication1. Це вікно може бути використане для одночасного показу довільного числа проектів. За замовчуванням усі дерева згорнуті, і потрібні вузли варто розвертати клацанням по вузлу з "плюсиком" або подвійним клацанням по відповідній назві.

У правому вікні "Source" показується вихідний код проекту.

У лівому нижнім вікні "Navigator" показується список імен членів класу додатка - імена змінних і підпрограм. Подвійне клацання по назві приводить до того, що у вікні редактора вихідного коду відбувається перехід на те місце, де задана відповідна змінна або підпрограма.



Рис. 3.3. Редагування вихідного коду додатка

Середовище NetBeans створює заготівлю методів - у них є порожнє тіло. Для здійснення методом якої-небудь діяльності варто дописати свій власний код. Напишемо традиційний приклад - вивід повідомлення "Привіт!". Для цього замість коментарю

// TODO code application logic here

("описати отут логіку роботи додатка") напишемо рядок висновку тексту

System.out.println("Привіт!");

Клас System, "система", має поле out, "назовні". Це об'єкт, призначений для підтримки виводу. У нього є метод println, призначений для виводу тексту в режимі консолі.

Консольне уведення-виведення раніше широко застосовувалося в операційних системах, орієнтованих на роботу в режимі командного рядка. При цьому основним засобом взаємодії користувачів із програмами служила текстова консоль ( "пульт керування"). У ній пристроєм уведення служила клавіатура, а пристроєм виводу - вікно операційної системи, що забезпечує вивід тексту в режимі друкарської машинки (системним шрифтом з буквами, що мають однакову ширину). Дуже багато прикладів програм у навчальних курсах по Java орієнтовані на роботу в такому режимі. У цей час у зв'язку з тим, що переважна більшість користувачів працюють із програмами в графічному режимі, роботу в консольному режимі не можна розглядати як основну форму вводу-виводу. Тим більше, що NetBeans дозволяє без особливих зусиль створювати графічний користувальницький інтерфейс (GUI - Graphics User Interface) додатка. А консольний режим варто застосовувати тільки як проміжний, зручний в налагоджувальний режим як засіб виводу допоміжної інформації.

Завдання до роботи

1. Вивчити приклади додатків, які поставляються разом з середовищем програмування, з категорії звичайних Java-додатків.

2. Розробити консольний додаток з теоретичної частини.

3. Вивести на консоль наступний набір символів:

1

1 2 3

1 2 3 4 5

1 2 3 4 5 6 7

3.2 Використання циклів у додатку Java

Зміст роботи. Розглядаються програми, у яких використовуються оператори циклів For, While для багаторазового виконання певних операторів.

Програма 1. Обчислення суми й добутку послідовності з 10 випадкових чисел.

1. public class ForCycle {

2. public static void main(String[] args) {

3. inttmp = 0;

4. long tmp2 = 1;

5. System.out.print("Сума\t\tпроизведение \n");

6. for(int i=0;i<10;i++){

7. tmp += (int)Math.round(Math.random()*10);

8. tmp2 = tmp2*tmp;

9. System.out.print(tmp+"\t\t"+tmp2+"\n");

10. }

11. }

12. }

У рядку 02 об'являємо головний метод main().В оголошенні змінної tmp типу int присвоюємо їй початкове значення(tmp=0,ініціалізація змінної tmp в рядку 03). У змінній tmp буде зберігатися сума 10 членів послідовності з випадкових чисел. Далі повідомляємо змінну tmp2 типу long,у якій будемо зберігати значення добутку членів послідовності (04). У циклі for( 06-10) перебуває сума й добуток елементів послідовності. Генерація випадкового члена послідовності здійснюється з використанням стандартної функції Math.random(), що повертає випадкове число в діапазоні від 0 до 1. Далі множимо випадкове число на 10 і округляємо Math.round() Вивід результатів виконується в рядку 09.

Програма 2. Обчислення квадратного кореня числа за допомогою ітераційної формули Герона.

1. public class Sqrt {

2. static void sqrt(long a){

3. double b=a;

4. int i=0;

5. while ((b*b>a)&&(i<200)){

6. b=(b+a/b)/2;

7. i++;

8. }

9. System.out.print(b);

10. }

11. public static void main(String[] args) {

12. sqrt(45);

13. }

14. }

Для обчислення квадратного кореня числа використовуємо ітераційну формулу Герона Для цього використовуємо цикл

While з передумовою((b*b>a)&&(i<200)).

У рядку 02 повідомляємо новий метод sqrt()з одним параметром a типуlong.В оголошенні змінній b типу double присвоюємо їй початкове значення(b=a,ініціалізація змінної b в рядку 03). У змінній b будемо зберігати проміжні значення кореня, що обчислюються в циклі по формулі Геронаb=(b+a/b)/2.Далі повідомляємо змінну i типу int та ініціюємо її значенням 0. Дана змінна знадобиться як лічильник циклу.