Magnum news - Глава №2. Введення в типи даних і операції з ними

1. Що таке прості типи даних.
2. літерали
3. Ініціалізація змінних.
4. Область дії змінних
5. Арифметичні операції над змінними.
6. Операції відносини і логічні операції
7. Операції відносини.
8. Логічні операції.
9. Використання круглих дужок
10. Оператор присвоювання і його укорочена форма
11. операція присвоювання
12. Укорочена форма операції присвоювання
13. Перетворення і приведення типів даних
14. при присвоєнні
15. Приведення несумісних типів
16. Перетворення типів у виразах
17. Перелік запитань до самоперевірки
18. Домашнє завдання
19. друге

Нарешті вдалося закінчити ще одну статтю з мого циклу з вивчення Java. Це маленький привід для гордості, що я все ж не закинув поки цю справу. Так, що всіх кому це цікаво, ласкаво просимо під кат =)

Дана глава дає кончина про такі речі як:

І так приступимо =)

Повністю переписувати розділ з книги я не буду, хоча моя дружина іноді говорить, що саме так я і роблю =) Але все ж коротко згадати про все варто!

Що таке прості типи даних.

Або як їх ще називають "примітивні типи даних", це:

• byte
• short
• int
• long
• float
• double
• char
• boolean

Список типів змінних наведено в порядку збільшення діапазону можливих збережених в них даних (від меншого до більшого), за винятком двох останніх (про них я згадаю окремо).

Типи даних від byte до long - це цілочисельні типи даних. З огляду на, що мова Java є строго універсальна мова програмування, то це ті типи в яких можуть міститися тільки цілі числа (без дробової частини). Діапазон допустимих значень у кожній з них свій:

Тип Розрядність в бітах Діапазон допустимих значень byte 8 Від -128 до 127 short 16 Від -32 768 до 32 767 int 32 Від -214 748 3648 до 214 748 3647 long 64 Від -9 223 372 036 854 775 808 до 9 223 372 036 854 775 807

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

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

Типи даних float і double - це в яких можна зберігати дані з дробової частина (в школі їх називали дробом). Розміри виділяється для них пам'яті за замовчуванням 32 і 64 біта.

Як я і говорив одним з типів заслуговують на окрему увагу, є тип char. Даний тип не є чимось новим, як і в інших мовах він призначений для зберігання символів. Його відмінністю являє же можливість запису будь-якого символу будь-якої мови в світі, так звана кодування Unicode (не плутати з кодуванням відображення символів на екрані).

Присвоюється ж значення змінної такого типу в наступному форматі:

char ch; ch = 'a';

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

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

ch = 90;

Те при виведенні на екран цієї змінної, виведеться не числиться 90, а символ "Z" якому відповідав би порядковий номер 90 в таблиці Unicode , Точніше ASCII яка входить до її складу!

Якщо ж спробувати поставити значення змінної в подвійних лапках, то видасть помилку про те, що даних тип не може бути автоматично перетворений в строковий тип даних!

Можна було б приділити більше уваги цій темі, але думаю поки це не потрібно.

Посилання по темі:

Наступним типом зі своїми пляшками є тип boolean, він може містити тільки два значення true або false. Але його особливість полягає не в цьому, а в тому, що він є логічним типом даних!

Що це означає?!

А то, що будь-яка операція порівняння або виконання логічного оператора типу if буде містити в собі логічне значення!

Логічний тип даних,

або логічний тип, або булевий тип (від англ. Boolean або logical data type) - примітивний тип даних в інформатики , Який приймає два можливих значення, іноді званих істиною (true) і брехнею (false). Присутній в переважній більшості мов програмування як самостійна сутність або реалізується через чисельний тип даних. У деяких мовах програмування за значення істина покладається 1, за значення брехня - 0.

Примітка: Через значень 0 і 1 не слід його приписувати до цілочисельним типам даних, це логічний тип даних!

літерали

Про це я не можу ні сказати =)) ні слова без посмішки. Як каже одна прислів'я:

Шкатулка просто відкривалася.

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

Але (драматична пауза, барабанний дріб і все таке) літерали, це всього лише значення змінних. Так, саме так! Це те значення, яке ми присвоюємо змінним =)

Єдине на, що варто звернути увагу, так це на те, що строковий літерал - це набір символів, укладений в подвійні лапки. наприклад:

System.out.println ( "Якийсь текст");

Де фраза "Якийсь текст" і буде строковим літералом.

Останнє, що я тут додам, так це шпаргалку по керуючим послідовностям символів для себе розумного =)

Керуюча послідовність Опис \ 'Висновок одинарної лапки \ "Висновок подвійної лапки \\ Висновок зворотної косої межі \ r Повернення каретки \ n Переклад на новий рядок \ f Переклад на нову сторінку \ t Відступ у вигляді табуляції \ d Повернення на одну позицію \ ddd Вісімкова константа, де ddd - вісімкове число \ uxxxx Шістнадцяткова константа, де xxxx - шестнадцатиричное число

Послідовність цих символів дуже широко застосовується при поданні інформації на екран (як можна зрозуміти із самої таблиці) для її форматування.

Ініціалізація змінних.

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

Умовна форма запису ініціалізації змінної (по суті вона ж і операція присвоювання значення, про що трохи пізніше буде згадано) виглядає так:

= значення;

Тут "значення" і буде тією самою точкою ініціалізації змінної або змінних.

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

Class DynInit {public static void main (String [] args) {double radius = 4, height = 5; // Змінна volume инициализируется динамічно під час виконання програми double volume = 3.1416 * radius * radius * height; System.out.println ( "Обсяг:" + volume); }}

Область дії змінних

Це те місце в коді де дана змінна буде виконувати свої функції і зберігати в собі якесь значення. Коли ж ця область закінчиться, то змінна перестане існувати і буде стерта з пам'яті, і як вже можна здогадатися, подивитися або отримати її значення буде неможливо! І при спробі це зробити буде видана помилка:

Error: (15, 9) java: can not find symbol symbol: variable a location: class com.gmail.vitaliy1984.Test

В якому говориться, що змінної якої присвоюється значення не існує!

Так що ж це за таке таємниче місце?

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

class ScopeDemo {public static void main (String [] args) {int x; // Ця змінна доступна для всього коду в методі main x = 10; if (x == 10) {// Початок нової області дії int y = 20; // Ця змінна доступна тільки в даном блоці // Обидві змінні "x" і "y" доступні в даному блоці System.out.println ( "x and y:" + x + "" + y); x = y * 2; } // y = 100; // Помилка! У цьому місці змінна "y" недоступна // А змінна "x" як і раніше доступна System.out.println ( "x is" + x); }}

Якщо вже зовсім простіше кажучи, то змінна буде діяти і жити від першої перед нею фігурної дужки "{" і закінчуючи такою ж її закриває "}". За їх межами цієї змінної просто не існує фізично!

Виходячи з цього, якщо змінна була оголошена наприклад, на початку методу (ще одне страшне слово, але воно вже надокучили і в книзі про це теж розповідається), то повторне її оголошення, наприклад, так:

public class Test {public static void main (String [] args) {int i, a; for (i = 0; i <10; i ++) {int a; a = 5 + i; System.out.println (a); }}}

приведе до помилки

Error: (8, 17) java: variable a is already defined in method main (java.lang.String [])

Що й не дивно =)

А ось якщо в даному прикладі спочатку оголосити змінну спочатку всередині циклу for, а потім повторно її оголосити вже за межами циклу нижче:

public class Test {public static void main (String [] args) {int i; for (i = 0; i <10; i ++) {int a; a = 5 + i; System.out.println (a); } Int a; a = 100; System.out.println (a); }}

Те помилки вже не буде, так як змінна "a" матиме різні області дії! Тобто перше оголошення змінної "a" обмежує її область дії циклом, і коли цикл закінчується, то вона перестає існувати і її повторне оголошення вже допустимо. Але з точки зору логіки і стилю коду, такого краще уникати, так як може призвести до плутанини при налагодженні коду.

Арифметичні операції над змінними.

Найпростіше і інтуїтивно зрозуміло з усього, що є! Це прості математичні операції такі "складання", "віднімання" і т.д.

Виняток становлять лише операції ділення по модулю, інкремент і декремент

Розподіл по модулю (залишок від ділення) "%"

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

Приклад коду програми, яка виконує розподіл по модулю можна подивитися тут .

Щоб не було плутанини, варто відзначити, що це не дрібна частина, яка залишається після виконання операції ділення. Ну наприклад:

10/3 = +3,333333333333333

Тобто це не +0,333333333333333! Це те число, яке залишається після перевірки того, скільки разів число 3 вміщується в 10-ти. наприклад:

10% 3 = 1
3 + 3 + 3 = 9
10 - 9 = 1

Ось такий от маленький примітивний приклад пояснює роботу ділення по модулю =)

Операції інкремента "++" і операція декремента "-"

Інкремент, инкрементирование (від англ. Increment "збільшення") - операція в багатьох мовах програмування, що збільшує змінну на 1. Декремент - зворотна операція на відміну від инкремента, яка зменшує значення на 1.

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

a = a + 1;

або декремента відповідно:

a = a - 1;

кожен раз, коли потрібно зробити так сказати один крок вперед або назад.

Найчастіше це використовується в циклічних операціях (цикл for який ми так любимо використовувати, але до сих пір не прочитали про нього).

У даних операцій є одна особливість, яка полягає в формі їх написання, називаються вони префиксная і Постфіксний форми! В

Префіксная форма (++ a або --a) - записавши вираз в даній формі операція збільшення або зменшення на 1, буде виконана до математичного обчислення.

На прикладі инкремента це виглядає так:

int a = 1; int b = 2; int c = ++ a + b;

Якщо зазвичай в математиці 1 + 2 дорівнюватиме 3, то в даному випадку все трохи інакше, спочатку змінна "a" яка дорівнювала 1 буде збільшена на 1, тим самим отримає значення 2, а вже потім буде виконано дію додавання, що в результаті дасть нам вже 4!

Постфіксний форма (a ++ або a--) - запис вираження в даній формі говорить про те, що спочатку будуть виконуватися математичні операції над змінними, а тільки потім буде проводиться збільшення або зменшення значення на 1. Дана форма використовується частіше ніж попередня в циклічних операція ( надокучили нам цикл for).

На прикладі инкремента це виглядає так:

int a = 1; int b = 2; int c = a ++ + b; System.out.println (c); System.out.println (a);

В даному випадку спочатку виконається операція додавання, що дасть змінної c значення 3 і тільки потім змінна a буде збільшена на 1!

Форма запису цих операцій має велике значення, так, що плутати його не можна ні в якому разі! Інакше можна отримати зовсім не той результат, який очікуєш.

- Ферштейн?
- Яволь хер майор

Операції відносини і логічні операції

Ці операції є як на мене фундаментом для операцій розгалуження і циклів, в яких вони найчастіше використовуються.

Операції відносини.

От чесно, не можу зрозуміти хто їх так назвав, але як на мене, то краще було б назвати їх в цій книзі "Операції порівняння". Бо саме цю роль по суті вони і виконують.

Вони з прирівнюються значення на рівність, визначають яке значення більше, а яке ні, і виходячи з цього дають результат у вигляді true або false =)

Примітка: оператори порівняння "<", ">", "> =", "<=" застосовуються до змінних типу від byte до char, а ось до змінних типу boolean їх застосування буде не логічно.

І на відміну від математичних операцій не мають пріоритетів, точніше вони, тобто, ось тільки використовувати подібного роду операції ладу логіку на їх пріоритеті досить безглуздо.

Знак операції Значення == одно! = Не дорівнює> більше <менше> = більше або дорівнює <= менше або дорівнює

Найчастіше вони використовуються при роботі з операторами розгалуження (if).

Логічні операції.

Операції, суть яких не в порівнянні значень, а більше в їх об'єднанні в одне вираз.

Оператор Значення & і | або ^ виключає або || укорочена форма або && укорочена форма і! Чи не

наприклад:

if (a == b & c> a) System.out.println ( "Який чудовий день!");

Також, як і операції порівняння, результатом їх роботи буде теж значення типу boolean.

Невеликий особливістю даних операцій є те, що деякі з них мають "скорочену форму запису". Напевно я знову-таки чіпляюся, але от якось скорочена форма не зовсім схожа на скорочену, чому, можна подивитися в таблиці вище. Як на мене логічний було б зробити форму записи навпаки =) Але суть не в цьому, адже малося на увазі чи буде виконуватися все умова чи ні!

