728x90
๋ฐ˜์‘ํ˜•

1. if ๋ฌธ

1) if ๋ฌธ๊ณผ else ๋ฌธ์˜ ๊ธฐ๋ณธ ๊ตฌ์กฐ

- if ๋ฌธ : ์ฃผ์–ด์ง„ ์กฐ๊ฑด์ด ์ฐธ์ผ ๋•Œ ์‹คํ–‰๋˜๋Š” ์ฝ”๋“œ

- else ๋ฌธ: if ๋ฌธ์˜ ์กฐ๊ฑด์ด ๊ฑฐ์ง“์ผ ๋•Œ ์‹คํ–‰๋˜๋Š” ์ฝ”๋“œ

if (์กฐ๊ฑด๋ฌธ) {
	<์ˆ˜ํ–‰ํ•  ๋ฌธ์žฅ>;
    <์ˆ˜ํ–‰ํ•  ๋ฌธ์žฅ2>;
} else {
	<์ˆ˜ํ–‰ํ•  ๋ฌธ์žฅ3>;
    <์ˆ˜ํ–‰ํ•  ๋ฌธ์žฅ4>;
}

 

2) ๋น„๊ต ์—ฐ์‚ฐ์ž

๋น„๊ต ์—ฐ์‚ฐ์ž ์„ค๋ช…
x <  y x๊ฐ€ y๋ณด๋‹ค ์ž‘๋‹ค
x > y x๊ฐ€ y๋ณด๋‹ค ํฌ๋‹ค
x == y x์™€ y๊ฐ€ ๊ฐ™๋‹ค
x != y x์™€ y๊ฐ€ ๊ฐ™์ง€ ์•Š๋‹ค
x >= y x๊ฐ€ y๋ณด๋‹ค ํฌ๊ฑฐ๋‚˜ ๊ฐ™๋‹ค
x <= y y์‚ฌ x๋ณด๋‹ค ํฌ๊ฑฐ๋‚˜ ๊ฐ™๋‹ค
// ๋ˆ์ด 3000์› ์ด์ƒ ์žˆ์œผ๋ฉด ํƒ์‹œ, ์•„๋‹ˆ๋ฉด ๊ฑท๊ธฐ
int money = 2000;
if (money > 3000) {
    System.out.println("ํƒ์‹œ");
} else {
    System.out.println("๊ฑท๊ธฐ");
}
 // ๊ฑท๊ธฐ

 

3) and, or, not ์—ฐ์‚ฐ์ž

์—ฐ์‚ฐ์ž ์„ค๋ช…
x && y x์™€ y ๋ชจ๋‘ ์ฐธ์ด์–ด์•ผ ์ฐธ
x || y x์™€ y ๋‘˜ ์ค‘์—์„œ ์ ์–ด๋„ ํ•˜๋‚˜๊ฐ€ ์ฐธ์ด๋ฉด ์ฐธ
!x x๊ฐ€ ๊ฑฐ์ง“์ด๋ฉด ์ฐธ
// ์นด๋“œ๊ฐ€ ์žˆ๊ฑฐ๋‚˜ ๋ˆ์ด3000์› ์ด์ƒ ์žˆ์œผ๋ฉด ํƒ์‹œ, ์•„๋‹ˆ๋ฉด ๊ฑท๊ธฐ
int money = 2000;
boolean card = true;
if (money > 3000 || card) {
    System.out.println("ํƒ์‹œ");
} else {
    System.out.println("๊ฑท๊ธฐ");
}

// ํƒ์‹œ

 

4)  contains

- ํ•ด๋‹น ์•„์ดํ…œ์ด ์žˆ๋Š”์ง€ ์กฐ์‚ฌํ•˜๋Š” ๋ฉ”์„œ๋“œ / ์กฐ๊ฑด๋ฌธ์— ๋งŽ์ด ํ™œ์šฉ๋œ๋‹ค

import java.util.ArrayList;

public class money {
	public static void main(String[] args) {
	ArrayList<String> pocket = new ArrayList<String>();
	pocket.add("paper");
	pocket.add("cellphone");
	pocket.add("money");
	
	if (pocket.contains("money")) {
		System.out.println("ํƒ์‹œ๋ฅผ ํƒ€๊ณ  ๊ฐ€๋ผ");
	} else {
		System.out.println("๊ฑธ์–ด๊ฐ€๋ผ");
	}
	
	}
}

// ํƒ์‹œ๋ฅผ ํƒ€๊ณ  ๊ฐ€๋ผ

 

5) else if

- ์žˆ๋‹ค์™€ ์—†๋‹ค์ค‘์— ์—†์„ ๊ฒฝ์šฐ ๋‹ค์‹œ ๊ฒฝ์šฐ๋ฅผ ๋‚˜๋ˆ„์–ด์ฃผ๋Š” ์กฐ๊ฑด๋ฌธ์— ํ•ด๋‹นํ•œ๋‹ค

(if, else๊ฐ€ ์—ฌ๋Ÿฌ๋ฒˆ ์‚ฌ์šฉ๋˜์–ด ํ•œ ๋ฒˆ์— ์ดํ•ดํ•˜๊ธฐ๊ฐ€ ์‰ฝ์ง€ ์•Š๊ณ  ์‚ฐ๋งŒํ•œ ๋Š๋‚Œ์ด๋“œ๋Š๋ฐ... ์ด๋ฅผ ๋ณด์™„ํ•˜๊ธฐ ์œ„ํ•ด์„œ... ์ž๋ฐ”๋Š” ์—ฌ๋Ÿฌ ์กฐ๊ฑด์„ ํŒ๋‹จํ•  ์ˆ˜ ์žˆ๊ฒŒ ํ•˜๋Š” else if ๋ฌธ์ด ์žˆ๋‹ค)

package test;
import java.util.ArrayList;

public class money {
	public static void main(String[] args) {
	boolean hasCard = true;
	ArrayList<String> pocket = new ArrayList<String>();
	pocket.add("paper");
	pocket.add("cellphone");
	
	if (pocket.contains("money")) {
		System.out.println("ํƒ์‹œ๋ฅผ ํƒ€๊ณ  ๊ฐ€๋ผ");
	} else {
		if (hasCard) {
			System.out.println("ํƒ์‹œ๋ฅผ ํƒ€๊ณ  ๊ฐ€๋ผ");
		}else {
			System.out.println("๊ฑธ์–ด๊ฐ€๋ผ");
		}
	}
	
	}
}

// ํƒ์‹œ๋ฅผ ํƒ€๊ณ  ๊ฐ€๋ผ

 

์•„๋ž˜ else if ๋ถ€๋ถ„๋“ค์„ ์ˆ˜์ •ํ•˜๋ฉด ์กฐ๊ธˆ ๊ฐ„๋‹จํ•˜๊ฒŒ ๋‚˜ํƒ€๋‚ด๋ฉด ์•„๋ž˜๋กœ ๋‚˜ํƒ€๋‚ด์งˆ ์ˆ˜ ์žˆ๋‹ค / else if๋Š” ๊ฐœ์ˆ˜์ œํ•œ ์—†์ด ์‚ฌ์šฉ ๊ฐ€๋Šฅ

	if (pocket.contains("money")) {
		System.out.println("ํƒ์‹œ๋ฅผ ํƒ€๊ณ  ๊ฐ€๋ผ");
	}else if (hasCard) {
		System.out.println("ํƒ์‹œ๋ฅผ ํƒ€๊ณ  ๊ฐ€๋ผ");
	}else {
		System.out.println("๊ฑธ์–ด๊ฐ€๋ผ");
	}

 

2. switch / case ๋ฌธ

: if ๋ฌธ๊ณผ ๋น„์Šทํ•˜์ง€๋งŒ ์ข€ ๋” ์ผ์ •ํ•œ ํ˜•์‹์ด ์ž‡๋Š” ์กฐ๊ฑด๋ฌธ..

=> ์ž…๋ ฅ ๋ณ€์ˆ˜์˜ ๊ฐ’๊ณผ ์ผ์น˜ํ•˜๋Š” case ์ž…๋ ฅ๊ฐ’(์ž…๋ ฅ๊ฐ’1, ์ž…๋ ฅ๊ฐ’2,....) ์ด ์žˆ๋‹ค๋ฉด ํ•ด๋‹น case ๋ฌธ์— ์†ํ•œ ๋ฌธ์žฅ๋“ค์ด ์‹คํ–‰๋œ๋‹ค...

  break ๋ฌธ ๋˜ํ•œ ์กด์žฌ(ํ•ด๋‹น case๋ฌธ์„ ์‹คํ–‰ํ•œ ๋’ค swirch ๋ฌธ์„ ๋น ์ ธ๋‚˜๊ฐ€๊ธฐ ์œ„ํ•จ), break ๋ฌธ์ด ์—†๋‹ค๋ฉด, ๋‹ค์Œ case๋กœ ์ด๋™

 

package test;
import java.util.ArrayList;

public class money {
	public static void main(String[] args) {
		int month = 8;
		String monthString = " ";
		switch(month) {
		case 1: monthString = "January";
		break;
		case 2: monthString = "February";
		break;
		case 3: monthString = "March";
		break;
		case 4: monthString = "April";
		break;
		case 5: monthString = "May";
		break;
		case 6: monthString = "June";
		break;
		case 7: monthString = "July";
		break;
		case 8: monthString = "August";
		break;
		case 9: monthString = "September";
		break;
		case 10: monthString = "October";
		break;
		case 11: monthString = "November";
		break;
		case 12: monthString = "December";
		break;
		default: monthString = "Invalid month";
		break;
		}
		System.out.println(monthString);
	}
}

ํ•ด๋‹นํ•˜๋Š” ์ˆซ์ž์— ๋Œ€ํ•œ case๊ฐ€ ์‹คํ–‰๋˜์—ˆ๋‹ค!!

๋งŒ์•ฝ month๊ฐ€ 1์—์„œ 12์‚ฌ์ด์˜ ์ˆซ์ž๊ฐ€ ์•„๋‹Œ ๋‹ค๋ฅธ ๊ฐ’์ด ์ €์žฅ๋˜์–ด ์žˆ๋‹ค๋ฉด defaul: ๋ฌธ์žฅ์ด ์ˆ˜ํ–‰๋œ๋‹ค!

๊ฐ’์ด ์ •ํ˜•ํ™”๋˜์–ด ์žˆ๋Š” ๊ฒฝ์šฐ if ๋ฌธ๋ณด๋‹ค๋Š” switch/case ๋ฌธ์„ ์“ฐ๋Š” ๊ฒƒ์ด ์ฝ”๋“œ์˜ ๊ฐ€๋…์„ฑ์ด ์ข‹๋‹ค!!

 

3. while ๋ฌธ

: ์กฐ๊ฑด๋ฌธ์ด ์ฐธ์ธ ๋™์•ˆ ์ˆ˜ํ–‰ํ•  ๋ฌธ์žฅ๋“ค์„ ๋ฐ˜๋ณตํ•ด์„œ ์ˆ˜ํ–‰ํ•œ๋‹ค

package test;

public class tree {
	public static void main(String[] args) {
		int treeHit = 0;
		while (treeHit < 10) {
			treeHit++; // treeHit += 1; ๋กœ๋„ ํ‘œํ˜„๊ฐ€๋Šฅ
			System.out.println("๋‚˜๋ฌด๋ฅผ " + treeHit + "๋ฒˆ ์ฐ์—ˆ์Šต๋‹ˆ๋‹ค.");
			if (treeHit == 10) {
				System.out.println("๋‚˜๋ฌด ๋„˜์–ด๊ฐ‘๋‹ˆ๋‹ค.");
			}
		}

	}
}

