[Java] ๋๋ค์๊ณผ ์คํธ๋ฆผ - (1) ๋๋ค์ ๊ธฐ๋ณธ
0.๐ถ๋ค์ด๊ฐ๋ฉฐ
์๋ฐ๋ JDK1.5์์ ์ถ๊ฐ๋ ์ ๋ค๋ฆญ์ผ๋ก ํ ๋ฒ, JDK1.8์์ ์ถ๊ฐ๋ ๋๋ค์์ ๋ฑ์ฅ์์ ๋ ํ ๋ฒ ํฐ ๋ณํ๊ฐ ์๊ฒผ๋ค๊ณ ํฉ๋๋ค. ๋๋ค์์ ๋์ ์ผ๋ก ๊ฐ์ฒด์งํฅ ์ธ์ด์๋ ์๋ฐ๋ ํจ์ํ ์ธ์ด์ ๊ธฐ๋ฅ๊น์ง ๊ฐ์ถ๊ฒ ๋ ๊ฒ์ด์ฃ .
๊ฐ์ธ์ ์ผ๋ก ์๋ฐ์คํฌ๋ฆฝํธ์ Arrow Function๊ณผ ๊ณ ์ฐจ ํจ์๊ฐ ๋งค์ฐ ๋ง์์ ๋๋ ๊ธฐ๋ฅ์ด๋ผ๊ณ ์๊ฐํ์๋๋ฐ์. ์๋ฐ์์๋ ๋๋ค์๊ณผ ์คํธ๋ฆผ์ด๋ผ๋ ๊ฐ๋ ์ผ๋ก ๋น์ทํ ๊ธฐ๋ฅ์ ์ ๊ณตํด์ค๋ค๋ ์ฌ์ค์ด ๋งค์ฐ ๋ฐ๊ฐ์ ๊ณ , ์ด๋ฅผ ์๊ฐํ๊ธฐ ์ํด ๊ธ์ ์จ๋ณด๋ คํฉ๋๋ค.
1.๐๋๋ค์์ด๋?
๋๋ค์์ ๋ฉ์๋๋ฅผ ํ๋์ "์"์ผ๋ก ํํํ ๊ฒ์ ๋๋ค. ํ์ด์ฌ์ด๋ ์๋ฐ์คํฌ๋ฆฝํธ์ ๋น๊ตํ๋ค๋ฉด ์๋ฐ๋ ๋ฉ์๋ ํ๋๋ฅผ ์ ์ํ๋ ๊ณผ์ ์ด ์๋นํ ๊ท์ฐฎ์ต๋๋ค. ๋๋ค์์ ์๋ฐ์ ๋ฉ์๋ ์ ์ ๊ณผ์ ์ ๊ต์ฅํ ๊ฐํธํ๊ฒ ํด์ฃผ๊ณ , ์ ์ ํ ์ฌ์ฉํ๋ค๋ฉด ๊ฐ๋ ์ฑ ์ญ์ ๋์ผ ์ ์์ต๋๋ค.
๋๋ค์์ ์์๋ฅผ ํ๋๋ง ์ดํด๋ณด๊ฒ ์ต๋๋ค.
// ๊ธฐ์กด ๋ฉ์๋ ์ ์ ๋ฐฉ์
int sum(int a, int b) {
return a + b;
}
// ์ ๋ฉ์๋๋ฅผ ๋๋ค์์ผ๋ก ๋ณ๊ฒฝ
(a, b) -> a + b;
๋๋ค์์ ๋ณด์๋ฉด ๊ธฐ์กด ๋ฐฉ์๋ณด๋ค ํจ์ฌ ๊ฐ๊ฒฐํด์ง ๊ฒ์ ๋ณผ ์ ์์ต๋๋ค. ๋ํ ์กฐ๊ธ๋ง ์ต์ํด์ ธ๋ ๊ฐ๋ ์ฑ์ด ๊ธฐ์กด ๋ฐฉ์๋ณด๋ค ํจ์ฌ ๋ฐ์ด๋ฉ๋๋ค.
๋ํ ๋๋ค์์ผ๋ก ๋ณ๊ฒฝํ ๋ sum์ด๋ผ๋ ๋ฉ์๋ ์ด๋ฆ๊ณผ ๋ฆฌํด ํ์ ์ด ์ฌ๋ผ์ก๋๋ฐ ์ด๋ฌํ ์ด์ ์์ ๋๋ค์์ "์ต๋ช ํจ์"๋ผ๊ณ ๋ ๋ถ๋ฆ ๋๋ค.
2.โ๋๋ค์ ์์ฑํ๋ ๋ฒ
์ ์์์์ ์ด์ง ์ดํด๋ณธ ๊ฒ์ฒ๋ผ ๋๋ค์์ ์์ฑํ๋ ๋ฒ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
- ๋ฉ์๋์์ ์ด๋ฆ๊ณผ ๋ฆฌํด ํ์ ์ ์ ๊ฑฐํด์ค๋๋ค.
- ์ ์ธ๋ถ ๋ฐ๋ก ๋ค์ -> ๋ฅผ ์ถ๊ฐํด์ค๋๋ค.
์ฝ๋๋ก ํ ๋ฒ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
// ๊ธฐ์กด ๋ฐฉ์์ ๋ฉ์๋
int max(int a, int b) {
return a > b ? a : b;
}
// ๋๋ค์ ๋ณํ - (1) ๊ธฐ๋ณธ ๋ฐฉ์
(int a, int b) -> { return a > b ? a : b; }
// ๋๋ค์ ๋ณํ - (2) return๋ฌธ ๋์ ์์ผ๋ก ๋์ฒด
// ์์ ์ฐ์ฐ ๊ฒฐ๊ณผ๊ฐ ์๋์ ์ผ๋ก ๋ฆฌํด๊ฐ์ด ๋๋ค.
(int a, int b) -> a > b? a : b
// ๋๋ค์ ๋ณํ - (3) ๋งค๊ฐ๋ณ์์ ํ์
์๋ต
// ๋งค๊ฐ๋ณ์์ ํ์
์ด ์ถ๋ก ๊ฐ๋ฅํ ๊ฒฝ์ฐ ์๋ต๊ฐ๋ฅ -> ๋๋ถ๋ถ ์๋ต ๊ฐ๋ฅ
(a, b) -> a > b ? a : b
์๋ฐ์คํฌ๋ฆฝํธ Arrow Function์ ์ต์ํ์๋ค๋ฉด ๋งค์ฐ ์น์ํ ํํ์ด์ค ๊ฒ์ด๊ณ , ์ต์ํ์ง ์์ผ์๋๋ผ๋ ๋๋ค์ ๋ณํ ๋ฐฉ์์ ์๋ถํฐ ์ฐจ๊ทผ์ฐจ๊ทผ ์ดํด๋ณด์๋ฉด ์ดํดํ๊ธฐ ์ด๋ ต์ง ์์ผ์ค ๊ฒ ๊ฐ์ต๋๋ค!
3.๐ํจ์ํ ์ธํฐํ์ด์ค
๋๋ค์์ ํจ์ํ ์ธํฐํ์ด์ค์ ๋ฐ์ ํ ๊ด๊ณ๊ฐ ์์ต๋๋ค. ํจ์ํ ์ธํฐํ์ด์ค์ ๋ํด ์์๋ณด๊ธฐ ์ ๋๋ค์์ ์ ์ฒด๋ถํฐ ์์๋ณด๋๋ก ํ๊ฒ ์ต๋๋ค.
์๋ฐ๋ ๊ฐ์ฒด์งํฅ ์ธ์ด์ ๋๋ค. ๊ฐ์ฒด์งํฅ ์ธ์ด์์ ํจ์ํ ์ธ์ด๊ฐ์ ํํ ๋ฐฉ์์ ์ฌ์ฉํ ์ ์๊ฒ ๋ ์ด์ ๊ฐ ๋ญ๊น์? ์ง๊ธ๊น์ง ๋๋ค์์ด ๋ฉ์๋์ ๋๋ฑํ ๊ฒ์ฒ๋ผ ์ค๋ช ํด์๋๋ฐ ์ฌ์ค ๋๋ค์์ ์ต๋ช ๊ตฌํ ๊ฐ์ฒด์ ๋๋ฑํฉ๋๋ค.
์ฝ๋๋ก ์ดํด๋ณด์ฃ .
(a, b) -> a > b ? a : b
์์ ๊ฐ์ ๋๋ค์์ ํธ์ถํ๊ณ ์ถ๋ค๋ฉด ์ด๋ป๊ฒ ํด์ผํ ๊น์..? ๋ฉ์๋๋ฅผ ํธ์ถํ๋ ค๋ฉด ์ฐธ์กฐํ์ ์ด ์์ด์ผํ๊ณ ๊ทธ ์ฐธ์กฐ ํ์ ์ ํตํด ๋ฉ์๋ ์ด๋ฆ์ผ๋ก ํธ์ถํ๋ ๊ฒ ์ผ๋ฐ์ ์ ๋๋ค. ๋๋ค์์ ๊ทธ ๋ฐฉ์์ ์ ์ฉํ๋ ค๊ณ ์๋ํด๋ด ์๋ค.
ํ์
f = (a, b) -> a > b ? a : b
์์ ๊ฐ์ด ์จ์ฃผ๊ณ ์ถ์๋ฐ f์ ํ์ ์ ์ด๋ป๊ฒ ํด์ฃผ์ด์ผํ ์ง ๋ต์ด ๋์ค์ง ์์ต๋๋ค. ํ์ง๋ง ์ฐธ์กฐํ ํ์ ์ด๋ ํด๋์ค๊ฑฐ๋ ์ธํฐํ์ด์ค๊ฐ ํ๋ณด๊ตฐ์ด ๋ ์ ์๊ฒ ์ฃ ? ์ด๋ ๋ง์ฝ ํ์ ์ด ์ธํฐํ์ด์ค์ด๊ณ ๊ทธ ์ธํฐํ์ด์ค์ ๊ตฌํํด์ผํ ๋ฉ์๋๊ฐ ํ๋์ธ ๊ฒฝ์ฐ๋ผ๋ฉด ์ด๋จ๊น์? ์์์ ๋งํ๋ ์ต๋ช ๊ตฌํ ๊ฐ์ฒด์ ๋๋ฑํ๋ค๋ผ๋ ๋ง์ด ์ฌ๊ธฐ์ ์ข ๋ ๊ตฌ์ฒดํ๋ฉ๋๋ค.
์๋์ ๊ฐ์ด ๊ตฌํํ ๋ฉ์๋๊ฐ ํ๋์ธ ์ธํฐํ์ด์ค๊ฐ ์๋ค๊ณ ๊ฐ์ ํด๋ด ์๋ค.
interface MyInterface {
public abstract int max(int a, int b);
}
์ ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ ์ต๋ช ๊ตฌํ ํด๋์ค๋ ์๋์ ๊ฐ์ด ์์ฑํ ์ ์์ต๋๋ค.
MyInterface f = new MyInterface() {
public int max(int a, int b) {
return a > b ? a : b;
}
}
int bigger = f.max(5, 3); // ๋ฉ์๋ ํธ์ถ
์ ์ฝ๋์ ๋๋ค์์ ์ด์ฉํด ์๋์ฒ๋ผ ๋ฐ๊ฟ ์ ์์ต๋๋ค.
MyInterface f = (a, b) -> a > b ? a : b;
int bigger = f.max(5, 3);
์ ์ฝ๋์ฒ๋ผ ๋ฐ๊ฟ ์ ์๋ ์ด์ ๊ฐ ๋ฐ๋ก ๋๋ค์์ด ์ค์ ๋ก๋ ์ต๋ช ๊ตฌํ ๊ฐ์ฒด์ด๊ธฐ ๋๋ฌธ์ ๋๋ค. ๋ํ ๋๋ค์์์ ๋ฉ์๋ ์ด๋ฆ, ๋งค๊ฐ ๋ณ์์ ํ์ , ๋ฆฌํด ๊ฐ์ ์๋ตํด๋ ์ฌ๋ฐ๋ฅด๊ฒ ์ถ๋ก ํ ์ ์๋ ์ด์ ๋ ๊ตฌํํ ์ธํฐํ์ด์ค์์ ๋ชจ๋ ์ ๋ณด๋ฅผ ์ป์ ์ ์๊ธฐ ๋๋ฌธ์ ๋๋ค.
์ด์ฒ๋ผ ์๋ฐ์์๋ ๊ตฌํํ ๋ฉ์๋๊ฐ ํ๋์ธ ์ธํฐํ์ด์ค๋ฅผ ์ ์ํด์ ๋๋ค์์ ์์ฐ์ค๋ฝ๊ฒ ๋ค๋ฃฐ ์ ์๊ฒ ๋์๊ณ ์ด ๋, ๋๋ค์์ ๋ค๋ฃจ๊ธฐ ์ํ ์ธํฐํ์ด์ค๋ฅผ ๋ฐ๋ก ํจ์ํ ์ธํฐํ์ด์ค๋ผ๊ณ ํฉ๋๋ค.
์๋์ ๊ฐ์ด @FunctinalInterface ์ด๋ ธํ ์ด์ ์ ๋ถ์ฌ์ฃผ๋ฉด ์ปดํ์ผ๋ฌ๊ฐ ํจ์ํ ์ธํฐํ์ด์ค๋ฅผ ์ ์ ํ ์ ์ํด์ฃผ์๋์ง ์ฒดํฌํด์ฃผ๊ธฐ๋ ํฉ๋๋ค.
@FunctionalInterface
interface MyInterface {
public abstract int max(int a, intb);
}
4.๐จ๋๊ฐ๋ฉฐ
์ด๋ฒ ๊ธ์์๋ ๋๋ค์์ ๊ธฐ๋ณธ ๊ฐ๋ ์ ๋ํด ์์๋ณด์์ต๋๋ค. ์๋ฐ์ ๊ธฐ์กด ์ฑ์ง์ ๊นจ์ง ์๊ณ ์ธํฐํ์ด์ค๋ฅผ ์ฌ์ฉํด ๋๋ค์์ด๋ผ๋ ํจ์ํ ์ธ์ด์ ํน์ง์ ๊ฐ์ ธ์๋ค๋ ๊ฒ์ด ๋งค์ฐ ๋๋ผ์ด ๊ฒ ๊ฐ์ต๋๋ค.
ํธ๋ฆฌํจ์ ๋ง์ด ์ ๊ณตํด์ฃผ๋ ๊ธฐ๋ฅ์ธ๋งํผ ์์์๋ณด๋ฉด ์ข์ ๊ฒ ๊ฐ๋ค๋ ์๊ฐ์ด ๋ค๊ณ ๊ธฐํ๊ฐ ๋๋ฉด ์ถํ ๊ฐ์ ์ฃผ์ ๋ก ๊ธ์ ๋ ์จ๋ณด๋๋ก ํ๊ฒ ์ต๋๋ค.