Java'da döngüler. Sonsuz for (Java) döngüsü
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. İÇİNDE java dili Aşağıdaki döngü türleri vardır:
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. Başka herhangi biri olabilir sayısal tip, örneğin yüzer. 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. İÇİNDE bu durum 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ü yürütme, test koşulunu sağlamayan 12 sayısına ulaştığında, program bu sayıyı atlayacak ve dizinin bir sonraki öğesine geçecektir.
Aynı eylemin birkaç kez veya belirli bir koşula kadar yapılması gerektiğinde, döngüler kurtarmaya gelir.
Java dilinin 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.
Neredeyse tüm programlama dillerinde olduğu gibi, Java'da da belirli bir kod parçasını tekrar tekrar tekrarlamak için araçlar vardır. Bu tür araçlara döngü denir. Java'daki döngüler, while ve for gibi ifadelerle ve bunların varyasyonlarıyla temsil edilir. Döngüler tipik olarak, belirli öğeleri bulmak ve daha sonra bunlar üzerinde işlem yapmak için tek boyutlu ve çok boyutlu diziler ve veri yapılarını yinelemek için kullanılır. Ancak Java döngüsü gibi bir aracı kullanmanın tek yolu bu değildir. Bunlar ele alındıkça kullanım örnekleri verilecektir.
Java while döngüsü: açıklama ve örnekler
While, Java'daki temel döngü ifadesidir. Gövdesi içine alınmış kod parçası, gerçek değeri sağladıktan sonra parantez içindeki ifadenin koşuluna kadar tekrarlanacaktır. While işleci genel olarak aşağıdaki biçime sahiptir: while (koşul)(//döngü gövdesi). Mantıksal koşulun değeri doğru olmaktan çıkar çıkmaz, döngü gövdesindeki kodun yürütülmesi durdurulur. Kontrol hemen ardından gelen hatta aktarılacaktır. Döngü gövdesinde yalnızca bir ifade varsa, kaşlı ayraçlar atlanabilir. Ancak, programcılar arasında bunların her zaman açık olması iyi bir uygulama olarak kabul edilir. Bir örnek verelim:
genel sınıf whileDemo(
System.out.println("1'den 10'a Kadar Sayıları Yazdır");
süre (saymak<=10) {
System.out.println(sayı);
Başlangıçta bildirilen değişken sayısı 1 değerine sahiptir. Daha sonra, operatörün adından sonra parantez içine alınmış bir mantıksal ifade görürüz. Değer true ise, sayma değişkeninin değeri 10'a eşit veya küçük olana kadar döngü true döndürür. Her geçişte veya yinelemede, değişkenin değeri 1 artacak ve konsol ekranında görüntülenecektir. Değişkenin değeri 11 değerine ulaştığında döngü sonlandırılmıştır. Count değişkeninin değeri başlangıçta 11 olsaydı, döngü koşulu yanlış olurdu. Program vücuda bile girmiyordu. Java sözdiziminin, gövde olmadan bir While deyimi kullanmayı mümkün kıldığına dikkat edilmelidir. Aşağıdaki örneği ele alalım. Diyelim ki iki değişkeniniz var: i=100 ve j=200. Aritmetik ortalamalarını programlı olarak hesaplama göreviyle karşı karşıyayız, bu amaçla "boş" while döngüsünü kullanabilirsiniz:
(++i<- — j);
Bu işlemin sonucunda, bu iki değişkenden herhangi birinin değeri, başlangıç değerlerinin ortalamasına eşit olacaktır. Bu örnekte de görebileceğiniz gibi, döngü bir gövde olmadan sorunsuz çalıştı ve koşullu ifadede gerekli tüm eylemleri gerçekleştirdi.
do while döngüsü
Önceki örneklerde, koşul ifadesi false döndürürse, program döngü gövdesini yok sayar ve yürütmeye devam eder. Ancak bazen, koşul ifadesinin doğruluğundan bağımsız olarak, döngü gövdesinde bulunan kodun yürütülmesinin en az bir kez zorunlu olduğu durumlar ortaya çıkar. Başka bir deyişle, bazen koşullu ifadenin doğruluğunu döngünün sonunda değil, başında kontrol etmek gerekir. Benzer işlevsellik, do-while koşullu adına sahip bir tür while döngüsü tarafından sağlanabilir. Aşağıdaki biçime sahiptir: do (// döngü gövdesi) while (koşul). Gördüğünüz gibi, burada önce döngü gövdesi yürütülür ve ardından koşulun doğruluğu kontrol edilir. Bu, her yinelemede yapılır. Yukarıdaki kod, while durumunda olduğu gibi çalışacaktır. Ancak sayma değişkenini 11 olarak ayarlasaydık, döngünün gövdesi, ifade ifadenin doğruluğunu test etmeden önce yine de bir kez yürütülürdü.
Örnekler ve açıklama: for - Java döngüsü
For döngüsü, Java dilinde çok yönlü ve verimli bir dil biçimidir. JavaSDK'nın 5. sürümüne kadar, for ifadesinin yalnızca bir geleneksel biçimi vardı. Ondan sonra yeni bir tane çıktı - foreach. Bu bölümde, operatörün geleneksel formuna odaklanacağız. Java'daki for döngüsü şöyle görünür:
için (inti=0; ben<10; i++) {//Loop statements to be executed
Kontrol, döngü sonundaki koda aktarılmadan önce sayaç görevi gören i değişkeni başlatılır. Ardından, sayacın belirli bir değerle karşılaştırıldığı koşullu ifadeyi kontrol etmeniz gerekir. Program true döndürürse, döngünün gövdesi yürütülür. Bu durumda sayacın değeri önceden belirlenmiş bir adım kadar değiştirilir ve koşullu ifade yeniden kontrol edilir. Bu, koşul yanlış olana kadar devam eder. Daha iyi anlamak için, döngünün nasıl çalıştığına dair bir örnek. Java için.
halka açık sınıf ForLoops(
genel statik geçersiz main(String args)(
niyet_değeri=11;
için; // n öğeli "bir şey" türünde bir dizi oluştur
for(int ben = 0; ben< n; i++){
dizi[i] = yeniBirşey(); // "bir şey" yarat ve onu bir diziye koy
}
Bir Java döngüsünden nasıl çıkılır
Döngüden çıkmak için, ara - "kes", devam - "devam ettir" ve geri dön - "geri dön" anahtar kelimeleri vardır. Break komutu, programı döngüyü izleyen ifadeleri yürütmesi için değiştirir. Java'da döngüyü kırma koşulları, if-dallanma yoluyla yapılır. Ana şey, kontrolün döngü gövdesinin ana kısmından önce yapılmasıdır.
//m dizisini oluşturduktan sonra şunu yazıyoruz:
için(a:m)(
eğer (a==5) kırılırsa;
System.out.println(a);
}
Java'daki dal ve döngü işleçleri genellikle birlikte çalışır: döngüyü başlatırız ve içinde, döngüyü kırmamız veya başka bir şey yapmamız gereken koşulun hala karşılanıp karşılanmadığını kontrol ederiz.
İç içe bir döngüde break kullanırsanız, yalnızca iç içe döngü bozulur, dıştaki döngü ise çalışmaya devam eder.
Java'da bir for döngüsünün yinelemesini kırmak için devam kullanılır. Program kendisine ulaştığında iterasyonun tamamlanmamış kısmını atlar, sayacı günceller ve bir sonraki iterasyona geçer.
While yapılarında, aynı devam farklı çalışır: bizi döngüye devam etme koşulunu kontrol etmeye döndürür. Başka bir komut - dönüş - programı, yöntemin çağrıldığı ve döngünün bulunduğu yere döndürür.
Hem devam et hem de ara, bir etiketle - kodun istenen kısmına atlamak için - goto'ya benzer şekilde kullanılabilir:
breakMark1; //Mark1'in daha yüksek bir yerde olduğunu varsayarsak:
Java sonsuz döngü
Sonsuz bir döngü oluşturmak kolaydır - sadece şunun için parametreleri dışarıda bırakın:
için (; ;) ()
Bundan faydalanmak daha zordur. Genellikle döngünün sonsuzluğu, programın çalışmasını engelleyen kritik bir hatadır. Bu nedenle, her döngünün doğru zamanda doğru şekilde tamamlanıp tamamlanmadığı kontrol edilmelidir. Bunun için ihtiyacınız var:
- döngü gövdesinde kesme koşullarını belirtin,
- break koşulundaki değişkenin döngünün durdurulacağı bir değer alabildiğinden emin olun.
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ım edebileceğini.
Adından da anlaşılacağı gibi bir döngü, aynı kod parçasını gerekli sayıda çalıştırmanın bir yoludur (ancak kodu döngüde 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 bu değişkene "10" değerini atadı. 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 sonsuz bir döngü kullanmamız gerekiyorsa, ancak hangi noktada ondan çı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 koşullu ifadeyi kontrol ederek döngünün kapanış kaşlı ayracından sonra kaldığı yerden devam etmek yerine, burada olduğu gibi 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, başlatmak için biraz daha fazla manipülasyon gerektirdiğinden. Ö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şkende değişiklik 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.