/*
๋‚˜๋ฌด๋ฅผ 1๋ฒˆ ์ฐ์—ˆ์Šต๋‹ˆ๋‹ค.
๋‚˜๋ฌด๋ฅผ 2๋ฒˆ ์ฐ์—ˆ์Šต๋‹ˆ๋‹ค.
๋‚˜๋ฌด๋ฅผ 3๋ฒˆ ์ฐ์—ˆ์Šต๋‹ˆ๋‹ค.
๋‚˜๋ฌด๋ฅผ 4๋ฒˆ ์ฐ์—ˆ์Šต๋‹ˆ๋‹ค.
๋‚˜๋ฌด๋ฅผ 5๋ฒˆ ์ฐ์—ˆ์Šต๋‹ˆ๋‹ค.
๋‚˜๋ฌด๋ฅผ 6๋ฒˆ ์ฐ์—ˆ์Šต๋‹ˆ๋‹ค.
๋‚˜๋ฌด๋ฅผ 7๋ฒˆ ์ฐ์—ˆ์Šต๋‹ˆ๋‹ค.
๋‚˜๋ฌด๋ฅผ 8๋ฒˆ ์ฐ์—ˆ์Šต๋‹ˆ๋‹ค.
๋‚˜๋ฌด๋ฅผ 9๋ฒˆ ์ฐ์—ˆ์Šต๋‹ˆ๋‹ค.
๋‚˜๋ฌด๋ฅผ 10๋ฒˆ ์ฐ์—ˆ์Šต๋‹ˆ๋‹ค.
๋‚˜๋ฌด ๋„˜์–ด๊ฐ‘๋‹ˆ๋‹ค.
*/

while๋ฌธ์˜ ์กฐ๊ฑด๋ฌธ : treeHit < 10 (10๋ณด๋‹ค ์ž‘์€ ๋™์•ˆ ์ˆ˜ํ–‰) / +1 ์ปค์ง€๋ฉด์„œ ์ˆ˜ํ–‰ํ•˜๊ณ  / 10์ด ๋˜๋ฉด์„œ ์ข…๋ฃŒ.. while ๋ฌธ ๋น ์ ธ๋‚˜์˜ด

 

 

1) ๋ฌดํ•œ ๋ฃจํ”„

: ๋ฌดํ•œํ•˜๊ฒŒ while ๋ฌธ ๋‚ด์˜ ๋ฌธ์žฅ๋“ค์„ ์ˆ˜ํ–‰... ๋น ์ ธ๋‚˜์˜ค์ง€ ๋ชปํ•œ๋‹ค...

package test;

public class loop {
	public static void main(String[] args) {
		while (true) {
			System.out.println("Ctrl-C๋ฅผ ๋ˆŒ๋Ÿฌ์•ผ while๋ฌธ์„ ๋น ์ ธ๋‚˜๊ฐˆ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.");
		}
	}
}

/*
Ctrl-C๋ฅผ ๋ˆŒ๋Ÿฌ์•ผ while๋ฌธ์„ ๋น ์ ธ๋‚˜๊ฐˆ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
Ctrl-C๋ฅผ ๋ˆŒ๋Ÿฌ์•ผ while๋ฌธ์„ ๋น ์ ธ๋‚˜๊ฐˆ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
Ctrl-C๋ฅผ ๋ˆŒ๋Ÿฌ์•ผ while๋ฌธ์„ ๋น ์ ธ๋‚˜๊ฐˆ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
...
*/

[Ctrl] + [c] : ์ข…๋ฃŒ

 

2) while ๋ฌธ ๋น ์ ธ๋‚˜๊ฐ€๊ธฐ - break

: while ๋ฌธ์„ ๊ฐ•์ œ๋กœ ๋ฉˆ์ถฐ์•ผ ํ•  ๋•Œ ์‚ฌ์šฉํ•œ๋‹ค

package test;

public class loop {
	public static void main(String[] args) {
		int coffee = 10;
		int money = 300;
		
		while (money > 0) {
			System.out.println("๋ˆ์„ ๋ฐ›์•˜์œผ๋‹ˆ ์ปคํ”ผ๋ฅผ ์ค๋‹ˆ๋‹ค.");
			coffee--;
			System.out.println("๋‚จ์€ ์ปคํ”ผ์˜ ์–‘์€ " + coffee + "์ž…๋‹ˆ๋‹ค.");
			if (coffee == 0) {
				System.out.println("์ปคํ”ผ๊ฐ€ ๋‹ค ๋–จ์–ด์กŒ์Šต๋‹ˆ๋‹ค. ํŒ๋งค๋ฅผ ์ค‘์ง€ํ•ฉ๋‹ˆ๋‹ค.");
				break;
			}
		}
	}
}

/*
๋ˆ์„ ๋ฐ›์•˜์œผ๋‹ˆ ์ปคํ”ผ๋ฅผ ์ค๋‹ˆ๋‹ค.
๋‚จ์€ ์ปคํ”ผ์˜ ์–‘์€ 9์ž…๋‹ˆ๋‹ค.
๋ˆ์„ ๋ฐ›์•˜์œผ๋‹ˆ ์ปคํ”ผ๋ฅผ ์ค๋‹ˆ๋‹ค.
๋‚จ์€ ์ปคํ”ผ์˜ ์–‘์€ 8์ž…๋‹ˆ๋‹ค.
๋ˆ์„ ๋ฐ›์•˜์œผ๋‹ˆ ์ปคํ”ผ๋ฅผ ์ค๋‹ˆ๋‹ค.
๋‚จ์€ ์ปคํ”ผ์˜ ์–‘์€ 7์ž…๋‹ˆ๋‹ค.
๋ˆ์„ ๋ฐ›์•˜์œผ๋‹ˆ ์ปคํ”ผ๋ฅผ ์ค๋‹ˆ๋‹ค.
๋‚จ์€ ์ปคํ”ผ์˜ ์–‘์€ 6์ž…๋‹ˆ๋‹ค.
๋ˆ์„ ๋ฐ›์•˜์œผ๋‹ˆ ์ปคํ”ผ๋ฅผ ์ค๋‹ˆ๋‹ค.
๋‚จ์€ ์ปคํ”ผ์˜ ์–‘์€ 5์ž…๋‹ˆ๋‹ค.
๋ˆ์„ ๋ฐ›์•˜์œผ๋‹ˆ ์ปคํ”ผ๋ฅผ ์ค๋‹ˆ๋‹ค.
๋‚จ์€ ์ปคํ”ผ์˜ ์–‘์€ 4์ž…๋‹ˆ๋‹ค.
๋ˆ์„ ๋ฐ›์•˜์œผ๋‹ˆ ์ปคํ”ผ๋ฅผ ์ค๋‹ˆ๋‹ค.
๋‚จ์€ ์ปคํ”ผ์˜ ์–‘์€ 3์ž…๋‹ˆ๋‹ค.
๋ˆ์„ ๋ฐ›์•˜์œผ๋‹ˆ ์ปคํ”ผ๋ฅผ ์ค๋‹ˆ๋‹ค.
๋‚จ์€ ์ปคํ”ผ์˜ ์–‘์€ 2์ž…๋‹ˆ๋‹ค.
๋ˆ์„ ๋ฐ›์•˜์œผ๋‹ˆ ์ปคํ”ผ๋ฅผ ์ค๋‹ˆ๋‹ค.
๋‚จ์€ ์ปคํ”ผ์˜ ์–‘์€ 1์ž…๋‹ˆ๋‹ค.
๋ˆ์„ ๋ฐ›์•˜์œผ๋‹ˆ ์ปคํ”ผ๋ฅผ ์ค๋‹ˆ๋‹ค.
๋‚จ์€ ์ปคํ”ผ์˜ ์–‘์€ 0์ž…๋‹ˆ๋‹ค.
์ปคํ”ผ๊ฐ€ ๋‹ค ๋–จ์–ด์กŒ์Šต๋‹ˆ๋‹ค. ํŒ๋งค๋ฅผ ์ค‘์ง€ํ•ฉ๋‹ˆ๋‹ค.
*/

