CodeGym /Blog Java /rawak /Penyata Sementara
John Squirrels
Tahap
San Francisco

Penyata Sementara

Diterbitkan dalam kumpulan
Program pertama kami ialah urutan arahan yang dilaksanakan satu demi satu. Tiada garpu. Ini termasuk HelloWorld, yang memaparkan ucapan salam. Ia termasuk pengiraan aritmetik. Selepas program pertama kami, kami belajar cara membuat cawangan, iaitu cara membuat program melakukan tindakan yang berbeza bergantung pada keadaan tertentu. Berikut ialah kod untuk mengawal sistem pemanasan dan penyaman udara pusat:

if (tempRoom>tempComfort)
    airConditionerOn();
if (tempRoom<tempComfort)
    heaterOn();
Ambil langkah seterusnya. Dalam kehidupan seharian, kita sering melakukan tindakan berulang yang seragam, contohnya, mengupas epal untuk pai. Proses yang menarik ini boleh digambarkan sebagai:
  1. Sekiranya terdapat epal dalam mangkuk, maka kami melaksanakan langkah 1.1 hingga 1.4:

    1. 1.1. Ambil sebiji epal
    2. 1.2. Kupas dan potong menjadi kepingan
    3. 1.3. Susun hirisan epal dalam kerak pai dalam kuali
    4. 1.4. Kembali ke langkah 1.
Penyataan sementara - 2Katakan anda mempunyai sepuluh biji epal, dua tangan dan satu pisau. Dalam kehidupan sebenar, anda mengupas keseluruhan sedozen secara berurutan, mengikut algoritma yang sama untuk setiap epal. Tetapi bagaimana kita membuat program melakukan tindakan berulang untuk setiap epal?
  • Kami mengikat diri kami dengan bilangan epal, tetapi jika kami tidak mempunyai jumlah yang mencukupi, maka beberapa arahan akan dilaksanakan tanpa "muatan" (dan kami mungkin memotong diri kami semasa cuba mengupas epal yang tidak wujud).
  • Jika terdapat lebih banyak epal daripada arahan untuk mengupas, maka beberapa epal akan dibiarkan tidak dikupas.
  • Kod sedemikian sukar dibaca. Ia mempunyai banyak ulangan dan sukar untuk diubah suai.

Gelung ialah pernyataan yang membenarkan tindakan dilakukan berulang kali

Gelung while Java akan berfungsi dengan baik dalam kes kami. Konstruk ini meletakkan pelbagai tindakan ke dalam struktur yang ringkas dan mudah difahami. Menggunakan gelung sementara , algoritma penghirisan epal untuk pai mungkin kelihatan seperti ini di Jawa:

while (numberOfApplesInBowl > 0) {
    apple = bowl.grabNextApple();
    arrangeInPie(apple.peel().slice());
    numberOfApplesInBow--; // "--" is the decrement operator, which reduces the number of apples by one
}
System.out.println("The apples for the pie have been processed.");

Sintaks arahan

Varian pertama pernyataan while adalah seperti ini:

while (Boolean expression) {
	// Loop body — the statement(s) that are repeatedly executed
}
Berikut ialah penjelasan langkah demi langkah tentang perkara yang berlaku apabila kod ini dilaksanakan:
  1. Kami menilai ungkapan Boolean yang terdapat dalam kurungan selepas kata kunci while .
  2. Jika ungkapan Boolean dinilai kepada benar, maka pernyataan dalam badan gelung dilaksanakan. Selepas pernyataan terakhir dalam badan gelung dilaksanakan, maka kita pergi ke langkah 1
  3. Jika ungkapan Boolean dinilai palsu, maka kita melompat ke pernyataan pertama selepas gelung sementara .

Gelung dengan prasyarat

Oleh kerana kita sentiasa menilai ungkapan Boolean (syarat untuk memasuki gelung) sebelum kita melaksanakan badan gelung, bentuk gelung while ini sering dipanggil gelung dengan prasyarat . Mari kita bina jadual sepuluh kuasa pertama nombor:

public static void main(String[] args) {
    int base = 3; // The number that will be exponentiated
    int result = 1; // The result of exponentiation
    int exponent = 1; // The initial exponent
    while (exponent <= 10) { // The condition for entering the loop
        result = result * base;
        System.out.println(base + " raised to the power of " + exponent + " = " + result);
        exponent++;
    }
}
Output konsol:

3 raised to the power of 1 = 3
3 raised to the power of 2 = 9
3 raised to the power of 3 = 27
3 raised to the power of 4 = 81
3 raised to the power of 5 = 243
3 raised to the power of 6 = 729
3 raised to the power of 7 = 2187
3 raised to the power of 8 = 6561
3 raised to the power of 9 = 19683
3 raised to the power of 10 = 59049
Process finished with exit code 0

Gelung dengan postcondition

Berikut ialah varian kedua gelung ini:

do {
    // Loop body — the statement(s) that are repeatedly executed
} while (Boolean expression);
Berikut ialah penjelasan tentang perkara yang berlaku apabila kod ini dilaksanakan:
  1. Badan gelung dilaksanakan (sejurus selepas kata kunci do ).
  2. Kami menilai ungkapan Boolean yang terdapat dalam kurungan selepas kata kunci while .
  3. Jika ungkapan Boolean dinilai kepada benar, maka kita pergi ke langkah 1
  4. Jika ungkapan Boolean dinilai palsu, maka kita melompat ke pernyataan pertama selepas gelung sementara .
Dua perbezaan utama daripada gelung sebelumnya ialah: 1) badan gelung dilaksanakan sekurang-kurangnya sekali dan 2) ungkapan Boolean dinilai selepas badan gelung dilaksanakan. Sehubungan itu, gelung while jenis ini dipanggil gelung dengan postcondition . Kali ini kami akan memaparkan jadual kuasa nombor yang tidak melebihi 10000:

public static void main(String[] args) {
    int base = 3; // The number that will be exponentiated
    int result = base; // The result of exponentiation
    int exponent = 1; // The initial exponent
    do {
        System.out.println(base + " raised to the power of " + exponent + " = " + result);
        exponent++;
        result = result * base;
    } while (result < 10000); // The condition for exiting the loop
}
Output konsol:

3 raised to the power of 1 = 3
3 raised to the power of 2 = 9
3 raised to the power of 3 = 27
3 raised to the power of 4 = 81
3 raised to the power of 5 = 243
3 raised to the power of 6 = 729
3 raised to the power of 7 = 2187
3 raised to the power of 8 = 6561
Process finished with exit code 0
Beri perhatian kepada perubahan dalam kod. Bandingkan ini dengan gelung dengan prasyarat.

Fakta menarik tentang bekerja dengan gelung

Pernyataan bercabang dalam badan gelung

Terdapat dua pernyataan yang mempengaruhi pelaksanaan dalam gelung: break (yang akan kita bincangkan dengan lebih terperinci dalam bab seterusnya) dan teruskan.
  • teruskan — melangkau pelaksanaan seluruh badan gelung dalam lelaran semasa dan melompat ke penilaian ungkapan Boolean pernyataan sementara. Jika ungkapan bernilai benar, maka gelung diteruskan.
  • putus — segera menamatkan pelaksanaan lelaran semasa dan memindahkan kawalan ke pernyataan pertama selepas gelung. Oleh itu, pernyataan ini menamatkan pelaksanaan gelung semasa. Kami akan mempertimbangkannya dengan lebih terperinci dalam artikel seterusnya.
Ingat contoh buah kita. Jika kami tidak pasti kualiti epal, kami boleh menukar kod menggunakan pernyataan continue :

while (numberOfApplesInBowl > 0) {
    apple = bowl.grabNextApple();
    numberOfApplesInBow--; // "--" is the decrement operator, which reduces the number of apples by one
    if (apple.isBad()) { // This method returns true for rotten apples
        apple.throwInGarbage();
        continue; // Continue the loop. Jump to evaluation of numberOfApplesInBowl > 0
    }
    arrangeInPie(apple.peel().slice());
}
Pernyataan continue sering digunakan apabila pernyataan dalam badan gelung perlu dilaksanakan jika syarat tertentu dipenuhi. Sebagai contoh, kita mungkin mahu melakukan tindakan apabila penderia perkakasan dicetuskan (jika tidak, teruskan gelung di mana kita mengambil bacaan penderia) atau kita mungkin mahu mengira ungkapan hanya pada lelaran tertentu bagi gelung. Contoh kes terakhir boleh dilihat dalam penggunaan gelung sementara untuk mengira jumlah kubus nombor asli yang kuasa duanya kurang daripada bilangan nombor. keliru? Semak kod berikut:

public static void main(String[] args) {
    int sum = 0;  // Total amount
    int i = 0;  // Initial number in the series
    int count = 20;  // Number of numbers
    while (i <= count) {
        i++;  // Get the next number — "i++" is equivalent to "i = i + 1"
        if (i * i <= count)  // If the square of the number is less than
            continue;  // the number of numbers, then we won't calculate the sum
                            // Jump to the next number in the loop
        sum += i * i * i;  // Otherwise, we calculate the sum of the cubes of numbers
    }  // "sum += i * i * i" is notation that is equivalent to "sum = sum + i * i * i"
    System.out.println(sum);  // Print the result
}

Gelung tak terhingga

Pernyataan bercabang ini paling kerap digunakan dalam gelung tak terhingga. Kami memanggil gelung tak terhingga jika keadaan Boolean untuk keluar dari gelung tidak pernah berpuas hati. Dalam kod, ia kelihatan seperti ini:

while (true) {
    // Loop body 
}
Dalam kes ini, pernyataan putus membantu kami keluar dari gelung. Jenis gelung ini sesuai apabila menunggu keadaan luaran yang ditentukan di luar badan gelung. Contohnya, dalam sistem pengendalian atau permainan (keluar dari gelung bermakna keluar dari permainan). Atau apabila menggunakan algoritma yang mencuba, dengan setiap lelaran gelung, untuk menambah baik beberapa hasil, tetapi mengehadkan bilangan lelaran berdasarkan masa berlalu atau kejadian peristiwa luaran (cth pemeriksa, catur atau ramalan cuaca). Ingat bahawa dalam keadaan biasa gelung tak terhingga tidak diingini. Untuk menunjukkan, mari kembali kepada eksponen:

public static void main(String[] args) {
    int base = 3; // The number that will be exponentiated
    int result = 1; // The result of exponentiation
    int exponent = 1; // The initial exponent
    while (true) {
        result = result * base;
        System.out.println(base + " raised to the power of " + exponent + " = " + result);
        exponent++;
        if (exponent > 10)
            break; // Exit the loop
    }
}
Output konsol:

3 raised to the power of 1 = 3
3 raised to the power of 2 = 9
3 raised to the power of 3 = 27
3 raised to the power of 4 = 81
3 raised to the power of 5 = 243
3 raised to the power of 6 = 729
3 raised to the power of 7 = 2187
3 raised to the power of 8 = 6561
3 raised to the power of 9 = 19683
3 raised to the power of 10 = 59049
Process finished with exit code 0

Gelung bersarang

Dan sekarang kita sampai ke topik terakhir kita tentang gelung. Ingat pai epal itu (saya harap anda tidak lapar pada masa ini) dan gelung mengupas epal kami:
  1. Sekiranya terdapat epal dalam mangkuk, maka kami melaksanakan langkah 1.1 hingga 1.4:

    1. 1.1. Ambil sebiji epal
    2. 1.2. Kupas dan potong menjadi kepingan
    3. 1.3. Susun hirisan epal dalam kerak pai dalam kuali
    4. 1.4. Kembali ke langkah 1.
Mari kita terangkan proses penghirisan dengan lebih terperinci:
  1. Bilangan kepingan = 0
  2. Selagi bilangan kepingan adalah < 12, maka lakukan langkah 2.1 hingga 2.3

    1. 2.1. Potong satu lagi kepingan epal
    2. 2.2. Bilangan kepingan++
    3. 2.3. Kembali ke langkah 2
Dan kami akan menambah ini pada algoritma membuat pai kami:
  1. Jika terdapat epal dalam mangkuk, maka kami melaksanakan langkah 1.1 hingga 1.6:

    1. 1.1. Ambil sebiji epal
    2. 1.2. Kupas ia
    3. 1.3. Bilangan kepingan = 0
    4. 1.4. Selagi bilangan kepingan adalah < 12, maka lakukan langkah 1.4.1 hingga 1.4.3
      1. 1.4.1. Potong satu lagi kepingan epal
      2. 1.4.2. Bilangan kepingan++
      3. 1.4.3. Kembali ke langkah 1.4
    5. 1.5. Susun hirisan epal dalam kerak pai dalam kuali
    6. 1.6. Kembali ke langkah 1.
Sekarang kita mempunyai gelung dalam gelung. Binaan seperti ini sangat biasa. Sebagai contoh terakhir, mari kita bina salah satu jadual pendaraban yang kita pelajari untuk mencintai di sekolah rendah.

 public static void main(String[] args) {
    // Print the second factors in a row
    System.out.println("    2  3  4  5  6  7  8  9"); 
    int i = 2;  // Assign the first factor to the variable
    while (i < 10) {  // First loop: execute as long as the first factor is less than 10
        System.out.print(i + " | ");  // Print the first factor at the beginning of the line
        int j = 2;  // The starting value of the second factor
        while (j < 10) { // Second loop: execute as long as the second factor is less than 10
            int product = i * j;  // Calculate the product of the factors
            if (product < 10)  // If the product is a single digit, then we print two spaces after the product
                System.out.print(product + "  ");
            else  // Otherwise, print the product and one space after it
                System.out.print(product + " ");
            j++;  // Increment the second factor by one
        }  // Go to the beginning of the second loop, i.e. "while (j < 10)"
        System.out.println();  // Move to the next line on the console
        i++;  // Increment the first factor by one
    } // Go to the beginning of the first loop, i.e. "while (i < 10)"
}
Output konsol:

    2  3  4  5  6  7  8  9
2 | 4 6 8 10 12 14 16 18
3 | 6 9 12 15 18 21 24 27
4 | 8 12 16 20 24 28 32 36
5 | 10 15 20 25 30 35 40 45
6 | 12 18 24 30 36 42 48 54
7 | 14 21 28 35 42 49 56 63
8 | 16 24 32 40 48 56 64 72
9 | 18 27 36 45 54 63 72 81
Process finished with exit code 0
Gelung (khususnya, pernyataan while ) adalah salah satu blok binaan asas perisian. Dengan menyelesaikan tugasan pada CodeGym, anda akan mempelajari semua jenis gelung yang berbeza, memahami selok-beloknya dan memperoleh kemahiran praktikal dalam menggunakannya.
Komen
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION