1. ์šฐ๋ฆฌ ์‚ถ์˜ ๊ณ ๋ฆฌ

๋งค์šฐ ์ž์ฃผ ์šฐ๋ฆฌ์˜ ์‚ถ์€ ์šฐ๋ฆฌ๊ฐ€ ๊ฐ™์€ ํ–‰๋™์„ ์—ฌ๋Ÿฌ ๋ฒˆ ์ˆ˜ํ–‰ํ•˜๋„๋ก ์š”๊ตฌํ•ฉ๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด ๋งŽ์€ ํŽ˜์ด์ง€๋กœ ๊ตฌ์„ฑ๋œ ๋ฌธ์„œ๋ฅผ ์Šค์บ”ํ•ด์•ผ ํ•œ๋‹ค๊ณ  ๊ฐ€์ •ํ•ฉ๋‹ˆ๋‹ค. ๋™์ผํ•œ ์ ˆ์ฐจ๋ฅผ ๋ฐ˜๋ณตํ•ด์„œ ๋ฐ˜๋ณตํ•ฉ๋‹ˆ๋‹ค.

  • ์Šค์บ๋„ˆ์— ์ฒซ ํŽ˜์ด์ง€ ๋„ฃ๊ธฐ
  • ์Šค์บ” ๋ฒ„ํŠผ์„ ๋ˆ„๋ฅด์„ธ์š”
  • ์Šค์บ๋„ˆ์— ๋‹ค์Œ ํŽ˜์ด์ง€ ๋„ฃ๊ธฐ

์ด๊ฒƒ์€ ์ˆ˜๋™์œผ๋กœ ์ˆ˜ํ–‰ํ•˜๊ธฐ ์–ด๋ ต์Šต๋‹ˆ๋‹ค. ์ด ํ”„๋กœ์„ธ์Šค๊ฐ€ ์–ด๋–ป๊ฒŒ๋“  ์ž๋™ํ™”๋  ์ˆ˜ ์žˆ๋‹ค๋ฉด ์ข‹์„ ๊ฒƒ์ž…๋‹ˆ๋‹ค.

๋˜๋Š” ๋‹ค๋ฅธ ์˜ˆ๋ฅผ ๊ณ ๋ คํ•˜์‹ญ์‹œ์˜ค. ๋ฐ›์€ ํŽธ์ง€ํ•จ์—์„œ ์ฝ์ง€ ์•Š์€ ๋ชจ๋“  ์ด๋ฉ”์ผ์„ ์ŠคํŒธ์œผ๋กœ ํ‘œ์‹œํ•˜๊ณ  ์‹ถ๋‹ค๊ณ  ๊ฐ€์ •ํ•ด ๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค. ์˜›๋‚  ์˜›์ ์— ๊ฐ ์ด๋ฉ”์ผ์„ ํ•œ ๋ฒˆ์— ํ•˜๋‚˜์”ฉ ์„ ํƒํ•˜๊ณ  ์ŠคํŒธ์œผ๋กœ ํ‘œ์‹œํ•ด์•ผ ํ–ˆ์Šต๋‹ˆ๋‹ค.

๊ทธ๋Ÿฌ๋‚˜ ํ”„๋กœ๊ทธ๋ž˜๋จธ๋Š” ๊ฒŒ์œผ๋ฅด๊ธฐ ๋•Œ๋ฌธ์— ์˜ค๋ž˜ ์ „์— ์ด ํ”„๋กœ์„ธ์Šค๋ฅผ ์ž๋™ํ™”ํ–ˆ์Šต๋‹ˆ๋‹ค. ์ด์ œ ๋ฌธ์ž ๋ชฉ๋ก์„ ์„ ํƒํ•˜๊ณ  "์ŠคํŒธ์œผ๋กœ ํ‘œ์‹œ"๋ฅผ ํด๋ฆญํ•˜๋ฉด ์ด๋ฉ”์ผ ํด๋ผ์ด์–ธํŠธ๊ฐ€ ๋ชฉ๋ก์„ ํ†ตํ•ด ๊ฐ ์ด๋ฉ”์ผ์„ ์ŠคํŒธ ํด๋”๋กœ ์ด๋™ํ•ฉ๋‹ˆ๋‹ค.

