Пр. 1 Необходимост от обработване на редица от еднотипни данни

В програма се обработва средният успех на учениците от един клас (например с цел намиране на средния успех на целия клас или определяне на ученика с най-висок среден успех). Масивът е удобно средство за представяне на редицата от данни за средния успех, а именно – всеки елемент на масива ще съответства на средния успех на един ученик. Ще отбележим следните три характеристики на масива: а) елементите на масива са краен брой (в случая – равен на броя на учениците в класа); б) елементите на масива са от един и същи тип (в разглеждания пример средният успех на всеки ученик е реално число) и в) елементите на масива са подредени по някакъв признак (тук например може да считаме, че елементите са подредени според номерата на учениците).

Масивът е структурен тип данни, чиито стойности се представят с крайна редица от еднотипни стойности.

На всеки елемент на масива може да се съпостави неговият пореден номер в установената наредба между елементите, наречен индекс на елемента. Индексът определя мястото на елемента в масива. В случая с учениците на всеки среден успех се съпоставя поредният номер на ученика (таблица 1).

Възможно е елементите на масив да са подредени по два и повече признака. Така например оценките на всеки ученик в класа могат да се подредят по номера на ученика и по изучавания предмет (таблица 2). Броят на признаците, по които са подредени елементите на масива, се нарича размерност на масив.

При двумерните масиви мястото на елемента в масива се определя от два индекса. Например в таблица 2 оценката 3.00 съответства на двойката индекси 1 и Английски език.

Таблица 2:

Едномерните и двумерните масиви са най-използваните структури от еднотипни данни в ЕП.

Масивът в Java е променлива и като такава, преди използването му трябва да бъде деклариран. Декларацията може да се извърши по два начина – тип, следван от [] или тип и име, следвано от []. Тази декларация не заделя памет за масива. Заделянето се извършва с помощта на оператора new т.е. масивът в Java е обект.

Стъпките за създаване на масив са три: деклариране, заделяне на памет и нейната инициализация.

Пр. 1

int [] ArrInteger = new int[5];

Ако се извърши само декларация на името на масива, в паметта се заделя място, което се инициализира по-късно с оператора new. Декларирането на променливата на масива и заделянето на памет могат да се извършат с отделни оператори.

Пр. 2

int [] ArrInteger;          //деклариране на променливата масив

ArrInteger = new int[5];   //заделяне на памет за 5 елемента

За достъп до елемент на масива се използва индекс, като индексирането започва от 0. Следователно последният елемент има индекс, равен на размера на масива минус единица. Тогава последният елемент на масива от Пр. 2 ще има индекс 4. За да се обърнем към елемент на масива, се изписва името на масива, последвано от квадратни скоби с индекса на елемента, към който искаме достъп.

Пр. 3

ArrInteger[2];

Инициализацията на масива може да се извърши по два начина:

• Инициализация, чрез присвояване на начални стойности на всеки елемент на масива поотделно:

ArrInteger[0]=10;

ArrInteger[1]=15;

ArrInteger[2]=20;

ArrInteger[3]=21;

ArrInteger[4]=13;

• Инициализиране при деклариране на масива, без да се използва оператора new:

int ArrInteger [] = {10, 15, 20, 21, 13};

boolean array2 [] = {true, false, true};

в този случай компилаторът сам определя брой на елементите (размера на масива), заделя необходимата памет и я инициализира със зададените стойности.

Елементите на масива може да са от всеки тип, позволен за езика. Те може дори да са също от тип масив.

Масивът поддържа свойство lentgh, което връща дължината му и е удобно за определяне на горната граница при индексиране. Долната е винаги 0.

Пр. 4

for (int I=0; I<ArrInteger.length;I++)

ArrInteger[I]=0;  // нулиране на масива от горния пример

Многомерни масиви

Двумерният масив в езика Java се декларира с използване на две размерности. По същество той се явява едномерен масив от скрити указатели към едномерни масиви.

Пр. 5

int [][] matrix = new int [10][100];

//матрица с размерност 10х100

Съответно достъпът до елемент от двумерен масив се извършва чрез посочване на два индекса:

Пр. 6

matrix [2][35];

Инициализиране на многомерни масиви:

а) int myarrayX [][] = {{5, 6, 3},

{7, 2, 1},

{4, 0, 9}};

б) int myarrayY [][] = {{1},

{2, 3},

{4, 5, 6},

{7, 8, 9}};

При обработка на масиви, когато се налага обхождане на всички техни елементи, обикновено се използва операторът за цикъл for.

Пр. 7

• Извеждане на едномерен масив на екран

int myarray [] = {1, 2, 3, 4, 5};

for (int I=0; I<myarray.length; I++)

{

Syatem.out.println(myarray[I]);

}

• Извеждане на многомерен масив на екран

int myarray2 [][]={{1, 2, 3},

{4, 5, 6}};

for (int I=0; I<myarray2.length;I++)

{

for (int K=0; K<myarray2.length; K++)

{

System.out.println(myarray[I][K]);

}

}

Примерна програма

Пр. 8 Съставете програма, която по дадени стойности х₁, х₂,…, х₁₂, отговарящи на месечния оборот (в левове) на фирма за всеки от дванадесетте месеца на изминалата година, определя средномесечната стойност на оборота.

Проектиране: Програмата въвежда и обработва еднотипно 12 стойности от реален тип, които е най-добре да се представят като реален масив (например с име ) с 12 елемента. Средномесечната стойност на оборота се определя по формулата за намиране на средно аритметично:

Изчисляването по формулата може да се програмира с помощта на оператор за цикъл с параметър, защото предварително е известно, че трябва да се съберат 12 числа.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Пр. 1 Подреждане на три реални числа в намаляващ ред

Алгоритъмът за решаване на задачата е следният:

1. Въведете три реални числа и ги запомнете (в променливи a, b и c).
2. Ако a<b, разменете стойностите на a и b.
3. Ако b<c, разменете стойностите на b и c.
4. Ако a<b, разменете стойностите на a и b.
5. Изведете стойностите на a, b и c (вече подредени).
6. Край на работата.

В алгоритъма се повтарят многократно две действия – сравняване и размяна на стойностите на две променливи. Следователно, ако предварително съставим тези подалгоритми, можем да ги използваме за описанието му.

Коя е основната разлика между един подалгоритъм и алгоритъма, който го използва? В повечето случаи основният алгоритъм получава от потребителя стойности за началните данни и съобщава крайните резултати отново на потребителя. Докато подалгоритъмът обикновено получава началните си данни от основния алгоритъм и му връща крайните си резултати. Например подалгоритъмът за сравняване на две числа получава стойностите, които се сравняват, от основния алгоритъм, а резултатът от сравнението се връща отново към основния алгоритъм, за да се използва в следващите му действия.

Подпрограми

Програмата, реализираща основния алгоритъм за решаването на определена задача, се нарича главна (или основна) програма.

