Java döngüsünü kırmak. Java'da döngüler. Örnekler ve açıklama: for - Java döngüsü

Aynı eylemin birkaç kez veya belirli bir koşula kadar yapılması gerektiğinde, döngüler kurtarmaya gelir.

İÇİNDE java dili Döngü oluşturmanın birkaç yolu vardır. Tahmin edebileceğiniz gibi, hepsini dikkate alacağız.

Bir döngü bildirmenin ilk yolu, aşağıdaki yapıyı kullanmaktır: for (döngü başlangıç ​​koşulu; bitiş koşulu; döngünün gideceği adım) ( döngü gövdesi )

Hemen örneklere geçelim. Diyelim ki "merhaba dünya" ifadesini 10 kez gösterme görevimiz var. Döngü kullanmıyorsanız, sadece System.out.println("Hello world"); yazabilirsiniz. on kez ve sorunu çöz. Bunun için döngüleri kullanalım. Yeni bir sınıf oluşturun ve örneğin CuclesInJava olarak adlandırın. Şimdi bir döngü koşulu (0 olsun), 10'luk bir bitiş koşulu ve bir adım bildirin. Adım adım gideceğiz. Döngünün gövdesine System.out.println("Hello world"); satırını koyun.

İşte bir örnek kod:

Bu kodun sonucu, "Merhaba dünya!" ifadesinin art arda 10 satırı olacaktır.

Daha karmaşık bir şey yazmaya ne dersiniz? Temel olanları zaten öğrendik. Onları kullanalım.

Adım + bazı değişkenler 5'e eşit olduğunda her seferinde bir uyarı içeren bir satır görüntüleyecek basit bir uygulama yazalım. Çok kötü bir hayal gücüm var))

Öncelikle konsoldan girilen bir değişkeni girdi olarak kabul edecek bir kod yazalım. Bir önceki yazıda bu kodun bir örneğini vermiştim ve daha sonra nasıl çalıştığını ve nereden geldiğini anlatacağım konusunda anlaşmıştık. Şimdilik, sadece kullanacağız:

Ardından, sıfırdan başlayıp ona kadar sayacak bir döngü yazmanız gerekir (önceki örnekte olduğu gibi). Döngü gövdesinde, bu değişkenin 5'e eşit olup olmadığını kontrol edecek bir koşullu ifade yazıyoruz ve öyleyse, "OK" dizesini görüntüleyeceğiz. İşte sahip olduklarım:

java.util.Scanner'ı içe aktarın;