์—ฌ๊ธฐ์„œ ๋ฌด์—‡์„ ๋งํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๊นŒ? ์ปดํ“จํ„ฐ๋‚˜ ํ”„๋กœ๊ทธ๋žจ์ด ํ•œ ๋ฒˆ์˜ ํด๋ฆญ์œผ๋กœ ์ˆ˜๋ฐฑ ๋˜๋Š” ์ˆ˜์ฒœ ๊ฐœ์˜ ๋‹จ์กฐ๋กœ์šด ์ž‘์—…์„ ์‹คํ–‰ํ•  ์ˆ˜ ์žˆ์„ ๋•Œ ๋งค์šฐ ํŽธ๋ฆฌํ•ฉ๋‹ˆ๋‹ค. ์ด์ œ ์ด ์ž‘์—…์„ ์ˆ˜ํ–‰ํ•˜๋Š” ๋ฐฉ๋ฒ•๋„ ๋ฐฐ์šฐ๊ฒŒ ๋ฉ๋‹ˆ๋‹ค.


2. while๋ฃจํ”„

if-else ๋ฌธ์€ ํ”„๋กœ๊ทธ๋ž˜๋ฐ ๊ธฐ๋Šฅ์„ ํฌ๊ฒŒ ํ™•์žฅํ•˜์—ฌ ๋‹ค์–‘ํ•œ ์ƒํ™ฉ์—์„œ ๋‹ค์–‘ํ•œ ์ž‘์—…์„ ์ˆ˜ํ–‰ํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•  ์ˆ˜ ์žˆ๊ฒŒ ํ–ˆ์Šต๋‹ˆ๋‹ค. ๊ทธ๋Ÿฌ๋‚˜ ์šฐ๋ฆฌ ํ”„๋กœ๊ทธ๋žจ์„ ํ›จ์”ฌ ๋” ๊ฐ•๋ ฅํ•˜๊ฒŒ ๋งŒ๋“œ๋Š” ๋˜ ํ•˜๋‚˜์˜ ์š”์†Œ๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค. ๋ฐ”๋กœ ๋ฃจํ”„์ž…๋‹ˆ๋‹ค .

Java ์—๋Š” while, for๋ฐ ์˜ 4๊ฐ€์ง€ ์ข…๋ฅ˜์˜ ๋ฃจํ”„๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค . ์ด์ œ ๊ทธ ์ค‘ ์ฒซ ๋ฒˆ์งธ๋ฅผ ํŒŒํ—ค์ณ ๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.for-eachdo-while

๋ฃจํ”„ while๋Š” ๋งค์šฐ ๊ฐ„๋‹จํ•ฉ๋‹ˆ๋‹ค. ์กฐ๊ฑด ๊ณผ ๋ฃจํ”„ ๋ณธ๋ฌธ ์˜ ๋‘ ๋ถ€๋ถ„์œผ๋กœ๋งŒ ๊ตฌ์„ฑ๋ฉ๋‹ˆ๋‹ค . ๋ฃจํ”„ ๋ณธ๋ฌธ์€ ์กฐ๊ฑด์ด ์ธ ํ•œ ๋ฐ˜๋ณตํ•ด์„œ ์‹คํ–‰๋ฉ๋‹ˆ๋‹ค true. ์ผ๋ฐ˜์ ์œผ๋กœ while๋ฃจํ”„๋Š” ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

while (condition)
   statement;
while๋‹จ์ผ ๋ช…๋ น๋ฌธ์ด ์žˆ๋Š” ๋ฃจํ”„ ์— ๋Œ€ํ•œ ํ‘œ๊ธฐ๋ฒ•
while (condition)
{
   block of statements
}
while๋ช…๋ น๋ฌธ ๋ธ”๋ก์ด ์žˆ๋Š” ๋ฃจํ”„ ์— ๋Œ€ํ•œ ํ‘œ๊ธฐ๋ฒ•

