[Java ์ดํดํ๊ธฐ] 5. ์๋ฐ์ ํจ์(๋ฉ์๋)๋? (1)
๐ฉท Java์ ํจ์๋?
Java์์์ ํจ์๋ ๋ณดํต ๋ฉ์๋๋ผ๊ณ ๋ถ๋ฆฌ๋ฉฐ, ๋ฉ์๋๋ ํน์ ์์ ์ ์ํํ๋
๊ธฐ๋ฅ์ ๊ฐ์ง๋๋ค. ๋ฐ๋ณต์ ์ธ ์์ ์ ํผํ๊ธฐ ์ํด ์ฌ์ฉ๋ฉ๋๋ค.
๐ ๋ฉ์๋์ ์ ์
- ์๋ฐ์์์ ํจ์๋ ์ผ๋ฐ์ ์ผ๋ก ๋ฉ์๋(method)๋ผ๊ณ ๋ถ๋ฆฌ๋ฉฐ, ๊ฐ์ฒด์ ํ๋์ ์ ์ํฉ๋๋ค.
- ์๋ฐ๋ ๊ฐ์ฒด ์งํฅ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์ด๊ธฐ ๋๋ฌธ์, ๋ชจ๋ ํจ์๋ ํด๋์ค์ ์ผ๋ถ๋ก ์กด์ฌํฉ๋๋ค.
- ์ด๋ฅผ ํตํด ๋ฐ์ดํฐ(์์ฑ)์ ๊ธฐ๋ฅ(๋ฉ์๋)์ ํจ๊ป ์บก์ํํ์ฌ, ๋ชจ๋์ฑ, ์ฌ์ฌ์ฉ์ฑ, ์ ๋ณด ์๋ ๋ฑ์ ๊ฐ์ฒด ์งํฅ์ ์ฃผ์ ์์น์ ์คํํฉ๋๋ค.
- ๋งค๊ฐ๋ณ์์ ์๋ ์ ํ์ด ์์ต๋๋ค.
๐ค ํจ์(๋ฉ์๋)์ ์ข ๋ฅ
ํ์ค ํจ์ (Standard Functions) |
์ฌ์ฉ์ ์ ์ ํจ์ (User-Defined Functions) |
|
์ ์ | ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ๋ด์ฅ๋์ด ์๋ ํจ์ |
ํ๋ก๊ทธ๋๋จธ๊ฐ ํน์ ์์
์ ์ํํ๊ธฐ ์ํด ์ง์ ์์ฑํ๋ ํจ์ |
ํน์ง | ๋ด์ฅ ๊ธฐ๋ฅ, ์ ๋ขฐ์ฑ, ์ด์์ฑ | ๋ง์ถคํ ๊ตฌํ, ์ ์ฐ์ฑ, ์ฌ์ฌ์ฉ์ฑ |
์์ | Math.sqrt(double a), System.out.println(String x), Arrays.sort(array) |
ํ๋ก๊ทธ๋๋จธ๊ฐ ํน์ ์์ ์ ์ํํ๊ธฐ ์ํด ์ง์ ์์ฑํ๋ ํจ์ |
๐ค ๋ฉ์๋์ ์ค์์ฑ
1. ๋ชจ๋์ฑ(Modularity)
ํจ์๋ฅผ ์ฌ์ฉํ๋ฉด ํฐ ํ๋ก๊ทธ๋จ์ ์์, ๊ด๋ฆฌํ๊ธฐ ์ฌ์ด ๋ถ๋ถ์ผ๋ก ๋๋ ์ ์์ต๋๋ค.
์ด๋ ๊ฒ ๋ชจ๋ํ๋ ์ฝ๋๋ ์ดํดํ๊ธฐ ์ฝ๊ณ , ํ ์คํธํ๊ธฐ ์ฝ๊ณ , ์ ์ง๋ณด์ํ๊ธฐ ์ฌ์์ง๋๋ค.
๊ฐ ํจ์๋ ํน์ ์์ ์ ์ํํ๊ณ , ํ๋ก๊ทธ๋จ์ ๋ค๋ฅธ ๋ถ๋ถ๊ณผ ๋ ๋ฆฝ์ ์ผ๋ก ๊ฐ๋ฐ๋ ์ ์์ต๋๋ค.
์ด๋ ๊ฐ๋ฐ ํ๋ก์ธ์ค๋ฅผ ๊ฐ์ํํ๊ณ , ์ค๋ฅ๋ฅผ ์ฝ๊ฒ ์๋ณํ๊ณ ์์ ํ ์ ์๊ฒ ํฉ๋๋ค.
2. ์ฌ์ฌ์ฉ์ฑ(Reusability)
์ผ๋จ ์ ์ค๊ณ๋ ํจ์๋ฅผ ๊ฐ๋ฐํ๋ฉด, ๊ทธ ํจ์๋ ๋ค์ํ ํ๋ก๊ทธ๋จ์์ ์ฌ์ฌ์ฉ๋ ์ ์์ต๋๋ค.
ํจ์๋ฅผ ํตํด ์ฝ๋์ ์ค๋ณต์ ํผํ๊ณ , ๊ฐ์ ์ฝ๋๋ฅผ ์ฌ๋ฌ ๊ณณ์์ ์ฌ์ฉํจ์ผ๋ก์จ ๊ฐ๋ฐ ์๊ฐ์ ์ ์ฝํ ์ ์์ต๋๋ค.
์๋ฅผ ๋ค์ด, ๋ฐ์ดํฐ ๊ฒ์ฆ, ์ํ ๊ณ์ฐ ๋ฑ์ ์ํํ๋ ํจ์๋ ๋ค์ํ ํ๋ก๊ทธ๋จ์์ ๋์ผํ๊ฒ ํ์ํ ์ ์์ต๋๋ค.
3. ์ ๋ณด ์๋(Information Hiding)
ํจ์๋ ์ธ๋ถ ๊ตฌํ์ ์จ๊ธฐ๋ฉด์ ํน์ ๊ธฐ๋ฅ์ ์ ๊ณตํ ์ ์์ต๋๋ค.
ํจ์๋ฅผ ์ฌ์ฉํ๋ ์ฌ์ฉ์๋ ํจ์๊ฐ ์ด๋ป๊ฒ ๊ทธ ์์ ์ ์ํํ๋์ง ์ ํ์ ์์ด, ์ ๋ ฅ์ ์ ๊ณตํ๊ณ ๊ธฐ๋ํ๋ ์ถ๋ ฅ์ ๋ฐ์ ์ ์์ต๋๋ค.
์ด๋ ์์คํ ์ ๋ณต์ก์ฑ์ ์ค์ด๊ณ , ์ฌ์ฉ์๊ฐ ์์คํ ์ ๋ค๋ฅธ ๋ถ๋ถ์ ์ํฅ์ ์ฃผ์ง ์๊ณ ๋ ์ฝ๋๋ฅผ ๋ณ๊ฒฝํ๊ฑฐ๋ ๊ฐ์ ํ ์ ์๊ฒ ํฉ๋๋ค.
4. ์ ์ง ๋ณด์์ฑ(Maintainability)
ํจ์๋ก ์ฝ๋๋ฅผ ๊ตฌ์ฑํ๋ฉด ๊ฐ ๋ถ๋ถ์ด ์ ์ ์๋์ด ์์ด ํ๋ก๊ทธ๋จ์ ๋ ์ฝ๊ฒ ์ดํดํ๊ณ ๊ด๋ฆฌํ ์ ์์ต๋๋ค.
๋ฌธ์ ๊ฐ ๋ฐ์ํ๊ฑฐ๋ ์๊ตฌ ์ฌํญ์ด ๋ณ๊ฒฝ๋์์ ๋, ๊ด๋ จ ํจ์๋ง ์์ ํ๋ฉด ๋๋ฏ๋ก ์ ์ฒด ์ฝ๋ ๊ธฐ๋ฐ์ ๋ํ ์ดํด ์์ด๋ ๋ณ๊ฒฝ์ ์ ์ฉํ ์ ์์ต๋๋ค.
5. ํ ์คํธ ์ฉ์ด์ฑ(Testability)
ํจ์ ๋จ์๋ก ์ฝ๋๋ฅผ ๋ถ๋ฆฌํ๋ฉด ๊ฐ ํจ์์ ๋ํ ๋จ์ ํ ์คํธ๊ฐ ๊ฐ๋ฅํด์ง๋๋ค.
์ด๋ ์ํํธ์จ์ด ๊ฐ๋ฐ์์ ๋งค์ฐ ์ค์ํ ๋ถ๋ถ์ผ๋ก, ๊ฐ ํจ์์ ๋์์ ์ ํํ ๊ฒ์ฆํ ์ ์์ต๋๋ค.
ํจ์๊ฐ ์์๋๋ก ๋์ํ๋์ง ํ์ธํจ์ผ๋ก์จ ์ ์ฒด ์์คํ ์ ์ ๋ขฐ์ฑ์ ํฅ์ํ ์ ์์ต๋๋ค.
6. ์ถ์ํ(Abstraction)
ํจ์๋ ๋ณต์กํ ์์ ์ ์ถ์ํํ๋ ๋ฐ ๋์์ ์ค๋๋ค. ํ๋ก๊ทธ๋๋จธ๋ ๋ณต์กํ ๋ก์ง์ ํจ์ ๋ค์ ์จ๊ธฐ๊ณ , ๊ฐ๋จํ ์ธํฐํ์ด์ค๋ฅผ ํตํด ํด๋น ๊ธฐ๋ฅ์ ์ ๊ณตํ ์ ์์ต๋๋ค. ์ด๋ ํ๋ก๊ทธ๋จ์ ์ ์ฒด์ ์ธ ์ค๊ณ๋ฅผ ๋จ์ํํ๊ณ , ๋ ๋์ ์์ค์ ํ๋ก๊ทธ๋๋ฐ์ ๊ฐ๋ฅํ๊ฒ ํฉ๋๋ค.
๐ฉต ๋ฉ์๋์ ๊ตฌ์กฐ
- ๋ฉ์๋๋ ํด๋์ค ๋ด์ ์ ์๋๋ฉฐ, ํน์ ์์ ์ ์ํํ๋ ์ฝ๋ ๋ธ๋ก์ ๋๋ค.
๋ฉ์๋๋ ํธ์ถ(call)๋ ๋ ์คํ๋๋ฉฐ, ์ ๋ ฅ(๋งค๊ฐ๋ณ์), ์ฒ๋ฆฌ, ๊ทธ๋ฆฌ๊ณ ์ถ๋ ฅ(๋ฐํ๊ฐ)์ ์์๋ก ๋์ํฉ๋๋ค.
์ ๊ทผ์ ์ด์ ๋ฐํํ์
๋ฉ์๋๋ช
(๋งค๊ฐ๋ณ์๋ชฉ๋ก) {
// ์คํ ์ฝ๋
return ๋ฐํ๊ฐ;
}
- ์ ๊ทผ์ ์ด์(Access Modifier): ๋ฉ์๋์ ์ ๊ทผํ ์ ์๋ ๋ฒ์๋ฅผ ์ง์ ํฉ๋๋ค (public, protected, private, ์๋ต ๊ฐ๋ฅ).
- ๋ฐํํ์ (Return Type): ๋ฉ์๋๊ฐ ๋ฐํํ๋ ๊ฐ์ ๋ฐ์ดํฐ ํ์ ์ ๋ช ์ํฉ๋๋ค. ๋ฐํ๊ฐ์ด ์๋ ๊ฒฝ์ฐ void๋ฅผ ์ฌ์ฉํฉ๋๋ค.
- ๋ฉ์๋๋ช (Method Name): ๋ฉ์๋๋ฅผ ํธ์ถํ ๋ ์ฌ์ฉํ๋ ์ด๋ฆ์ ๋๋ค.
- ๋งค๊ฐ๋ณ์๋ชฉ๋ก(Parameter List): ๋ฉ์๋ ํธ์ถ ์ ํ์ํ ์ ๋ ฅ๊ฐ์ ์ ์ํฉ๋๋ค. ์ฌ๋ฌ ๋งค๊ฐ๋ณ์๋ ์ฝค๋ง๋ก ๊ตฌ๋ถํฉ๋๋ค.
- ๋ฐํ๊ฐ(Return Value): ๋ฉ์๋ ์คํ ํ ๊ฒฐ๊ด๊ฐ์ ๋ฐํํฉ๋๋ค. void์ธ ๊ฒฝ์ฐ ๋ฐํํ์ง ์์ต๋๋ค.
Example )
1. ๋ฉ์๋ ์ ์
public class MySum {
// ๋ ์ ์์ ํฉ์ ๋ฐํํ๋ ๋ฉ์๋
public int sum(int num1, int num2) {
int sum = num1 + num2;
return sum;
}
}
2. ๋ฉ์๋ ํธ์ถ
public class Main {
public static void main(String[] args) {
MySum mySum = new MySum();
// ์ธ์คํด์ค ๋ฉ์๋๋ ๊ฐ์ฒด๋ฅผ ์์ฑ ํ ์ฌ์ฉ ๊ฐ๋ฅ. ํ๋จ ์ฐธ์กฐ
int result = mySum(5, 3);
System.out.println("Result: " + result); // ์ถ๋ ฅ: Result: 8
}
}
ํจ์๋ ํ๋ก๊ทธ๋๋ฐ์ ๋์ฑ ํจ์จ์ ์ผ๋ก ๊ด๋ฆฌํ๊ธฐ ์ฌ์ด ์์ ์ผ๋ก ๋ง๋ญ๋๋ค!
๋ค์ ํฌ์คํธ์์๋ ํจ์์ ๋ํด์ ์ด์ด๋๊ฐ๊ฒ ์ต๋๋ค.
๐โ๏ธ