genel sınıf CuclesInJava(

int değişken = tarayıcı.nextInt(); //buna yavaş yavaş ulaşacağız ve sonra nasıl çalıştığı netleşecek

için (int ben = 1 ; ben< 10 ; i++ ) {

int yeniDeğişken = i + değişken;

if (newVariable== 5) (

Pek iyi olmadı. Bu örnekle dallar ile birlikte döngüleri nasıl kullanabileceğinizi göstermek istedim.

Döngüleri bildirmenin bir sonraki yolu while(koşul doğrudur)(yürütülecek kod bloğu) iledir. Bu tasarımın başka bir formu var:

do(yürütülecek kod bloğu) while(koşul doğru). Birinci ve ikinci arasındaki fark, koşulun doğru olup olmadığına bakılmaksızın ikincinin bir döngü yürütmesidir. Kendiniz düşünebilirsiniz: önce kodu çalıştırırız ve sonra durumu kontrol ederiz. Ve koşul doğru olmasa bile, kod yine de bir kez, yapının ilk formunda koşul ilk kez kontrol edildiğinde yürütülecek ve doğru olana kadar kod yürütülmeyecektir.

Kod sezgisel olmalıdır. Bence while ve do-while yapılarıyla şunları yapabileceğinizi belirtmekte fayda var: "döngü" döngüden çıkış koşulunu kaydetmezseniz veya yanlış kaydederseniz program. Yukarıdaki örneğe bakın ve i- yerine i++ yazsaydım ne olurdu bir düşünün; veya i>0 yerine, i<0. Моя программа никогда не вышла бы из цикла и продолжала бы выводить строку Hello world! до тех пор, пока не завис компьютер. Поэтому, будьте очень осторожными с циклами и всегда следите, чтобы из них Ваша программа могла выйти или закончить работу.

Peki, do-while ile bir örnek:

Bununla ilgili makaleyi bitirebileceğimizi düşünüyorum. Java'da döngüler. Gördüğünüz gibi tasarımlar çok karmaşık değil ama oldukça kullanışlı. Dizilere ve dizilere aşina olduğumuzda özellikle faydalı olacaklar.

Java While Do döngüsü, aynı kod parçasını birden çok kez çalıştırmanıza izin veren bir ifadedir. Bu döngü, koşullar karşılandığında eylemleri tekrarlamak için kullanılabilir.

döngü sırasında

Java dilinde inşa edilmesi en kolay olan while döngüsüdür. Bir while anahtarı, bir döngü koşulu ve bir döngü gövdesinden oluşur:

while (koşul) ( // döngü gövdesi)

Döngü gövdesinin her ayrı çalıştırması bir yineleme olarak ele alınır. Her yinelemeden önce, döngü koşulları değerlendirilir. Gövdesi, yalnızca değerlendirmedeki döngünün koşulu true ise yürütülür.

Döngünün yinelemeleri bir şeyi değiştirir ve bir noktada koşul false olarak değerlendirilir ve ardından döngü sona erer. Koşulu hiçbir zaman yanlış döndürmeyen bir döngü, sonsuz sayıda yürütülür. Bu tür döngülere sonsuz denir.

Örnek

int sayı = 0; süre (say< 10) { System.out.println(num); num++; }

Bu örnek, 0 ile 9 arasındaki sayıları verir. Adım adım kodu inceleyelim. İlk olarak, num değişkenini 0 değeriyle başlatıyoruz. Bu döngü sayacı olacaktır. Program while değerine ulaştığında döngünün durumu değerlendirilir. Bizim durumumuzda 0< 10 возвращает значение true и исполняется тело цикла. Внутри цикла выводится переменная num , а затем увеличивается на 1 . На этом завершается первая итерация.

İlk çalıştırmadan sonra, Java While Loop koşulu ikinci kez değerlendirilir. 1< 10 по-прежнему возвращает true , после чего запускается следующая итерация цикла. Один и тот же процесс повторяется несколько раз.

Son yineleme, num'un değeri 9 olduğunda başlar. Döngü sayacı son kez yazdırılır ve değer 10'a yükseltilir. Bu kez, döngü koşulu false olarak değerlendirdiğinden yeni bir yineleme başlatılamaz. 10, 10'dan küçük olmadığı için.

Böylece, döngü koşulu sağlandığı sürece döngü çalışır. Bu bilgiyle donanmış olarak, daha karmaşık ve işlevsel döngüler oluşturabilirsiniz. Diziyi yineleyelim:

Dize adları = ("Doc", "Aptal", "Utangaç", "Huysuz", "Apşırık", "Uykulu", "Mutlu"); int dizini = 0; iken (dizin< names.length) { System.out.println(names); index++; }

Bu örneğin konsepti öncekine benzer. Döngü sayacını başlatıyoruz ve tüm öğeler görüntülenene kadar dizi üzerinde yinelemeye başlıyoruz. Sonuç olarak, diziler üzerinde yineleme yapmak oldukça yaygındır ve Java'nın bunun için daha uygun bir yapısı vardır, For döngüsü.

do while döngüsü

Java while do döngüsü while döngüsüne benzer, ancak önemli bir farkı vardır: while döngüsünden farklı olarak, burada koşul her yinelemenin sonunda kontrol edilir. Bu, do-while döngüsünün her zaman en az bir kez yürütüldüğü anlamına gelir:

do ( // döngü gövdesi) while (koşul);

Örnek

do-while, önce döngünün gövdesini çalıştırır, ardından koşullarını değerlendirir. Sonuca bağlı olarak döngü durur veya bir sonraki iterasyon başlar. Basit bir isim tahmin etme oyununa bakalım:

Tarayıcı tarayıcı = yeni Tarayıcı(System.in); Dize tahmini; do ( System.out.print("Adını tahmin et: "); tahmin et = tarayıcı.nextLine(); ) while (!"Daffy Duck".equals(tahmin et)); System.out.println("Tebrikler! Adımı tahmin ettiniz!");

Bu Java örneği, system.ini'den girişi ayrıştırmak için Tarayıcı'yı kullanırken. Bu, çoğu durumda klavyeyle etkileşime giren standart giriş kanalıdır. Basitçe söylemek gerekirse, oyuncunun girdiği metni okuruz.

Oyun, kullanıcıya en az bir kez sormanızı ve oyuncu doğru cevapları girdiği sürece bunu yapmanızı gerektirir. do-while döngüsü bu tür durumlar için idealdir. Döngünün gövdesinde kullanıcı değerini alıyoruz ve ardından cevabın doğruluğu kontrol ediliyor. Döngü, kullanıcının girişi Daffy Duck değerine eşit olana kadar çalışmalıdır. Doğru cevap alınırsa döngü durur ve oyuncuyu zaferinden dolayı tebrik ederiz.

Sonuç olarak

Bu yayın makalenin bir çevirisidir " Beş Dakikada Java'nın While ve Do-While Döngüleri» arkadaş canlısı bir proje ekibi tarafından hazırlanmıştır

Döngü, bir programın birçok kez tekrar eden bir parçasıdır.

Java'da iki tür döngü vardır: "while" türü ve "n-times" türü.

İlk tür olan "kadar", bir koşul sağlanana kadar bazı eylemleri tekrarlamak için tasarlanmıştır. Örnek: bir sayıyı üç basamak olana kadar 5 artırın.

İkinci tip "n-kez", bazı eylemleri önceden belirlenmiş sayıda tekrarlamak için tasarlanmıştır. Örnek: Bir sayıyı kendisi ile 4 kez çarpın.

While Döngüsü (while ve do...while ifadeleri)

While ifadesi, parametresi doğru olduğu sürece belirtilen eylemleri tekrarlar.

Örneğin, böyle bir döngü 4 kez yürütülecek ve ekranda "1 2 3 4" görüntülenecektir:

int ben = 1; iken (ben< 5) { System.out.print(i + " "); i++; }

Böyle bir döngü asla yürütülmez ve ekranda hiçbir şey gösterilmez:

int ben = 1; iken (ben< 0) { System.out.print(i + " "); i++; }

Böyle bir döngü süresiz olarak yürütülecek ve ekranda "1 2 3 4 5 6 7 ..." görüntülenecektir:

int ben = 1; while (doğru) ( ​​System.out.print(i + " "); i++; )

Döngünün tekrarlanıp tekrarlanmayacağına karar veren koşul, döngünün her adımından önce ve ilk adımdan önce kontrol edilir. Ne oluyor diyorlar ön onay koşullar.

ile bir süre döngüsü var doğrulama sonrası koşullar. Yazmak için do ... while deyimleri kullanılır.

Böyle bir döngü 4 kez yürütülecek ve ekranda “2 3 4 5” görüntülenecektir:

< 5);

Böyle bir döngü 1 kez yürütülecek ve ekranda "2" görüntülenecektir:

int ben = 1; do ( i++; System.out.print(i + " "); ) while (i< 0);

do...while döngüsünün gövdesi en az bir kez yürütülür. Bu ifade, programdaki bazı eylemlerin en az bir kez gerçekleştirilmesi gerektiğinde, ancak belirli koşullar altında birçok kez tekrarlanması gerektiğinde kullanışlıdır.

Aşağıdaki programa göz atın (bir segmentten rastgele bir tamsayı tahmin eder ve kullanıcıdan klavyeden seçenekler girerek bunu tahmin etmesini ister, kullanıcı sayıyı tahmin edene kadar, program ona tahmin edilen sayıdan daha fazla veya daha azını söyler. kullanıcının girdiği değerden daha fazla):

java.util.Scanner'ı içe aktarın; public class Main ( public static void main(String args) ( // prog - program tarafından oluşturulan sayı // kullanıcı - kullanıcı tarafından girilen sayı int prog, kullanıcı; // 1'den 10'a kadar rastgele bir tamsayı oluştur prog = (int)(Math.random() * 10) + 1; System.out.println("1'den 10'a kadar bir sayı tahmin ettim, tahmin edin."); System.out.print("Numaranızı giriniz: ") ; Tarayıcı girişi = yeni Tarayıcı( System.in); // Giriş akışında bir tamsayı olup olmadığını kontrol edin if(input.hasNextInt()) ( do ( // Giriş akışından bir tamsayı okuyun user = input.nextInt( ); if(user == prog) ( System.out.println("Doğru tahmin ettiniz!"); ) else ( // Sayının aralık içinde olup olmadığını kontrol edin if (user > 0 && user<= 10) { System.out.print("Вы не угадали! "); // Если число загаданное программой меньше... if(prog < user) { System.out.println("Моё число меньше."); } else { System.out.println("Моё число больше."); } } else { System.out.println("Ваше число вообще не из нужного отрезка!"); } } } while(user != prog); } else { System.out.println("Ошибка. Вы не ввели целое число!"); } System.out.println("До свиданья!"); } }

Programda aşağıdaki değişiklikleri yapın:

Program kesimden bir sayı düşünmeli, ancak sıfır hariç [−10;10] segmentinden bir tamsayı düşünmelidir. Aynı zamanda, program tarafından üretilen rasgele sayıların dağılımının tek tip olmasını sağlamaya çalışın (yani, sıfırın düşmesi durumunda, başka bir sayıyla, örneğin 1 ile değiştirilemez, çünkü o zaman 1 geri kalan sayılardan iki kat olasılıkla düşecektir).

Program pozitif bir sayı tahmin ederse ve kullanıcı negatif bir sayı girerse, program kullanıcıya işarette bir hata yaptığını sormalıdır. Ve tam tersi.

Döngü tipi "n-times" (ifade için)

for ifadesi üç parametre içerir. Birincisi başlatma, ikincisi tekrarlama koşulu ve üçüncüsü yineleme olarak adlandırılır.

For (başlatma; koşul; yineleme) ( // döngü gövdesi, yani döngüsel olarak tekrarlanan eylemler)

İlk parametrede, genellikle, döngünün tekrar sayısının sayılacağı bir değişken seçilir. Sayaç denir. Sayaca bir miktar başlangıç ​​değeri verilir (hangi değerden değişeceğini gösterirler).

İkinci parametrede, sayaç üzerindeki bazı kısıtlamalar belirtilir (hangi değere değişeceğini gösterirler).

Üçüncü parametre, döngünün her adımından sonra sayacı değiştiren bir ifade belirtir. Genellikle bu bir artış veya azalmadır, ancak sayaca yeni bir değer atanacak herhangi bir ifadeyi kullanabilirsiniz.

Döngünün ilk adımından önce sayaca bir başlangıç ​​değeri atanır (başlatma gerçekleştirilir). Bu sadece bir kez olur.

Döngünün her adımından önce (ancak başlatmadan sonra), tekrar koşulu kontrol edilir, doğruysa döngü gövdesi bir kez daha yürütülür. Aynı zamanda, ilk kontrol sırasında koşul yanlış olsa bile, döngü gövdesi bir kez bile çalıştırılamayabilir.

Döngünün her adımının tamamlanmasından sonra ve bir sonraki adımın başlamasından önce (ve dolayısıyla tekrar koşulu kontrol edilmeden önce) bir iterasyon gerçekleştirilir.

Aşağıdaki program 1'den 100'e kadar sayıları ekrana yazdırır:

için (int ben = 1; ben<= 100; i++) { System.out.print(i + " "); }

Aşağıdaki program 10'dan -10'a kadar olan sayıları ekrana yazdırır:

(int s = 10; s > -11; s--) için ( System.out.print(s + " "); )

Sunulan program 1'den 33'e kadar tek sayıları görüntüler:

için (int ben = 1; ben<= 33; i = i + 2) { System.out.print(i + " "); }

Sunulan program, dizi parçası 2, 4, 6, 8, ... 98, 100'ün öğelerinin toplamını hesaplayacaktır. Yani:

int toplam = 0; // Burada sonucu toplayacağız (int j = 2; j

Sunulan program bir değişkenden bir sayı yükseltecek A değişkenden doğal güce N:

Çift a = 2; int n = 10; çift ​​çözünürlük = 1; // Burada sonucu toplayacağız (int i = 1; i<= n; i++) { res = res * a; } System.out.println(res);

Sunulan program 2n+2 dizisinin ilk 10 elemanını gösterecek, burada n=1, 2, 3…:

için (int ben = 1; ben< 11; i++) { System.out.print(2*i + 2 + " "); }

Sunulan program, a 1 =3 olmak üzere 2a n−1 +3 dizisinin ilk 10 öğesini gösterecektir:

int a = 3; için (i=1; ben<=10;i++) { System.out.print(a + " "); a = 2*a + 3; }

Bir döngüde, aynı anda birkaç sayaç ayarlayabilirsiniz. Bu durumda, yinelemedeki ve başlatmadaki birkaç ifade virgülle ayrılır. Yalnızca bir yineleme koşulu belirtebilirsiniz, ancak bu, aynı anda birkaç sayaç içeren bir ifade olabilir.

Sunulan program, a 1 =3 olmak üzere 2a n−1 -2 dizisinin ilk 10 öğesini gösterecektir:

için (int a=3, i=1; i<=10; a=2*a-2, i++) { System.out.print(a + " "); }

Sunulan program aşağıdaki "0 -1 -4 -9 -16 -25" sırasını gösterecektir:

(int a=0, b=0; a-b) için<=10; a++, b--) { System.out.print(a*b + " "); }

Döngü sonlandırma erken (break deyimi)

Döngü gövdesi içindeki operatörü çağırırsanız, hem "while" tipi döngü hem de "n-times" tipi döngü programın ilerisinde tamamlanabilir. kırmak. Bu durumda, döngüden anında çıkış gerçekleşir, mevcut adım tamamlanmasa bile (yani, aradan sonra başka ifadeler varsa, bunlar yürütülmez).

Aşağıdaki örnek sonucunda ekranda sadece "1 2 3 4 End" rakamları görüntülenecektir:

için (int a=1; a

Program döngüyü beşinci kez çalıştırdığında (döngüye 5'e eşit bir sayaçla girer), hemen kontrol edilecek ve break ifadesinin yürütüleceği koşul doğru olacaktır. Döngü gövdesinin geri kalanı (ekrana çıktı) artık üretilmeyecek: program, döngüden sonra ve sonrasında belirtilen işlemlerin yürütülmesine hemen devam edecektir.

Break deyiminin yardımıyla kasıtlı olarak sonsuz bir döngüyü kesebilirsiniz. Örnek (ekranda “100 50 25 12 6 3 1 0” görüntülenecek ve bundan sonra döngü duracaktır):

int = 100; while (true) ( ​​​​System.out.print(s + " "); s = s / 2; if(s == 0) ( break; ) )

Break deyimini yalnızca bir koşul oluştuğunda çağırmak mantıklıdır, aksi takdirde döngü ilk adımında programın ilerisinde sonlandırılacaktır.

int bir; for (a=25; a>0; a--) ( break; System.out.print(a + " "); ) System.out.print("a=" + a);

Yukarıdaki örnekte, ekrana döngüdeki çıktı bir kez bile olmayacak ve değişken A döngüden sonra ekranda görüntülenir, değerinin hiç değişmediği ortaya çıkar, yani “a=25” (ve başka bir şey) görüntülenmez.

Değişkenin döngü başlamadan önce bildirildiğine de dikkat edin. Döngü parametrelerinde bir değişken bildirildiğinde, onun dışında erişilemez olduğu ortaya çıkar ve bu durumda, döngünün bitiminden sonra sayacın hangi değere sahip olacağını bulmak için aksi gerekliydi.

Görevler

1000 1003 1006 1009 1012 1015 … dizisindeki dört basamaklı sayıların tümünü gösteren bir program yazınız.

1 3 5 7 9 11 13 15 17 … dizisinin ilk 55 elemanını gösteren bir program yazınız.

90 85 80 75 70 65 60 … dizisinin negatif olmayan tüm elemanlarını gösteren bir program yazınız.

2 4 8 16 32 64 128 … dizisinin ilk 20 elemanını gösteren bir program yazınız.

a 1 =2 olmak üzere 2a n-1 -1 dizisinin 10000'den küçük tüm terimlerini yazdırın.

a 1 = -166 olmak üzere 2a n-1 +200 dizisinin tüm iki basamaklı terimlerini yazdırın.

Kullanıcının klavyeden girdiği n doğal sayısının faktöriyelini hesaplayan bir program yazınız.

Kullanıcı tarafından klavyeden girilen bir doğal sayının tüm pozitif bölenlerini görüntüleyin.

Kullanıcının klavyeden girdiği doğal sayının asal olup olmadığını kontrol edin. Gereksiz işlemler yapmamaya çalışın (örneğin, önemsiz olmayan en az bir bölen bulduktan sonra, sayının bileşik olduğu zaten açıktır ve kontrol etmeye devam etmenize gerek yoktur). Ayrıca, eğer varsa, bir doğal sayının (n) en küçük böleninin zorunlu olarak doğru parçasında yer aldığına dikkat edin.

a 1 =3 ve a 2 =2 olmak üzere 2a n-2 -2 dizisinin ilk 12 elemanını görüntüleyen bir program yazın.

Fibonacci dizisinin ilk 11 terimini görüntüleyin. Dizinin birinci ve ikinci terimlerinin bire eşit olduğunu ve sonraki her birinin bir önceki iki terimin toplamı olduğunu hatırlatırız.

Kullanıcı tarafından klavyeden girilen bir doğal sayı için, tüm rakamlarının toplamını hesaplayın (sayıda kaç basamak olacağı önceden bilinmemektedir).

N şehrinde tramvayla seyahat, yırtma kağıt biletlerle yapılıyor. Her hafta, tramvay deposu, yerel matbaadan 000001 ile 999999 arasında numaralar içeren bir rulo bilet sipariş eder. "Şanslı" bir bilet, sayının ilk üç hanesinin toplamının son rakamın toplamına eşit olduğu bilettir. örneğin 003102 veya 567576 numaralı biletlerde olduğu gibi üç haneli. Tramvay deposu, her şanslı biletin sahibine bir hediyelik eşya vermeye karar verdi ve şimdi kaç hediyelik eşyanın gerekli olacağını merak ediyor. Programı kullanarak, bir ruloda kaç tane şanslı bilet olduğunu sayın?

City N, 50.000 farklı rafa sahip büyük bir depoya sahiptir. Depo yönetimi, işçilerin rahatlığı için yerel matbaadaki her raf için 00001'den 50000'e kadar numaralı bir plaka sipariş etmeye karar verdi, ancak plakalar basıldığında matbaanın 2 sayısını basmadığı ortaya çıktı. bir arıza nedeniyle, bu nedenle bir veya daha fazla iki içeren tüm plakalar (örneğin, 00002 veya 20202) - yeniden yazılmalıdır. Bu hatalı plakalardan kaçının kusurlu bir lotta olduğunu sayan bir program yazınız.

Elektronik saat, zamanı 00:00 - 23:59 formatında gösterir. İki nokta üst üstenin solunda iki nokta üst üstenin sağında gösterilen simetrik bir kombinasyonun günde kaç kez gösterildiğini hesaplayın (örneğin, 02:20, 11:11 veya 15:51).

Amerikan ordusunda 13 sayısı şanssız kabul edilir ve Japonlarda - 4. Uluslararası tatbikatlardan önce, Rus ordusunun karargahı 4 veya 13 rakamlarını içeren askeri teçhizat numaralarını hariç tutmaya karar verdi (örneğin, 40123, 13313, 12345 veya 13040) yabancı meslektaşları utandırmamak için. Ordunun emrinde 100.000 birim askeri teçhizat varsa ve her savaş aracının 00001 ile 99999 arasında bir numarası varsa, o zaman kaç numaranın hariç tutulması gerekecek?

2010, Alexey Nikolaevich Kostin. Moskova Devlet Pedagoji Üniversitesi Matematik Fakültesi TIDM Bölümü.

Son güncelleme: 31.10.2018

Diğer bir kontrol yapısı türü döngülerdir. Döngüler, belirli koşullara bağlı olarak, belirli bir eylemi birçok kez gerçekleştirmeye izin verir. Java dili aşağıdaki döngü türlerine sahiptir:

döngü için

for döngüsü aşağıdaki resmi tanıma sahiptir:

([sayaç başlatma]; [koşul]; [sayaç değişikliği]) ( // işlemler ) için

Döngü için bir standart düşünün:

için (int ben = 1; ben< 9; i++){ System.out.printf("Квадрат числа %d равен %d \n", i, i * i); }

Döngü bildiriminin ilk bölümü olan int i = 1, counter i'yi oluşturur ve başlatır. Sayacın int türünde olması gerekmez. Float gibi başka herhangi bir sayısal tür olabilir. Döngü yürütülmeden önce sayaç değeri 1'e eşit olacaktır. Bu durumda, değişken bildirimi ile aynıdır.

İkinci kısım, döngünün yürütüleceği koşuldur. Bu durumda, i 9'a ulaşana kadar döngü çalışacaktır.

Üçüncü kısım ise sayacı birer birer artırmaktır. Yine, birer birer artırmamıza gerek yok. Şunları azaltabilirsiniz: i-- .

Sonuç olarak döngü bloğu, i'nin değeri 9 olana kadar 8 kez çalışacak ve her seferinde bu değer 1 artacaktır.

Bir döngü bildirirken tüm koşulları belirtmek zorunda değiliz. Örneğin, şöyle yazabiliriz:

int ben = 1; for (; ;)( System.out.printf("%d'nin karesi %d'dir \n", i, i * i); )

Döngünün tanımı aynı kalır, ancak artık tanımdaki bloklar boştur: for (;;) . Artık başlatılmış sayaç değişkeni, koşul yoktur, bu nedenle döngü sonsuza kadar sürecektir - sonsuz bir döngü.

Veya birkaç bloğu atlayabilirsiniz:

int ben = 1; için (; ben<9;){ System.out.printf("Квадрат числа %d равен %d \n", i, i * i); i++; }

Bu örnek ilk örneğe eşdeğerdir: bizim de bir sayacımız var, sadece döngünün dışında yaratılıyor. Bir döngü yürütme koşulumuz var. Ve zaten for bloğunun kendisinde sayaçta bir artış var.

for döngüsü aynı anda birden çok değişkeni tanımlayabilir ve yönetebilir:

int n = 10; for(int i=0, j = n - 1; ben< j; i++, j--){ System.out.println(i * j); }

döngü yap

do döngüsü önce döngü kodunu çalıştırır ve ardından while deyimindeki koşulu kontrol eder. Ve bu koşul doğru olduğu sürece döngü tekrar eder. Örneğin:

int = 7; do( System.out.println(j); j--; ) while (j > 0);

Bu durumda döngü kodu, j sıfır olana kadar 7 kez çalışacaktır. do döngüsünün, while deyimindeki koşul doğru olmasa bile eylemlerin en az bir kez yürütüleceğini garanti ettiğini not etmek önemlidir. Yani, şunu yazabiliriz:

int j = -1; do( System.out.println(j); j--; ) while (j > 0);

j başlangıçta 0'dan küçük olsa da, döngü yine de bir kez yürütülür.

döngü sırasında

While döngüsü hemen bir koşulun doğruluğunu kontrol eder ve koşul doğruysa döngü kodu yürütülür:

int = 6; while (j > 0)( System.out.println(j); j--; )

ifadeleri devam ettir ve kes

Break deyimi, döngü işini bitirmemiş olsa bile istediğiniz zaman döngüden çıkmanızı sağlar:

Örneğin:

< nums.length; i++){ if (nums[i] >10) mola; System.out.println(sayılar[i]); )

Döngü, dizi öğesinin 10'dan büyük olup olmadığını kontrol ettiğinden, son iki öğeyi konsolda görmeyeceğiz, çünkü nums[i] 10'dan büyük olduğunda (yani, 12'ye eşit), break deyimi çalışacaktır. ve döngü sona erecek.

Doğru, 10'dan küçük olan son elemanı da görmeyeceğiz. Şimdi, sayı 10'dan büyükse döngü bitmeyecek, sadece bir sonraki elemana gidecek şekilde yapacağız. Bunu yapmak için, devam deyimini kullanırız:

int sayılar = yeni int ( 1, 2, 3, 4, 12, 9 ); için (int ben = 0; ben< nums.length; i++){ if (nums[i] >10) devam; System.out.println(sayılar[i]); )

Bu durumda, döngünün yürütülmesi, test koşulunu sağlamayan 12 sayısına ulaştığında, program bu sayıyı atlayacak ve dizinin bir sonraki öğesine geçecektir.

Bu öğreticide, farklı döngü türlerine bakarak kodumuzun bölümlerini kontrollü bir şekilde nasıl yeniden çalıştıracağımızı öğreneceğiz. java. Döngüler hakkında daha fazla bilgi edinin: sırasında, Yapmak-sırasında, için. Hangi durumlarda hangi döngülerin kullanıma en uygun olduğunu belirlemeye çalışacağız.

Daha sonra rastgele sayılar konusuna kısaca göz atacağız ( rastgelesayılar). Şuna bakalım java-Sınıf Rastgele ve oyunumuzda bize nasıl yardımcı olabileceğini.

Adından da anlaşılacağı gibi bir döngü, aynı kod parçasını gerekli sayıda yürütmenin bir yoludur (döngüde kodu yürütmenin sonucu mutlaka tekrar edilmeyecektir). Döngü yürütmesinin tekrar sayısı ya önceden belirlenebilir ya da programcının kendisi tarafından bilinmeyebilir. Dilin kullanmamızı önerdiği ana döngü türlerini ele alacağız. Java. Ve sonra bazılarını oyunumuza dahil edeceğiz, böylece onu geliştireceğiz.

döngü sırasında

Döngü sırasında en basit sözdizimine sahiptir. Hatırlamak eğer- biraz önce incelediğimiz talimatlar. Koşullu operatör ifadesinde eğer(kelimeden sonra parantez içinde eğer) hemen hemen her operatör ve değişken kombinasyonunu koyabilirsiniz. İfade doğruysa ( doğru), ardından bloğun gövdesindeki kod eğer infaz edilecek. Benzer şekilde, bir döngüde sırasında değerlendirilebilecek bir ifade koyduk. doğru veya YANLIŞ, bu kodda gösterildiği gibi:

int x = 10; while(x > 0)( x--; //x, döngünün her yinelemesinde bir azalır)

Burada neler oluyor? Döngünün dışındaki ilk şey sırasında bir değişken bildirdik X tip int ve bunu atadı değişken değer"10". Sonra döngü başlar sırasında, yazıldığı durumda “ x > 0”- bu, döngü gövdesinde yazılan kodun sırasında değişken olduğu sürece yürütülecek X Daha 0 ve koşul değere ulaşmayacak YANLIŞ. Bu nedenle, kod 10 kez çalıştırılacaktır(x=10,x>0 ; x=9,x>0 ; x=8,x>0 ; x=7,x>0 ; x=6,x>0 ; x=5 ,x>0 ; x=4,x>0 ; x=3,x>0 ; x=2,x>0 ; x=1,x>0). Döngünün ilk geçişinde x=10, saniyede 9 , üçüncüde 8 vesaire. Ve ne zaman X eşit olacak 0 , bu durumda döngüye girme koşulu sağlanmaz ve program döngü bitiminden sonraki satırdan devam eder.

Operatördeki ile aynı eğer, döngünün bir kez bile yürütülmeyeceği bir durum mümkündür. Aşağıdaki örneğe bir göz atın:

int x = 10; while(x > 10)( //bazı kodlar //ancak x 10'dan büyük olana kadar asla çalışmaz)

Ek olarak, koşul ifadesinin karmaşıklığı veya döngü gövdesine yazılabilecek kod miktarı konusunda herhangi bir kısıtlama yoktur:

int oyuncuYaşamları = 3; int yabancı Gemiler = 10; while(playerLives >0 && alienShips >0)( //Tüm oyun kodları burada //... //... // etc. ) //playerLives veya alienShips = 0 olduğunda program burada devam edecek

Bu döngü, değişkenlerden biri oyuncuLives, veya yabancıGemiler sıfıra eşit veya sıfırdan küçük olmayacaktır. Bu koşullardan biri oluşur oluşmaz, koşuldaki ifade şu değeri alacaktır: YANLIŞ döngü sona erdikten sonra program bir sonraki satırdan devam edecektir.

Program döngü gövdesine girdikten sonra, döngü koşulu şu duruma gelse bile yürütüleceğini belirtmekte fayda var: YANLIŞ, döngü gövdesinde bir yerde, çünkü koşul yalnızca girişte kontrol edilir:

int x = 1; while(x > 0)( x--; //x şimdi 0 ve koşul bir dahaki sefere yanlış olarak değerlendirilecek //Ama bu satır yürütülecek //Ve bu //Ve hatta bu )

Yukarıdaki örnekte, döngünün gövdesi bir kez yürütülecektir. Ek olarak, döngünün sonsuza kadar çalışması için bir koşul belirleyebilirsiniz - buna denir sonsuz döngüİşte bir örnek:

int x = 0; while(true)( x++; //Gerçekten büyüyeceğim!)

Döngülerinden çıkın. anahtar kelime kırmak

Ya gerçekten kullanmamız gerekirse Sonsuz döngü, ancak ne zaman çıkacağımıza karar verebilmemiz için. Bu amaçla içinde java bir anahtar kelime var kırmak. Kullanabiliriz kırmak döngüden "çıkmamız" gerektiğinde:

int x = 0; while(true)( x++; //Gerçekten büyüyeceğim! break; //Hayır, yapmayacaksın! //koda buradan ulaşılmayacak)

gibi farklı karar verme araçlarını birleştirmenin mümkün olduğunu zaten tahmin etmişsinizdir. eğer,başka,anahtar döngümüzün içinde sırasında ve aşağıda ele alacağımız diğer döngüler. Örneğin:

int x = 0; int çokBüyük = 10; while(true)( x++; //çok büyüyeceğim! if(x == tooBig)( break; //Hayır, yapmayacaksın. ) //buradaki kod x 10 olana kadar kullanılabilir olacak)

Daha birçok farklı varyasyon yazabilirsiniz ama bizim için daha önemli. pratik kullanım bu bilgi, bu yüzden şimdi derine inmeyeceğiz. Bir döngüde çalıştırılabilen başka bir konsepte bakalım.

anahtar kelime devam etmek

devam etmek neredeyse aynı şekilde çalışır kırmak. anahtar kelime devam etmek sizi döngünün gövdesinden atacak, ancak döngünün kapanış kaşlı ayracı sonrasında kaldığı yerden devam etmek yerine, koşullu ifadeyi kontrol edin. kırmak. Aşağıdaki örnek kullanımını gösterir devam etmek:

int x = 0; int çokBüyük = 10; int tooBigToPrint = 5; while(true)( x++; //çok büyüyeceğim! if(x == tooBig)( break; ) //Hayır, büyümeyeceksin. //buradaki kod sadece x 10 olana kadar mevcut olacak if(x > = tooBigToPrint)( //artık ekrana yazdırılmayacak ama döngü devam edecek; ) //buradaki kod x 5 olana kadar geçerli olacak //x'i ekrana yazdıracak kod )

Açıklama: değişkenleri bildirir ve başlatırız. Döngüye giriyoruz - değişkenin değerine ekleyin X birim (şimdi X= 1). "1, 10 mu?" — YANLIŞ- ilk operatör eğer yapılmaz. Sonraki Kontrol"1, 5'ten büyük veya ona eşit mi?" — YANLIŞ- ikinci operatör eğer yapılmaz. Çıktı X ekrana.

Durumu düşünün ne zaman X döngüye girerken 5 değerini alacaktır. Döngüye giriyoruz - değişkenin değerine ekleyin X birim (şimdi X= 6). "6, 10 mu?" — YANLIŞ- ilk operatör eğer yapılmaz. Bir sonraki kontrol "6, 5'ten büyük veya eşittir?" — doğru- vücuda girmek eğer — devam etmek, döngüden çıkın ve döngü giriş koşulunu kontrol edin.

Şimdi seçenek ne zaman X döngüye girerken 9 değerini alacaktır. Döngüye giriyoruz - değişkenin değerine ekleyin X birim (şimdi X= 10). "10 mu 10?" — doğru- vücuda girmek eğer — kırmak, döngüden çıkın ve kod döngünün kapanış kaşlı parantezinin arkasında devam edecek sırasında.

do while döngüsü

Bir özellik dışında önceki döngü ile hemen hemen aynı - koşullu ifade, döngü gövdesinden sonra kontrol edilecektir. Bunun anlamı, döngü Yapmak-sırasında her zaman en az bir kez yürütülür. Bir örneğe göz atın:

int x = 0; do ( x++; ) while(x< 10); //x теперь = 10

anahtar kelimeler kırmak,devam etmek

döngü için

Döngü için olduğundan daha karmaşık bir sözdizimine sahiptir. sırasında Ve Yapmak-sırasında, çünkü onu başlatmak biraz daha fazla manipülasyon gerektiriyor. Önce bir göz atalım, sonra parça parça ayıralım:

için(int ben = 0; ben< 10; i++){ //Что-то, что должно произойти 10 раз будет записано здесь }

Derleyici bunu nasıl görüyor? Bunun gibi:

For(bildirim ve başlatma; koşul; döngünün her yinelemesinden sonra değişiklik)( // döngü gövdesi)

• Bildirim ve başlatma- yeni bir tane oluşturduk tip değişkeni int isim ile Ben ve ona değer atadı 0 ;
• Durum– daha önce tartışılan diğer döngüler gibi, burada döngüye girme koşulunu kontrol ediyoruz. Değer olarak hesaplanırsa doğru, ardından döngü gövdesine giriyoruz;
• Değiştirmek her döngüden sonra- yukarıdaki örnekte Ben++ döngünün bir sonraki geçişinden sonra değişkenin değerine ulaştığımız anlamına gelir Ben bir (1) ekleyin. Ayrıca, değişken değişikliğinde yazabiliriz ve Ben— birini çıkarmak için, örneğin:

anahtar kelimeler kırmak,devam etmek bu döngüde de kullanılabilir.

Döngü için başlatma, durum kontrolü ve değişken değiştirme kontrolünü ele alır. Bu döngüyü tanıdıktan hemen sonra uygulamamızda pratik olarak deneyelim. rastgele numaralar Ve yöntemler.