๋งค์šฐ ๊ฐ„๋‹จํ•ฉ๋‹ˆ๋‹ค. ๋ฌธ ๋˜๋Š” ๋ฌธ ๋ธ”๋ก์€ ๋ฃจํ”„ ์กฐ๊ฑด ์ด ๊ฐ™์„ ๋•Œ๊นŒ์ง€ ๋ฐ˜๋ณตํ•ด์„œ ์‹คํ–‰๋ฉ๋‹ˆ๋‹ค .true

์ž‘๋™ ๋ฐฉ์‹์€ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค. ๋จผ์ € ์กฐ๊ฑด์„ ํ™•์ธํ•ฉ๋‹ˆ๋‹ค. ์ฐธ์ด๋ฉด ๋ฃจํ”„ ๋ณธ๋ฌธ์ด ์‹คํ–‰๋ฉ๋‹ˆ๋‹ค( ๋ฌธ ๋˜๋Š” ๋ฌธ ๋ธ”๋ก ). ๊ทธ๋Ÿฐ ๋‹ค์Œ ์กฐ๊ฑด์ด ๋‹ค์‹œ ํ™•์ธ๋˜๊ณ  ๋ฃจํ”„ ๋ณธ๋ฌธ์ด ๋‹ค์‹œ ์‹คํ–‰๋ฉ๋‹ˆ๋‹ค. ์กฐ๊ฑด ์ด ๊ฑฐ์ง“์ด ๋  ๋•Œ๊นŒ์ง€ ๊ณ„์†ํ•ฉ๋‹ˆ๋‹ค .

์กฐ๊ฑด์ด ํ•ญ์ƒ true ์ด๋ฉด ํ”„๋กœ๊ทธ๋žจ ์‹คํ–‰์ด ์ค‘์ง€๋˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค. ๋ฃจํ”„์— ์˜๊ตฌ์ ์œผ๋กœ ๊ณ ์ •๋ฉ๋‹ˆ๋‹ค.

๋งจ ์ฒ˜์Œ ํ™•์ธํ–ˆ์„ ๋•Œ ์กฐ๊ฑด์ด ๊ฑฐ์ง“ ์ด๋ฉด ๋ฃจํ”„ ๋ณธ๋ฌธ์ด ํ•œ ๋ฒˆ๋„ ์‹คํ–‰๋˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค.


3. ๋ฃจํ”„์˜ ์˜ˆ

๋‹ค์Œ์€ ์‹คํ–‰ ์ค‘์ธ ๋ฃจํ”„์˜ ๋ช‡ ๊ฐ€์ง€ ์‹ค์šฉ์ ์ธ ์˜ˆ์ž…๋‹ˆ๋‹ค.

์•”ํ˜ธ ์„ค๋ช…
int n = 5;
while (n > 0)
{
   System.out.println(n);
   n--;
}
ํ™”๋ฉด์— 5์ค„์ด ํ‘œ์‹œ๋ฉ๋‹ˆ๋‹ค.
5
4
3
2
1
์•”ํ˜ธ ์„ค๋ช…
int  n = 0;
while (n < 10)
{
   System.out.println(n);
   n++;
}
ํ™”๋ฉด์— 10์ค„์ด ํ‘œ์‹œ๋ฉ๋‹ˆ๋‹ค.
0
1
...
8
9
์•”ํ˜ธ ์„ค๋ช…
Scanner console = new Scanner(System.in);
while(console.hasNextInt())
{
   int x = console.nextInt();
} 
ํ”„๋กœ๊ทธ๋žจ์€ ์ˆซ์ž๊ฐ€ ์ž…๋ ฅ๋˜๋Š” ํ•œ ํ‚ค๋ณด๋“œ์—์„œ ์ˆซ์ž๋ฅผ ์ฝ์Šต๋‹ˆ๋‹ค.
์•”ํ˜ธ ์„ค๋ช…
while (true)
   System.out.println("C");