Всяка подпрограма, съдържаща се в главната програма, реализира подалгоритъм на основния алгоритъм. Изпълнението на подпрограмата се предизвиква с указване на нейното име и списък от съответни параметри. Подпрограмата може да се изпълни за различни стойности на входните данни (зададени чрез параметри от списъка)  и да върне различни резултати (отново зададени в същия списък).

Например ако подалгоритъмът за размяна на стойностите на две променливи е реализиран като подпрограма, то неговите параметри трябва да са два – променливите, чиито стойности се разменят.

Основната програма обикновено си взаимодейства с потребителя за въвеждането и извеждането на данни, докато подпрограмите ползват данни от главната програма и връщат в нейната среда получените резултати.

• Възможно е някои подпрограми, подобно на основната програма, да ползват описани в тях други подпрограми.
• Вече създадена и проверена, една подпрограма може да се използва в различни програми.

Подпрограми в Java

В езика Java се допускат два вида подпрограми, наречени съответно процедури и функции т.е. подпрограмите, това са всъщност методите, реализиращи съответния алгоритъм.

Подпрограмите-функции служат за описание на подалгоритми, при изпълнението на които се получава един единствен резултат, който се присвоява на функцията.

Подпрограмите-процедури могат да се използват за получаване на произволен брой резултати, но самата процедура не приема стойност.

Методите на класа имат следният синтаксис:

<служебна дума> тип <име> ([параметър1];[параметър2] ;…])

{

тяло;

}

Служебната дума може да бъде една или повече.

В следващата таблица ще обясним приложението на служебните думи:

Когато се посочва тип се реализира подпрограма-функция, а типът се нарича тип на функцията (т.е. типът на резултата, който ще бъде върнат). За да бъде върнат резултат на функцията, то в тялото й, трябва да зададем return(<израз>). Когато връщаме число, като стойност на функцията, не е необходимо да пишем скоби.

Когато вместо тип се използва служебната дума void – се реализира подпрограма-процедура. Служебна дума void, показва че на самият метод не се присвоява стойност т.е. това е подпрограма-процедура.

Структурата на подпрограмата е аналогична на структурата на основната програма.

Параметрите в скобите се наричат формални параметри. Те служат за задаване на входните (началните) и изходните данни (резултати) на подпрограмите. Поради тази причина тези параметри се наричат формални. Обикновено резултатът на функцията е само една стойност. За име на тази стойност се счита името на самата функция, а списъкът от формални параметри на функцията определя само входните данни.

Параметрите, които дефинираме в тялото на подпрограмата се наричат локални параметри, а тези, дефинирани в тялото на класа – глобални.

Ако в подпрограма искаме да използваме някой от глобалните параметри, то трябва да укажем това с помощта на служебната дума this.

Пр. 2  Нека е даден следният фрагмент от програма:

class Fragment {

int x;  // глобални параметри

int y;

int z;

…

void Exampl (int x; int a) {

//локален параметър с име като на

// глобален и др. локален параметър

x=2;   //присвоява стойност на локален

//параметър

a=3;            //присвоява стойност на локален

// параметър

this.x=7;     //присвоява стойност на глобален

// параметър

this.y = 1;   //присвоява стойност на глобален

//параметър

this.z = 0;   //присвоява стойност на глобален

//параметър

…

}

…

}

Пр. 3   Деклариране на процедура и функция:

1. Деклариране на процедура, която разменя стойностите на две променливи a и b:

, но смяната на тези два локални параметъра не засяга глобалните параметри, от които те са взели стойностите си.

1. Деклариране на функция, която сравнява две реални числа х и у, и ако х<у връща стойност true, а в противен случай – false:

Допустими са подпрограми и без параметри. Например процедура, която отпечатва на екран текст “Добър ден” няма нужда от входни данни и не връща резултат, който да се използва от основната програма.

Изпълнение на подпрограми

Дефинирането на една подпрограма определя какво трябва да е нейното действие, но не и кога (при изпълнение на главната програма) да се изпълни това действие.

Изпълнението на подпрограма става чрез нейното извикване от главната програма. Това става чрез името на подпрограмата и списък от фактически параметри, за които тя трябва да бъде изпълнена.

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

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

Пр. 4 Активиране на процедури и функции:

1. void main() {

boolean b;

float x = 23.45;

float y = 23.455;

…

b=Little(x, y); //извикване (активиране) на функция

//Little и присвояване на нейната стойност на променлива b

…

}

2. Ако искаме да разменим местата на две променливи T и Р, то активирането на процедурата ще бъде:

change_a_b(Т, Р);

3. Ако искаме да отпечатаме резултата от сравнението на две числа 2*L и K:

System.out.println(Little(2*L, K));

Заместването на формалните параметри на подпрограмите с различни фактически параметри при активиране на подпрограмата се нарича механизъм за предаване на параметри. Механизмът за предаване на параметри позволява подпрограмата да се изпълнява за различни входни данни и да получава различни изходни резултати.

Пр. 5 Примерна програма за подреждане на три реални числа в намаляващ ред:

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Полиморфизъм

Съществуването на две или повече функции с еднакви имена, които извършват еднакви (подобни) действия се нарича полиморфизъм. Той е свързан с предефиниране на функцията. Предефинирането може да стане статично, в рамките на един клас (статичен полиморфизъм) или динамично, при наследяване (динамичен полиморфизъм).

Статичен полиморфизъм – да се предефинира (статично) един метод (overload) означава да се предостави негова друга реализация с използване на различен брой или тип на параметрите. В един клас могат да се дефинират методи с едно и също име, но сигнатурата им трябва да е различна. За да се считат за един метод, реализиращ статичен полиморфизъм, методите с еднакви имена трябва да връщат един и същ тип.

Пр. 1

class Equality(){

static boolean intEqual(int i, int j){return i==j;}

static boolean intEqual(int i, double d){return i==(int)d;}

static boolean intEqual(double d, int j){return (int)d==j;}

static boolean intEqual(double d, double e){return (int)d==(int) e;}

static boolean intEqual(int i, char c){return i==(int)c;}

static boolean intEqual(char c, int j){return (int)c==j;}

static boolean intEqual(char c, char d){return (int)c==(int)d;}

}

//използване

if(Equality.intEqual(x, y)){//в зависимост от типа на х  и у ще

//се извивка метод

…

}

Динамичен полиморфизъм – да се предефинира (динамично) или преопредели един метод (override) означава да се предостави нова реализация на дадения метод, различна от наследената от суперкласа реализация. Новата реализация в подкласа има същото име, същия брой и тип на параметрите и връща същия резултат като реализацията на метода в подкласа.

Пр. 2

import java.io.*;

class Base {

int a = 1;

void printing() {

System.out.println(“Печата в клас Base”);

}

void basing(){

System.out.println(“Метод на класа Base”);

printing();

System.out.println(“Стойността на променливата е:”+a);

}

}

class New extends Base{

int a = 2;

void printing(){

System.out.println(“Печата в клас New”);

}

}

