Effectively Final
Java8์์ final์ด ๋ถ์ง ์์ ๋ณ์์ ๊ฐ์ด ๋ณ๊ฒฝ๋์ง ์๋๋ค๋ฉด, ๊ทธ ๋ณ์๋ฅผ Effectively final์ด๋ผ๊ณ ํฉ๋๋ค.
๋๋ค์์๋ ์ฌ์ฉํ ์ ์๋ ๋ก์ปฌ ๋ณ์๋ Effectively Final๋ง ์ฌ์ฉ์ด ๊ฐ๋ฅํ๋ค.
public class EffectivelyFinal {
public static void main(String[] args) {
new Pint().go();
}
}
class Pint {
void go() {
int baseAnInt = 111;
Function<Integer, Integer> function = (num) -> num + baseAnInt;
System.out.println(baseAnInt+"baseAnInt");
System.out.println(function.apply(10)+"function");
}
}
์์ ์ฝ๋๋ฅผ ๋ณด๋ฉด baseAnInt๋ Effectively Final์ด๋ค.
์๋ฐ์์๋ ํ๋ก๊ทธ๋จ์ด ๊ฐ์ด ๋ณ๊ฒฝํ์ง ์๋ ์๋ฅผ final๋ก ์ถ์ธก์ ํ ์ ์๋ค.
์ฌ๊ธฐ์ ๋๋ค์์ ์ค์ํ ๋ถ๋ถ์ ๋๋ค์์์ ์ฐธ์กฐํ๋ ๋ก์ปฌ ๋ณ์์ ๊ฐ์ ๋ณ๊ฒฝ์ ํ ์ ์๋ค.
์ด ๋ถ๋ถ์ ์ค์ฝํ์ ๋ด์ฉ์ ์ดํดํ๋ฉด ๋ ์ดํดํ๊ธฐ ์ฝ๋ค. ==> ์ด ๋ถ๋ถ์ ๋ค์์ ๋ ์ค๋ช
ํ์ฌ ๊ฐ๋จํ๊ฒ ์ค๋ช ์ ํ๋ฉด GO()๋ฉ์๋์ ์ค์ฝํ์ ๋๋ค์ ์ค์ฝํ๊ฐ ๊ฐ๋ค. ๊ฐ์ ์ค์ฝํ์์ ๋์ผํ ๋ณ์๋ฅผ ์ง์ ํ ์ ์๊ณ ์ด๋ฌํ ๋ถ๋ถ์ ๋ฐ์ ์ฝ๋๋ฅผ ๋ณด๋ฉด ์ ์ ์๋ค.
์ค์ฝํ๋
๋จผ์ ์ค์ฝํ๋ ๋ณ์๋ฅผ ์ฌ์ฉํ ์ ์๋ ๋ฒ์
baseAnInt๋ฅผ ์ ์ธํ๊ณ ๋๋ค์์์ ์ฌ์ฉํ๋ ์ด๋ฏธ ์ค์ฝํ์์ ์ ์๊ฐ ๋์ด์ ธ ์๋ค๊ณ ๋์จ๋ค.
์ด๊ฒ์ ํตํด์ ๋๋ค๋ go๋ฉ์๋๋ ๋์ผํ ์ค์ฝํ๋ฅผ ๊ฐ์ง๊ณ ์๋ค๊ณ ์ดํดํ ์ ์๋ค.
๋๋ค? Effectively Final?
๋๋ค์์์ ์ฌ์ฉ๋๋ ๋ณ์๋ ํด๋น ๋ณ์๋ฅผ ์๋ฏธํ๋ ๊ฒ์ด ์๋ ๋ณต์ฌ๋ณธ์ด๋ค.
๊ทผ๋ณธ์ ์ธ ์ด์ ๋ ์๋ช ์ฃผ๊ธฐ๊ฐ ๋ค๋ฅด๊ธฐ ๋๋ฌธ์ด๋ค.
1. ๋ก์ปฌ ๋ณ์๋ฅผ ์๊ฐ์ ํด๋ณด๋ฉด ๋ฉ์๋๊ฐ ์คํ์ด ๋๊ณ ๋๋๋ฉด ์๋ช ์ฃผ๊ธฐ๋ ๋์ด ๋๋ค.
ํ์ง๋ง ๋๋ค๋ ๊ณ ์ฐจ ํจ์์ฌ์ ๋๋ค ์์ฒด๋ฅผ ์ธ์๋ก ๋ฐ๊ณ ๋ฆฌํด์ ํ ์ ์๊ธฐ ๋๋ฌธ์ ๋๋ค์ ์๋ช ์ฃผ๊ธฐ๋ ์ฌ์ ํ ์คํ์ ํ๊ณ ์์ ์ ์๋ค.
์ฆ. ๋ก์ปฌ ๋ณ์์ ์๋ช ์ฃผ๊ธฐ๊ฐ ๋๋๋ ๋๋ค๋ ๋ก์ปฌ ๋ณ์์ ๊ฐ์ ๋ณต์ฌํ์ฌ ๊ฐ์ง๊ณ ์์ด์ผ ํ๋ค.
https://incheol-jung.gitbook.io/docs/study/kotlin-in-action/8
8์ฅ ๊ณ ์ฐจ ํจ์: ํ๋ผ๋ฏธํฐ์ ๋ฐํ ๊ฐ์ผ๋ก ๋๋ค ์ฌ์ฉ - Incheol's TECH BLOG
์ฝํ๋ฆฐ ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ์ปฌ๋ ์ ํจ์๋ ๋๋ถ๋ถ ๋๋ค๋ฅผ ์ธ์๋ก ๋ฐ๋๋ค. filter์ map์ ์ธ๋ผ์ธ ํจ์๋ค. ๋ฐ๋ผ์ ๊ทธ ๋ ํจ์์ ๋ณธ๋ฌธ์ ์ธ๋ผ์ด๋๋๋ฉฐ, ์ถ๊ฐ ๊ฐ์ฒด๋ ํด๋์ค ์์ฑ์ ์๋ค. ํ์ง๋ง ์ด ์ฝ
incheol-jung.gitbook.io
2. ๋ก์ปฌ ๋ณ์์ ๋๋ค์ Thread๋ฅผ ์ดํดํ์
- ๋ก์ปฌ ๋ณ์
- JVM์์ Stack์ ์ ์ฅ์ด ๋๋ค.
- Stack์ ๋ฐ๋ฅธ Thread๊ฐ ๋ฐฐ์ ์ด ๋๊ณ Thread ์ข ๋ฃ๋ ๋ก์ปฌ ๋ณ์์ ๋์ ์๋ฏธํ๋ค
- ๋๋ค์ ์ฐ๋ ๋
- ๋๋ค๋ ๋ณ๋์ Thread๋ฅผ ๊ฐ์ง๋ค.
- ๋ง์ฝ์ Stack์ ์ง์ ์ ๊ทผ์ด ๊ฐ๋ฅํ์ฌ ์ฐธ์กฐํ๊ณ ์๋ค๊ณ ํ๋ค๋ฉด ์ด๊ฒ์ ๋ฉํฐ ์ฐ๋ ๋์ ์ํ
- ๋๋ค๊ฐ ์ฐธ์กฐํ ๋ณ์์ ์๋ช ์ฃผ๊ธฐ๋ ๋๋ค๊ฐ ์์ผ๋ฉด ๋ณด์ฅ์ด ๋๋ค.
์ค์ฝํ
https://wakestand.tistory.com/179
์๋ฐ ๋ณ์์ ์ค์ฝํ๊ฐ ๋ญ๋ง?
๋ฉด์ ์ ๋ง์ด ๋ฌผ์ด๋ณด๋ ๊ฒ์ด ๋ณ์์ ์ค์ฝํ์ธ๋ฐ ์ค์ฝํ๊ฐ ๋ญ ๋ง์ธ์ง ๊ฐ์ด ์์์ ์ด๋ ค์ธ ์ ์๋๋ฐ ๋ง์ ๋ณด๋ฉด ๋จ์ํ๋ค ๋จผ์ ์ค์ฝํ๋ ๋ณ์๋ฅผ ์ฌ์ฉํ ์ ์๋ ๋ฒ์๋ฅผ ์๊ธฐํ๋๋ฐ {} ์์์ ๋ณ์
wakestand.tistory.com
๊ธฐ๋ณธ์ ์ธ ์ค์ฝํ์ ๋ด์ฉ์ ๋งํฌ๋ฅผ ํตํด์ ํ์ธ์ด ๊ฐ๋ฅํ๋ค.
์ด ํ์ด์ง์์ ์ค๋ช ํ๋ ์ค์ฝํ๋ ๋๋ค์์ ๋๋ค , ๋ก์ปฌ ํด๋์ค , ์ต๋ช ํด๋์ค์ ๋ํ ์ค์ฝํ๋ฅผ ๋น๊ตํ๊ณ
๋๋ค์ ๋ํ ํน์ง์ ์์๋ณด๊ธฐ ์ํด ์์ฑ์ ํ๊ณ ์๋ค.
class Pint {
private int baseAnInt = 111;
class LocalClass{
int baseAnInt = 1;
void localClass(){
System.out.println(baseAnInt);//1
}
}
Consumer<Integer>consumer = new Consumer<Integer>() {
int baseAnInt=2;
@Override
public void accept(Integer integer) {
System.out.println(baseAnInt);//2
}
};
void go() {
Function<Integer, Integer> function = (baseAnInt) -> baseAnInt + baseAnInt;//111
}
}
๋ก์ปฌ ํด๋์ค์ , ์ต๋ช ํด๋์ค๋ ๊ฐ๊ฐ baseAnInt์ ๊ฐ์ ๋ณ๊ฒฝ์ ํ ์ ์์ง๋ง ๋๋ค์์ ๋ณ๊ฒฝ์ด ๋ถ๊ฐ๋ฅ ํ๋ค.
์ด๊ฒ์ ํตํด ์์ 2๊ฐ์ ๋๋ค์์ ์๋ก ๋ค๋ฅธ ์ค์ฝํ๋ฅผ ํตํด ๋์์ ํ๋ค๋ ๊ฒ์ ์ ์ ์๋ค.
์ด๊ฒ์ ๋ํ ์์ธํ ๋ด์ฉ์ ๋ฐ์ ๋ธ๋ก๊ทธ๋ฅผ ์ฐธ๊ณ
https://tjdtls690.github.io/studycontents/java/2022-10-24-lambda_anonymous_local_class_difference/
[์๋ฐ, Java] ๋๋ค (Lambda) - ์๋์ (Shadowing)
.
tjdtls690.github.io
'๐พBackEnd > ๐ Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
ํจ์ํ ํ๋ก๊ทธ๋๋ฐ & ๋๋ค (0) | 2023.01.28 |
---|