๋ˆ์ด 0๋ณด๋‹ค ํด๋•Œ๋™์•ˆ ์ง„ํ–‰ํ•˜๋‹ค... 0์ด ๋˜์–ด๋ฒ„๋ฆฌ๋ฉด ์ถœ๋ ฅํ›„ break๊ฐ€ ํ˜ธ์ถœ๋˜์–ด while ๋ฌธ์„ ๋น ์ ธ๋‚˜๊ฐ„๋‹ค

 

3) while ๋ฌธ์œผ๋กœ ๋Œ์•„๊ฐ€๊ธฐ - continue

: while ๋ฌธ ์•ˆ์˜ ๋ฌธ์žฅ์„ ์ˆ˜ํ–‰ํ•  ๋•Œ ์–ด๋–ค ์กฐ๊ฑด์„ ๊ฒ€์‚ฌํ•ด์„œ ์ฐธ์ด ์•„๋‹Œ ๊ฒฝ์šฐ while ๋ฌธ์„ ๋น ์ ธ๋‚˜๊ฐ€๋Š” ๋Œ€์‹  while ๋ฌธ์˜ ๋งจ ์ฒ˜์Œ, ์ฆ‰ ์กฐ๊ฑด๋ฌธ์œผ๋กœ ๋Œ์•„๊ฐ€๊ฒŒ ํ•˜๊ณ  ์‹ถ์€ ๊ฒฝ์šฐ continue๋ฅผ ์‚ฌ์šฉ(๋น ์ ธ๋‚˜๊ฐ€์ง€ ์•Š๊ณ  ๋‹ค์‹œ ์˜ฌ๋ผ๊ฐ€์„œ ์ง„ํ–‰)

package test;

public class loop {
	public static void main(String[] args) {
		int a = 0;
		while (a < 10) {
			a++;
			if (a % 2 == 0) {
				continue; // ์ง์ˆ˜์ธ ๊ฒฝ์šฐ ์กฐ๊ฑด๋ฌธ์œผ๋กœ ๋Œ์•„๊ฐ„๋‹ค.
			}
			System.out.println(a); // ํ™€์ˆ˜๋งŒ ์ถœ๋ ฅ๋œ๋‹ค
		}
	}
}

/*
1
3
5
7
9
*/

a๊ฐ€ ์ง์ˆ˜์ด๋ฉด continue๋ฌธ์ด ์‹คํ–‰๋˜์–ด while ๋ฌธ์˜ ๋งจ ์ฒ˜์Œ์œผ๋กœ ๋Œ์•„๊ฐ€๊ฒŒ ํ•œ๋‹ค!! 

๊ทธ๋Ÿฌ๋ฏ€๋กœ a๊ฐ€ ์ง์ˆ˜์ด๋ฉด System.out.println(a)๋Š” ์ˆ˜ํ–‰๋˜์ง€ ์•Š๊ธฐ ๋•Œ๋ฌธ์— ํ™€์ˆ˜๋งŒ ์ถœ๋ ฅ๋  ๊ฒƒ์ด๋‹ค!!!!

 

4. for ๋ฌธ

: ๋ฌธ์žฅ์„ ๋ฐ˜๋ณตํ•ด์„œ ์ˆ˜ํ–‰ํ•ด์•ผ ํ•  ๊ฒฝ์šฐ์— ์‚ฌ์šฉ

 

1) for ๋ฌธ์˜ ๊ธฐ๋ณธ ๊ตฌ์กฐ

// ๊ธฐ๋ณธ ๊ตฌ์กฐ
for (์ดˆ๊นƒ๊ฐ’; ์กฐ๊ฑด๋ฌธ; ์ฆ๊ฐ“๊ฐ’) {
	...
}

/////
String[] numbers = ["one", "two", "three"]
for (int i = 0; i < numbers.length; i++) :
	System.out.println(numvers[i]);
}
/*
one
two
three
*/

i์˜ ์ดˆ๊นƒ๊ฐ’์€ 0, ์กฐ๊ฑด๋ฌธ์€ i < numbers.length, ์ฆ๊ฐ“๊ฐ’์€ i++์ด ๋œ๋‹ค!!

=> i ๊ฐ’์ด numbers์˜ ๊ฐœ์ˆ˜๋ณด๋‹ค ์ž‘์€ ๋™์•ˆ ๊ณ„์† i ๊ฐ’์„ 1์”ฉ ์ฆ๊ฐ€์‹œํ‚ค๋ฉฐ for ๋ฌธ์˜ ๋ฌธ์žฅ๋“ค์„ ์ˆ˜ํ–‰

 

2) for ๋ฌธ์œผ๋กœ ๋Œ์•„๊ฐ€๊ธฐ - continue

: while ๋ฌธ๊ณผ ๋งˆ์ฐฌ๊ฐ€์ง€๋กœ ์ ์šฉ!

int[] marks = {90, 25, 67, 45, 80};
for (int i = 0; i < marks.length; i++) {
	if (marks[i] < 60) {
    	continue; // ์กฐ๊ฑด๋ฌธ์œผ๋กœ ๋Œ์•„๊ฐ„๋‹ค.
    }
    System.out.println((i+1)+"๋ฒˆ ํ•™์ƒ ์ถ•ํ•˜ํ•ฉ๋‹ˆ๋‹ค. ํ•ฉ๊ฒฉ์ž…๋‹ˆ๋‹ค.");
}