Залежно від форми написання оператора, буде залежати виконання поставленого умови цілком або тільки його одна частина! Наприклад, якщо написати умова використовуючи скорочену форму оператора "і":

if (a! = 0 && (b% a) == 0) {// тут якась операція}

В даному випадку перевіриться тільки перша частина умови, а друга буде проігнорована якщо змінна "a" дорівнюватиме нулю, отже, операція всередині не буде виконуватися (так запобігає поділ на нуль). А ось якщо записати цю умову без використання скороченої форми:

if (a! = 0 & (b% a) == 0) {// тут якась операція}

Те будуть перевірятися обидва умови, в результаті чого буде проведена операція ділення на нуль =)

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

Ось, мабуть, і все, що варто сказати про ці операція.

Нижче наведена таблиця значень, одержуваних в результаті виконання логічних операцій "і", "або", "виключає або", "не"; якщо використовувати в якості значень, значення типу boolean:

a b a & b a | b a ^ b! a false false false false false true true false false true true false false true false true true true true true true true false false

Використання круглих дужок

По мимо вже відомого математичного властивості підвищення пріоритету виконання операцій, у них є ще одна приємна властивість. Це підвищення читабельності коду, що істотно спрощує розбір чужого коду! Ну наприклад:

a = 10 / b + a * d - 2

І так

a = (10 / b) + (a * d) - 2

Очевидно ж, що так читати цей вислів легше, незважаючи на знання пріоритетів виконання математичних операцій .

Оператор присвоювання і його укорочена форма

операція присвоювання

Мабуть, найпростіше, що є =)

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

