ืืืืืช ื- while ื ืืฆืืช ืืืขื ืืื ืฉืคืช ืชืื ืืช, ืื'ืืืื ืืื ื ืืืฆืืช ืืืคื. ืืขืื ืืืืื ื-Java ืืืฉืคืืช ืืืจืืช ืืืฆืขืช ืืฉืคื ืื ืืืืง ืฉื ืืฆืืจืืช ืื ืขืื ืืขืจื ืฉื ืืชื ืื ืฉืืคืขืื ืืืชื ื ืืื. ืืืืืจ ืื, ืื ื ืืืืืื ืืืืจ ืขื ืืื ืืขืืื ืขื ืืืืืช while .
ืืฉืืื ืื ืืืืืจืื?
ืืชืืื ืืืช ืืจืืฉืื ืืช ืฉืื ืืื ืจืฆืฃ ืฉื ืืืจืืืช ืฉืืืคืขืื ืฆืขื ืืืจ ืฆืขื ืืื ืืืจ ืื. ืืื ืืืืืืช ืืืืจืืช. ืืืืฉื ืืชืืื ื ืืืฉืชืืฉ ืืกื ืืคืื ืืขืืจืช ืืคืขืืืื ืืืชื ืื. ืืืื, ืขื ืื ืช ืืืฆืข ืคืขืืืืช ืืืืจืืช, ืืฉ ืืืืืจืืืช. ืืืื ืืืืืจืื ืื ืืื ืืืชืจืื ืืช ืืืจืืจืื ืืืืชืจ ืืืชืื ืชืื ืืชืืืืื ืฉืืกืคืงืช ืืืืืืฆืื ืฉื ืชืืืืืื. ืชืืจ ืืขืฆืื ืฉืืชื ืฆืจืื ืืืชืื ืชืืื ืืช ืืขืงื ืฉืกืืคืจืช ืืช ืืกืคืจ ืืฆืขืืื ืฉื ื ืงืื ืืืื. ืืืฉืืชื ืขืืืจ, ืืืฉื, 10,000 ืฆืขืืื, ืืชืืื ืืช ืืืืจื ืืฉืืื ืื ืืืืขื ืขื ืืืขื ืฉืืืฉื. ืืืฉืืื ืฉื ืืืฆืืช ืืืืขื ืืืืื ืืืชืืื ืืืืืื (ืื ืคืกืืืืืงืื) ืื:While (number of steps less than 10,000)
{
Count steps
}
Send notification "you have reached the goal"
ืืืืืจ, ืืจืืข ืฉืืกืคืจ ืืฉืืืื ืฉืืื ืืื ืฉืฆืืื ืืชื ืื, ืืชืืื ืืช ืืืฆืืช ืืืืืืจ ืื ืืฉืืืืช ืืืืขื. ืื ืืืืื ืืืจืช. ืืืืื ื ืฉืืชื ืฆืจืืืื ืืฉื ื ืฉืืจ (ืื ื ืืื). ืฉืืจ ื ืืฉื ืืขื ืืขื ืคื ืื ืืชื ืืืื ืืงืจืื ืืืชื ืฉืืืฉ ืคืขืืื ืืจืฆืืคืืช ืืืื ืืืฆืืฅ. ืื ืืชื ืืืืืื ืชืืื ืืช ืฉืชืืคืกืช ืืช ืื ืืกืืื ืืช ืฉืื ืืืงืื ืฉืืจ, ืืื ืชืฆืืจื ืืืฉืชืืฉ ืื ืืืืืื:
While (success < 3)
learn a poem
ืงืื ืกืืจืืงืฆืืืช ืืืืืช ืืฉืืฉืืช ืืื ืืืคืืืงืฆืืืช ืืืื ืืืืืช ืืืืืจื ืืืช ืืืฉืืฉืืช, ืืืฉื, ืืืืืื ืฉืคืืช ืื ื ืืื ื ืืืื ื ืืื ื.
ืืขืื ืืืืื ืืืืื ื ืฉืื
ืืื ืืคืชืืจ ืืขืืืช ืืื ืืืืืืืืช ืืขืื, ืืืืืคื ืืืื ืืืชืจ, ืืื ืืืคืื ืคืขืืืืช ืืืืจืืช ืื ืฉื ืืช ื-Java, ืืชื ืืืื ืืืฉืชืืฉ ืืืืืืช while . Java while loop ืืขืืื ืืื ืืืงืจื ืฉืื ื. ืขืืฆืื ืื ืืกืืจ ืืกืคืจ ืคืขืืืืช ืืืื ื ืชืืฆืืชื ืืืืื. ืืฆืืจืช ืืืืืช while ื ืืฆืืช ืืืขื ืืื ืฉืคืืช ืืชืื ืืช. ืืื ืืืืจ ืขื ืืฉืคื ืื ืืืืง ืฉื ืืฆืืจืืช ืื ืขืื ืืขืจื ืฉื ืืืืื ืืฉืืืื ืฉืื ื ืืื. ืฆืืจืช ืืืืืช ื- while ืืื ืืืืงืื:while(condition == true) {
// statement or loop body
}
ืืชื ืื ืืืื ืืืืืช ืืืืื ืืืืืื ื, ืืืืืจ ืืื ืฉื ืืชื ืืืืจ ืฉืืื ื ืืื ืื ืื ื ืืื. ืื ื ืืื ืืืืืืืช ืืืืืืืื ืืืืืื ืืื:
s != "exit";
a > 5;
true;
ืืืฃ ืืืืืื ืืืืฆืข ืื ืขืื ืืืืืื ืืืืชื ื ื ืืื. ืืืฉืจ ืืชื ืื ืืืคื ืื ื ืืื, ืืฉืืืื ืืืขืืจืช ืืฉืืจืช ืืงืื ืฉืืืืขื ืืืจื ืืืืืื. ืื ื ืขืฉื ืฉืืืืฉ ืืืฉืคื ืืื ืืืื ืืืืืื, ืื ื ืืชื ืืืืชืจ ืขื ืคืืื ืืชืืืชืืช (ืืื ืขืืืฃ ืื ืืขืฉืืช ืืืช). ืืืืืื ืืืืื ืืืขืจื ืืคื ื ืชืืืืช ืืืืืช ื- while , ืืืืืจ ืืื ืืื ืคืขื ืืคื ื ืืืฆืืข ืืืืจื ืืืื ืฉื ืืืฆืืจื.
ืืขืื ืืืืื ืืืืืืืช
ืืื ื ืืชืื ืชืืื ืืช ืฉืชืกืื ืืช ืื ืืืกืคืจืื ื-1 ืขื 10 ืืืืฆืขืืช ืืืืืช while :public class WhileTest0 {
public static void main(String[] args) {
int i = 0;
int sum = 0;
//while loop
while (i < 11) {
sum = sum + i;
i++;
}
System.out.println(sum);
}
}
ืืคืื ืืื:
55
ืื ืื ื ืฆืจืืืื ืืืฉื ืืช ืืกืืื ืฉื ืื ืืืกืคืจืื ื-1 (ืื ืืืคืก, ืื ืื ืืฉื ื) ื-10. ืื ืื ื ืืืคืืื ืืช ืืกืืื ืืืชืืืชื ืืืช ืืืืื ื ืืจืืฉืื ืืฉืืืื ืืืคืก, ืื ืืืื ืืช ืืืืื ื ืืืื ืืื ืืขืืจ ืฉื ืืืืืื. ื ืืฉืื ืืกืื ืขื ืฉืืืจืืืื ื ืืฉืชืืื ื-10 (ืืืืืจ, ืคืืืช ื-11. ืืืืคื ืืืื, ื ืืื ืืืชืื ืืช ืืชื ืื i <= 10 ). ื ืืงื ืืืืื ื ืืกืคืช ืฉื ืืืืืช Java while . ืื ืื ื ืืืืืื ืืืชืื ืชืืื ืืช ืฉืื ืืฉืชืืฉืื ืืืื ืื ืืกืคืจืื ืฉืืืื ืืืืืืื. ืื ืื ืืืื ืื ืืคืก ืื ืืกืคืจ ืฉืืืื, ืืชืืื ืืช ืฆืจืืื ืืืืื ืขื ืื ืืืกืืื ืืช ืืขืืืื.
import java.util.Scanner;
public class WhileTest {
public static void main(String[] args) {
int positiveNumber = 1;
Scanner scanner = new Scanner(String.valueOf(positiveNumber));
while (positiveNumber > 0) {
Scanner sc = new Scanner(System.in);
System.out.println("Enter positive number:");
positiveNumber = sc.nextInt();
System.out.println("ok, next");
}
System.out.println("The number should be positive");
}
}
ื ืืชื ืืฉืคืจ ืืช ืืชืืื ื ืืืืืกืืฃ ืื, ืืืฉื, ืืืืืง ืื ืืืฉืชืืฉ ืืืื ืืืืืง ืืกืคืจ ืืื ืชื ืืืจ, ืื ืฉืืืกืคืจ ืืื ืืกืคืจ ืฉืื.
ืืืืืช ืขืฉื ืชืื ืืื
ืืืืืช ื- while ืืงืืืกืืช , ืืื ืืืืืืืืช ืืืขืื, ืืืืงืช ืืื ืื ืืชื ืื ื ืืื. ืืื, ืื ืืืื ืืืืงืจื ืืืืืจ ืขื ืชื ืื ืืืงืื. ืืืืืืช ื- while ืืฉ ืื ืืขืฉืืช ืืืื, ืืืืื ืขื ืชื ืื ืคืืกื. ืืืืืจ, ืืคื ื ืฉืืชืงืืื ืืืืงืช ืืืืชืืช ืืชื ืื, ืืืืื ืืื ืชืชืืฆืข ืืคืืืช ืคืขื ืืืช:do {
// Loop body - periodically executed statement(s)
}while(Boolean expression);
ืื, ืืืืืื ืืจืืฉืื ื ืขื ืืืืื ืืื ืชืืจืื ืื:
public class WhileTest0 {
public static void main(String[] args) {
int i = 0;
int sum = 0;
do
{
sum = sum + i;
i++;
} while (i < 11);
System.out.println(sum);
}
}
ืืืืืจ ืืื ืกืืคื
ื ืืชื ืืืฉืชืืฉ ืืืืืืช while ืืื ืืืจืื ืืืืืืช ืืื ืกืืคืืืช ืืฆืืจื while(true) : ืืืืืื, ืื ื ืชืืื ืืช ืฉืืืคืืกื ืืื ืกืืฃ (ืขื ืืื ื ืืืื ืกืื) ืกืืจื ืฉื ืืกืคืจืื ืฉืืืื:public class EndlessLoop {
public static void main(String[] args) {
int i = 0;
while (true) {
System.out.println(i++);
}
}
}
ืืื ืืืืง ืืช ืื ืฉืืืืช, ืื ื ืืฆืืขืื ืื ืืฆืคืืช ืืฉืืขืืจ ืืืืื ืืงืืจืก Java ืฉืื ื
GO TO FULL VERSION