/*
1๋ฒˆ ํ•™์ƒ ์ถ•ํ•˜ํ•ฉ๋‹ˆ๋‹ค. ํ•ฉ๊ฒฉ์ž…๋‹ˆ๋‹ค.
3๋ฒˆ ํ•™์ƒ ์ถ•ํ•˜ํ•ฉ๋‹ˆ๋‹ค. ํ•ฉ๊ฒฉ์ž…๋‹ˆ๋‹ค.
5๋ฒˆ ํ•™์ƒ ์ถ•ํ•˜ํ•ฉ๋‹ˆ๋‹ค. ํ•ฉ๊ฒฉ์ž…๋‹ˆ๋‹ค.
*/

์ ์ˆ˜๊ฐ€ 60์  ๋ฏธ๋งŒ์ด๋ฉด continue๋ฌธ์ด ์‹คํ•ด๋˜์–ด ์ถ•ํ•˜๋ฉ”์‹œ์ง€๋ฅผ ์ถœ๋ ฅํ•˜๋Š” ๋ถ€๋ถ„์ด ์ˆ˜ํ–‰ํ•˜์ง€ ์•Š๊ณ , 

for ๋ฌธ์˜ ์ฒซ๋ถ€๋ถ„์œผ๋กœ ๋Œ์•„๊ฐ‘๋‹ˆ๋‹ค!!!

=> ๋ฐ˜๋ณต๋ฌธ์„ ์ˆ˜ํ–‰ํ•  ๋•Œ, ํŠน์ • ์กฐ๊ฑด์—์„œ๋Š” ์ˆ˜ํ–‰ํ•˜์ง€ ์•Š๊ณ  ๊ฑด๋„ˆ๋›ฐ์–ด์•ผ ํ•  ๋•Œ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค!!!!

 

3) ์ด์ค‘ for ๋ฌธ

: for ๋ฌธ์„ ๋‘๋ฒˆ ์‚ฌ์šฉํ•œ ๊ฒƒ..

// ๊ตฌ๊ตฌ๋‹จ ๋งŒ๋“ค๊ธฐ
package test;

public class gugudan {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		for (int i=2; i < 10; i++) {
			for (int j=1; j <10; j++) {
				System.out.print(i*j+" ");
			}
			System.out.println(""); // ์ค„์„ ๋ฐ”๊พธ์–ด ์ถœ๋ ฅํ•˜๋Š” ์—ญํ• ์„ ํ•œ๋‹ค
		}
	}
}

/*
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 
*/

๋‹จ์ด ๋ฐ”๋€”๋•Œ println์„ ์‚ฌ์šฉํ•˜์—ฌ ์ค„๋ฐ”๊ฟˆํ•˜์—ฌ ๋ฌธ์ž๋ฅผ ์ถœ๋ ฅํ•˜์˜€๋‹ค!!

 

5. for each ๋ฌธ

: ์ด์ „์— ๋ฐฐ์› ๋˜ for๋ฌธ์„ ํ™œ์šฉํ•œ ์˜ˆ์ œ(์ฒจ๋ด„)

// for each ๋ฌธ์˜ ๊ตฌ์กฐ
for (type ๋ณ€์ˆ˜๋ช…: iterate) {
	body-of-loop
}

iterate๋Š” ๋ฃจํ”„๋ฅผ ๋Œ๋ฆด ๊ฐ์ฒด์ด๊ณ  iterate ๊ฐ์ฒด์—์„œ ํ•œ ๊ฐœ์”ฉ ์ˆœ์ฐจ์ ์œผ๋กœ ๋ณ€์ˆ˜๋ช…์— ๋Œ€์ž…๋˜์–ด for ๋ฌธ์ด ์ˆ˜ํ–‰๋œ๋‹ค...

iterate์— ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋Š” ์ž๋ฃŒํ˜•์€ ๋ฃจํ”„๋ฅผ ๋Œ๋ฆด ์ˆ˜ ์žˆ๋Š” ์ž๋ฃŒํ˜•(๋ฐฐ์—ด์ด๋‚˜ ArrayList๋“ฑ)๋งŒ ๊ฐ€๋Šฅํ•˜๋‹ค...

+ ๋ณ€์ˆ˜๋ช…์˜ type(์ž๋ฃŒํ˜•)์€ iterate ๊ฐ์ฒด์— ํฌํ•จ๋œ ์ž๋ฃŒํ˜•๊ณผ ์ผ์น˜ํ•ด์•ผํ•œ๋‹ค!!!

 

String[] numbers = {"one", "two", "three"};
for(int i = 0; i < numbers.lengh; i++) {
	System.out.println(numbers[i]);
}

// for each ๋ฌธ์„ ์‚ฌ์šฉํ•œ๋‹ค๋ฉด...
String[] numbers = {"one", "two", "three"};
for(String number: numbers) {
	System.out.println(number);
}

 

๋ฌธ์ œ...

1. everywhere

2. i % 3 == 0

3. i >5 / int j=0; j <5; j++;

4. int i = 1; i < 101; i++;

5. int mark: marks / total / marks.length;

 

728x90
๋ฐ˜์‘ํ˜•
728x90
๋ฐ˜์‘ํ˜•

