메서드
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);
}
}
문제점
- 같은 연산을 두 번 수행함
- 계산 1 부분과, 계산 2 부분이 거의 같음
같은 코드를 여러 번 반복해서 작성해야하고 어떤 연산을 수행하는지 출력하는 부분을 변경 혹은 제거하고 싶을 때 해당 코드를 다 찾아다니면서 수정해야 한다는 문제가 있음
함수(function)
함수 정의
add(a, b) = a + b
- 이름이 add이고, a, b라는 두 값을 받는 함수, 이 함수는 a + b 연산을 수행함.
함수 사용
add(1, 2) -> 결과 : 3
add(5, 6) -> 결과 : 11
add(3, 5) -> 결과 : 8- 함수에 값을 입력 시, 함수가 가진 연산을 처리하고 결과를 출력함.
- 여러 번 같은 계산을 해야 하면 함수를 만들어두고(정의), 필요한 입력 값을 넣어서 해당 함수를 호출하면 된다.
- 함수를 호출할 때는 외부에서는 필요한 값만 입력하면 계산된 결과가 출력됨.
- 같은 함수를 다른 입력 값으로 여러 번 호출할 수 있다.
- 함수를 한 번 정의해두면 계속해서 재사용 할 수 있다(핵심).
평균 함수
두 수의 평균을 구하기 위해서는 (a + b) / 2라는 공식을 사용해야 한다. 이것을 함수로 정의해서 사용하면 됨.
함수 정의
avg(a, b) = (a + b) / 2
함수 사용
avg(4, 6) -> 결과 : 5
avg(10, 20) -> 결과 : 15
avg(100, 200) -> 결과 : 150
프로그램 언어는 필요한 기능을 미리 정의해두고 필요할 때마다 호출해서 사용할 수 있도록 수학의 함수 개념을 차용해서 사용함.
메서드 사용
자바에서는 함수를 메서드(Method)라 한다.
메서드도 함수의 한 종류이다.
Method1Ref
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 + " 연산 수행");
int sum = a + b;
return sum;
}
}
메서드 사용으로 중복이 제거되고 코드가 깔끔해진다.
메서드 정의
public static int add(int a, int b) {
System.out.println(a + "+" + b + " 연산 수행");
int sum = a + b;
return sum;
}- 위 부분이 메서드, 이것을 함수를 정의하는 것과 같이, 메서드를 정의한다고 표현함
- 메서드는 수학의 함수와 유사하게 생김, 함수에 값을 입력하면, 어떤 연산을 처리한 다음에 결과를 반환함
메서드는 크게 메서드 선언과 메서드 본문으로 나눌 수 있음
메서드 선언(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) : 메서드를 호출할 때 전달하는 입력 값을 정의한다. 이 변수들을 해당 메서드 안에서만 사용됨, 메서드 선언에 사용되는 변수를 파라미터(parameter), 매개변수라 한다.
메서드 본문(Method Body)
{
System.out.println(a + "+" + b + " 연산 수행");
int sum = a + b;
return sum;
}- 메서드가 수행해야 하는 코드 블록
- 메서드를 호출하면 메서드 본문이 순서대로 실행됨
- 메서드 본문은 블랙박스, 메서드를 호출하는 곳에서는 메서드 선언을 알지만 메서드 본문은 모른다.
- 메서드의 실행 결과를 반환하려면 return문을 사용해야 한다. return문 다음에 반환할 결과를 적어주면 된다.
- return sum : sum 변수에 들어있는 값을 반환한다.
메서드 호출
앞서 정의한 메서드를 호출해서 실행하려면 메서드 이름에 입력 값을 전달하면 된다(메서드 호출).
int sum1 = add(5, 10);
int sum2 = add(15, 20);
메서드 호출 시 실행 순서
int sum1 = add(5, 10) // add 메서드를 5, 10을 전달해 호출
int sum1 = 15; // add(5, 10)이 실행, 실행 결과 반환 값 15
// sum1에 15 값이 저장메서드를 호출하면 메서드는 계산을 끝내고 결화를 반환한다(메서드 호출이 끝나면 해당 메서드가 반환한 결과 값으로 치환).
- 메서드 호출이 끝나면 메서드 정의에 사용한 파라미터 변수인 int a, int b는 물론그 안에서 정의한 int sum도 제거됨(메모리 낭비 x)
메서드 호출과 용어 정리
메서드 호출 시 메서드에 넘기는 값과 파라미터의 타입이 맞아야 한다(넘기는 값과 파라미터의 순서와 갯수도 맞춰야 함).
호출 : call("hello", 20)
메서드 정의 : int call(String str, int age)
인수(Argument)
"hello", 20처럼 넘기는 값을 Argument, 인수 또는 인자라 한다.
매개변수(Parameter)
메서드를 정의할 때 선언한 변수인 String str, int age를 매겨변수, 파라미터라 한다.
메서드를 호출 시 인수를 넘기면 그 인수가 매개변수에 대입된다.
용어정리
- 인수라는 용어는 '들어가는 수'라는 의미를 가진다. 즉, 메서드 내부로 들어가는 값을 의미한다(인자도 같은 의미).
- parameter, 매개변수는 '중간에서 전달하는 변수'라는 의미를 가짐. 즉, 메서드 호출부와 메서드 내부 사이에서 값을 전달하는 역할을 하는 변수
메서드 정의
public static int add(int a, int b) {
// 메서드 본문, 실행 코드
}
제어자 반환타입 메서드이름(매개변수 목록) {
메서드 본문
}- 제어자(Modifier) : 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;
}
public static void printFooter() {
System.out.println("= 프로그램을 종료합니다 =");
}
}
- 매개변수가 없는 경우
- 선언: public static void printHeader()와 같이 매개변수를 비워두고 정의
- 호출 : printHeader(); 와 같이 인수를 비워두고 호출
- 반환타입이 없는 경우
- 선언 : public static void printHeader()와 같이 반환 타입을 void로 정의
- 호출 : printHeader(); 와 같이 반환 타입이 없으므로 메서드만 호출하고 반환 값을 받지 않으면 됨
- String str = printHeader(); 반환 타입이 void이기 때문에 이렇게 반환 값을 받으면 컴파일 오류가 발생
void와 return 생략
모든 메서드는 항상 return을 호출해야 한다. 반환 타입이 void의 경우에는 예외로 printFooter()와 같이 생략해도 된다. 자바 컴파일러가 반환 타입이 없는 경우에는 return을 마지막줄에 넣어준다(return을 만나면 해당 메서드는 종료된다).
반환타입
반환 타입이 있으면 반드시 값을 반환해야 한다.
반환 타입이 있는 메서드는 반드시 return을 사용해서 값을 반환해야 한다.
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문이 실행되지 않기 때문에 컴파일 오류가 발생
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;
} else {
return false;
}
}
}
- if 조건을 만족하지 않아도 else를 통해 return문이 실행됨.
Return문을 만나면 그 즉시 메서드를 빠져나간다.
package method;
public class MethodReturn2 {
public static void main(String[] args) {
checkAge(10);
checkAge(20);
}
public static void checkAge(int age) {
if (age < 18) {
System.out.println(age + "살, 미성년자는 출입이 불가합니다.");
return;
}
System.out.println(age + "살 , 입장하세요.");
}
}
- 18세 미만은 "출입 불가"를 출력하고 바로 return문이 수행됨, 따라서 다음 로직을 수행하지 않고, 해당 메서드를 빠져나옴
- 18세 이상의 경우 "입장하세요"를 출력하고, 메서드가 종료된다. 반환 타입이 없는 void형은 마지막 줄의 return은 생략 할 수 있음
반환 값 무시
반환 타입이 있는 메서드를 호출했는데 만약 반환 값이 필요없다면 사용하지 않아도 된다.
메서드 호출과 값 전달
자바는 항상 변수의 값을 복사해서 대입한다. - 자바에서 중요한 대원칙 하나
변수와 값 복사
MethodValue0
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);
}
}
실행과정
int num1 = 5; // num1의 값 5
int num2 = num1; // num2 변수에 대입하기 전에 num1의 값 5를 읽는다 num1 = 5, num2 = 5
num2 = 10; // num2에 10을 대입 결과: num1 = 5, num2 = 10
값을 복사해서 대입하는 부분
int num2 = num1;
- num1에 있는 값 5를 복사해서 num2에 넣는다
- 복사로 표현하는 이유는 num1의 값을 읽어도 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);
// num1의 값에 changeNumber의 결과를 받지 않았으므로 num1의 값은 5 그대로임
}
public static void changeNumber(int num2) {
System.out.println("2. changeNumber 변경 전, num2: " + num2);
num2 = num2 * 2;
System.out.println("3. changeNumber 변경 후, num2: " + num2);
}
}
실행과정
- changeNumber(num1) 호출 시점
- num1의 값 5를 읽고 복사해서 num2에 전달 → 핵심
- changeNumber메서드 실행 중
- num2의 변경은 num1에 영향을 주지 않는다(num1의 값을 복사해서 전달하기 때문).
자바는 항상 값을 복사해서 전달하기 때문에 num2의 값을 바꾸더라도 num1에는 영향을 주지 않는다.
메서드 호출과 이름이 같은 변수
MethodValue2
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
}
}
main( ) 메서드임, 각각의 메서드 안에서 사용하는 변수는 서로 완전히 분리된 다른 변수임(이름이 같아도 다른 변수). main( )의 number와 changeNumber( )의 number는 서로 다른 변수임.
메서드 호출과 값 반환받기
MethodValue3
package method;
public class MethodValue3 {
public static void main(String[] args) {
int num1 = 5;
System.out.println("changeNumber 호출 전, num1: " + num1); //5
num1 = changeNumber(num1);
System.out.println("changeNumber 호출 후, num1: " + num1); //5
}
public static int changeNumber(int num2) {
num2 = num2 * 2;
return num2;
}
}
메서드와 형변환
명시적 형변환
MethodCasting1
package method;
public class MethodCasting1 {
public static void main(String[] args) {
double number = 1.5;
//printNumber(number); //타입 불일치로 컴파일 오류
printNumber((int)number); // 명시적 형변환
}
public static void printNumber(int n) {
System.out.println("숫자: " + n);
}
}
자동 형변환
MethodCasting2
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);
}
}
정리
메서드를 호출할 때는 전달하는 인수의 타입과 매개변수의 타입이 맞아야 한다. 단, 타입이 달라도 자동 형변환이 가능한 경우에는 호출할 수 있다.
메서드 오버로딩
- 자바는 메서드의 이름뿐만 아니라 매개변수 정보를 함께 사용해서 메서드를 구분한다.
오버로드 성공
add(int a, int b)
add(int a, int b, int c)
add(double a, double b)
이름이 같고 매개변수가 다른 메서드를 여러 개 정의하는 것을 메서드 오버로딩(Overloading)이라 한다.
오버로딩 규칙
메서드의 이름이 같아도 매개변수 타입 및 순서가 다르면 오버로딩을 할 수 있다(반환 타입은 인정하지 않음).
오버로드 실패
int add(int a, int b)
double add(int a, int b)
메서드 시그니처(method signature)
메서드 시그니처 = 메서드 이름 + 매개변수 타입(순서)
자바에서 메서드를 구분할 수 있는 고유한 식별자나 서명을 뜻함, 메서드 시그니처는 메서드의 이름과 매개변수 타입(순서 포함)으로 구성되어 있다. 쉽게 이야기 해서 메서드를 구분할 수 있는 기준.
자바 입장에서는 각각의 메서드를 고유하게 구분할 수 있어야 함(그래야 어떤 메서드를 호출할 지 결정할 수 있음).
메서드 이름이 같아도 메서드 시그니처가 다르면 다른 메서드로 간주한다.
반환 타입은 시그니처에 포함되지 않기 때문에 메서드 시그니처가 같으므로 메서드 구분이 불가능해서 컴파일 오류가 발생한다.
OverLoading1
package method;
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;
}
}
OverLoading2
package method;
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");
}
}
OverLoading3
package method;
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));
}
// int add 메서드를 주석처리 해도 코드는 실행 됨
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;
}
}
먼저 본인의 타입에 최대한 맞는 메서드를 찾아서 실행하고, 그래도 없으면 형변환 가능한 타입의 메서드를 찾아서 실행.
문제
1. 아래 코드를 메서드로 리펙토링
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);
}
}
Ref
package method.ex;
public class MethodEx1 {
public static void main(String[] args) {
System.out.println("평균값: " + avg(1, 2, 3));
System.out.println("평균값: " + avg(15, 25, 35));
}
public static double avg(int a, int b, int c) {
int sum = a + b + c;
return sum / 3.0;
}
}
2. 반복출력 리펙토링
package method.ex;
public class MethodEx2 {
public static void main(String[] args) {
String message = "Hello, wrold!";
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);
}
}
}
Ref
package method.ex;
public class MethodEx2Ref {
public static void main(String[] args) {
String message = "Hello, world!";
printMessage(message, 3);
System.out.println(); // 함수 출력 간의 공백
printMessage(message, 5);
System.out.println(); // 함수 출력 간의 공백
printMessage(message, 7);
}
public static void printMessage(String str, int n) {
for (int i = 0; i < n; i++) {
System.out.println(str);
}
}
}
3. 입출금 리펙토링
package method.ex;
public class MethodEx3 {
public static void main(String[] args) {
int balance = 10000;// 입금 1000
int depositAmount = 1000;
balance += depositAmount;
System.out.println(depositAmount + "원을 입금하였습니다. 현재 잔액: " + balance + "원");// 출금 2000
int withdrawAmount = 2000;
if (balance >= withdrawAmount) {
balance -= withdrawAmount;
System.out.println(withdrawAmount + "원을 출금하였습니다. 현재 잔액: " + balance + "원");
} else {
System.out.println(withdrawAmount + "원을 출금하려 했으나 잔액이 부족합니다.");
}
System.out.println("최종 잔액: " + balance + "원");
}
}
Ref
package method.ex;
public class MethodEx3Ref {
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;
}
}
- 메서드 추출(Extract Method) : 코드 전체 구조를 한 눈에 볼 수 있게하고 각 기능(로직)을 메서드로 분리하여 변경 사항 발생 시 특정 메서드로 수정범위를 한정하여 유지보수 하기 좋게 만드는 것.
- 메서드를 재사용하는 목적 외에도 메서드를 적절하게 사용해서 분류하면 구조적으로 읽기 쉽고 유지보수하기 좋은 코드를 만들 수 있다(메서드의 이름으로 인해 프로그램을 더 읽기 좋게 만들 수 있다).
4. 은행계좌 입출금
- 실행 예시와 같은 프로그램 작성
package method.ex;
import java.util.Scanner;
public class MethodEx4 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int balance = 0;
int menu = 0;
while (true) {
menuView();
menu = scanner.nextInt();
scanner.nextLine();
// switch
switch (menu) {
case 1:
System.out.print("입금액을 입력하세요: ");
balance = deposit(balance, scanner.nextInt());
break;
case 2:
System.out.print("출금액을 입력하세요: ");
balance = withdraw(balance, scanner.nextInt());
break;
case 3:
System.out.println("현재 잔액: " + balance + "원");
case 4:
System.out.println("시스템을 종료합니다.");
return; // return을 사용하면 while문 밖으로 나갈 수 있음
default:
System.out.println("잘못된 메뉴를 선택했습니다.");
}
// if - else if - else
// if (menu == 1) {
// System.out.print("입금액을 입력하세요: ");
// balance = deposit(balance, scanner.nextInt());
// } else if (menu == 2) {
// System.out.print("출금액을 입력하세요: ");
// balance = withdraw(balance, scanner.nextInt());
// } else if (menu == 3) {
// System.out.println("현재 잔액: " + balance + "원");
// } else if (menu == 4) {
// System.out.println("시스템을 종료합니다.");
// break;
// } else {
// 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;
}
public static void menuView() {
System.out.println("메뉴를 선택하세요.");
System.out.println("----------------------------------------");
System.out.println("1.입금 | 2.출금 | 3.잔액 확인 | 4.종료" );
System.out.println("----------------------------------------");
}
}
정리
변수명 vs 메서드명
변수 이름은 일반적으로 명사를 사용, 메서드는 무언가 동작하는데 사용하기 때문에 일반적으로 동사로 시작
- 변수명 예) : customerName, totalSum, employeeCount, isAvailable
- 메서드명 예) : printReport( ), calculateSum( ), addCustomer( ), getEmployeeCount( )
메서드 사용의 장점
- 코드 재사용: 메서드는 특정 기능을 캡슐화하므로, 필요할 때마다 그 기능을 다시 작성할 필요 없이 해당 메서드를 호출함으로써 코드를 재사용할 수 있다.
- 코드의 가독성: 이름이 부여된 메서드는 코드가 수행하는 작업을 명확하게 나타내므로, 코드를 읽는 사람에게 추가적인 문맥을 제공한다.
- 모듈성: 큰 프로그램을 작은, 관리 가능한 부분으로 나눌 수 있다. 이는 코드의 가독성을 향상시키고 디버깅을 쉽게 만든다.
- 코드 유지 관리: 메서드를 사용하면, 코드의 특정 부분에서 문제가 발생하거나 업데이트가 필요한 경우 해당 메서드만 수정하면 된다. (코드 전체 베이스에 영향을 주지 않고 변경사항을 적용할 수 있다.
- 재사용과 확장성: 잘 설계된 메서드는 다른 프로그램이나 프로젝트에서도 재사용할 수 있으며, 새로운 기능을 추가하거나 기존 기능을 확장하는데 유용함
- 추상화: 메서드를 사용하는 곳에서는 메서드의 구현을 몰라도 된다. 프로그램의 다른 부분에서는 복잡한 내부 작업에 대해 알 필요 없이 메서드를 사용할 수 있다.
- 테스트와 디버깅 용이성: 개별 메서드는 독립적으로 테스트하고 디버그할 수 있다. (코드의 문제를 신속하게 찾고 수정하는 데 도움이 됨)
메서드는 효율적이고 유지 보수가 가능한 코드를 작성하는 데 매우 중요한 도구
'항해 99 > Java' 카테고리의 다른 글
| Java 기초 8 - 객체 지향 프로그래밍 (0) | 2024.01.25 |
|---|---|
| Java 기초 7 - 클래스, 기본형과 참조형 (1) | 2024.01.25 |
| Java 기초 5 - 배열 (0) | 2024.01.22 |
| Java 기초 4 - 훈련 (1) | 2024.01.22 |
| Java 문법 기초 테스트-3 (1) | 2024.01.22 |
