НАСЛЕДЯВАНЕ


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

Работа с повече от един клас
Реалните програми използват повече от един клас за решаване на определена задача. Възможни са два подхода за вмъкване на класове – всеки клас да бъде в нов файл или няколко класа да са в един файл. Двата подхода имат следните различия:
1.Няколко класа в един файл:
В този случай само един от класовете може да има име, съвпадащо с името на файла. Именно този клас ще бъде видим от другите файлове и се нарича основен, а останалите класове са помощни. За да са видими, те трябва да бъдат декларирани със служебната дума public.

Пр. 1  
CODE

1 2 3 4 5 6 7 8 9 10 11 12 13

// начало на Example.java class Example {        int a;                void main (String[] arg) {                 Extra e = new Extra();                      …      } } class Extra {      int x;       … } // край на Example.java

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

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

Пр. 2  
CODE

1 2 3 4 5 6

class Base {         ... //определяне на данни и методи } class New extends Base {         ... //определяне на данни и методи }

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

Пр. 3  
CODE

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

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     … }

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

Пр. 3  
CODE

1 2 3 4 5 6

class Base {         //елементи на базовия клас (суперклас) } class New extends Base {         //елементи на извлечения клас (подклас) }

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

Пр. 4
CODE

1 2 3 4 5 6 7 8 9 10 11 12 13

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
CODE

1 2 3 4 5 6 7 8 9 10 11 12 13 14

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

CODE

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

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();    // възможно
        …
       }
}   

ИНТЕРФЕЙС
Освен затварянето на данните и програмите в клас и наследяване на класовете, третата характеристика на обектно-ориентираното програмиране е полиморфизмът. Това е използване на един и същ програмен код за еднакви или подобни действия върху различни данни. Той се реализира при обръщение към метод от обект и в зависимост от типа на параметрите и самия обект се изпълнява един или друг програмен код.

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

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

Пр. 1
CODE

1 2 3 4 5 6 7 8 9 10 11 12 13 14

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
CODE

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

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
CODE

1 2 3 4 5 6

abstract class Shape {         //абстрактния метод getArea() се реализира от // подкласа         public abstract double getArea(); … }

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

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

Пр. 4
CODE

1 2 3

interface Helpable {         public void help(); }

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

Пр. 5
CODE

1 2 3 4 5 6

class Topic implements Helpable {         String strNameTopic;         public void help() {             System.out.println(“Помощ за ”+strNameTopic);         } }

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

CODE

1 2 3

[public]  interface <име> [extends <интерфейс>…]  { //тяло, съдържащо заглавни редове на методи и константи }

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

ПОДАЛГОРИТМИ И ПОДПРОГРАМИ


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

Пр. 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 се допускат два вида подпрограми, наречени съответно процедури и функции т.е. подпрограмите, това са всъщност методите, реализиращи съответния алгоритъм.
Подпрограмите-функции служат за описание на подалгоритми, при изпълнението на които се получава един единствен резултат, който се присвоява на функцията.
Подпрограмите-процедури могат да се използват за получаване на произволен брой резултати, но самата процедура не приема стойност.
Методите на класа имат следният синтаксис:
CODE

1 2 3 4

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

Служебната дума може да бъде една или повече.
В следващата таблица ще обясним приложението на служебните думи:
Служебна дума         Приложение
рublic                  Показва, че метода е достъпен навсякъде, където е достъпен класа, в който е описан.
рrivate                  Показва, че метода не е достъпен за подкласовете.
рrotected                  Показва, че метода е достъпен само за класа, неговите подкласове и пакета.
рrivate protected      Показва, че метода е достъпен само за класа и неговите подкласове.
final                  Показва, че метода не може да се предефинира в подклас.
аbstract                  Показва, че метода няма тяло (реализация).
native                  Показва, че реализацията на метода е направена на език, различен от Java.
synchronized         Показва, че в един момент само една програма може да изпълнява дадения метод.



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

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

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:

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

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

Изпълнение на подпрограми
Дефинирането на една подпрограма определя какво трябва да е нейното действие, но не и кога (при изпълнение на главната програма) да се изпълни това действие.
Изпълнението на подпрограма става чрез нейното извикване от главната програма. Това става чрез името на подпрограмата и списък от фактически параметри, за които тя трябва да бъде изпълнена.
Фактическите параметри, при извикване на подпрограмата, трябва да са толкова на брой, колкото са формалните параметри при нейното описание, като се запазва съответствието между типовете в реда на изброяването им.
Ако в програмата е указано активиране на подпрограма, то на това място се изпълняват операторите от блока на подпрограмата, като формалните параметри се заместват със зададените фактически параметри, т.е. ролята на фактическите параметри е да получат конкретните стойности на входните и изходни данни на подпрограмата.

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

1 2 3 4 5 6 7 8 9

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));

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

ТИП МАСИВ


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

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

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

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

Пр. 1
    CODE

1	int [] ArrInteger = new int[5];

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

Пр. 2
    CODE

1 2	int [] ArrInteger;         //деклариране на променливата масив     ArrInteger = new int[5];  //заделяне на памет за 5 елемента

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

Пр. 3
     CODE

1	ArrInteger[2];

Инициализацията на масива може да се извърши по два начина:
•    Инициализация, чрез присвояване на начални стойности на всеки елемент на масива поотделно:
ArrInteger[0]=10;
ArrInteger[1]=15;
ArrInteger[2]=20;
ArrInteger[3]=21;
ArrInteger[4]=13;
•    Инициализиране при деклариране на масива, без да се използва оператора new:
CODE

1 2	int ArrInteger [] = {10, 15, 20, 21, 13}; boolean array2 [] = {true, false, true};

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

Пр. 4
   CODE

1 2	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  
CODE

1 2 3 4 5 6

•    Извеждане на едномерен масив на екран int myarray [] = {1, 2, 3, 4, 5}; for (int I=0; I<myarray.length; I++)    {        Syatem.out.println(myarray[I]);    }

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

1 2 3 4 5 6 7 8 9

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 Съставете програма, която по дадени стойности х1, х2,..., х12, отговарящи на месечния оборот (в левове) на фирма за всеки от дванадесетте месеца на изминалата година, определя средномесечната стойност на оборота.

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