a = 10;

або так

a = b = c = 20;

Це приклад даної операції. В останньому випадку відбувається присвоювання спочатку змінної "c" потім "b" і тільки потім "a", використовувати його не рекомендується, як кажуть - це погана практика.

Укорочена форма операції присвоювання

Тут не так як з логічними операторами! Особливість даної операції полягає спрощення певної дії:

a = a + 10;

Тобто це так би мовити більш розширена форма инкремента і декремента, коли потрібно збільшити значення змінної на якийсь певної значення. І щоб не писати математичний вираз повністю, можна записати його в спрощеній формі:

a + = 10;

і це буде те ж саме.

Дана форма може використовуватися на всіх математичних операціях і на частини логічних операцій:

Перетворення і приведення типів даних

при присвоєнні

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

Автоматичне розширення

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

Примітка: не можна автоматично перетворити одну змінну в одному, якщо діапазон її значень у кінцевій змінної іншого типу менше ніж у неї самої.

Більш повний опис можна було прочитати вище в " Що таке прості типи даних "

Для прикладу можна навести наступного код :

class LtoD {public static void main (String [] args) {long L; double D; L = 100123285L; D = L; // Автоматичне превращение long в double // L = D; відасть помилки !! так як нельзя преобрзовать double в long System.out.println ( "L и D:" + L + "" + D); }}

Тут змінна типу long автоматично на рівні компілятора перетворюється в тип double так як у нього діапазон допустимих значень для зберігання більше. А ось навпаки автоматично перетворити не можна, так як компілятор видасть помилку:

Error: (11, 13) java: incompatible types: possible lossy conversion from double to long

Але це не привід для розладу, так як тут на допомогу прийде така річ як "приведення несумісних типів".

Приведення несумісних типів

Це перетворення одного типу даних у якого діапазон значень більше, в той у якого він менше! Наприклад, той же тип double з прикладу вище в тип long.

Робиться це просто, потрібно лише дотриматися формат запису

Ну може не зовсім просто =) Потрібно пам'ятати дві речі:

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

Не можна змінну одного типу перетворити в абсолютно інший тип! Звучить сумбурно, але на прикладі стане ясніше:

int a; long b = 20; a = (double) b;

Це призведе до помилки:

Error: (8, 13) java: incompatible types: possible lossy conversion from double to int

Тобто типи не повинні перескакувати один через інший, так би мовити перестрибувати через голову. Вони повинні бити або ідентичними, або ж менше. Наприклад, так:

int a; long b = 20; a = (short або int) b;

І дуже важливо пам'ятати, що при такому приведення, частина значення може загубитися або відбудеться переповнення типу! І значення буде не таким яким ми його очікуємо побачити =)

На прикладі це буде виглядати так:

int a; duble b = 20.5; a = (int) b;

В даному випадку змінна перетворюється на тип double в int, але якщо вивести отримане значення на екран, то виведеться тільки число 20, а решта 0,5 пропадуть =)

Перетворення типів у виразах

Ще однією цікаво особливістю мови Java є це саме автоматичне приведення типів!

