1. 메서드
두 숫자를 입력받아서 더하고 출력하는 단순한 기능 개발해 보자. 먼저 1 + 2를 수행 후, 다음으로 10 + 20을 수행할 것임.
package method;
public class Method1 {
public static void main(String[] args) {
// 계산1
int a = 1;
int b = 2;
System.out.println(a + " + " + b + " 연산 수행");
int sum1 = a + b;
System.out.println("결과1 출력 : " + sum1);
// 계산2
int x = 10;
int y = 20;
System.out.println(x + " + " + y + " 연산 수행");
int sum2 = x + y;
System.out.println("결과2 출력 : " + sum2);
}
}[Method1]
여기서 문제점은 같은 연산을 두 번 수행함.
계산1 부분과 계산2 부분은 거의 같음.
만약 프로그램의 여러 곳에서 이와 같은 계산을 반복해야 한다면 같은 코드를 여러 번 반복해서 작성해야 함.
더 나아가 어떤 연산 수행하는지 출력하는 부분을 변경하거나 또는 제거하고 싶다면 해당 코드를 다 찾아다니면서 모두 수정해야 함.
메서드 사용
자바에서 함수를 메서드(Method)라고 함.
메서드도 함수의 한 종류라 생각하면 되고, 지금은 둘 다 구분하지 않으며 일단 이 정도로만 알아두자.
package method;
public class Method1Ref {
public static void main(String[] args) {
// 계산 1
int sum1 = add(5, 10);
System.out.println("결과1 출력 : " + sum1);
// 계산 2
int sum2 = add(15, 20);
System.out.println("결과2 출력 : " + sum2);
}
// add 메서드 (메서드는 선언과 본문으로 나눌 수 있음)
public static int add(int a, int b) { // 메서드 선언(메서드 이름, 매개변수(파라미터) 목록 포함)
// 메서드 본문
System.out.println(a + " + " + b + " 연산 수행");
return a + b;
}
/*
해당 함수에 위치하여 Ctrl + B하면 해당 함수로 이동함.
*/
}[Method1Ref]
메서드를 사용하면 중복 제거되어 코드가 상당히 깔끔해진 것을 볼 수 있음.
add 함수가 바로 메서드인데, 함수 정의하는 것과 같이 메서드 정의한다고 표현함.
메서드는 크게 메서드 선언과 메서드 본문으로 나눌 수 있음.
1. 메서드 선언(Method Declaration)
- public static int add(int a, int b)
- 메서드 이름, 반환타입, 매개변수(파라미터) 목록을 포함.
- 메서드 선언 정보를 통해 다른 곳에서 해당 메서드 호출 할 수 있음.
public static
- public : 다른 클래스에서 호출할 수 있는 메서드라는 뜻. (접근 제어에서 학습함)
- static : 객체 생성하지 않고 호출할 수 있는 정적 메서드라는 뜻. 자세한 내용은 뒤에서 학습. int add(int a, int b)
- int : 반환 타입을 정의. 메서드 실행 결과 반환할 때 사용할 반환 타입 지정.
- add : 메서드 이름을 부여. 이 이름으로 메서드 호출 할 수 있음.
- (int a, int b) : 메서드 호출할 때 전달하는 입력 값 정의. 이 변수들은 해당 메서드 안에서만 사용. 파라미터(매개변수)라고 함.
2. 메서드 본문(Method Body)
- 메서드가 수행해야 하는 코드 블록.
- 메서드를 호출하면 메서드 본문이 순서대로 실행.
- 메서드 본문은 블랙박스임. 메서드 호출하는 곳에서 메서드 선언은 알지만 메서드 본문은 모름.
- 메서드 실행 결과 반환하려면 return 문을 사용해야 함. return문 다음에 반환할 결과를 적어주면 됨.
▶ 메서드 용어정리
1. 인수(Argument)
- 영어로 Argument로, 한글로는 인수 또는 인자라고 함.
- 실무에서는 인수, 인자, Argument(아규먼트) 모두 사용하니 알아두자.
- 인수는 들어가는 수라는 의미를 가짐. 즉 메서드 내부로 들어가는 값을 의미함.
2. 매개변수(Parameter)
- 메서드 정의할 때 선언한 변수.
- 메서드 호출할 때 인수를 넘기면, 그 인수가 매개변수에 대입됨.
- 실무에서는 매개변수, 파라미터 용어 모두 사용하니 알아두자.
- 매개변수는 중간에서 전달하는 변수라는 의미를 가짐. 즉 메서드 호출부와 메서드 내부 사이에서 값을 전달하는 역할하는 변수임.
메서드 정의
public static int add(int a, int b) {
// 메서드 본문, 실행 코드
}
제어자 반환타입 메서드 이름(매개변수 목록) {
메서드 본문
}
- 제어자(Modifier) : pubilc, static과 같은 부분. 설명은 뒤에서. 지금은 항상 public static 키워드를 입력.
- 반환타입(Return Type) : 메서드가 실행된 후 반환하는 데이터의 타입을 지정. 메서드가 값을 반환하지 않는 경우, 없다는 뜻의 void 사용.
- 메서드 이름(Method Name) : 메서드를 호출하는 데 사용.
- 매개변수(Parameter) :
입력 값으로, 메서드 내부에서 사용할 수 있는 변수. 매개변수는 옵션임. 입력값이 필요 없는 메서드는 매개변수 지정하지 않아도 됨.
- 메서드 본문(Method Body) : 실제 메서드의 코드가 위치함. 중괄호 { } 사이에 코드 작성
package method;
public class Method2 {
public static void main(String[] args) {
printHeader();
System.out.println("프로그램을 동작합니다.");
printFooter();
}
public static void printHeader() {
System.out.println("= 프로그램을 시작합니다 =");
return ; // void의 경우 생략 가능
}
public static void printFooter() {
System.out.println("= 프로그램을 종료합니다 =");
}
}[Method2]
printHeader(), printFooter() 메서드는 매개변수가 없고, 반환타입도 없음.
○ 매개변수가 없는 경우
- 선언 : public static void printHeader()와 같이 매개변수 비워두고 정의.
- 호출 : printHeader();와 같이 인수 비워두고 호출하면 됨.
○ 반환타입이 없는 경우
- 선언 : public static void printHeader()와 같이 반환 타입을 void로 정의하면 됨.
- 호출 : printHeader();와 같이 반환 타입이 없으므로 메서드만 호출하고 반환 값 받지 않으면 됨.
void와 return 생략
- 모든 메서드는 항상 reutrn을 호출해야 함.
- 하지만 반환타입이 void인 경우 예외로 생략 가능.
package method;
public class MethodReturn1 {
public static void main(String[] args) {
boolean result = odd(2);
System.out.println(result);
}
public static boolean odd(int i) {
if (i % 2 == 1) {
return true;
} else {
return false;
}
}
}[MethodReturn1]
반환 타입이 있으면 반드시 값을 반환해야 함. 조건문 함께 사용할 때 주의해야 함.
package method;
public class MethodReturn1 {
public static void main(String[] args) {
boolean result = odd(2);
System.out.println(result);
}
public static boolean odd(int i) {
if (i % 2 == 1) {
return true;
}
}
}
if문 조건 만족할 때는 true가 반환되지만, 조건 만족하지 않으면 return문 실행되지 않고, 누락했다는 컴파일 오류가 발생
java : missing return statement
따라서 위와 같은 코드로 reutrn문을 else 통해 입력해서 실행되게 해야 함.
package method;
public class MethodReturn2 {
public static void main(String[] args) {
checkAge(16);
checkAge(20);
}
public static void checkAge(int age) {
if(age < 18) {
System.out.println(age + "살, 미성년자는 출입이 불가능합니다.");
return; // 반환타입이 void이므로 반환값없이 return만 작성.
}
System.out.println(age + "살, 입장하세요.");
// 반환타입이 void이므로 return 생략 가능한 것임.
}
}[MethodReturn2]
return문을 만나면 그 즉시 메서드를 빠져나감.
18세 미만일 경우 출입 불가능하다를 출력하고 return 문이 수행됨. 따라서 다음 로직 수행하지 않고 해당 메서드를 빠져나옴.
마지막 줄에 입장하세요를 출력하고, 메서드는 종료되는데 이때 반환타입이 없는 void형이기 때문에 마지막 줄의 return은 생략 가능.
만약 반환 타입이 있는 메서드 호출했는데 반환값이 필요하지 않다면 사용하지 않아도 됨.
예시 : int sum = add(1, 2)에서는 반환된 값을 받아서 sum에 저장함.
예시 : add(1, 2) 반환된 값을 사용하지 않고 버림. 위에처럼 호출 결과를 변수에 담지 않고, 단순히 메서드만 호출함.
자바에서 가장 중요한 대원칙!
자바는 항상 변수의 값을 복사해서 대입한다.
이 대원칙은 반드시 이해해야 함. 그러면 아무리 복잡한 상황에서 코드를 단순하게 이해할 수 있음.
package method;
public class MethodValue0 {
public static void main(String[] args) {
// 자바는 항상 변수의 값을 복사해서 대입함 → 이 대원칙은 반드시 이해해야 함.
int num1 = 5;
int num2 = num1;
num2 = 10;
System.out.println("num1 = " + num1);
System.out.println("num2 = " + num2);
}
}[MethodValue0]
1. num1의 값은 5.
2. num2 변수에 대입하기 전 num1의 값 5를 읽고 num2에 넣으면 num1은 5, num2는 5.
3. num2에 10을 대입하면 num1은 5, num2는 10.
여기서 값을 복사해서 대입한다는 부분이 바로 int num2 = num1;임.
이 부분은 num1에 있는 값 5를 복사해서 num2에 넣는 것.
복사한다고 표현한 이유는 num1의 값을 읽어도 num1에 있는 기존 값이 유지되고, 새로운 값이 num2에 들어가기 때문.
따라서 num1의 값이 num2에 복사가 된 것 같음.
num1이라는 변수 자체가 num2에 들어가는 것이 아니라 num1에 들어있는 값을 읽고 복사해서 num2에 넣은 것이라고 생각하자.
간단하게 num1에 있는 값을 num2에 대입한다고 표현하지만, 실제로는 그 값을 복사해서 대입하는 것.
package method;
public class MethodValue1 {
public static void main(String[] args) {
int num1 = 5;
System.out.println("1. changeNumber 호출 전, num1 : " + num1);
changeNumber(num1);
System.out.println("4. changeNumber 호출 후, num1 : " + num1);
}
public static void changeNumber(int num2) {
System.out.println("2. changeNumber 변경 전, num2 : " + num2);
num2 = num2 * 2;
System.out.println("3. changeNumber 변경 후, num2 : " + num2);
}
}[MethodValue1]
4. changeNumber 호출 후, num1의 값을 예상해서 실행해 보자.
만약 10이라고 생각했다면 대원칙을 다시 한번 생각하자.
자바는 항상 변수의 값을 복사해서 대입한다.
- 과정 -
num1에 5를 대입함. (num1 : 5)
호출 전 num1의 값은 5를 출력.
changeNumber(num1)에서 num1의 값 5를 읽고 그 값이 num2에 복사됨. (num1 : 5 / num2 : 5)
함수 호출 한 곳으로 가서 코드를 실행하면 변경 전 num2의 값은 5를 출력.
num2 = num2 * 2에서 num2에 2를 곱함. (num1 : 5 / num2 : 10)
변경 후 num2의 값은 10을 출력.
다시 돌아가서 호출 후 num1의 값은 5를 출력.
결과적으로 매개변수 num2의 값만 10으로 변경되고 num1의 값은 변경되지 않고 기존 값인 5로 유지.
자바는 항상 값을 복사해서 전달하기 때문에 num2의 값을 바꾸더라도 num1에는 영향을 주지 않음.
package method;
public class MethodValue2 {
public static void main(String[] args) {
int number = 5;
System.out.println("1. changeNumber 호출 전, number : " + number); // 5
changeNumber(number);
System.out.println("4. changeNumber 호출 후, number : " + number); // 5
}
public static void changeNumber(int number) {
System.out.println("2. changeNumber 변경 전, number : " + number); // 5
number = number * 2;
System.out.println("3. changeNumber 변경 후, number : " + number); // 10
}
}[MethodVlalue2]
같은 문제를 호출자의 변수 이름과 매개변수의 이름을 같게 해서 한 번 더 풀어보기.
이번에는 main()에 정의한 변수와 메서드의 매개변수(파라미터)의 이름이 둘 다 number로 같음.
main()도 사실 메서드임. 각각의 메서드 안에서 사용하는 변수는 서로 완전히 분리된 다른 변수임. 이름이 같아도 완전히 다른 변수!
헷갈리지 말기.
메서드를 사용해서 값을 변경하려면 어떻게 해야 하는지 아래 코드를 살펴보기.
package method;
public class MethodValue3 {
public static void main(String[] args) {
int num1 = 5;
System.out.println("changeNumber 호출 전, num1 : " + num1);
num1 = changeNumber(num1);
System.out.println("changeNumber 호출 후, num1 : " + num1);
}
public static int changeNumber(int num2) {
num2 = num2 * 2;
return num2;
}
}[MethodValue3]
메서드의 반환 형을 변환하여 호출 결과를 반환받아서 사용하면 됨.
void를 int로 바꾸고, return 값을 입력한 뒤 main() 메서드에서 전달받아 호출하면 값이 변경되는 것을 볼 수 있음.
꼭 기억하기.
자바는 항상 변수의 값을 복사해서 대입하는 것!
package method;
public class MethodCasting1 {
public static void main(String[] args) {
double number = 1.5;
// printNumber(number); // double → int에 대입하므로 컴파일 오류
printNumber((int)number); // 명시적 형변환 사용해 double → int로 변환
}
public static void printNumber(int n) {
System.out.println("숫자 : " + n);
}
}[MethodCasting1]
메서드 형변환
printNumber(number)는 컴파일 오류가 발생함.
메서드 호출하는데 int형 파라미터에 double형 인수를 전달하는 데 있어 불가능함.
따라서 명시적형변환을 하게 됨.
명시적 형변환을 사용해 double을 int로 변환하여 출력함.
package method;
public class MethodCasting2 {
public static void main(String[] args) {
int number = 100;
printNumber(number);
}
public static void printNumber(double n) {
System.out.println("숫자 : " + n);
}
}[MethodCasting2]
자동형변환
앞에서 배운 자동 형변환이 그대로 적용.
double형 매개변수에 int형 인수를 전달하는데 문제없이 잘 작동함.
메서드를 호출할 때는 전달하는 인수의 타입과 매개변수의 타입이 잘 맞아야 함.
단, 타입이 달라도 자동형변환이 가능한 경우에는 호출 가능.
- 오버로딩 -
이름이 같고, 매개변수가 다른 여러 개 메서드를 여러개 정의하는 것을 메서드 오버로딩이라고 함.
오버로딩 번역하면 과적이라는 뜻인데, 과하게 물건을 담았다고 생각하면 됨. 즉 같은 이름의 메서드를 여러개 정의했다고 이해.
- 규칙 -
메서드 이름이 같아도 매개변수의 타입 및 순서가 다르면 오버로딩 할 수 있음.
참고로 반환타입은 인정하지 않음.
▶ 오버로딩 성공
add(int a, int b)
add(int a, int b, int c)
add(double a, double b)
▶ 오버로딩 실패
int add(int a, int b)
double add(int a, int b)
- 메서드 시그니처 -
메서드 시그니처는 메서드 이름 + 매개변수 타입(순서)을 의미.
자바에서 메서드를 구분할 수 있는 고유한 식별자나 서명을 뜻하는데, 메서드를 구분할 수 있는 기준을 말함.
package overloading;
public class Overloading1 {
public static void main(String[] args) {
System.out.println("1 : " + add(1, 2));
System.out.println("2 : " + add(1, 2, 3));
}
public static int add(int a, int b) {
System.out.println("1번 호출");
return a + b;
}
public static int add(int a, int b, int c) {
System.out.println("2번 호출");
return a + b + c;
}
}[Overloading1]
첫 번째 add 메서드는 두 정수를 받아서 합을 반환.
두 번째 add 메서드는 세 정수를 받아서 합을 반환.
첫 번째 메서드와 이름은 같지만 매개변수 목록이 다름.
1 : 정수 1, 2를 호출했으므로 add(int a, int b)가 호출됨.
2 : 정수 1, 2, 3을 호출했으므로 add(int a, int b, int c)가 호출됨.
package overloading;
public class Overloading2 {
public static void main(String[] args) {
myMethod(1, 1.2);
myMethod(1.2, 1);
}
public static void myMethod(int a, double b) {
System.out.println("int a, double b");
}
public static void myMethod(double a, int b) {
System.out.println("double a, int b");
}
}[Overloading2]
1 : 정수1, 실수1.2를 호출했으므로 myMethod(int a, double b)가 호출됨.
2 : 실수 1.2, 정수1을 호출했으므로 myMethod(double a, int b)가 호출됨.
package overloading;
public class Overloading3 {
public static void main(String[] args) {
System.out.println("1 : " + add(1, 2));
System.out.println("2 : " + add(1.2, 1.5));
}
public static int add(int a, int b) {
System.out.println("1번 호출");
return a + b;
}
public static double add(double a, double b) {
System.out.println("2번 호출");
return a + b;
}
}[Overloading3]
매개변수의 타입이 다른 경우
1 : 정수1, 정수2를 호출했으므로 add(int a, int b)가 호출됨.
2 : 실수1.2, 실수1.5를 호출했으므로 add(double a, double b)가 호출됨.
만약 여기서 첫 번째 메서드 삭제하게 되면 1번은 자동형변환이 발생하여 add(double a, doub b)가 호출됨.
정리하면, 먼저 본인의 타입에 최대한 맞는 메서드를 찾아서 실행하고, 그래도 없으면 형변환 가능한 타입의 메서드를 찾아서 실행함.
1-1. 메서드 문제
[MethodEx1]
메서드를 잘 이해하고 있는지 확인하기 위해 다음 코드를 메서드를 사용하도록 리팩토링 하자.
package method.ex;
public class MethodEx1 {
public static void main(String[] args) {
int a = 1;
int b = 2;
int c = 3;
int sum = a + b + c;
double average = sum / 3.0;
System.out.println("평균값 : " + average);
int x = 15;
int y = 25;
int z = 35;
sum = x + y + z;
average = sum / 3.0;
System.out.println("평균값 : " + average);
}
}
package method.ex;
public class MethodEx1 {
public static void main(String[] args) {
System.out.println("평균값 : " + averagge(1, 2, 3));
System.out.println("평균값 : " + averagge(15, 25, 35));
}
public static double averagge(int a, int b, int c) {
int sum = a + b + c;
return sum / 3.0;
}
}[MethodEx2Ref]
다음은 특정 숫자만큼 같은 메시지를 반복 출력하는 기능이다.
메서드를 사용해서 리팩토링 해보자.
package method.ex;
public class MethodEx2 {
public static void main(String[] args) {
String message = "Hello, world!";
for(int i = 0; i < 3; i++) {
System.out.println(message);
}
for(int i = 0; i < 5; i++) {
System.out.println(message);
}
for(int i = 0; i < 7; i++) {
System.out.println(message);
}
}
}package method.ex;
public class MethodEx2Ref {
public static void main(String[] args) {
printMessage("Hello, world!", 3);
printMessage("Hello, world!", 5);
printMessage("Hello, world!", 7);
}
public static void printMessage(String message, int times) {
for(int i = 0; i < times; i++) {
System.out.println(message);
}
}
}메시지를 출력하는 메서드에서 해당 문자열과 반복할 횟수를 파라미터로 받음.
[MethodEx3]
다음은 입금, 출금을 나타내는 코드이다.입금(deposit)과 출금(withdraw)을 메서드로 만들어서 리팩토링 해보자.
package method.ex;
public class MethodEx3 {
public static void main(String[] args) {
int balance = 10000;
// 입금 1000
int depositAmout = 1000;
balance += depositAmout;
System.out.println(depositAmout + "원을 입금하였습니다. 현재 잔액 " + balance + "원");
// 출금 2000
int withdrawAmout = 2000;
if(balance >= withdrawAmout) {
balance -= withdrawAmout;
System.out.println(withdrawAmout + "원을 출금하였습니다. 현재 잔액 : " + balance + "원");
} else {
System.out.println(withdrawAmout + "원을 출금하려 햇으나 잔액이 부족합니다.");
}
System.out.println("최종 잔액 : " + balance + "원");
}
}실행 결과
10000원을 입금하였습니다. 현재 잔액 : 11000원
2000원을 출금하였습니다. 현재 잔액 : 9000원
최종 잔액 : 9000원package method.ex;
public class MethodEx3 {
public static void main(String[] args) {
int balance = 10000;
balance = deposit(balance, 1000);
balance = withdraw(balance, 2000);
System.out.println("최종 잔액 : " + balance + "원");
}
public static int deposit(int balance, int amount) {
balance += amount;
System.out.println(amount + "원을 입금하였습니다. 현재 잔액 : " + balance + "원");
return balance;
}
public static int withdraw(int balance, int amount) {
if(balance >= amount) {
balance -= amount;
System.out.println(amount + "원을 출금하였습니다. 현재 잔액 : " + balance + "원");
} else {
System.out.println(amount + "원을 출금하려 했으나 잔액이 부족합니다.");
}
return balance;
}
}리팩토링 결과 보면 main()은 세세한 코드가 아니라 전체 구조를 한눈에 볼 수 있게 됨.
쉽게 말해 책의 목차를 보는 것과 같은데, 더 자세히 알고 싶으면 해당 메서드를 찾아서 들어가면 됨.
그리고 출금 부분이 메서드로 명확하게 분리되었기 때문에 이후에 변경 사항이 발생하면 관련된 메서드만 수정하면 됨.
특정 메서드로 수정 범위가 한정되기 때문에 더 유지보수 하기 좋음.
이런 리팩토링을 메서드 추출(Extract Method)라고 함.
메서드를 재사용하는 목적이 아니어도 괜찮음.
메서드를 적절하게 사용 헤서 분류하면 구조적으로 읽기 쉽고 유지보수 하기 좋은 코드 만들 수 있음.
그리고 메서드의 이름 덕분에 프로그램을 더 읽기 좋게 만들 수 있음.
[MethodEx4]
다음 실행 예시 참고해서, 사용자로부터 계속 입력을 받아 입금과 출금을 반복 수행하는 프로그램 작성.
또한 간단한 메뉴를 표시하여 어떤 동작을 수행해야 할지 선택할 수 있게 하자.
출금 시 잔액이 부족하다면 "x원을 출금하려 했으나 잔액이 부족합니다."라고 출력해야 함.
해당하는 메뉴 번호 외에 다른 번호 선택 시 "올바른 선택이 아닙니다. 다시 선택해주세요."라고 출력해야 함.
package method.ex;
import java.util.Scanner;
public class MethodEx4 {
public static void main(String[] args) {
int balance = 0;
Scanner scanner = new Scanner(System.in);
while(true) {
System.out.println("---------------------------------");
System.out.println("1.입금 | 2.출금 | 3.잔액 확인 | 4.종료");
System.out.println("---------------------------------");
System.out.print("선택 : ");
int menu = scanner.nextInt();
int amount;
switch (menu) {
case 1 :
System.out.print("입금액을 입력하세요 : ");
amount = scanner.nextInt();
balance = deposit(balance, amount);
break;
case 2 :
System.out.print("출금액을 입력하세요 : ");
amount = scanner.nextInt();
balance = withdraw(balance, amount);
break;
case 3 :
System.out.println("현재 잔액 : " + balance);
break;
case 4 :
System.out.println("프로그램을 종료합니다.");
return;
default :
System.out.println("올바른 선택이 아닙니다. 다시 선택해주세요.");
}
}
}
public static int deposit (int balance, int amount) {
balance += amount;
System.out.println(amount + "원을 입금하였습니다. 현재 잔액 : " + balance + "원");
return balance;
}
public static int withdraw (int balance, int amount) {
if(balance >= amount) {
balance -= amount;
System.out.println(amount + "원을 출금하였습니다. 현재 잔액 : " + balance + "원");
} else {
System.out.println(amount + "원을 출금하려 했으나 잔액이 부족합니다.");
}
return balance;
}
}2. 정리
○ 변수명 / 메서드명 ○
- 변수 이름은 일반적으로 명사를 사용.
- 메서드는 무언가 동작하는데 사용하기 때문에 일반적으로 동사를 사용.
○ 메서드 사용의 장점 ○
1. 코드 재사용
- 메서드는 특정 기능을 캠슐화하므로, 필요할 때마다 그 기능을 다시 작성할 필요 없이 해당 메서드를 호출함으로써 코드 재사용 가능.
2. 코드의 가독성 : 이름이 부여된 메서드는 코드가 수행하는 작업을 명확하게 나타내므로, 코드를 읽는 사람에게 추가적인 문맥을 제공.
3. 모듈성 : 큰 프로그램을 작은, 관리 가능한 부분으로 나눌 수 있음. 이는 코드의 가독성을 향상시키고 디버깅 쉽게 만듦.
4. 코드 관리 유지
- 메서드를 사용하면, 코드의 특정 부분에서 문제가 발생하거나 업데이트가 필요한 경우 해당 메서드만 수정하면 됨.
- 이렇게 되면 전체 코드 베이스에 영향 주지 않고 변경 사항 적용 할 수 있음.
5. 재사용과 확장성 : 잘 설계된 메서드는 다른 프로그램이나 프로젝트에서도 재사용 가능. 새로운 기능 추가하거나 기존 기능 확장하는데 유용.
6. 추상화 : 메서드 사용하는 곳에서 메서드의 구현을 몰라도 됨. 프로그램의 다른 부분에서 복잡한 내부 작업에 대해 알 필요 없이 메서드 사용 가능.
7. 테스트와 디버깅 용이성 : 개별 메서드는 독립적으로 테스트하고 디버그 할 수 있음. 이는 코드의 문제를 신속하게 찾고 수정하는데 도움이 됨.
'Studying > JAVA' 카테고리의 다른 글
| [JAVA]_Array(배열) (1) | 2024.12.09 |
|---|---|
| [JAVA]_Scanner(스캐너) (1) | 2024.12.05 |
| [JAVA]_Casting(형변환) (0) | 2024.12.03 |
| [JAVA]_Scope(스코프) (0) | 2024.12.03 |
| [JAVA]_Loop Statement(반복문) (0) | 2024.12.03 |
