Sikl — bir yoki bir necha operatorlarni, dasturchi tomonidan o‘rnatilgan shart asosida bir necha marotaba bajarishi tushuniladi. Sikl tugashi uchun, biror bir shart qo‘yiladi va shu shart asosida operatorlar bir necha marotaba bajariladi. Java dasturlash tilida quyidagi sikl operatorlari mavjud: for, while, do-while.

Bularni barchasini birma-bir ko‘rib chiqamiz. Bu darsda «while» va «do-while» sikl operatorlarini o‘rganamiz.

WHILE operatori.

«While» operatori dastur tuzishda ko‘p ishlitiladigan sikl operatori hisoblanadi. Bu operator bir yoki bir necha operatorlar guruhini, qo‘yilgan shart yolg‘on(false)bo‘lguncha bajaradi. Qachonki shart rost bo‘lsa, sikl o‘z ishini boshlaydi va shartdagi qiymatlar sikl ichida o‘zgartirib boriladi. Tushungan bo‘lsangiz, haqiqiy dasturlarda sikl ichida kamida 2 ta operator bo‘ladi, biri biror operator, ikkinchisi shartni o‘zgartirish uchun ishlatiladigan operator.  Sikl opertori ham blok ichiga olinishi mumkin(agar bir necha operatorlar bo‘lsa). Sintaksisi quyidagicha:

while (shart) {
operatorlar bloki
}

Shart har doim mantiqiy qiymat qabul qiladi: rost(true) yoki yolg‘on(false). Blok ichiga istalgancha operatorlar yozish mumkin, yoki umuman yozmaslik ham mumkin.

Odatda, blokdagi operatorlar, sikl tanasi deb yuritiladi. Endi misol ko‘ramiz,

class test{
public static void main(String[] args){
    int son=10;
    while (son<20){
        System.out.println(son);
        son++;
    }
}
}

«int» tipida «son» nomli o‘zgaruvchi e’lon qilinib, «10» soni o‘zlashtirildi. So‘ng sikl boshlandi, bu sikl kiritilgan son(10), «20» sonidan katta bo‘lguncha bajariladi. Sikl tanasida, «son» o‘zgaruvchi qiymati ekranga chiqarilib, bu o‘zgaruvchi bittaga oshirilmoqda(qiymat 11 ga teng bo‘ladi). Shundan so‘ng, kompilyator yana sikl boshiga chiqib, shartni tekshiradi(11<20 rost). Agar, shart rost(true) bo‘lsa, sikl yana ishini davom ettiradi, endi ekranga «11» soni chiqadi va yana «son» o‘zgaruvchi qiymati bittaga oshiriladi(o‘zgaruvchi qiymati 12). Shu tariqa shart yolg‘on bo‘lguncha sikl aylanaveradi.

Qachonki, «son» o‘zgaruvchi qiymati «20«ga teng bo‘lsa, shart yolg‘on qiymatni qaytaradi(20<20 yolg‘on) va sikl o‘z ishini tugatadi.

sikl_1

Agar shart boshidanoq yolg‘on bo‘lsa, sikl umuman ishlamasligi ham mumkin, ya’ni kompilyator sikl tanasiga umuman kiraolmaydi.

class test{
public static void main(String[] args){
    int d=10;
    while (d<10){
        System.out.println(d);
        d++;
    }
}
}

Bu misolda sikl umuman ishlamaydi, chunki (10<10) shart yolg‘on(10=10 bo‘lsa, rost bo‘lar edi) va dastur hech qanday amal bajarmaydi.

sikl_2

Bundan ko‘rinib turibdiki, bu sikl operatorini «sharti avval tekshiriladigan» sikl operatori deyish mumkin ekan.

Ba’zi paytlarda sikl tanasi bo‘lmasligi ham mumkin, agar «while» operatoridan so‘ng nuqta-vergul(;) qo‘yib qo‘ysangiz, sikl tugagan hisoblanadi. Misol,

class test{
public static void main(String[] args){
    int d=10;
    int c=20;
    while (++d < --c);
    System.out.println("Urta qiymat"+d);
}
}

Barcha ishlar «while» ichida amalga oshirilmoqda. «d» o‘zgaruvchi qiymati bittaga oshirilib, «c» o‘zgaruvchi qiymati bittaga kamaytirilmoqda. Ekranga chiqarish operatori esa siklga umuman tegishli emas. Sikl o‘zi ichidagi qiymatlar bilan aylanaveradi, toki «d=15«, «c=15» bo‘lmaguncha. Ular «15» bo‘lgandan so‘ng, shart yolg‘on bo‘ladi va sikl o‘z ishini tugatadi. So‘ng «d» o‘zgaruvchi qiymati ekranga chiqadi. Bunday ayyor yo‘l bilan ikki sonning o‘rta qimatini topish mumkin. Natija,

sikl_3

DO-WHILE operatori.

YUqoridagi «while» sikl operatorida, agar shart yolg‘on bo‘lsa sikl umuman ishlamasligini ko‘rib o‘tdik. Agar shart yolg‘on bo‘lsa ham, sikl tanasidagi operatorlar bir marotaba bajarilishi kerak bo‘lsa, «do-while» sikl operatoridan foydalanamiz. Bu operatorda oldin operatorlar bajariladi, so‘ng siklga qo‘yilgan shart tekshiriladi. Shu sababli sikl tanasi kamida bir marotaba ishlaydi. Bunday siklni  «sharti keyin tekshiriladigan» sikl deyish mumkin. Sintaksisi quyidagicha:

do {
operatorlar bloki;
} while (shart);

Misol ko‘ramiz, yuqoridagi misolni «do-while» orqali yozamiz.

class test{
public static void main(String[] args){
    int d=10;
    do {
    System.out.println("son "+d);
    ++d;
    } while (d<20);
}
}

Ko‘rib turganingizdek, dastlab «do» operatori ichi bajarilmoqda, so‘ng shart bajarilmoqda.

sikl_4

Misolni tushuntirishga xojat yo‘q deb o‘ylayman. Keling endi, shartni yolg‘on qilamiz,

class test{
public static void main(String[] args){
    int d=10;
    do {
    System.out.println("son "+d);
    ++d;
    } while (d<10);
}
}

Shart 10<10 ko‘rinishiga keldi, bu albatta yolg‘on, lekin dastlab «do» operatori ichi bajarilishi lozim, so‘ng shartga o‘tiladi. Demak, shart xato bo‘lsa ham, sikl bir marotaba bajarildi.

sikl_5