class OverrideTest {

public static void main(String[]) throws IOException {

System.out.println(“Използваме обект на клас Base…”);

Base b = new Base();

b.printing();

b.basing();

System.out.println(“Използваме обект на клас Newt…”);

New n = new New();

n.printing();

n.basing();

}

}

Един клас може да бъде дефиниран като последен със служебната дума final. Такъв клас не може да бъде наследяван, т.е. не може да има подкласове. Създаването на класове final позволява защита на информацията. Методите от тип последен също се дефинират със служебната дума final и не могат да се преопределят в подкласовете.

Абстрактни методи и класове – това са методи, които са обявени в един клас, но не са реализирани в него. Такъв клас се нарича абстрактен, явявайки се всъщност само шаблон. Действиетелната реализация на метода се предоставя на подкласовете посредством преопределяне. В Java за указване на абстрактен метод се използва ключовата дума abstract.

Пр. 3

abstract class Shape {

//абстрактния метод getArea() се реализира от

// подкласа

public abstract double getArea();

…

}

Класът  Shape е обявен с ключовата дума abstract, показваща, че даденият клас включва в себе си един абстрактен (или нереализиран) метод. Това означава, че в действителност не може да бъде създаден обект от класа Shape, а само обекти от подкласовете, които осигуряват реализацията на метода getArea().

Класът, съдържащ абстрактни методи се нарича абстрактен, в противен случай – функционален.

Интерфейс – това е начин на задължаване на класовете да имат определени свойства. Той по структура прилича на  класа, като включва полета и методи, но се различава от него по това, че  не може да се създават негови екземпляри. Методите в интерфейса не трябва да се реализират, а полетата могат да бъдат само константи.

На интерфейса може да се гледа като на абстрактен клас, съдържащ само абстрактни методи и константи.

Пр. 4

interface Helpable {

public void help();

}

Интерфейсът в Java се използва, когато се създава клас, който  го реализира. Реализацията означава включване на реализации на всички методи на интерфейса в класа. За да се укаже, че дадения Java клас реализира методите на определения интерфейс, се използва служебната дума implements. Всеки клас може да реализира неограничен брой интерфейси.

Пр. 5

class Topic implements Helpable {

String strNameTopic;

public void help() {

System.out.println(“Помощ за ”+strNameTopic);

}

}

Интерфейсите могат да се наследяват и синтаксисът на интерфейса в общия случай е следния:

[public]  interface <име> [extends <интерфейс>…]  {

//тяло, съдържащо заглавни редове на методи и константи

}

Където тялото съдържа само заглавни редове на методи и константи, а модификаторът за достъп public се използва, ако интерфейсът ще бъде използван извън пакета. За разлика от класа,  всеки интерфейс може да наследява много интерфейси. (Класът може да наследява един клас, но да реализира много интерфейси.)

В интерфейсът може да се използва в качеството на тип данни. Може да се обявяват променливи от тип интерфейс. Всеки обект от клас, реализиращ интерфейса, може да се присвои на присвои на променлива от типа на интерфейса.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Работа с повече от един клас

Реалните програми използват повече от един клас за решаване на определена задача. Възможни са два подхода за вмъкване на класове – всеки клас да бъде в нов файл или няколко класа да са в един файл. Двата подхода имат следните различия:

1. Няколко класа в един файл:

В този случай само един от класовете може да има име, съвпадащо с името на файла. Именно този клас ще бъде видим от другите файлове и се нарича основен, а останалите класове са помощни. За да са видими, те трябва да бъдат декларирани със служебната дума public.

Пр. 1

// начало на Example.java

class Example {

int a;

void main (String[] arg) {

Extra e = new Extra();

…

}

}

class Extra {

int x;

…

}

// край на Example.java

Въпреки че класът Extra е дефиниран след основния клас Example, той може да бъде използван в него.

1. Класове в различни файлове:

Възможно е всеки клас от една програма да се разполага в отделен файл с име, съвпадащо с името на класа. Така класовете по подразбиране са видими.

Наследяване на класовете

Един Java клас може да се обяви като наследник на някакъв  друг клас. Това става чрез служебната дума extends.

Пр. 2

class Base {

… //определяне на данни и методи

}

class New extends Base {

… //определяне на данни и методи

}

В новия клас New се съдържат всички данни и методи, определени в класа Base и още някои собствени декларации. Така новият клас се явява разширение на класа Base. Предимството на пораждане на класове един от друг е очевидно – възможност за многократно използване на вече въведена програма.

Пр. 3

class Door { // описание на обикновена врата

boolean stateOpen;

void open() {stateOpen = true; }

void close() {StateOpen = false;}

}

