TMP (์์์ ์ฅ๋ณ์)
tmp๋ ์์์ ์ฅ๋ณ์๋ก ๊ฐ์ ๊ตํํ ๋ ์ฃผ๋ก ์ฌ์ฉ๋ฉ๋๋ค.
๋ฌธ์ ํ๋ฉฐ tmp์ ๋ํด ์ดํดํด ๋ด ์๋ค.
๋ฌธ์
์ ์ 2๊ฐ๋ฅผ ์ ๋ ฅ๋ฐ์ ์ฃผ์ธ์ .
a , b๊ฐ ์ค๋ฆ์ฐจ์์ด ๋๋๋ก ๋ฐ์ดํฐ๋ฅผ ๋ณ๊ฒฝํด ์ฃผ์ธ์.
public class Test01 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("์ ์ 1 ์
๋ ฅ >> ");
int a = sc.nextInt();
System.out.print("์ ์ 2 ์
๋ ฅ >> ");
int b = sc.nextInt();
if(a > b) {
// ๋ฐ์ดํฐ ๊ตํ ์๊ณ ๋ฆฌ์ฆ ๋ก์ง
int tmp = a;
// tmp , temp, ์์์ ์ฅ๋ณ์
// >> ๊ฐ์ ๊ตํํ ๋ ์ฃผ๋ก ์ฌ์ฉ๋จ
a = b;
b = tmp;
}
System.out.println("a= "+a);
System.out.println("b= "+b);
}
}
์ ์ 3๊ฐ๋ฅผ ์ ๋ ฅ๋ฐ์ ์ดํฉ๊ณผ ํ๊ท ์ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค
public class Test03 {
public static void main(String[] args) {
int num1, num2, num3; // ์ฌ์ฉ์์๊ฒ ์
๋ ฅ๋ฐ์ ๊ฐ์ ์ ์ฅํ๋ ๊ณต๊ฐ
int sum; // ์ดํฉ
double avg; // ํ๊ท
// ์ฌ์ฉ์์๊ฒ ์ ์ 3๊ฐ ์
๋ ฅ๋ฐ๋ ์ฝ๋
Scanner sc = new Scanner(System.in);
System.out.println("์ ์ 3๊ฐ๋ฅผ ์
๋ ฅ๋ฐ์ ์ดํฉ๊ณผ ํ๊ท ์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์
๋๋ค. ");
System.out.print("์ ์ 1 ์
๋ ฅ >> ");
num1 = sc.nextInt();
System.out.print("์ ์ 2 ์
๋ ฅ >> ");
num2 = sc.nextInt();
System.out.print("์ ์ 3 ์
๋ ฅ >> ");
num3 = sc.nextInt();
// ์
๋ ฅ๋ฐ์ ์ ์๋ค์ ์ดํฉ ๋ฐ์ดํฐ์ ์ ์ฅํ๋ ์ฝ๋
sum = num1 + num2 + num3;
// ์ดํฉ๋ฐ์ดํฐ / 3ํด์ ํ๊ท ์ ๋์ถํ๋ ์ฝ๋
avg = sum / 3.0;
System.out.println("์ดํฉ "+sum);
System.out.println("ํ๊ท "+avg);
}
}
while vs for๋ฌธ
๋ฐ๋ณต ํ์๋ฅผ ์ ๋ (for) vs ๋ชจ๋ฅผ ๋ (while)
๋ฌดํ๋ฃจํ (๋ฌดํ ๋ฐ๋ณต๋ฌธ) == while๋ฌธ
+ ์ข
๋ฃ์กฐ๊ฑด
while๋ฌธ๊ณผ for๋ฌธ์ ๊ตฌ์กฐ
while๋ฌธ
โถ while (์กฐ๊ฑด์) { }
์กฐ๊ฑด์ ์์ด true์ผ ๋ ์ค๊ดํธ ์์ ์คํ๋ฌธ์ ์คํํ๋ค.
์คํ๋ฌธ์ด ๋๋๋ฉด , ๋ค์ ์กฐ๊ฑด์์ ํตํด true or false๋ฅผ ํ๋จํ๋ค.
true๋ฉด ์คํ๋ฌธ์ ๊ณ์ ์คํํ๊ณ false๋ฉด while๋ฌธ์ ์ข ๋ฃํ๋ค.
for๋ฌธ
โถ for(์ด๊ธฐํ; ์กฐ๊ฑด์; ์ฆ๊ฐ์) { }
int i ๋ณ์๋ฅผ ์ ์ธํ์ฌ ์ด๊น๊ฐ์ 1๋ก ์ด๊ธฐํํ๋ค.
์ด๊น๊ฐ 1์ 10๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ผ๋ฏ๋ก ์คํ๋ธ๋ก์ ์คํํ๋ค.
์คํ๋ธ๋ก์ ๋น ์ ธ๋์ i์ 1์ ๋ํ๊ณ i๊ฐ ์กฐ๊ฑด์์ ๊ฐ์ด ๋ ๋๊น์ง ๋ฐ๋ณตํ๋ค.
i๊ฐ ์กฐ๊ฑด์์ ๊ฐ์ด ๋์์ผ๋ฉด ์กฐ๊ฑด์ด ์ถฉ์กฑํ์ง ์์ผ๋ฏ๋ก for๋ฌธ์ ์ข ๋ฃํ๋ค.
while๋ฌธ ๊ด๋ จ๋ฌธ์
โถ ์ ์๋ฅผ ์ ๋ ฅ๋ฐ๋๋ฐ 0 ์ดํ๊ฐ ์ ๋ ฅ๋๋ฉด ์ข ๋ฃ๋๋ ํ๋ก๊ทธ๋จ์ ๋๋ค.
public static void main(String[] args) {
// ์ ์๋ฅผ ์
๋ ฅํ ๊ฑด๋ฐ 0์ดํ์ ์ ์๊ฐ ์
๋ ฅ๋๋ฉด ์ข
๋ฃ
Scanner sc = new Scanner(System.in);
while(true) {
System.out.println("์ ์ ์
๋ ฅ >> ");
int num = sc.nextInt();
if (num <= 0) { // 0์ดํ์ ์ ์๊ฐ ์
๋ ฅ๋์๋ค๋ฉด
break;
// ์์ ๊ณผ ๊ฐ์ฅ ๊ฐ๊น์ด ๋ฐ๋ณต๋ฌธ์ "์ฆ์" ๋น ์ ธ๋์ต๋๋ค.
}
System.out.println("num= " +num);
}
โถ ํ์์ ์ด๋ฆ์ ์ ๋ ฅํ๋๋ฐ "์ข ๋ฃ"๋ผ๊ณ ์ ๋ ฅํ๋ฉด ์ข ๋ฃ
while (true) {
System.out.println("ํ์์ด๋ฆ์
๋ ฅ >> ");
String name = sc.next();
if(name.equals("์ข
๋ฃ")) { // ๋ฐ๋์ ์ข
๋ฃ์กฐ๊ฑด์ด ์๋ค.
break;
}
}
โถ ์ ์๋ฅผ ์ ๋ ฅ๋ฐ์ ์ดํฉ์ด 100์ด ๋์ด๊ฐ ์ ์ข ๋ฃ
int sum = 0;
while(true) {
System.out.print("์ ์ ์
๋ ฅ >> ");
int num = sc.nextInt();
sum += num;
System.out.print("sum = "+sum);
if(sum > 100) { // ์ดํฉ์ด 100์ด ๋์ด๊ฐ๋ฉด
break;
}
}
์ํ๊ธฐ ํ๋ก๊ทธ๋จ
์ฌ์ฉ์์๊ฒ ๊ธ์ก์ ์ ๋ ฅ๋ฐ๊ณ
ํ๋งค๊ฐ๋ฅํ ์ํ์ ๋ณด์ฌ์ค ์์ ์ ๋๋ค.
์ฌ์ฉ์๊ฐ ์ํ๋ ๋ฉ๋ด๋ฅผ ์ ๋ ฅํ ๋ค์
ํด๋น ์ํ์ ์ฃผ๊ณ
๋ง์ฝ ํด๋น ์ํ๋ณด๋ค ๋์ด ์ ์ ๊ฒฝ์ฐ ์ค ์ ์์
๋์ด ๋ง์ฝ ๋จ์๋ค๋ฉด ์๋๋ฐํ
public class Test02 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int money; // ์ฌ์ฉ์์๊ฒ ๋ฐ์ ๊ธ์ก
int product1 = 1200; // ์ฝ๋ผ
int product2 = 900; // ์ฌ์ด๋ค
int menu; // ์ฌ์ฉ์๊ฐ ์
๋ ฅํ๋ ๋ฉ๋ด๋ฒํธ (1 or 2)
while(true) {
System.out.print("์ํ๊ธฐ์ ๋ฃ์ ๊ธ์ก์ ์
๋ ฅํ์์ค >> ");
money = sc.nextInt();
if(900 <= money && money < 10000) {
break;
}
System.out.println("900์์ ~ 10000 ์ฌ์ด์ ๊ฐ์ ์
๋ ฅํด์ฃผ์ธ์");
}
// ์ํ ์ถ๋ ฅ
System.out.println("1. ์ฝ๋ผ 1200์");
System.out.println("2. ์ฌ์ด๋ค 900์");
// ์ฌ์ฉ์์๊ฒ ๋ฉ๋ด ์
๋ ฅ๋ฐ์์
// 1 ~ 2๋ง ์
๋ ฅ๊ฐ๋ฅ
// ์๋ชป์
๋ ฅํ๋ฉด ๋ค์ ์
๋ ฅ
while(true) {
System.out.print("๋ฉ๋ด๋ฅผ ์
๋ ฅํ์ธ์ >> ");
menu = sc.nextInt();
if(1 <= menu && menu <= 2) {
break;
}
System.out.println("1~2 ์ฌ์ด์ ์ซ์๋ฅผ ์
๋ ฅํด์ฃผ์ธ์.");
}
if(menu == 1) {
if(money < product1) {
System.out.println("๊ธ์ก์ด ๋ถ์กฑํฉ๋๋ค.");
}
else {
money -= product1;
System.out.println("์ฃผ๋ฌธํ์ ์ฝ๋ผ ๋์์ต๋๋ค");
}
}
else if(menu == 2) {
if(money < product2) {
System.out.println("๊ธ์ก์ด ๋ถ์กฑํฉ๋๋ค.");
}
else {
money -= product2 ;
System.out.println("์ฃผ๋ฌธํ์ ์ฌ์ด๋ค ๋์์ต๋๋ค");
}
}
// ๋จ์ ๋์ด ์๋ค๋ฉด ์๋ ๋ฐํ
if(money > 0) {
System.out.println("๋จ์๋ " +money+"์ ๋ฐํ๋ฉ๋๋ค!");
}
}
}
for๋ฌธ ๊ด๋ จ๋ฌธ์
โถ ๋ฌธ์ 1)
1 ~ 10 ์ฌ์ด์ ์ ์์ค์์ ์ง์๋ง ์ถ๋ ฅํด ์ฃผ์ธ์.
for(int i = 1; i <= 10; i++) {
if(i % 2 == 0) { // ์ง์๋ผ๋ฉด
System.out.println(i);
}
}
โถ ๋ฌธ์ 2)
1 ~ 10 ์ฌ์ด์ ์ ์๋ฅผ ์ถ๋ ฅํ ์์ ์ ๋๋ค.
๋ค๋ง ํ์๋ ์ถ๋ ฅํ์ง ๋ง์ ์ฃผ์ธ์.
for(int i = 1; i <= 10; i++) {
if(i % 2 == 1) { // ํ์๋ผ๋ฉด
continue; // ์๋์ ๊ธฐ๋ฅ์ ์๋ตํด์ค ~
// ์์ ๊ณผ ๊ฐ์ฅ ๊ฐ๊น์ด ๋ฐ๋ณต๋ฌธ์ ์ฒ์์ผ๋ก "์ฆ์" ์ด๋
// " ๋ฐ๋ณต๋ฌธ์ ๊ณ์ํ ๊ฑด๋ฐ ๋ฉ์ถ๊ณ ์ถ์ง ์์ "
// ๊ทผ๋ฐ ~~ ํ ๊ฒฝ์ฐ๋ผ๋ฉด ๊ทธ๋๋ง ์ํ๊ณ ์ถ์ด
}
System.out.println(i);
}
์ฐ์ต๋ฌธ์
โถ ๋ฌธ์ 1
์ ์๋ฅผ ์
๋ ฅ๋ฐ์ต๋๋ค.
์
๋ ฅ๋ ์ ์๊ฐ ์ง์๋ผ๋ฉด ์ดํฉ์ ๋ํด์ฃผ์ธ์.
0 ์ดํ๊ฐ ์
๋ ฅ๋๋ฉด ๋ฉ์ถฅ๋๋ค.
๋ฉ์ถ๊ณ ์ ์ต์ข
์ดํฉ์ ์ถ๋ ฅํด ์ฃผ์ธ์.
public class PracticeTest01 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// ์ฌ์ฉ์๋ก๋ถํฐ ์ ์๋ฅผ ์
๋ ฅ๋ฐ๊ธฐ ์ํด Scanner๋ฅผ ์์ฑํฉ๋๋ค.
System.out.println("์ ์๋ฅผ ์
๋ ฅ๋ฐ์ ์ต์ข
์ดํฉ์ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์
๋๋ค.");
// ์ด๋ค ํ๋ก๊ทธ๋จ์ธ์ง ์ค๋ช
์ ํด์ค๋๋ค.
int sum = 0;
while (true) {
// ๋ฐ๋ณต ํ์๋ ๋ฒ์๊ฐ ๋์์์ง ์๊ธฐ ๋๋ฌธ์ while๋ฌธ์ ์ฌ์ฉํฉ๋๋ค.
System.out.print("์ ์๋ฅผ ์
๋ ฅํด์ฃผ์ธ์ >> ");
int num = sc.nextInt();
// ์ ์๋ฅผ ์์ฑํ๊ณ ์ฌ์ฉ์๋ก๋ถํฐ ์ ์๋ฅผ ์
๋ ฅ ๋ฐ์ต๋๋ค.
if (num <= 0) { // 0 ์ดํ๊ฐ ์
๋ ฅ๋๋ฉด
break; // ๋ฉ์ถฅ๋๋ค.
}
if (num % 2 == 0) { // ์ง์๋ผ๋ฉด else๋ ๋ค์ด๊ฐ๋ ์๊ด์๋๋ฐ ์์ break๊ฐ
sum += num; // ์ดํฉ์ ๋ํด์ฃผ์ธ์ . ๋ฌดํ๋ฃจํ์ ํ์ถ์กฐ๊ฑด์์ ๋ ํ์คํ๊ฒ ์๊ฒ ํ๊ฒ ์ํด์
// else๋ฅผ ์ฐ์ง ์์ต๋๋ค.
}
System.out.println("์ ์๋ค์ ์ต์ข
์ดํฉ์ "+sum+"์
๋๋ค.");
}
โถ ๋ฌธ์ 2
1 ~ 10๊น์ง์ ์ ์๋ฅผ ์ญ์์ผ๋ก ์ถ๋ ฅํด ์ฃผ์ธ์.
ex) 10 9 8 7 6 5 4.... 1
public class PracticeTest02 {
public static void main(String[] args) {
System.out.println("1 ~ 10๊น์ง์ ์ ์๋ฅผ ์ญ์์ผ๋ก ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ ์
๋๋ค.");
// ์ด๋ค ํ๋ก๊ทธ๋จ์ธ์ง ์ค๋ช
ํด์ค๋๋ค.
System.out.println("์ญ์ ์ถ๋ ฅ");
// ์๋ฌด๋ง๋ ์์ด ๊ทธ๋ฅ ์ซ์๋ง ๋์ค๋ฉด ๋ฐ๋ฐํ๋๊น
// ์ญ์์ผ๋ก ์ถ๋ ฅ๋ ๊ฒ์ ์๋ ค์ฃผ๋ ์ฝ๋๋ฅผ ์์ฑํ์ต๋๋ค.
for(int i = 1; i < 11; i++) {
// ๋ฒ์๊ฐ ์ ํด์ ธ ์์ผ๋ for๋ฌธ์ ์ฌ์ฉํด์ฃผ์์ต๋๋ค.
System.out.print(11-i);
// ์ญ์์ผ๋ก ์ถ๋ ฅํด์ผ ํ๋๋ฐ
// i๊ฐ 1๋ถํฐ ์์ํ๋๊น ์ถ๋ ฅ๋๋ ๋ถ๋ถ์ 11์ ๋ฃ์ด์
// ์ฒ์ ์์๊ฐ์ด 10์ผ๋ก ์ถ๋ ฅ๋๊ฒ ํฉ๋๋ค.
// ๊ทธ๋ ๊ฒ for๋ฌธ์ ๋๋ ค๋ณด๋ฉด
// ์ญ์์ผ๋ก ์ ์ถ๋ ฅ๋๋ ๋ชจ์ต์ ๋ณด์ค ์ ์์ต๋๋ค.
}
โถ ๋ฌธ์ 3
์ ์๋ฅผ 2๊ฐ ์
๋ ฅ๋ฐ์์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ถ๋ ฅํด ์ฃผ์ธ์.
ex) a = 3 , b = 5 3 4 5
a = 10, b = 8 8 9 10
public class PracticeTest03 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// ์ ์๋ฅผ ์
๋ ฅ๋ฐ๊ธฐ ์ํด์ Scanner๋ฅผ ์์ฑํฉ๋๋ค.
System.out.println("์ ์ 2๊ฐ๋ฅผ ์
๋ ฅ๋ฐ์์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.");
// ์ด๋ค ํ๋ก๊ทธ๋จ์ธ์ง ์ค๋ช
ํด์ค๋๋ค.
while (true) {
// ์ค๋ฆ์ฐจ์์ ์ด๋ค ์์๋ก ์ด๋ป๊ฒ ์ถ๋ ฅ๋ ์ง ์ ์ ์๊ธฐ๋๋ฌธ์ while๋ฌธ์ ์ฌ์ฉํฉ๋๋ค.
System.out.print("์ฒซ๋ฒ์งธ ์ ์๋ฅผ ์
๋ ฅํ์์ค >> ");
int a = sc.nextInt();
System.out.print("๋๋ฒ์งธ ์ ์๋ฅผ ์
๋ ฅํ์์ค >> ");
int b = sc.nextInt();
// ์ ์ 2๊ฐ๋ฅผ ์
๋ ฅ๋ฐ์์ผ ํ๋๊น ์ ์๋ฅผ 2๊ฐ ๋ง๋ค์ด์ค๋๋ค
if(a > b) { // a๊ฐ b๋ณด๋ค ํด๋
for(int i = b; i <= a; i++) {
System.out.println(i);
// b๋ถํฐ a์ฌ์ด์ ์๋ ์ซ์๋ค ๋ด๋ฆผ์ฐจ์
}
}
else if(b > a) { // b๊ฐ a๋ณด๋ค ํด๋
for(int i = a; i <= b; i++) {
System.out.print(i);
// a๋ถํฐ b์ฌ์ด์ ์๋ ์ซ์๋ค ๋ด๋ฆผ์ฐจ์
}
}
break;
โถ ๋ฌธ์ 4
์ ์๋ฅผ 5๋ฒ ์
๋ ฅํฉ๋๋ค.
๋ชจ๋ ์
๋ ฅ์ด ๋๋ ํ, ์
๋ ฅํ ์ ์์ค์์ ๊ฐ์ฅ ํฐ ๊ฐ์ ์ถ๋ ฅํด ์ฃผ์ธ์.
( pivot ๊ธฐ์ค )
public class PracticeTest04 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// ์ ์๋ฅผ ์
๋ ฅํด์ผ ๋๋ Scanner ์์ฑ
System.out.println("์ ์๋ฅผ 5๋ฒ ์
๋ ฅํ์ฌ ์
๋ ฅํ ์ ์์ค ๊ฐ์ฅ ํฐ ๊ฐ์ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ ์
๋๋ค.");
// ์ด๋ค ํ๋ก๊ทธ๋จ์ธ์ง ์ค๋ช
ํฉ๋๋ค.
while(true) {
// ์ด๋ค ๊ฐ์ด ๊ฐ์ฅ ํด์ง ๋ชจ๋ฅด๋๊น while๋ฌธ์ผ๋ก ์์ฑํฉ๋๋ค.
System.out.print("์ฒซ๋ฒ์งธ ์ ์๋ฅผ ์
๋ ฅํ์ธ์ >> ");
int num1 = sc.nextInt();
System.out.print("๋๋ฒ์งธ ์ ์๋ฅผ ์
๋ ฅํ์ธ์ >> ");
int num2 = sc.nextInt();
System.out.print("์ธ๋ฒ์งธ ์ ์๋ฅผ ์
๋ ฅํ์ธ์ >> ");
int num3 = sc.nextInt();
System.out.print("๋ค๋ฒ์งธ ์ ์๋ฅผ ์
๋ ฅํ์ธ์ >> ");
int num4 = sc.nextInt();
System.out.print("๋ค์ฏ๋ฒ์งธ ์ ์๋ฅผ ์
๋ ฅํ์ธ์ >> ");
int num5 = sc.nextInt();
// ์ฌ์ฉ์๋ก ๋ถํฐ ์ ์๋ฅผ ์ด 5๊ฐ ์
๋ ฅ ๋ฐ์ต๋๋ค.
int fight1 = 0;
int fight2 = 0;
int final1 = 0;
// ๋๊ฒฐ์์ ์ด๊ธด ์ซ์๋ฅผ ์ ์ฅํ ์ ์ฅ๊ณต๊ฐ์ ๋ง๋ค์ด์ค๋๋ค.
if(num1 > num2) { // num1์ด num2๋ณด๋ค ํฌ๋ค๋ฉด
fight1 = num1; // num1์ ๊ฐ์ fight1์ ์ ์ฅํ๋ค.
}
else if (num1 < num2){ // num1์ด num2๋ณด๋ค ์๋ค๋ฉด
fight1 = num2;// num2์ ๊ฐ์ fight1์ ์ ์ฅํ๋ค.
}
if(num3 > num4) { // num3์ด num4๋ณด๋ค ํฌ๋ค๋ฉด
fight2 = num3; // num3์ ๊ฐ์ fight2์ ์ ์ฅํ๋ค.
}
else if (num3 < num4){ // num4๊ฐ num3๋ณด๋ค ํฌ๋ค๋ฉด
fight2 = num4; // num4์ ๊ฐ์ fight2์ ์ ์ฅํ๋ค.
}
if(fight1 > fight2) { // fight1์ด fight2๋ณด๋ค ํฌ๋ค๋ฉด
final1 = fight1; // fight1์ ๊ฐ์ final1์ ์ ์ฅํ๋ค.
}
else if(fight2 > fight1) { // fight2๊ฐ fight1๋ณด๋ค ํฌ๋ค๋ฉด
final1 = fight2; // fight2์ ๊ฐ์ final1์ ์ ์ฅํ๋ค.
}
if(final1 > num5) { // final1์ด num5๋ณด๋ค ํฌ๋ค๋ฉด
System.out.println("์ ์๋ค ์ค ๊ฐ์ฅ ํฐ ๊ฐ์ " + final1 + "์
๋๋ค."); // final1์ ์ถ๋ ฅํ๋ค.
break; // while๋ฌธ์ ๋ง๋ฌด๋ฆฌํ๋ค.
}
else if(num5 > final1) { // final1์ด num5๋ณด๋ค ํฌ๋ค๋ฉด
System.out.println("์ ์๋ค ์ค ๊ฐ์ฅ ํฐ ๊ฐ์ " + num5 + "์
๋๋ค."); // num5๋ฅผ ์ถ๋ ฅํ๋ค.
break; // while๋ฌธ์ ๋ง๋ฌด๋ฆฌํ๋ค.
}
โถ ๋ฌธ์ 5
1 ~ 100 ์ฌ์ด์ ์ ์๋ง 1๋ฒ ์
๋ ฅํฉ๋๋ค. ์
๋ ฅํ ์ ์์ ์ฝ์๋ค์ ๋ชจ๋ ์ถ๋ ฅํด ์ฃผ์ธ์.
public class practiceTest05 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// ์ ์๋ฅผ ์
๋ ฅ๋ฐ์์ผ ํ๊ธฐ์ Scanner๋ฅผ ์์ฑํฉ๋๋ค.
System.out.println("1 ~ 100์ฌ์ด์ ์ ์๋ฅผ ํ๋ฒ ์
๋ ฅํ์ฌ ์
๋ ฅํ ์ ์์ ์ฝ์๋ค์ ๋ชจ๋ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ ์
๋๋ค.");
// ์ด๋ค ํ๋ก๊ทธ๋จ์ธ์ง ์ค๋ช
ํ์์ต๋๋ค.
while(true) {
System.out.print("1 ~ 100์ฌ์ด์ ์ ์๋ฅผ ์
๋ ฅํ์์ค >> ");
int num = sc.nextInt();
if(1 <= num && num <= 100) {
break;
}
} // break๊ฐ ์ข
๋ฃ์กฐ๊ฑด ์์ด ์์ฑ๋ ๊ฒฝ์ฐ
// ๊ทธ ๊ธฐ๋ฅ์ ํ์์ด ๋ฐ๋ณต์ ์ํ๋ ์ฝ๋๋ค!
'ํ์คํ ๊ฐ๋ฐ์ ์์ฑ๊ณผ์ ๐ชซ > ใ Java ใ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Java] ํด๋์ค ์์ (1) | 2024.07.10 |
---|---|
[Java] ๊ฐ์ฒด(Object)์ Class (1) | 2024.07.03 |
[Java] ํจ์์ ์ฌ๋ฌ๊ฐ์ง ์ ํ๊ณผ ForEach๋ฌธ (2) | 2024.07.02 |
[Java] ์ด์ค for๋ฌธ๊ณผ ๋ฐฐ์ด (0) | 2024.07.02 |
[Java] ์๋ฐ ๊ธฐ๋ณธ๋ถ๋ฒ ,๋ณ์ , ํจ์ , ํ๋ฆ ์ ์ด๋ฌธ (0) | 2024.06.26 |