1) ์ œ์–ด๋ฌธ

  : ์‹คํ–‰๋ฌธ์˜ ์ˆ˜ํ–‰ ์ˆœ์„œ๋ฅผ ๋ณ€๊ฒฝํ•˜๋Š” ๊ฒƒ (์กฐ๊ฑด๋ฌธ, ๋ฐ˜๋ณต๋ฌธ, ๋ถ„๊ธฐ๋ฌธ์œผ๋กœ ๊ตฌ๋ถ„) 

 

  • ์กฐ๊ฑด๋ฌธ : ์กฐ๊ฑด์‹์˜ ๊ฒฐ๊ณผ์— ๋”ฐ๋ผ ์—ฌ๋Ÿฌ ์‹คํ–‰ ๊ฒฝ๋กœ  ์ค‘ ํ•˜๋‚˜๋ฅผ ์„ ํƒํ•œ๋‹ค. ์„ ํƒ๋ฌธ์ด๋ผ๊ณ ๋„ ํ•œ๋‹ค. ex)  ๋‹ค์–‘ํ•œ ์ข…๋ฅ˜์˜ if ๋ฌธ,  switch ๋ฌธ
  • ๋ฐ˜๋ณต๋ฌธ : ์กฐ๊ฑด์— ๋”ฐ๋ผ ๊ฐ™์€ ์ฒ˜๋ฆฌ๋ฅผ ๋ฐ˜๋ณตํ•œ๋‹ค ex)  for ๋ฌธ, while ๋ฌธ, do~while ๋ฌธ
  • ๋ถ„๊ธฐ๋ฌธ : ์‹คํ–‰ ํ๋ฆ„์„ ๋ฌด์กฐ๊ฑด ๋ณ€๊ฒฝํ•˜๋Š” break ๋ฌธ๊ณผ continue ๋ฌธ์ด ์žˆ๋‹ค.
  • ์ œ์–ด๋ฌธ ๋‚ด๋ถ„์— ๋‹ค๋ฅธ ์ œ์–ด๋ฌธ์„ ํฌํ•จํ•  ์ˆ˜ ์žˆ์–ด ์ œ์–ด๋ฌธ์„ ์‚ฌ์šฉํ•˜๋ฉด ํ๋ฆ„์ด ๋ณต์žกํ•œ ํ”„๋กœ๊ทธ๋žจ๋„ ๊ฐœ๋ฐœํ•  ์ˆ˜ ์žˆ๋‹ค.

 

2) ์กฐ๊ฑด๋ฌธ 

 

2-1) ๋‹จ์ˆœ if ๋ฌธ 

  • ์กฐ๊ฑด์‹์ด true์ผ ๋•Œ๋งŒ ์‹คํ–‰๋ฌธ์„ ์ˆ˜ํ–‰ํ•œ๋‹ค
  • ์กฐ๊ฑด์‹์ด true์ผ ๋•Œ ์‹คํ–‰๋ฌธ์ด ํ•˜๋‚˜๋ผ๋ฉด { } ๋ฅผ ์ƒ๋žตํ•  ์ˆ˜ ์žˆ๋‹ค

2-2) if~else ๋ฌธ 

  • ์กฐ๊ฑด์‹์˜ true๋‚˜ false์— ๋”ฐ๋ผ ๋‹ค๋ฅธ ์‹คํ–‰๋ฌธ์„ ์ˆ˜ํ–‰ํ•  ๋•Œ ์‚ฌ์šฉํ•œ๋‹ค

import java.util.Scanner;

public class java0402 {

       public static void main(String[] args) {

              Scanner in = new Scanner(System.in);

              System.out.print("์ˆซ์ž๋ฅผ ์ž…๋ ฅํ•˜์„ธ์š”:");

              int number = in.nextInt();

              if (number % 2 == 0)

                   System.out.println("์ง์ˆ˜!");

              else

                    System.out.println("ํ™€์ˆ˜!");

               System.out.println("์ข…๋ฃŒ");

         }

}

9~12ํ–‰๊ณผ ๊ฐ™์ด ๋‹จ์ˆœํ•œ if~else ๋ฌธ์€ ์กฐ๊ฑด ์—ฐ์‚ฐ์ž๋ฅผ ์‚ฌ์šฉํ•ด ๋” ๊ฐ„๊ฒฐํ•˜๊ฒŒ ํ‘œํ˜„ํ•  ์ˆ˜ ์žˆ๋‹ค

 

=> System.out.println(number % 2 == 0 ? "์ง์ˆ˜!" : "ํ™€์ˆ˜!");

 

2-3) ๋‹ค์ค‘ if ๋ฌธ 

 

  • ์กฐ๊ฑด์ด ๋‹ค์–‘ํ•  ๋•Œ๋Š” ๋‹ค์ค‘ if ๋ฌธ์œผ๋กœ ํ‘œํ˜„ํ•˜๋ฉด ์ข‹๋‹ค
  • if ๋ฌธ ๋‹ค์Œ์— else if ๋ฌธ์„ ์—ฐ์† ์ถ”๊ฐ€ํ•ด ๊ฐ ์กฐ๊ฑด์„ ์ฐจ๋ก€๋Œ€๋กœ ์ ๊ฒ€ํ•œ ํ›„ ๋งŒ์กฑํ•˜๋Š” ์‹คํ–‰๋ฌธ์„ ์ˆ˜ํ–‰ํ•œ๋‹ค
  • ๋‹ค์ค‘ if ๋ฌธ์€ ์—ฌ๋Ÿฌ ์กฐ๊ฑด ์ค‘ ํ•˜๋‚˜๋งŒ ture๋กœ์จ ํ•ด๋‹น ์‹คํ–‰๋ฌธ์„ ์ˆ˜ํ–‰ํ•˜๊ณ , ๋‚˜๋จธ์ง€๋Š” ๋” ์ด์ƒ ๋น„๊ตํ•˜์ง€ ์•Š๋Š”๋‹ค.

2-4) ์ค‘์ฒฉ if ๋ฌธ

 

  • if ๋ฌธ์— ๋‹ค๋ฅธ if ๋ฌธ์ด ํฌํ•จ๋˜๋Š” ๊ฒƒ
  • ์ค‘์ฒฉ if ๋ฌธ์—๋Š” if ์ ˆ๊ณผ else ์ ˆ์— ๊ด€๋ จ๋œ ์‹คํ–‰๋ฌธ์ด ๋ช…ํ™•ํ•˜๊ฒŒ ํ‘œ์‹œ๋˜๋„๋ก ์ค‘๊ด„ํ˜ธ๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด ์ข‹๋‹ค.(์‚ฌ์šฉ ์•ˆํ•ด๋„ ์‹คํ–‰์€ ๊ฐ€๋Šฅํ•˜์ง€๋งŒ ํ˜ผ๋ž€์Šค๋Ÿฌ์šธ ์ˆ˜ ์žˆ๋‹ค)

์™ผ์ชฝ if ๋ฌธ์˜ ๊ฒฝ์šฐ ๋“ค์—ฌ์“ฐ๊ธฐ๋ฅผ ์ž˜๋ชปํ•ด์„œ ๋งˆ์น˜ else์ ˆ์ด ์™ธ๋ถ€ if ๋ฌธ๊ณผ ์—ฐ๊ฒฐ๋˜์–ด ์žˆ๋Š” ๊ฒƒ์ฒ˜๋Ÿผ ๋ณด์ธ๋‹ค.

 