class LockingDoor extends Door {// описание на врата, която

//се заключва с ключ. Автоматично се наследяват (включват)

// stateOpen, open() и close()

boolean stateLocked;

void  lock() { stateLocked = true;}

void unlock() { stateLocked = false;}

class SecretDoor extends Door { //описание на врата, която се

//заключва с код. Автоматично се наследяват (включват)

//stateOpen, open и close

…

}

class LockingAlarmedDoor extends LockingDoor {//описание на

//врата …Автоматично се наследяват (включват)

// stateOpen, open, close, stateLocked, lock, и unlock

…

}

Наследяването от примера е онагледенo на следната диаграма:

Суперклас и подклас

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

Пр. 3

class Base {

//елементи на базовия клас (суперклас)

}

class New extends Base {

//елементи на извлечения клас (подклас)

}

При наследяването се добавят нови членове данни и/или методи, като се запазват и всички данни и методи на суперкласа. Методите и данните на суперкласа се наследяват в подкласа.

Елементите на суперкласа се използват в подкласа директно със задаване на тяхното име. Когато има елементи на класа и подкласа с едно и също име, за достъп до елементите на класа  се използва служебната дума super.

Пр. 4

class Base {

int x, y;

}

class New extends Base {

int z, y;

void example() {

x = 1;                    // х от суперклас Base

y = 1;           // у отизвлечен клас New

super.y = 1; // достъп до елемент у на суперклас

//Base

z = 1;          // от извлечен клас New

}

}

Достъп

Пред членовете данни и подпрограмите на класа може да се използва модификатор за достъп. Съответно:

• Скрит достъп: private. С този модификатор един елемент се обявява за скрит за всички методи, които са извън класа, в който е елемента;

Пр. 5

class Alfa {

private int privateDatum;

private void privateMethod() {

System.out.println(“Method from Alfa”);

…

}

class Beta {

void example() {

Alfa e = new alfa();

e.privateDatum = 1; // невъзможно!

e.privateMеthod();   // невъзможно!

…

}

}

• Видим достъп: public. С този модификатор елемента се обявява за видим и достъпен от всички външни програми. Видимите променливи могат да бъдат четени и да се променя тяхната стойност. Поради тази причина много рядко променливите имат такъв модификатор.

Пр. 6

class Alfa {

private int privateDatum;

private void privateMethod() {

System.out.println(“Method from Alfa”);

public int publicDatum;

public void publicMethod() {

System.out.println(“Method from Alfa”);

…

}

class LetterA {

void example() {

Alfa e = new Аlfa();

e.privateDatum = 1;  // невъзможно!

e.privateMеthod();    // невъзможно!

e. publicDatum = 2;  // възможно

e. publicMethod();    // възможно

…

}

}

• Защитен достъп: protected. Това е комбинация между скрития и видимия достъп. Всеки елемент, който е защитен, е видим в собствения си клас и във всички негови преки или косвени подкласове, а е скрит за всички останали части на програмата.

Пр. 7

class Alfa {

private int privateDatum;

private void privateMethod() {

System.out.println(“Method from Alfa”);

protected int protectedDatum;

protected void protectedMethod() {

System.out.println(“Method from Alfa”);

…

}

class LetterA extends Alfa {

void example() {

Alfa e = new Аlfa();

e.privateDatum = 1;     // невъзможно!

e.privateMеthod();       // невъзможно!

e.protectedDatum = 2;  // възможно

e.protectedMethod();    // възможно

…

}

}

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Всеки алгоритъм задава начин за решаване на съответна задача. Алгоритмите се различават по възможните множества от входни данни, получаваните резултати, правилата за достигане на резултата и др. Алгоритмите се характеризират (и отличават помежду си) по седем параметри.

В зависимост от типа на съставящите ги команди алгопритмите се разделят на три основни вида – последователни (линейни), разклонени и циклични.

Основните начини за представяне на алгоритми са чрез използване на естествени езици (словесно описание), графични изображения (блок-схемни описания) и различни специализирани езици.

ЕП (езици за програмиране) са специализирани езици, предназначени за описание на алгоритми, които ще бъдат изпълнявани от компютър.

Програмата представя алгоритъма във форма и вид, които могат да се възприемат и изпълняват от компютърна система.

Най-общо програмата се състои от две части – част за описание на данните (определя типа на данните, техните имена и вид – константи или променливи) и част за описание на тяхната обработка (състои се от оператори, представящи обработката на данните).

Типове данни

Всеки тип данни може да се разглежда като съвкупност от следните три множества:

• множество от стойности (константи на типа), които могат да се присвояват на променливите от типа;
• множество от операции, в които могат да участват величините (константи и променливи) от типа;
• множество от отношения (релации) между величините (константи и променливи) от типа.

В уроци 1-8 разгледахме така наречените прости типове данни. Стойностите на тези типове са неделими (за разлика от стойностите на структурните типове данни). Най-използваните прости типове данни (цял, реален, знаков и логически) обикновено са вградени в универсалните ЕП и могат да се използват непосредствено в програмите. Такива типове се наричат стандартни типове данни. Освен това в ЕП на програмиста се предоставят и средства за създаване на собствени прости типове данни на базата на стандартни типове данни.

Стандартните прости типове в езика Java са реален (float; double), целочислен (byte; short; int; long), знаков (char) и логически (boolean).

Ограниченият тип в Java  може да се определя от програмиста.

Величините от прост тип имат стойности, които са неделими. За разлика от тях стойностите на величините от структурен тип могат да се разглеждат като съставени от повече стойности, наречени компоненти или елементи на съответната съставна стойност. Всяка от компонентите на съставната стойност принадлежи на друг, предварително определен тип.

Възможно е всички компоненти на един структурен тип да са от един и същи тип, но има и структурни типове, чиито компоненти могат да принадлежат на различни типове.

Изрази и приоритет на операциите

Изразът в програмата е правило за определяне на стойност от определен тип чрез комбиниране по подходящ начин на величини от различни типове, допустими операции с тях и кръгли скоби. В изразите като аргумент могат да участват и стойности на функции. Пример за такъв изпаз е: a + Math.pow(x,2).

При срещане на израз в програмата неговата стойност се намира с отчитане на приоритета на срещаните операции. Приоритетът на операциите в езика Java (в намаляващ ред) е, както следва:

• постфиксни – <израз>++, <израз>–;
• унарни – ++<израз>, –<израз>, +<израз>, -<израз>, !<израз>;
• мултипликативни – *, /, %;
• адитивни – +, -;
• отношения – <, <=, >, >=, instanceof;
• еднквост – ==, !=;
• логическо “И” – &&;
• логическо “ИЛИ” – ||;
• присвояване – =, +=, -=, /=, %=;

Оператори

Операторите в ЕП задават определена обработка на данните. Същевременно някои от тях дават възможност да се определи редът на изпълнение на други оператори.

При съставянето на линейни програми обикновено се използват следните оператори: оператор за въвеждане на данни, оператор за извеждане на резултати и оператор за присвояване. В ЕП Java съответните оператори са System.in.read(), System.out.print() и “=” и са представители на т.нар елементарни (прости) оператори.

Структурните оператори, за разлика от простите, могат да включват в тялото си и други оператори.

За да се обедини последователност от оператори в Java, се използват фигурни скоби “{…}”.

За реализация на разклонени алгоритми в ЕП са предвидени различни оператори за разклонение. В Java има два оператора – условен оператор if (за избор между два възможни варианта) и оператор switch (за избор между произволен брой варианти).

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

В езика за програмиране Java има три оператора за цикъла – цикъл с предусловие while, цикъл със следусловие do…while и цикъл с параметър for.

На фигура 1 са представени основните оператори в Java:

Фиг. 1:

оператори

последователност     разклонение       повторение

За да можете да използвате един оператор в програма, е необходимо да знаете две неща – как се записва (синтаксис) и как се изпълнява (семантика).

Следващите два примера включват почти всички изучени до момента елементи на език за програзиране Java.

Пр. 1   Програма реализираща разклонен алгоритъм

Да се състави програма на Java, която да пресмята обиколката (периметъра) и лицето на триълник по зададени дължини на страните a, b и c и да определя вида на триъгълника – разностранен, равнобедрен, равностранен.

Проектиране

Програмата изисква три променливи a, b и c от реален тип, в които ще се съхраняват дължините на страните на триъгълника. Въвеждаме и логическа променлива Flag, стойността на която ще се определя в зависимост от това дали съществува триъгълник с дължини на страните равни на въведените стойности a, b и c. Променливата p е предназначена за съхраняване стойността на полупериметъра, а S – на лицето на триъгълника. S и p са от реален тип.

Ще използваме известните формули от математиката за изчисляване на полупериметъра и лицето на триъгълника по Херонова формула:

След въвеждане на стойностите на a, b и c се извършва проверка съществува ли триъгълник с дължини на страните a, b и c. Видът на триъгълника се определя чрез сравняване на дължините на неговите страни.

Програмиране

Пр. 2   Програма, реализираща цикличен алгоритъм

Да се отпечата на екран таблицата за умножение на числата от 10 до 20.

Проектиране

Ще използваме два вложени цикъла, за да можем да изведем на екран всички възможни произведения. Също така, ще ни бъдат необходими две целочислени променливи I и J, които ще бъдат броячи.

Програмиране

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Изключение в това отношение прави само цикълът от пример 2, тялото на който се изпълнява винаги четири пъти. За по-ефективно записване на цикли, за които предварително е известно колко пъти ще се изпълнят, в повечето езици за програмиране има специален оператор, наречен цикъл с параметър.

Тук по-конкретно ще разгледаме как изглежда този цикъл в езика за програмиране Java.

Оператор за повторение for

При оператора за цикъл с параметър тялото се изпълнява по веднъж за всяка една стойност от предварително определена редица от стойности на даден параметър.

Операторът с параметър има следният вид:

for(<израз1>;<израз2>;<израз3>) {

<оператор1>;[[оператор2;]…;[операторN;]]  //тяло

}

Където <израз1> е оператор за инициализация, <израз2> е логически израз, а <израз3> е оператор, изпълняващ се след тялото на цикъла. Всъщност <израз1> ни задава началната стойност на параметъра (трябва да е от дискретен тип), <израз2> – крайната стойност, а <израз3> – стъпката с която се изменя параметъра. Цикълът се изпълнява, като започва от началната стойност на променливата и докато логическият израз има стойност true, като параметъра се изменя със зададената стъпка в <израз3>.

Когато тялото съдържа само един оператор, то може да се опише без фигурни скоби, но ако са повече, то фигурните скоби са задължителни.

Пр. 1  Цикъл с параметър

Управляващата променлива е от целочислен тип а тялото на цикъла се състои от два оператора:

for (int I=0; I<=15; I++) {//докато I е по-малко или равно на 15

J= I*I; //на J присвоява стойност I*I, отпечатва тази

System.out.print(J+”, “); //стойност и увеличава I с 1.

}

1. Проверката за край на цикъла се извършва преди изпълнението на тялото, което означава, че цикълът може да не се изпълни нито веднъж т.е. оператор за цикъл с параметър е оператор с предусловие.
2. Началната и крайната стойност на параметъра се пресмятат еднократно в началото на цикъла.

Сравнение на операторите за повторение

За да не допускате грешки при програмирането на цикли, ще изброим някои прилики и разлики в записването и използването на различните оператори за цикъл, разгледани в предишните два урока:

1. Ако тялото на цикъл от типовете, изброени в предишните уроци, включва повече от един оператор, те трябва да се запишат във фигурни скоби.
2. Тялото на циклите while и for може да не се изпълни нито веднъж, докато тялото на do…while… се изпълнява поне веднъж.
3. Тялото на цикъл while се изпълнява дотогава, докато условието за край има стойност true, на do…while…– докато условието има стойност false , а на for – докато управляващата променлива не е надхвърлила крайната стойност.
4. При while условието за край се иниацилизира преди влизане в цикъла.
5. При for броят на повторенията на тялото е предварително известен, докато при операторите с условие (while и do…while..) той зависи от това кога ще се изпълни условието за край.

Вложени цикли

Ако тялото на един оператор за цикъл включва друг оператор за цикъл, се получава конструкцията вложени цикли. Синтаксисът на всички оператори за цикъл в езика Java допуска влагане не само на два, но и на повече цикли. Фигура 1 дава представа как изглеждат вложени един в друг оператори за цикъл.

Фигура 1.

Изпълнението на вложените цикли е следното: при всяка итерация на външен цикъл се изпълнява целият вложен непосредствено в него вътрешен цикъл; изпълнението приключва, когато се изпълнят всички итерации на най-външния цикъл.

Програма с три вложени цикъла е дадена в следващия пример.

Пр. 2  Програма за намиране на броя на “щастливите комбинации”

Шестцифрена комбинация от цифри се нарича “щастлива”, ако сумата от първите 3 и последните 3 цифри на комбинацията е равна на 13.

В програмата първоначално се преброяват всички трицифрени комбинации (броят им се натрупва в променливата Nhappy) със сумата на цифрите (С1, С2 и С3), равна на 13. след това броят на “щастливите” комбинации се получава, като този брой (Nhappy) се повдигне на квадрат (защо?).

За да получим всички трицифрени комбинации, е удобно да използваме три вложени цикъла – съответно за генериране на първата, втората и третата цифра. За сяка така получена комбинация, ако сумата от трите цифри е 13 увеличаваме брой на намерените до момента “щастливи” комбинации с единица (Nhappy = ++Nhappy).

В програмата се използва оператор for, защото броят на повторение на всеки цикъл е известен предварително – той е равен на 10. Ще забележим, че тялото на най-вътрешния от трите вложени цикъла for ще се изпълни 1000 пъти.

1. С помощта на вложени цикли с малък брой оператори могат да се програмират значителен брой действия.
2. При влагане на цикли тялото на вътрешния цикъл трябва да се съдържа изцяло в тялото на външния.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Един алгоритъм е цикличен, когато при неговото изпълнение група от елементарни действия се повтаря многократно. В много случаи се налага организиране на повтарящи се действия. Такава например е задачата за намиране на сумата на редица от числа. Сумиране на голям брой числа може да се наложи, когато искате да проверите сметката си в магазина или пък когато класният ръководител определя средния успех на учениците в класа.

Пр. 1  Алгоритъм за определяне на сума

Предложеният алгоритъм решава задачата за намиране на сумата на числа, въвеждани последователно, като сумирането завършва, когато се въведе числото 0. сумата на числата се натрупва последователно (след всяко ввъвеждане) в параметър s. Следващото словесно описание представя типичен цикличен алгоритъм:

1. s = 0.
2. Въведете поредното число х.
3. Ако х ≠ 0, то s=s+x, в противен случай изпълнете стъпка 5.
4. Изпълнете стъпка 2.
5. Съобщете стойността на s (като резултат).
6. Прекратете работа.

Групата от повтарящи се действия в цикличните алгоритми се наричат тяло на цикъла. В примера тялото на цикъла представляват действията от стъпки 2, 3 и 4. Всяко изпълнение (повторение) на тялото на цикъла се нарича итерация. Задължително изискване е повторенията да са краен брой. Кога ще завърши цикълът се определя от т.нар. условие за край на повторенията, което в горния алгоритъм е х = 0 (проверява се на стъпка 3).

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

Стъпка 1 от горния алгоритъм е много важна за правилно му изпълнение, защото ако на s не беше дадена предварително стойност 0, а например 1, тогава s, получено на стъпка 5, няма да е сумата на въведените числа. Такива действия, които се извършват преди началото на цикъла с цел да се подготви неговото правилно изпълнение, се наричат подготовка или инициализация на цикъла.

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

1. Четирите основни елемента на всеки цикъл, въведени по горе – инициализация, тяло, управление на повторенията и условие за край, трябва внимателно да бъдат обмислени и проектирани, независимо по какъв начин ще се записва цикличният алгоритъм – словесно или чрез оператор за цикъл.
2. Забележете, че когато чрез цикъл в една променлива се натрупва сума, то тази променлива първоначално се нулира.

В езика Java има три циклични оператора. В този урок ще разгледаме два от тях, които се наричат съответно цикъл с предусловие и цикъл със следусловие. Двата оператора се различават помежду си по това дали условието за край на цикъла се проверява преди или след изпълнение на неговото тяло. Третият вид оператор за цикъл – с параметър, ще разгледаме в следващия урок.

Оператор за повторение с предусловие

Оператор за цикъл с предусловие while има следният вид:

while (<условие>) {

<оператор>;

[оператор2; ... операторN;]

}

, където условието е от логически тип и определя условието за край на цикъл, а операторът (кой да е оператор от езика Java) представлява тялото на цикъла. Т.е. оператора се изпълнява докато условието от логически тип има стойност true, ако приеме стойност false, то оператора не се изпълнява повече.

Пр. 2  Оператор за цикъл с предусловие

Предполага се, че S и I са декларирани като целочислени променливи:

S = 0; I = 1;                       // инициализация

while (I <= 4) {                  // проверка за край

S = S+I*I;            // тяло

I = ++I;                 // управление на повторенията

}

Смисълът на оператора while може много лесно да бъде разбран, ако го преведем и прочетем като свързано изречение – “докато <условие> има стойност истина, изпълнявай <оператор>”. Иначе казано: преди всяка итерация се изчислява стойността на логическото условие; ако тя е true, се изпълнява оператора, а ако е false – цикълът се прекратява.

Да разгледаме по-подробно изпълнението на оператора за цикъла от пример 2:

• Преди влизане в цикъла променливите S и I приемат начални стойност 0 и 1 (инициализация);
• При първата итерация се проверява дали стойността на I е по-малка или равна на 4, т.е. 1<=4, и понеже това е вярно, се изпълняват операторите от тялото на цикъла (S = 0+1*1, т.е. S=1 и I = 1+1, т.е. I = 2);
• При втората итерация, понеже отново е вярно, че 2<=4, се изпълнява тялото (S = 1+2*2, т.е. S=5 и I = 2+1, т.е. I = 3);
• Трета итерация: Понеже 3<=4, следва че: S = 5+3*3 (=14), а  I = 3+1 (=4);
• Четвърта итерация: Проверката дали 4<=4 дава стойност истина и (за последен път) се изпълнява тялото на цикъла S = 14 + 4*4, т.е. S = 30 и I = 4+1 (=5);
• При проверка дали 5<=4 се получава лъже и цикълът се прекратява.

1. Тялото на цикъла може да не се изпълни нито веднъж!
2. Основните елементи на цикъла от пример 1 са посочени с помощта на коментари.

За да помните колко е важно управлението на повторенията, разгледайте цикъла от пример3, който довежда до т.нар. зацикляне (цикълът не завършва).

Пр. 3  Зацикляне

while (true) {System.out.println(“Безкраен цикъл”);}

Друг пример за циклична програма и използване на оператора while е даден в следващия пример:

Пр. 4  Основна част на програма за намиране на НОД по алгоритъма на Евклид

Оператор за повторение със следусловие

Операторът за цикъл със следусловие do…while има следната синтактична диаграма:

do {

<оператор>;

[<оператор1>; [<оператор2>;…]];

} while (<условие>);

, където условието е от логически тип и определя условието за край на цикъла, а операторите между do и while представляват тялото на цикъла.
Пр. 5 Основна част на програма – цикъл със следусловие (алгоритъм на Евклид)

Начинът на изпълнение на оператора за цикъл със следусловие се определя от следните две стъпки:

1. Изпълняват се последователно операторите между do и while.
2. Определя се стойността на логическото условие. Ако тя е false, се повтарят отново стъпки 1 и 2, а ако е true изпълнението на цикъла се прекратява.

Смисълът на оператора do…while… може да се изрази с изречението: “Изпълнявай операторите, докато стойността на условието стане истина.”

1. При цикъла със следусловие също може да се получи зацикляне, ако в тялото му няма оператор, който влияе върху условието за край.
2. Ако сравните двата начина за програмиране на алгоритъма на Евклид (пример 4 и пример 5), ще забележите, че в този случай е по-удобно цикълът да бъде записан чрез оператор while (защо?).
3. Операторът do…while… много често се използва в програмите (вж. пример 6) за проверка на това дали въведените от потребителя данни са коректни (по стойност, по тип и т.н.).
4. Тялото на оператора do…while… се изпълнява поне един път.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

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

Задача1: Съставете програма, която въвежда последователно: първо реално число, знак за операция (един от ‘+’, ‘-‘, ‘*’, ‘/’), второ реално число и изчислява и извежда стойността на съответната операция. В случай, че е въведен недопустим знак за операция, програмата трябва да дава съобщение “Грешна операция”.

Алгоритъм за решаване на задача 1 включва многовариантен избор на вземане на решение, защото пресмятането може да се извърши по един от четири възможни варианта (в зависимост от това дали е въведен знак ‘+’, ‘-‘, ‘*’ или ‘/’). Програмирането на този етап включва използването на няколко условни оператора.

Пр. 1  Избор между четири възможни варианта, реализиран с условни оператори.

Ако стойностите на роменливите number1 и number2 са двете въведени реални числа, а стойността на променливата operation е въведеният знак за операция, то пресмятането може да стане така:

if (operation ==‘*’) result = number1*number2;

else if (operation == ‘/’) result = number1/number2;

else if (operation == ‘+’) result = number1+number2;

else if (operation == ‘-’) result = number1-number2;

else InvalidOperation = true;

За такива случаи е предвиден специален оператор (оператор за многовариантен избор), който улеснява програмирането на случаи, когато се налага да се прави избор между повече възможни варианти на действие. Операторът за многовариантен избор представя вземането на решения при наличието на сложни условия и прави програмата много по-ясна и четлива.

В езика за програмиране Java за многовариантен избор се използва оператора switch. Действията, между които се избира, са взаимноизключващи се (изпълнява се не повече от едно действие). Взаимноизключващите се действия ще наричаме варианти.Ето как изглежда реализацията на оператора switch:

switch ( <ключ> ) {

case <вариант1>:<оператори>;

…

case <вариантN>:<оператори>;

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

}

Стойността на ключа след switch, определя кой от вариантите трябва да бъде изпълнен т.е. всеки вариант се сравнява с ключа и ако съвпадне, се изпълняват операторите след него. За да изпълни само тях (и да не продължи с изпълнението на другите) след всеки вариант трябва да се запише служебната дума break;.

Ролята на операторите след default е да посочат какво да изпълни програмата, ако случаят, който е въведен не съвпада с нито един от вариантите, посочени за многовариантния оператор.

Пр. 2  Оператор switch

1. Избор (между 4 варианта), определен от стойността на целочислена  променлива I:

switch (I)

{

case 1: y = x*x*x; break;

case 2: y = Math.abs(x); break;

case 3: y = 0; break;

case 4: y = Math.pow(x,4); break;

default: y = -1;

}

При изпълнение на този оператор , ако I има стойност 1, на у ще бъде присвоена стойността на израза х*х*х, ако I е 2, у ще получи стойността на Math.abs(x) и аналогично – за стойност на I=3 или 4, ще се премине към изплнението на оператора, следващ case. Ако е зададена друга стойност то на у ще се присвои стойност –1.

2. Избор (между четири варианта), определен от стойността на променлива grade от знаков тип:

switch (grade)

{

case ‘A’: System.out.println (“Congratulations!”);

break;

case ‘B’:System.out.println (“Not bad, B level is OK”); break;

case ‘C’:System.out.println (“C level is only average”);

break;

case ‘D’:System.out.println (“D level is terrible”);

break;

default:System.out.println(“No excuses!Study harder!”);

}

Примерна програма

Нека като пример за приложение на оператор да съставим програмат от задача 1.

Пр. 3  Програма за решаване на задача 1

Проектиране

Според условието на задача 1 аргументите и резултатът на операциите са реални числа, а знакът на операцията е от знаков тип. Ето защо в програмата се декларират променливите:

char operation;

float number1, number2, result;

Знакът на операцията може да бъде един от четирите ‘-‘, ‘*’, ‘/’,  ‘+’, като се избира между четири варианта. В този случай логично е да използваме оператора за многовариантен избор като най-удобно средство за програмиране:

switch (operation){

case ‘*’: result = number1 * number2; break;

case ‘/’: result = number1 / number2; break;

case ‘+’: result = number1 + number2; break;

case ‘-’: result = number1 – number2; break;

default: InvalidOperation = true;
}

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Разклонени алгоритми

Процесът на избор на един от няколко възможни варианта за действие нарича вземане на решение.

Какво решение ще вземем обикновено е свързано с това – дали е изпълнено или не някакво условие. Например ако се чудите дали днес да отидете на училище или не, то вероятно ще вземете решение според това дали броят на неизвинените ви отсъствия до момента не надхвърля максималния позволен брой. Подобни условия се наричат логически условия.

За представяне на такива условия в езиците за програмиране е въведен споциален тип данни, наричан логически (булев) тип данни.

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

Реализацията на разклонените алгоритми в езиците за програмиране се извършва чрез различни оператори за разклонение. В езика за програмиране Java има два такива оператора – условен оператор if…else (за избор между два възможни варианта) и оператор  (за избор между произволен брой варианти).

Стандартният логически тип, както и операторите за разклонение улесняват в много голяма степен програмирането на разклонени алгоритми.

Логически (булев) тип

Множеството от стойности на логически тип съдържа само две константи – true и false (съответно истина и лъжа).

Логическият тип се декларира със стандартния идентификатор boolean. Например логическите променливи В и Da се декларират по следния начин:

boolean   B, Da;

С логически величини могат да се извършват трите основни логически операции: двуаргументните – логическо умножение (което на Java се записва &&) и логическо събиране (на Java - || ) и едноаргументната – логическо отрицание (  ! – на Java).

Операторите за сравнение дават логически резултат,  въпреки че се прилагат върху други типове, основавайки се на сравнението на операндите – за равенство(= =), за неравенство (!=), за по-малко (<), за по-голямо (>), за по-голямо или равно (>=), за по-малко или равно (<=).

Пр. 1. Логически изрази

1. Ако броят на неизвинените отсъствия, направени до момента от ученика, е Neizv, а максималния допустим брой е MaxNeizv, то логическото условие, от което се определя решението на ученика, ще изглежда така:

Neizv < MaxNeizv

1. Ако добавим още едно изискване към горното условие, напричер часът (Chas) да не е повече от 11 преди обяд, то ще получим по-сложен логически израз:

(Neizv < MaxNeizv) && (Chas <= 11)

За константите true и false е прието, че са подредени по следния начин: false < true, което означава, че и логическите величини може да се сравняват.

Логически стойности не могат да се въвеждат чрез read.

Условен оператор

Един от операторите, който представя вземане на решение в програмата, е условният оператор. Най-простият вариант има вида:

if (<условие>) <оператор>;

, където условието е израз, водещ към логически резултат. Операторът може да бъде произволен оператор на Java, включително друг оператор if или блок от оператори. Ако е повече от един оператор, то задължително трябва да са заградени във фигурни скоби.

Пълната форма на условния оператор е следната:

if (<условие>) {

<оператори 1>;

} else {

<оператори 2>;

}

, където действието е следното: ако е изпълнено логическото условие след if (т.е. има стойност true), то се изпълняват <оператори 1>, ако не (т.е. условието има стойност false)– се изпълняват <оператори 2>, записани след else.

Пр. 2.  Правилно записани условни оператори:

1. Кратка форма:

if (Neizv<MaxNeizv)

Neizv = Neizv + 1;  //може да се запише и така: //Neizv = ++Neizv

// не сме записали фигурни скоби т.к. има само 1 оператор

2. Пълна форма (предполагаме, че са направени декларациите int A,B; char D):

if (A == B)

D = ‘Д’;

else D = ‘Н’;

Когато е само един оператор, може и да не се пишат фигурни скоби.

3. Условен оператор, съдържащ друг условен оператор  (предполага се, че са направени декларациите float X; boolean Sign;):

if (X<0) Sign = true;

else

if (X>0) Sign = false;

else System.out.println (“стойността е 0”);

4. Условен оператор със съставно условие (предполага се, че са направени декларациите int x; boolean y;)

if ((x>3) && (x<8))   y = true;

else y = false;

Семантиката на условния оператор е следната: в зависимост от изпълнението на зададено условие се извършва (или не) едно определено действие (if в кратка форма) или се избира и изпълнява едно от двете записани действия (if в пълна форма).

Изпълнението на условния оператор в кратката му форма е следното: определя се стойността на логическото условие; само когато тя е true, се изпълняват оператори1. При пълната форма – ако стойността на логическото условие е true, се изпълняват оператори1, а ако е false – оператори2 след else.

• Когато има само един оператор в “оператори1”, то фигурните скоби могат да се пропуснат;
• Условният оператор if може да съдържа кой да е оператор на Java, в това число и друг оператор if. Трябва да се има в предвид, че else съответства винаги на най-близкия предхождащ if. В сложните случаи може да се сгреши и за това се препоръчва използването на отместване (Пр. 2.3.).

Примерна програма

При програмиране на разклонени алгоритми се спазват същите етапи, които илюстрирахме при нашата първа програма на Java.

Пр. 3. Съставяне на програма, която определя дали дадено яло число, въведено от клавиатурата, се дели на 5 или на 15.

Проектиране:

Началните данни на програмата се състоят само то една-единствена целочислена стойност, която се въвежда от клавиатурата. Ето защо в програмата по-долу се декларира променлива IntNum от цял тип. Крайният резултат е съобщение дали IntNum се дели или не на 5 или 15. За съхраняване на резултата в програмата не е необходима променлива.

Алгоритъмът, по който ще проверяваме делимостта на числото, е известен – едно число се дели на 5, ако остатъкът при целочисленото му деление на 5 е   0. Следователно дали едно число се дели или не на 5 може да се определи чрез проверяване на стойността на логическия израз (IntNim%5)=0. Дали едно число се дели на 15 може да проверим, като установим дали то се дели едновременно на 5 и на 3.

Програмиране:

Следващата програма показва как може да се използва условния оператор if, за да програмираме разклонени алгоритми.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Пр. 1.

Нека да съставим алгоритъм за изчисляване на чистата заплата (ЧЗ) на работниците по дадена стойност на основната им заплата (ОЗ). ЧЗ се получава, като към ОЗ се прибави сума за прослужени години, равна на 21% от ОЗ (считаме, че всички работници са с еднакъв трудов стаж) и полученият сбор се намали с 20% (удръжки за данък общ доход). Алгоритъмът, по който може да извършите тези изчисления, е следният:

Вход: Стойност на ОЗ.

Изход: Стойност на ЧЗ.

Стъпка 1: Въведете и запомнете ОЗ.

Стъпка 2: Пресметнете и извършете присвояването

ЧЗ  = ОЗ + ОЗ*21/100.

Стъпка 3: Пресметнете и извършете присвояването

ЧЗ = ЧЗ – ЧЗ*20/100.

Стъпка 4: Съобщете стойността на ЧЗ като резултат.

Стъпка 5: Прекратете работа.

Предложеният алгоритъм е линеен алгоритъм, защото посочените в него действия се изпълняват по реда на записването им.

Записвайки този алгоритъм с помощта на език за програмиране, ще получим съответно линейна програма.

За да изпълним алгоритъма е необходимо да въведем и изведем стойностите на ОЗ и ЧЗ и да извършим някои изчисления и присвоявания и да изведем крайния резултат. Подобно е предназначението и на операторите, които езиците за програмиране предоставят за описание на линейни програми.

При съставяне на линейни програми на език за програмиране обикновено се използват следните основни оператори: оператор за въвеждане на начални данни, оператор за присвояване и оператор за извеждане на резултат.

Чрез оператор за извеждане може да извеждаме на екран кратки съобщения или текущата стойност на променливата за момента, в който извикваме този оператор.

Оператора за въвеждане служи за задаване на различни стойности на променливата от клавиатурата по време на изпълнението на програмата.

Чрез оператора за присвояване може да присвояваме различни стойности на променливите в тялото на програмата и по този начин променяме текущата стойност на променливата.

Оператор за присвояване

Оператора за присвояване служи за присвояване на междинни или крайни стойности на променливите. Той се иползва също така и при деклариране на променливите за определяне (задаване) на техните начални стойности.

Синтаксис на оператор за присвояване:

<идентификатор> = <израз>;

, където идентификатора е име на някаква променлива, а израза е израз, който искаме да присвоим на тази променлива.

Стойността на израза трябва да е от множеството на допустимите стойности, характерно за типа на променливата.

При изпълнение на оператора за присвояване първо се намира стойността на израза и след това тя се присвоява на променливата.

Пр. 2.

Нека I и J са декларирани предварително като целочислени променливи, а X и Y като реални:

1. I = (15 % 2) * 2;                  // вярно

2. X = Math.sqrt(I);                 // вярно

3. J = Math.abs(I) + X;           //грешка !

4. Y = – Math.abs(X) + I;        // вярно

5. int I = 100;       // вярно присвояване извършено

//още при деклариране на променливата

6. float X = 3.758;  // вярно присвояване извършено

//още при деклариране на променливата.

В Java са вградени и така наречените “съкратени оператори за присвояване”.

Нека х и у са декларирани променливи от подходящ тип. Съкратените оператори за присвояване са показани в следната таблица:

Оператор за въвеждане на данни

Операторът за въвеждане на данни позволява някои от променливите на изпълняваната програма да получат стойности от външно устройноство. В езика за програмиране Java въвеждането на данни става с помощта на стандартният метод read. Този метод са част от библиотека io на Java и за да можем да ги използваме в тялото на класа, който създаваме, трябва преди да започнем да описваме класа, да посочим, че ще използваме тази библиотека. Това става по следния начин:

import java.io.*; // с този ред посочваме, че ще ползваме //методите на библиотека io.

Методът за въвеждане на данни изглежда по следният начин:

System.in.read();

и чете байт от стандартния входен поток т.е. клавиатурата

Оператор за извеждане на данни

Както споменахме чрез оператора за извеждане на данни на компютърния екран могат да се отпечата стойностите на избрани променливи, като и различни съобщения.

Методите за извеждане на данни изглеждата така:

1. System.out.print(идентификатор [+ идентификатор+…]);

//когато искаме да отпечата стойността на даден

//параметър

1. System.out.print(“Кратко съобщение”);

// когато искаме да отпечата кратко съобщение

Аналогично е за System.out.println(…);

Разликата между методите print и println се състои в това, че при използване на print, след изписване на съобщението или стойността на променливата, указателят остава на същият ред, а при използване на println след изписването, указателят се премества на следвящия ред.

Както и при оператора за въвеждане на данни, за да можем да използваме тези методи, трябва преди това да посочим, че в класа ще се включват методи от библиотека io на Java. Това става отново чрез изписване на следният ред, преди започване описанието на класа:

import java.io.*;

Не е необходимо този ред да се записва за всеки отделен метод. Т.е. щом веднъж сме изписали реда преди описанието на класа, то в тялото на класа можем да използваме методите на библиотеката неограничен брой пъти.

Пр. 3

System.out.print(“have a nice day”); // извеждане на съоб-     // щение на екран.

System.out.println(“Name:” + name1);//извеждане на //съобщение Name и текущата стойност на променлива name1 на

//екран.

System.out.println(age+”,”+name1+”.”); // извежда на //екран стойностите на променливите age и name1, разделени със //запетая  и завършва с точка.

Първа програма (клас) на Java

С помощта на изучените до момента възможности на езика Java ние вече можем да съставяме цялости програми (макар и само линейни).

Нека нашата първа програма да бъде реализация на алгоритъма за изчисляване на сумата на две числа, който съставихме в началото на този урок. С това, че вече имаме готов алгоритъм, работата ни е улеснена до голяма степен, но все пак преди да напишем програмата, е необходимо да уточним от какъв тип и колко на брой са променливите, които ще използваме, за да представим водните данни, междинните и крайните резултати на алгоритъма. В този случай е лесно да се определи, че са ни необходими две реални променливи – за основната и чистата заплата съответно. Ще ги наречем съответно ОZ и CZ. Като използваме вече наученото за операторите за вход, изход и присвояване, лесно достигаме до следната програма (клас):

Във всички случаи, когато се съставя компютърна програма, преди да се премине към нейното непосредствено написване, е необходимо да се уточнят: алгоритъмът на обработката; типът на участващите величини; променливите, представени в програмата и т.н.

Предварителният анализ, планиране и проектиране на програмата могат да се направят просто наум (при по-елементарните задачи), но в повечето случаи е необходимо да отделите време и ресурси за тази цел. Направление на компютърната информатика, което се занимава с изучаването на тези въпроси, е софтуерното инженерство. Предвем на софтуерното инженерство са методите и средствата за планиране, анализ, проектиране, разработване и внедряване на компютърни програми.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.