Вся справа в тому, що за замовчуванням використовуються два типи даних: int і double! Як би це не звучало парадоксально, але залишиться фактом =) що всі цілочисельні змінні при виконанні математичних операцій будуть проходити подвійне автоматичне перетворення. например:

byte a, b, c; a = 120; b = 9; c = (byte) (a + b);

Спочатку обидві змінні будуть перетворені в тип int, потім буде виконана математична операція і отримане значення буде перетворено знову в тип byte.

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

byte a, b, c; a = 120; b = 9; c = (byte) a + b; // помилка, пропущені дужки Error: (10, 22) java: incompatible types: possible lossy conversion from int to byte

Тобто формальна запис буде наступною:

змінна = (тіп_в_которий_преобразуем) (змінна + змінна);

Таблиця пріоритету операцій починаючи від найвищого і закінчуючи найнижчим

() []. ++ - (префиксная форма) ++ - (Постфіксний форма) ~ <! * /% + - >> >>> <<>> = <<= ==! = &amp; ^ | && || ?: = Op =

Ось мабуть і все з чим нас знайомить дана глава в книзі. За звичаєм знайти всі приклади з цієї глави можна в моєму репозиторії .

Залишається тільки привести список питань до самоперевірки і домашнє завдання.

Перелік запитань до самоперевірки

1. Чому в Java строго визначені діапазони допустимих значень і області дії простих типів?

Відповідь: Для забезпечення переносимості програм, тобто платформ. Тільки так можна було бути впевненими, що на різних платформах результат виконання програм буде однаковим.

1. Що собою являє символьний тип в Java і чим він відрізняється від символьного типу в ряді інших мов програмування?

Відповідь: Символьний тип даних в Java це не що інше як таблиця Unicode символів. Це потрібно було для того, щоб дати можливість представляти символи всіх мов світу, тим самим зробити мову гнучким і популярних у всіх країнах.

1. "Змінна типу boolean може мати будь-яке значення, оскільки будь-яке ненульове значення інтерпретується як справжнє". Вірно чи невірно?

Відповідь: Ні не вірно! Тип boolean може містити тільки два значення true або false (істина або брехня). Для кожних видів даних в Java є свій тип даних.

1. Припустимо, результат виконання програми виглядає наступним чином:

Напишіть рядок коду виклику методу println (), де цей результат виводиться у вигляді одного рядка.

відповідь:

System.out.println ( "Один \ nДва \ nТрі");

1. Яка помилка допущені в наступному фрагменті коду?

for (i = 0; i <10; i ++) {int sum; sum = sum + 1; } System.out.println ( "Сума:" + sum);

Відповідь: В даному прикладі не дотримана область видимості (дії) змінної, при спробі відкомпілювати буде видана помилка:

Test.java:16: error: can not find symbol System.out.println ( "Сума:" + sum); ^ Symbol: variable sum location: class Test 1 error

Так як змінна sum обмежена областю дії циклу for і за його межами вона не існує. Далі, навіть якщо виправити цей момент, то не можна використовувати змінну попередньо її НЕ ініціалізувати зі значенням згідно типу самої змінної, в результаті чого програма видасть помилку при компіляції:

Test.java:11: error: variable sum might not have been initialized sum = sum + i; ^ 1 error

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

1. Поясніть відмінність між префиксной і постфіксной формами записи операції інкремента.

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

int x, y; x = 10; y = ++ x;

в результаті чого x і y матимуть значення 11, у випадку з постфіксной формою все буде трохи інакше:

int x, y; x = 10; y = x ++;

тут y дорівнюватиме 10, а x буде дорівнює 11.

1. Покажіть, яким чином укорочена логічна операція І може запобігти поділ на нуль.

відповідь:

class SCops {public static void main (String [] args) {int n, d, q; d = 0; // встановити для d нульове значення // Другий операнд не вирахував, оскільки значення змінної d дорівнює нулю if (d! = 0 && (n% d) == 0) {System.out.println (d + "є дільником" + n); } / * А тепер ті ж самі дії виконуються без використання укороченого логічного оператора. В результаті виникає помилка ділення на нуль: Exception in thread "main" java.lang.ArithmeticException: / by zero at SCops.main (SCops.java:*) * / if (d! = 0 & (n% d) == 0) {System.out.println (d + "є дільником" + n); }}}

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

1. До якого типу підвищуються типу bute і short при обчисленні виразів?

Відповідь: До типу int.

1. Коли виникає потреба в явному приведення типів?

Відповідь: Потреба в явному приведення типів виникає у випадку, коли результат виконання виразу потрібно привести до конкретно типу даних. Наприклад, замість double потрібно отримати значення типу int:

double x, y; int d; d = (int) (x + y);

в цьому випадку результатом обчислення буде ціле число (його дрібна частина загубиться) типу int. Так само і з іншими сумісні типами. Таке трапляється часто і тому потрібно самому уважно стежити за типами даних і їх діапазонами, щоб не отримати несподіваний результат!

1. Чи справляють надлишкові дужки вплив на ефективність виконання програм?

Відповідь: Ні, надлишкові дужки навпроти роблять код більш читабельним і логічним, але зловживати ними не варто.

1. Чи визначає блок коду область дії змінних?

Відповідь: Так. Мінлива оголошена всередині якогось блоку коду, буде недоступно за його межами, виняток є тільки глобальні змінні або змінні класу. Тобто якщо наприклад, змінна була оголошена всередині циклу, то за межами циклу вона вже не існує, а тому буде недоступна! А змінні оголошені до того ж циклу, навпаки будуть доступні всередині циклу.

Домашнє завдання

перше

Умова: Змінити програму з прикладу 2.1 таким чином, щоб вона розрахувала відстань до великого об'єкта за часом за яке повернеться відлуння. Так якщо грюкнути в долоні, то час за яке повернеться відлуння, дорівнюватиме часу проходженню звуку в прямому і зворотному напрямку.

Лістинг програми:

class Echo {public static void main (String [] args) {double sound; double dist; sound = 7.2 / 2; // Розраховуємо час за яке ми почуємо відлуння, розділивши його на 2, дізнаємося час до об'єкта без його повернення до нас dist = 1100 * sound; // Розраховуємо відстань до об'єкта System.out.println ( "Відстань до скелі одно" + dist + "фута"); }}

За принципом вирішення, програма досить проста, створюються дві змінні типу double "sound" і "dist". Потім виходячи з умови, беремо час, за яке звук доходить до спостерігача, він дорівнює 7.2 секунди, і ділимо його на 2, щоб дізнатися час, який долає звук в одну сторону. Ну, а потім приступаємо до розрахунку відстані до шуканого об'єкта, для цього ми беремо швидкість поширення звуку в повітрі, вона дорівнює 1100 футів в секунд у, і множимо її на отриманий результат від першої операції. У підсумку отримуємо бажаний результат.

друге

Умова: Напиши програму, яка знаходила б прості числа від 2 до 100.

Ось тут зізнаюся чесно, її я не вирішив на увазі плаваючих знань про цикли, але чесно і сумлінно розібрався в ній від і до.

Для початку варто зрозуміти, що таке прості числа ?!

Просте число

(Грец. Πρώτος ἀριθμός) - натуральне (ціле позитивне) число, що має рівно два різних натуральних дільники - одиницю і самого себе. Іншими словами, число x є простим, якщо воно більше 1 і при цьому ділиться без залишку тільки на 1 і на x. Наприклад, 5 - просте число, а 6 є складовим числом, так як, крім 1 і 6, також ділиться на 2 і на 3.

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

Там же можна трохи зшахраювати і взяти алгоритм вирішення :

1. Виписати підряд всі цілі числа від двох до n (2, 3, 4, ..., n).
2. Нехай змінна p спочатку дорівнює двом - першому простому числу.
3. Закреслити в списку числа від 2p до n вважаючи кроками по p (це будуть числа кратні p: 2p, 3p, 4p, ...).
4. Знайти Перший не закреслене число у списку, більше ніж p, і привласнити значенням змінної p це число.
5. Повторювати кроки 3 і 4, поки можливо.

Тепер цей алгоритм можна перевести в код:

class PrimeNumber {public static void main (String args []) {int i, j; boolean isprime; for (i = 2; i <100; i ++) {isprime = true; // перевірити, чи ділиться число без залишку for (j = 2; j <= i / j; j ++) // якщо число ділиться без залишку, значить, воно не просте if ((i% j) == 0) isprime = false; if (isprime) System.out.println (i + "- просте число."); }}}

Задаємо дві змінні "i" і "j" типу int, і одну змінну "isprime" типу boolean.

Далі створюємо перший цикл, який буде виконуватися майже 100 раз і буде починатися з 2, так як це перше просте число (воно більше 1 і ділиться тільки на 1, і саме на себе). Так само встановимо значення змінної isprime рівним true за замовчуванням.

Потім створюємо другий цикл, в ньому і відбувається вся магія! У ньому ми встановлюємо значення змінної "j" рівне 2, умовою виходу з цього циклу буде момент, при якому змінна "j" буде більше або дорівнює математичному вираженню, в якому змінна "i" буде ділиться на змінну "j".

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

Ну, а якщо коротко, то виконаються вони будуть тільки за умови, що задана умова буде мати значення true.

Тепер можна йти далі! Тепер ми створимо два логічних оператора if. У першому будемо перевіряти чи ділиться число без залишку, шляхом ділення по модулю, якщо число ділиться без залишку, то умова буде істинно і змінної isprime буде присвоєно значення false. Цей логічний оператор if буде належати вкладеному циклу for, враховуючи, що вони записані в скороченій формі (без фігурних дужок, їх би краще ставити, бо так простіше читати код).

У другому буде перевірятися значення змінної isprime на предмет істинності (забігаючи трохи наперед скажу, що оператор if виконується тільки в разі якщо заданий йому умову якраз таки істинно) і якщо це так, то на екран буде виводиться повідомлення, що таке то число є простим !

Не зрозуміло? Ось так і мені було по початку =)

Але як сказав один чоловік "не можеш зрозуміти, розпиши на листочку!". Що ми зараз і зробимо!

Перше значення змінної "i", яке надходить на вхід дорівнює 2, далі встановлюється значення змінної isprime як true, і переходить до вкладеного циклу. У ньому значенням змінної "j" теж дорівнює 2.

Йде перевірка умови виходу з циклу 2 <= 2/2? Ні 2 більше 0 означає цикл закінчується, і перший оператор if так і не виконується, так як досягнуто умова виходу з циклу, ще до його початку! І далі управління передається другому оператору if де йде перевірка змінної isprime на предмет істинності, а з огляду на, що вона за замовчуванням дорівнює true, то на екран буде виведено напис:

2 - просте число.

На цьому закінчується перша ітерація і починається все спочатку!

Для скорочення кількості тексту і того, що основний принцип вже описаний, я розпишу все в цифрах на прикладі двох ітерацій першого циклу =)

І так приступимо.

// Друга ітерація першого циклу for (i = 3; 3 <100; 3 ++) {isprime = true; for (j = 2; 2 <= (3/2 = 1.5); 2 ++) // значення умови виходу з циклу буде false if ((3% 2) == 0) isprime = false; // ця рядок не буде оброблятися так як цикл закінчений і не було жодної ітерації if (isprime) System.out.println (3 + "- просте число."); // ця операція буде мати значення true і на екран буде виведений текст "2 - просте число." } // Третя ітерація першого циклу for (i = 4; 4 <100; 3 ++) {isprime = true; for (j = 2; 2 <= (4/2 = 2); 2 ++) // значення умови виходу з циклу буде true і цикл запуститься на виконання if (((4% 2) == 0)) isprime = false; // цей рядок виконається так як значення логічного умови буде true і змінна isprime отримає значення false if (isprime) System.out.println (3 + "- просте число."); // ця операція отримає значення false і на екран нічого не відбудеться з так як число 4 не є простим} // Четверта ітерація першого циклу for (i = 5; 5 <100; 3 ++) {isprime = true; // Перша ітерація вкладеного циклу for (j = 2; 2 <= (5/2 = 2.5); 2 ++) // значення умови виходу з циклу буде true і цикл запуститься на виконання if ((((5% 2) == 0) = 1)) isprime = false; // цей рядок не буде виконаний так як результат логічного умови буде false // Друга ітерація вкладеного циклу for (j = 3; 3 <= (5/3 = 1.666 ...); 2 ++) // значення умови виходу з циклу буде false і цикл буде перервано if ((((5% 3) == 0) = 2)) isprime = false; // ця рядок не буде оброблятися так як цикл закінчений if (isprime) System.out.println (5 + "- просте число."); // ця операція буде мати значення true і на екран буде виведений текст "5 - просте число." }

Ось, мабуть, и все! Такий спосіб налагодження і перевірки звичайно не використовується на увазі очевидних факторів, так що тема налагодження додатків це вже окрема глава =). Але для наочності в даному прикладі дуже навіть нічого =)

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

Посилання на приклади і коди програм