3) ๋ฐ˜๋ณต๋ฌธ

 

3-1) while ๋ฌธ

 

  • ๋ฐ˜๋ณตํ•  ํšŸ์ˆ˜๋Š” ๋ฏธ๋ฆฌ ์•Œ ์ˆ˜ ์—†์ง€๋งŒ ์กฐ๊ฑด์€ ์•Œ ์ˆ˜ ์žˆ์„ ๋•Œ ์ฃผ๋กœ ์‚ฌ์šฉํ•˜๋Š” ๋ฐ˜๋ณต๋ฌธ
  • ์กฐ๊ฑด์‹์ด true ์ผ ๋™์•ˆ ๋ณธ์ฒด ์‹คํ–‰๋ฌธ์„ ๋ฐ˜๋ณต์ ์œผ๋กœ ์ˆ˜ํ–‰ํ•œ๋‹ค.
  • ์กฐ๊ฑด์‹์ด false์ด๋ฉด while ๋ฌธ ๋‹ค์Œ ์‹คํ–‰๋ฌธ์„ ์ˆ˜ํ–‰ํ•œ๋‹ค.

public class WhileDemo_2 {

         public static void main(String[] args) {

                int i = 1;

                while (i < 5) {

                System.out.print(i);

                  i++;

                }

          }

 }

i ๊ฐ’์ด 5๋ณด๋‹ค ์ž‘์„ ๋™์•ˆ ๋ฐ˜๋ณตํ•ด ์‹คํ–‰ํ•˜๋ฏ€๋กœ

๊ฒฐ๊ณผ๋Š”

1234

 

3-2) do~while ๋ฌธ

 

  •  while ๋ฌธ๊ณผ ๋น„์Šทํ•˜์ง€๋งŒ ์กฐ๊ฑด์‹ ํ‰๊ฐ€์™€ ๋ณธ์ฒด ์‹คํ–‰ ์ˆœ์„œ๊ฐ€ ๋‹ค๋ฅด๋‹ค
  • ๋ฐ˜๋ณต๋ฌธ ๋ณธ์ฒด๋ฅผ ๋จผ์ € ์‹คํ–‰ํ•œ ํ›„ ์กฐ๊ฑด์‹์„ ํ‰๊ฐ€ํ•œ๋‹ค(์ตœ์†Œํ•œ ํ•œ ๋ฒˆ์€ ๋ฐ˜๋ณต๋ฌธ ๋ณธ์ฒด๋ฅผ ์‹คํ–‰ํ•œ๋‹ค)
  • ์„ธ๋ฏธ์ฝ”๋ก ์œผ๋กœ ๋๋‚ด์•ผ ํ•˜๋ฉฐ, while ๋ฌธ๊ณผ ๋งˆ์ฐฌ๊ฐ€์ง€๋กœ ์กฐ๊ฑด์‹์ด ์—†์„ ๋•Œ๋Š” ์ปดํŒŒ์ผ ์˜ค๋ฅ˜๊ฐ€ ๋ฐœ์ƒํ•œ๋‹ค.
  • ๊ทผ๋ฐ ์ฝ”๋“œ ๋ณผ๋•Œ ์ž˜ ๋ณธ์ ์ด ์—†๋Š”๊ฒƒ ๊ฐ™์Œ.. ๊ฑฐ์˜ ๋ฐ˜๋ณต๋ฌธํ•˜๋ฉด while์ด๋‚˜ for์„ ์‚ฌ์šฉํ–ˆ๋˜ ๋“ฏํ•จ..

public class DoWhile1Demo {

        public static void main(String[] args) {

               int i = 1;

               do {

                      System.out.print(i);

                       i++;

                } while(i<5);

         }

}

์—ฐ์† ์ˆซ์ž๋ฅผ ์ถœ๋ ฅํ•˜๋Š” ์˜ˆ์ œ๋Š” while ๋ฌธ์„ ์‚ฌ์šฉํ•˜๋“  do~while ๋ฌธ์„ ์‚ฌ์šฉํ•˜๋“  ๊ฐ„์— ๊ฒฐ๊ณผ๋Š” ๊ฐ™๋‹ค.

=> ์‹คํ–‰ ๊ฒฐ๊ณผ๋ฅผ ๋ณด๋ฉด, do~while ๋ฌธ์€ ๋ณธํ…Œ๋ฅผ ํ•œ ๋ฒˆ ์‹คํ–‰ํ•˜์ง€๋งŒ, while ๋ฌธ์€ ๋ณธ์ฒด๋ฅผ ํ•œ ๋ฒˆ๋„ ์‹คํ–‰ํ•˜์ง€ ์•Š์€ ์ฑ„๋กœ ์ข…๋ฃŒํ•œ ๊ฒƒ์„  ์•Œ ์ˆ˜ ์žˆ๋‹ค.

 

3-3) for ๋ฌธ

 

  • ๋ฐ˜๋ณตํ•  ํšŸ์ˆ˜๋ฅผ ๋ฏธ๋ฆฌ ์•Œ ์ˆ˜ ์žˆ์„ ๋•Œ ์ฃผ๋กœ ์‚ฌ์šฉํ•˜๋Š” ๋ฐ˜๋ณต๋ฌธ
  • ์กฐ๊ฑด์‹์ด true์ด๋ฉด ๋ณธ์ฒด ์‹คํ–‰๋ฌธ์„ ๋ฐ˜๋ณต์ ์œผ๋กœ ์ˆ˜ํ–‰ํ•œ๋‹ค.
  • ๋‹ค๋ฅธ ๋ฐ˜๋ณต๋ฌธ์— ๋น„ํ•ด ์ฝ”๋“œ์˜ ๊ธธ์ด๊ฐ€ ์งง์Œ!!(๋‚ด๊ฐ€ ๋Š๋ผ๊ธฐ์—), ๊ฐ€์žฅ ํšจ์œจ์ ์ž„

public class For1Demo {