ํ”„๋กœ๊ทธ๋žจ์€ ํ™”๋ฉด์— ๋ฌธ์ž๋ฅผ ๋์—†์ด ์ธ์‡„ํ•ฉ๋‹ˆ๋‹ค.C
์•”ํ˜ธ ์„ค๋ช…
Scanner console = new Scanner(System.in);
boolean isExit = false;
while (!isExit)
{
   String s = console.nextLine();
   isExit = s.equals("exit");
}
ํ”„๋กœ๊ทธ๋žจ์€ ํ‚ค๋ณด๋“œ์—์„œ ์ค„์„ ์ฝ์Šต๋‹ˆ๋‹ค.

exit๋“ค์–ด๊ฐˆ ๋•Œ ๊นŒ์ง€ .

์•ž์˜ ์˜ˆ์—์„œ equals()๋ฉ”์„œ๋“œ๋Š” ๋ฌธ์ž์—ด์„ ๋น„๊ตํ•˜๋Š” ๋ฐ ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค. ๋ฌธ์ž์—ด์ด ๊ฐ™์œผ๋ฉด ํ•จ์ˆ˜๋Š” ๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค true. ๋ฌธ์ž์—ด์ด ๊ฐ™์ง€ ์•Š์œผ๋ฉด ๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค false.



4. ๋ฃจํ”„ ๋‚ด ๋ฃจํ”„

์กฐ๊ฑด๋ฌธ์— ๋Œ€ํ•ด ๋ฐฐ์šฐ๋ฉด์„œ ์กฐ๊ฑด๋ฌธ์„ ์—ฌ๋Ÿฌ ์กฐ๊ฑด๋ฌธ์„ ๊ฒฐํ•ฉํ•˜์—ฌ ๋ณต์žกํ•œ ๋…ผ๋ฆฌ๋ฅผ ๊ตฌํ˜„ํ•˜๋Š” ๋ฐ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์Œ์„ ํ™•์ธํ–ˆ์Šต๋‹ˆ๋‹ค. ์ฆ‰, ๋ฌธ if์•ˆ์— ๋ฌธ์„ ์‚ฌ์šฉํ•˜๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค if.

๋ฃจํ”„๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ๋™์ผํ•œ ์ž‘์—…์„ ์ˆ˜ํ–‰ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๋ฃจํ”„ ์•ˆ์— ๋ฃจํ”„๋ฅผ ์ž‘์„ฑํ•˜๋ ค๋ฉด ์ฒซ ๋ฒˆ์งธ ๋ฃจํ”„์˜ ๋ณธ๋ฌธ ์•ˆ์— ๋‘ ๋ฒˆ์งธ ๋ฃจํ”„๋ฅผ ์ž‘์„ฑํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค. ๋‹ค์Œ๊ณผ ๊ฐ™์ด ํ‘œ์‹œ๋ฉ๋‹ˆ๋‹ค.

while (condition for outer loop)
{
   while (condition for inner loop)
   {
     block of statements
   }
}
while๋‹ค๋ฅธ ๋ฃจํ”„ ๋‚ด๋ถ€ ์˜ ๋ฃจํ”„( ๋ฌธ ๋ธ”๋ก ํฌํ•จ )while

์„ธ ๊ฐ€์ง€ ์ž‘์—…์„ ์‚ดํŽด๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

์ž‘์—… 1 . Momํ™”๋ฉด์— ๋‹จ์–ด๋ฅผ 4๋ฒˆ ํ‘œ์‹œํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•˜๊ณ  ์‹ถ๋‹ค๊ณ  ๊ฐ€์ •ํ•ด ๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค . ๋ฃจํ”„๋Š” ์ •ํ™•ํžˆ ์šฐ๋ฆฌ์—๊ฒŒ ํ•„์š”ํ•œ ๊ฒƒ์ž…๋‹ˆ๋‹ค. ๊ทธ๋ฆฌ๊ณ  ์šฐ๋ฆฌ์˜ ์ฝ”๋“œ๋Š” ๋‹ค์Œ๊ณผ ๊ฐ™์„ ๊ฒƒ์ž…๋‹ˆ๋‹ค:

์•”ํ˜ธ ์„ค๋ช…
int  n = 0;
while (n < 4)
{
   System.out.println("Mom");
   n++;
}
ํ™”๋ฉด์— 4์ค„์ด ํ‘œ์‹œ๋ฉ๋‹ˆ๋‹ค.
Mom
Mom
Mom
Mom

์ž‘์—… 2 . Aํ•œ ์ค„์— 5๊ฐœ์˜ ๋ฌธ์ž s๋ฅผ ํ‘œ์‹œํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•˜๋ ค๊ณ  ํ•ฉ๋‹ˆ๋‹ค . ์ด๋ฅผ ์œ„ํ•ด์„œ๋Š” ๋‹ค์‹œ ํ•œ ๋ฒˆ ๋ฃจํ”„๊ฐ€ ํ•„์š”ํ•ฉ๋‹ˆ๋‹ค. ์ฝ”๋“œ๋Š” ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

์•”ํ˜ธ ์„ค๋ช…
int n = 0;
while (n < 5)
{
   System.out.print("A");
   n++;
}
๋Œ€์‹  ๋ฅผ println()์‚ฌ์šฉํ•˜๊ฒ ์Šต๋‹ˆ๋‹ค print(). ๊ทธ๋ ‡์ง€ ์•Š์œผ๋ฉด ๊ฐ ๋ฌธ์ž๊ฐ€ A ๋ณ„๋„์˜ ์ค„์— ํ‘œ์‹œ๋ฉ๋‹ˆ๋‹ค.

ํ™”๋ฉด ์ถœ๋ ฅ์€ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.
AAAAA

์ž‘์—… 3 . ๋ฌธ์ž s๋กœ ๊ตฌ์„ฑ๋œ ์‚ฌ๊ฐํ˜•์„ ํ‘œ์‹œํ•˜๋ ค๊ณ  ํ•ฉ๋‹ˆ๋‹ค A. ์ง์‚ฌ๊ฐํ˜•์€ 4ํ–‰ 5์—ด๋กœ ๊ตฌ์„ฑ๋˜์–ด์•ผ ํ•ฉ๋‹ˆ๋‹ค. ์ด๋ฅผ ๋‹ฌ์„ฑํ•˜๋ ค๋ฉด ์ด์ œ ์ค‘์ฒฉ ๋ฃจํ”„๊ฐ€ ํ•„์š”ํ•ฉ๋‹ˆ๋‹ค. ์šฐ๋ฆฌ๋Š” ๋‹จ์ˆœํžˆ ์ฒซ ๋ฒˆ์งธ ์˜ˆ(4์ค„์„ ์ถœ๋ ฅํ•˜๋Š” ์˜ˆ)๋ฅผ ์ทจํ•˜๊ณ  ํ•œ ์ค„์„ ์ถœ๋ ฅํ•˜๋Š” ์ฝ”๋“œ๋ฅผ ๋‘ ๋ฒˆ์งธ ์˜ˆ์˜ ์ฝ”๋“œ๋กœ ๋Œ€์ฒดํ•ฉ๋‹ˆ๋‹ค.

์•”ํ˜ธ ์„ค๋ช…
int n = 0;

while (n < 4) { int m = 0;
while (m < 5) { System.out.print("A"); m++; }
System.out.println(); n++; }
 
์™ธ๋ถ€ ๋ฃจํ”„๋Š” ๋ณด๋ผ์ƒ‰์ž…๋‹ˆ๋‹ค. ๋ณ€์ˆ˜๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ n๋ฃจํ”„ ๋ฐ˜๋ณต ํšŸ์ˆ˜๋ฅผ ๊ณ„์‚ฐํ•ฉ๋‹ˆ๋‹ค.

๋‚ด๋ถ€ ๋ฃจํ”„๋Š” ๋…น์ƒ‰์ž…๋‹ˆ๋‹ค. ๋ณ€์ˆ˜๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ m๋ฃจํ”„ ๋ฐ˜๋ณต ํšŸ์ˆ˜๋ฅผ ๊ณ„์‚ฐํ•ฉ๋‹ˆ๋‹ค. ๋‚ด๋ถ€ ๋ฃจํ”„๊ฐ€ ์™„๋ฃŒ๋œ ํ›„ ์ปค์„œ๋ฅผ ๋ช…์‹œ์ ์œผ๋กœ ๋‹ค์Œ ์ค„๋กœ ์ด๋™

ํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค . ๊ทธ๋ ‡์ง€ ์•Š์œผ๋ฉด ํ”„๋กœ๊ทธ๋žจ์ด ์ธ์‡„ํ•˜๋Š” ๋ชจ๋“  ๋ฌธ์ž๊ฐ€ ํ•œ ์ค„์— ํ‘œ์‹œ๋ฉ๋‹ˆ๋‹ค. ํ™”๋ฉด ์ถœ๋ ฅ์€ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.


AAAAA
AAAAA
AAAAA
AAAAA

์™ธ๋ถ€ ๋ฃจํ”„์™€ ๋‚ด๋ถ€ ๋ฃจํ”„๋Š” ์„œ๋กœ ๋‹ค๋ฅธ ๋ณ€์ˆ˜๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ๋ฃจํ”„ ๋ฐ˜๋ณต ํšŸ์ˆ˜๋ฅผ ๊ณ„์‚ฐํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค. System.out.println()๋˜ํ•œ ๋‚ด๋ถ€ ๋ฃจํ”„ ๋’ค์— ๋ช…๋ น์„ ์ถ”๊ฐ€ํ•ด์•ผ ํ–ˆ์Šต๋‹ˆ๋‹ค . ํ•ด๋‹น ๋ฃจํ”„๋Š” A๊ฐ™์€ ์ค„์— ๋ฌธ์ž s๋ฅผ ํ‘œ์‹œํ•˜๊ธฐ ๋•Œ๋ฌธ์ž…๋‹ˆ๋‹ค. ํ•œ ์ค„์˜ ๋ฌธ์ž๊ฐ€ ํ‘œ์‹œ๋˜๋ฉด ๋ˆ„๊ตฐ๊ฐ€ ์ปค์„œ๋ฅผ ์ƒˆ ์ค„๋กœ ์ด๋™ํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค.



5. Java์™€ Pascal ๋ฃจํ”„ ๋น„๊ต

๋งŽ์€ ๋ถ„๋“ค์ด ๊ณ ๋“ฑํ•™๊ต์—์„œ ํŒŒ์Šค์นผ์„ ๊ณต๋ถ€ํ–ˆ์Šต๋‹ˆ๋‹ค. ์—ฌ๊ธฐ์„œ ์ž๋ฃŒ๋ฅผ ๋” ์‰ฝ๊ฒŒ ์ดํ•ดํ•  ์ˆ˜ ์žˆ๋„๋ก Pascal๊ณผ Java๋กœ ์ž‘์„ฑ๋œ ๋ฃจํ”„ ๋น„๊ต๋ฅผ ์‚ดํŽด๋ณด์‹ญ์‹œ์˜ค while. Pascal์„ ๋ชจ๋ฅธ๋‹ค๋ฉด ์ด ๋ถ€๋ถ„์„ ๊ฑด๋„ˆ๋›ฐ์‹ญ์‹œ์˜ค.

ํŒŒ์Šค์นผ ์ž๋ฐ”
i := 3;
While i >= 0 Do
   Begin
      WriteLn(i);
      i := i - 1;
   End;
int i = 3;
while (i >= 0)
{
   System.out.println(i);
   i--;
}
i := 0;
While i < 3 Do
   Begin
      WriteLn(i);
      i := i + 1;
   End;
int i = 0;
while (i < 3)
{
   System.out.println(i);
   i++;
}
IsExit := False;
While Not isExit Do
   Begin
      ReadLn(s);
      isExit :=  (s = 'exit');
   End;
boolean isExit = false;
while (!isExit)
{
   String s = console.nextLine();
   isExit = s.equals("exit");
}
While True Do
   WriteLn('C');
while (true)
   System.out.println("C");
While True Do
   Begin
     ReadLn(s);
     If s = 'exit' Then
       Break;
   End;
while (true)
{
   String s = console.nextLine();
   if (s.equals("exit"))
     break;
}