์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
1 | ||||||
2 | 3 | 4 | 5 | 6 | 7 | 8 |
9 | 10 | 11 | 12 | 13 | 14 | 15 |
16 | 17 | 18 | 19 | 20 | 21 | 22 |
23 | 24 | 25 | 26 | 27 | 28 |
- ํ ์คํธ๋ถ์
- ์ธ๊ณต์ง๋ฅ
- ํ๋ธ๋ฃจ
- abap
- ๋ฐ์ดํฐ๋ถ์
- DFS
- ์์ฐ์ด์ฒ๋ฆฌ
- ๋ฅ๋ฌ๋
- ์ฝํ
- ์ฝ๋ฉํ ์คํธ
- ๋ฆฌ์กํธ
- ๊นํ๋ธ
- sap
- tableau
- erp
- ์๊ณ ๋ฆฌ์ฆ
- react
- nlp
- ๋ฐ์ดํฐ ๋ถ์
- AWS
- ํ์ด์ฌ
- ์๋ง์กด์น์๋น์ค
- ํ๋ธ๋ก
- github
- ๋น ๋ฐ์ดํฐ
- Git
- AI
- ์๋ฐ์คํฌ๋ฆฝํธ
- ํ ์คํธ๋ง์ด๋
- ๋ฐฑ์ค
- Today
- Total
DATA101
[Java] Syntactic Sugar ์๋ฏธ์ ์ผํญ์ฐ์ฐ์ ํ์ฉ ๋ฐฉ๋ฒ ๊ณต์ ! ๋ณธ๋ฌธ
[Java] Syntactic Sugar ์๋ฏธ์ ์ผํญ์ฐ์ฐ์ ํ์ฉ ๋ฐฉ๋ฒ ๊ณต์ !
DATA101 2021. 11. 17. 23:54๐ก ํ์ต ๋ชฉํ
Syntactic Sugar์ ์๋ฏธ์ Java์์ ์ผํญ์ฐ์ฐ์๋ฅผ ๋ค๋ฃจ๋ ๋ฐฉ๋ฒ์ ๋ํด ์ดํดํ๋ค.
Syntactic Sugar๋?
์ํคํผ๋์์์ ๊ฐ์ ธ์จ Syntactic Sugar ์๋ฏธ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
In computer science, syntactic sugar is syntax within a programming language that is designed to make things easier to read or to express. It makes the language "sweeter" for human use: things can be expressed more clearly, more concisely, or in an alternative style that some may prefer.
์ฆ, Syntactic Sugar๋ ์ฝ๋๋ฅผ ๋์ฑ ๊ฐ๊ฒฐํ๊ณ , ๋ช ํํ๊ฒ ์์ฑํจ์ผ๋ก์จ
๊ฐ๋ ์ฑ๊ณผ ์๋ฏธ ์ ๋ฌ๋ ฅ์ ๋์ด๋ ๊ธฐ๋ฒ์ ๋๋ค.
์์๋ฅผ ํตํด sugar code์ ๊ทธ๋ ์ง ์์ ์ฝ๋๋ฅผ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
Syntactic sugar ๋ถ์กฑ ์ฝ๋
int a = 10;
int b = 20;
int res;
// if~else ๊ตฌ๋ฌธ ํ์ฉ ์
if (a > b) {
res = a + b;
} else {
res = a - b;
}
System.out.println(res);
์์๋ ๋ ์ ์์ ํฌ๊ธฐ๋ฅผ ๋น๊ตํด ๊ฐ๊ธฐ ๋ค๋ฅธ ์ฐ์ฐ์ ์ํํ๊ณ ๊ฒฐ๊ด๊ฐ์ ์ถ๋ ฅํ๋ ์ฝ๋์ ๋๋ค.
if~else ๊ตฌ๋ฌธ์ ํ์ฉํด ๊ฐ ์กฐ๊ฑด์ ํด๋นํ๋ ์ฐ์ฐ์ ์ํํ๋๋ก ์ฝ๋๋ฅผ ์์ฑํ์์ต๋๋ค.
Java์์๋ ์ด์ฒ๋ผ if~else ๊ตฌ๋ฌธ์ ํ์ฉํด์ผ ํ๋ ์ํฉ ๋๋ค์์์๋ ์ผํญ์ฐ์ฐ์ ํ์ฉ์ ๊ถ์ฅํฉ๋๋ค.
Sugar ์ฝ๋
int a = 10;
int b = 20;
int res;
// ์ผํญ์ฐ์ฐ์ ํ์ฉ
res = a>b ? a+b : a-b;
System.out.println(res);
5๋ฒ์งธ ๋ผ์ธ์์ ๋ณผ ์ ์๋ฏ์ด, ์ผํญ์ฐ์ฐ์๋ฅผ ํ์ฉํ์ฌ ์ฝ๋๋ฅผ ๋์ฑ ๊ฐ๊ฒฐํ๊ฒ ์์ฑํ ์ ์์ต๋๋ค.
์ผํญ์ฐ์ฐ์๋?
์ผํญ์ฐ์ฐ์๋ if~else ๋ฌธ์ ์ธํธ๋ผ๊ณ ์๊ฐํ์๋ฉด ํธํฉ๋๋ค.
๋์ ๋ฐฉ์์ ๋ณด๋ฉด ์ฝ๊ฒ ์ดํดํ์ค ์ ์์ต๋๋ค.
์กฐ๊ฑด๋ฌธ ? ์กฐ๊ฑด๋ฌธ์ด true ์ ์ํํ ์ฐ์ฐ : ์กฐ๊ฑด๋ฌธ์ด false ์ ์ํํ ์ฐ์ฐ
๋งจ ์์ ์กฐ๊ฑด๋ฌธ์ ์ ๋ ฅํฉ๋๋ค.
์กฐ๊ฑด๋ฌธ ๋ค์ ๋ฌผ์ํ ๊ธฐํธ์ ์ฝ๋ก ๊ธฐํธ(:) ์ฌ์ด์๋ ์กฐ๊ฑด๋ฌธ์ด true์ผ ๊ฒฝ์ฐ ์คํ๋ ๋ฌธ์ฅ์ ์ ๋ ฅํ์ธ์.
์ฝ๋ก ๋ค์๋ ์กฐ๊ฑด๋ฌธ์ด false์ผ ๊ฒฝ์ฐ ์คํ๋ ๋ฌธ์ฅ์ ์ ๋ ฅํ์๋ฉด ๋ฉ๋๋ค.
์ผํญ์ฐ์ฐ์ ์ฅ์
if(3>2) {
System.out.println("ํธ๋์ด");
}else{
System.out.println("์ฝ๋ผ๋ฆฌ");
}
if ๋ด ์กฐ๊ฑด๋ฌธ์ด ์ฐธ์ผ ๊ฒฝ์ฐ, ํธ๋์ด๋ฅผ ์ฌ์ฉ์์๊ฒ ์ถ๋ ฅํ๊ณ ,
์กฐ๊ฑด๋ฌธ์ด ๊ฑฐ์ง์ผ ๊ฒฝ์ฐ์ ๋ ์ฝ๋ผ๋ฆฌ๋ฅผ ์ฌ์ฉ์์๊ฒ ์ถ๋ ฅํ๋๋ก ์์ฑํ ์ฝ๋์ ๋๋ค.
๋ฌด๋ ค 5์ค์ด๋ ์ฌ์ฉํ์์ต๋๋ค.
System.out.println( 3>2 ? "ํธ๋์ด" : "์ฝ๋ผ๋ฆฌ");
์์ ๋ฐฐ์ด ์ผํญ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ๋ฉด, ์กฐ๊ฑด๋ฌธ์ ๋ฐ๋ผ ํธ๋์ด๋ฅผ ์ถ๋ ฅํ ์ง, ์ฝ๋ผ๋ฆฌ๋ฅผ ์ถ๋ ฅํ ์ง ๊ฒฐ์ ํฉ๋๋ค.
ํจ์ฌ ์ฝ๋๊ฐ ๊ฐ๊ฒฐํ๊ณ ์ง๊ด์ ์ผ๋ก ๋ณด์ด์์ฃ ?
์ด์ฒ๋ผ ์ฝ๋๋ ๋์ ๋๋ฃ๊ฐ ์ฝ๊ณ ์ง๊ด์ ์ ์์๋ณผ ์ ์๋๋ก ์์ฑํด์ผ ํฉ๋๋ค.
๋ค์ ํ๋ฒ ๊ฐ์กฐ๋๋ฆฌ์๋ฉด,
if~else ๊ตฌ๋ฌธ์ด ๋ฑ์ฅํ๋ค๊ณ ํ๋ฉด ์์ฐ์ค๋ ์ผํญ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํด ๋ณผ ๊ฒ์ ๊ถ์ฅ๋๋ฆฝ๋๋ค.
์ค๋์ Syntactic sugar์ ์๋ฏธ์ ์ด๋ฅผ ์ํด ์ผํญ์ฐ์ฐ์ ํ์ฉ๋ฐฉ๋ฒ์ ๋ํด ๊ณต์ ํ์์ต๋๋ค.
ํฌ์คํ ๋ด์ฉ์ ์ค๋ฅ๊ฐ ์๋ค๋ฉด ์๋์ ํผ๋๋ฐฑ ๋ถํ๋๋ฆฝ๋๋ค.
๊ทธ๋ผ ์คํ๋ ์ฆ๊ฑฐ์ด ํ๋ฃจ ๋ณด๋ด์๊ธธ ๋ฐ๋๋๋ค.
๊ณ ๋ง์ต๋๋ค :)