       public static void main(String[] args) {

              for (int i = 1; i < 5; i++)

              System.out.print(i);

       }

}

  • for ๋ฌธ์€ ์ดˆ๊ธฐ์‹, ์กฐ๊ฑด์‹, ์ฆ๊ฐ์‹๋„ ์ƒ๋žตํ•  ์ˆ˜ ์žˆ๋Š”๋ฐ, ์ด๋•Œ๋Š” ๋ฌดํ•œ ๋ฐ˜๋ณต๋ฌธ์ด ๋œ๋‹ค.

  • for ๋ฌธ์—์„œ ์ดˆ๊ธฐ์‹์ด๋‚˜ ์ฆ๊ฐ์‹์ด 2๊ฐœ ์ด์ƒ ํ•„์š”ํ•˜๋‹ค๋ฉด ๋‹ค์Œ๊ณผ ๊ฐ™์ด ์‰ฝํ‘œ๋กœ ๊ตฌ๋ถ„ํ•ด์„œ ์ž‘์„ฑํ•œ๋‹ค.

 

4) ๋ถ„๊ธฐ๋ฌธ   **๋ถ„๊ธฐ๋ฌธ์„ ์‚ฌ์šฉํ•˜๋ฉด ํ”„๋กœ๊ทธ๋žจ ํ๋ฆ„์ด ๋ณต์žกํ•ด์ง€๊ธฐ ๋•Œ๋ฌธ์— ๊ผญ ํ•„์š”ํ•  ๋•Œ๋ฅผ ์ œ์™ธํ•˜๊ณ ๋Š” 3๊ฐ€ํ•˜3

 

4-1) break ๋ฌธ

 

  • ๋ฐ˜๋ณต๋ฌธ์ด๋‚˜ switch ๋ฌธ์˜ ๋ณธ์ฑ„๋ฅผ ๋ฒ—์–ด๋‚˜๋ ค๊ณ  ์ฃผ๋กœ ์‚ฌ์šฉ๋œ๋‹ค
  • ๋ ˆ์ด๋ธ”๊ณผ ํ•จ๊ป˜ ์‚ฌ์šฉํ•  ์ˆ˜๋„ ์žˆ๋‹ค. 
  • ๋ ˆ์ด๋ธ”์ด ์—†๋‹ค๋ฉด break ๋ฌธ์„ ํฌํ•จํ•˜๋Š” ๋งจ ์•ˆ์ชฝ ๋ฐ˜๋ณต๋ฌธ์„ ์ข…๋ฃŒํ•˜๊ณ , ๋ ˆ์ด๋ธ”์ด ์žˆ๋‹ค๋ฉด ๋ ˆ์ด๋ธ”๋กœ ํ‘œ์‹œ๋œ ์™ธ๋ถ€ ๋ฐ˜๋ณต๋ฌธ์„ ์ข…๋ฃŒ

public class BreakDemo {

        public static void main(String[] args) {

                int i = 1, j = 5;

                while (true) {

                      System.out.println(i++);

                       if (i >= j)

                           break;

               }

        }             

}

๋‹ต์€

1

2

3

4

4-2) continue ๋ฌธ

 

  • ๋ฐ˜๋ณต๋ฌธ์—์„œ๋งŒ ์‚ฌ์šฉ
  • continue๋ฌธ๋„ break ๋ฌธ์ฒ˜๋Ÿผ ๋ ˆ์ด๋ธ”์„ ๋ถ™์ผ ์ˆ˜ ์žˆ๋‹ค

public class ContinueDemo {

       public static void main(String[] args) {

              for (int i = 0; i < 10; i++) {

                    if (i % 2 == 0)

                        continue;

                    System.out.print(i);

             }

     }

}

๋‹ต์€

1

3

5

7

9

 

 

728x90
๋ฐ˜์‘ํ˜•

'java' ์นดํ…Œ๊ณ ๋ฆฌ์˜ ๋‹ค๋ฅธ ๊ธ€

java ๊ธฐ์ดˆ(ํŒจํ‚ค์ง€, ์ž์‹ ํด๋ž˜์Šค์™€ ๋ถ€๋ชจ ์ƒ์„ฑ์ž, ์ƒ์†๊ณผ ์ ‘๊ทผ์ œ์–ด  (0) 2023.04.07
java ๊ธฐ์ดˆ(๋ฌธ์ž์—ด์˜ ์„ ์–ธ๊ณผ ์ƒ์„ฑ, ๋ฌธ์žฅ์—ด์˜ ๋น„๊ต, ๋ฌธ์ž์—ด์˜ ๋‹ค์–‘ํ•œ ์—ฐ์‚ฐ, String ํด๋ž˜์Šค์—์„œ ์ œ๊ณตํ•˜๋Š” ์œ ์šฉํ•œ ์ •์  ๋ฉ”์„œ๋“œ, ๋ฐฐ์—ด๊ธฐ์ดˆ)  (0) 2023.04.06
์ •์ฒ˜๊ธฐ ์นด์šดํŠธ๋‹ค์šด ํ”„๋กœ๊ทธ๋žจ ๋งŒ๋“ค๊ธฐ(java, ํŒŒ์ด์ฌ), java ๊ธฐ์ดˆ(ํŒจํ‚ค์ง€, ํŒจํ‚ค์ง€ ์„ ์–ธ, import๋ฌธ, ์ƒ์†๊ณผ ์ ‘๊ทผ์ œ์–ด, final ํด๋ž˜์Šค)  (0) 2023.03.28
์—ฐ์‚ฐ์ž, ์ƒ์†(์ƒ์†์˜ ํ•„์š”์„ฑ, ์ƒ์†์ด๋ž€, ์ƒ์†์˜ ์„ ์–ธ, ๋ฉ”์„œ๋“œ ์˜ค๋ฒ„๋ผ์ด๋”ฉ, ์˜ค๋ฒ„๋กœ๋”ฉ ๋น„๊ต)  (0) 2023.03.27
java ๊ธฐ์ดˆ(๋ฐฐ์—ด ์‘์šฉ, ๊ฐ€๋ณ€ ๊ฐœ์ˆ˜ ์ธ์ˆ˜, ๊ฐ์ฒด์˜ ํƒ€์ž…, ์—ด๊ฑฐ ํƒ€์ž… ), ํŠน์ˆ˜๋ฌธ์ž ์›์ฃผ์œจ(ฯ€) ์“ฐ๋Š” ๋ฒ•  (0) 2023.03.25

+ Recent posts