메서드

메서드 시작

함수 (function)

add(a, b) = a + b

• 이름이 add 이고 a , b 라는 두 값을 받는 함수이다. 그리고 이 함수는 a + b 연산을 수행한다.
• add(1,2) -> 결과:3
  add(5,6) -> 결과:11
  add(3,5) -> 결과:8
• 같은 함수를 다른 입력 값으로 여러번 호출 할 수 있다.
• 재사용이 가능!

메서드 사용

<Method1Ref.java>

package method;

public class Method1Ref {
    public static void main(String[] args) {
        int sum1 = add(5, 10);
        System.out.println("결과1 출력:" + sum1);

        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)

• 메서드 이름, 반환타입, 매개변수(파라미터)
• public : 다른 클래스에서 호출할 수 있는 메서드라는 뜻
  static : 객체를 생성하지 않고 호출할 수 있는 정적 메서드라는 뜻
  int : 반환 타입을 정의, 메서드 실행결과를 반환할 때 사용할 반환 타입을 지정한다.
  add : 메서드 이름
  (int a, int b) : 메서드를 호출할 때 전달하는 입력값을 정의, 파라미터, 매개변수

메서드 본문

//1: 메서드 호출
int sum1 = add(5, 10);
//2: 파라미터 변수 a=5, b=10이 전달되면서 메서드가 수행된다.
public static int add(int a=5, int b=10) {
 int sum = a + b;
 return sum;
}
//3: 메서드가 수행된다.
public static int add(int a=5, int b=10) {
 int sum = a(5) + b(10);
 return sum;
}
//4: return을 사용해서 메서드 실행의 결과인 sum을 반환한다. sum에는 값 15가 들어있으므로 값 15가
반환된다.
public static int add(int a=5, int b=10) {
 int sum = 15;
 return sum(15);
}
//5: 메서드 호출 결과로 메서드에서 반환한 값 15가 나온다. 이 값을 sum1에 대입했다.
int sum1 = 15

메서드 호출과 용어정리

메서드를 호출할 때는 다음과 같이 메서드에 넘기는 값과 매개변수(파라미터)의 타입이 맞아야 한다. 물론 넘기는 값과
매개변수(파라미터)의 순서와 갯수도 맞아야 한다.

호출: 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 과 같은 부분이다. 제어자는 뒤에서 설명한다. 지금은 항상 public static 키워드를 입력하자.
• 반환 타입(Return Type): 메서드가 실행 된 후 반환하는 데이터의 타입을 지정한다. 메서드가 값을 반환하지 않는 경우, 없다는 뜻의 void 를 사용해야 한다. 예) void print(String str)
• 메서드 이름(Method Name): 메서드의 이름이다. 이 이름은 메서드를 호출하는 데 사용된다.
• 매개변수(Parameter): 입력 값으로, 메서드 내부에서 사용할 수 있는 변수이다. 매개변수는 옵션이다. 입력값이필요 없는 메서드는 매개변수를 지정하지 않아도 된다. 예) add()
• 메서드 본문(Method Body): 실제 메서드의 코드가 위치한다. 중괄호 {} 사이에 코드를 작성한다.

매개변수나 반환타입이 없는 경우

<Method2.java>

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("= 프로그램을 종료합니다 =");
    }
}

=> String str = printHeader(); 반환 타입이 void 이기 때문에 이렇게 반환 값을 받으면 컴파일 오류가 발생한다.

void 와 return 생략
반환 타입 void 의 경우에는 예외로 printFooter() 와 같이 생략해도 된다. 자바가 반환 타입이 없는 경우에는 return 을 마지막줄에 넣어준다. 참고로 return 을 만나면 해당 메서드는 종료된다.

반환타입

<MethodReturn1.java>

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==0){
            return true;
        }else {
            return false;
        }
    }
}

return 문을 만나면 그 즉시 메서드를 빠져나간다.

<MethodReturn2.java>

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 + "살, 입장하세요.");
    }
}

메서드 호출과 값 전달1

<MethodValue1.java>

package method;

public class MethodValue1 {
    public static void main(String[] args) {
        int num1 =5;
        System.out.println("1. changeNum 호출 전, num1 : "+num1);
        changeNum(num1);
        System.out.println("4. changeNum 호출 후, num1 : "+num1);
    }
    public static void changeNum(int num2){
        System.out.println("2. changeNym 변경 전, num2 : "+num2);
        num2 *= 2;
        System.out.println("3. changeNym 변경 후, num2 : "+num2);
    }
}

메서드 호출과 값 전달2

메서드 호출과 이름이 같은 변수

<MethodValue2.java>

package method;

public class MethodValue2 {
    public static void main(String[] args) {
        int num =5;
        System.out.println("1. changeNum 호출 전, num1 : "+num);
        changeNum(num);
        System.out.println("4. changeNum 호출 후, num1 : "+num);
    }
    public static void changeNum(int num){
        System.out.println("2. changeNym 변경 전, num2 : "+num);
        num *= 2;
        System.out.println("3. changeNym 변경 후, num2 : "+num);
    }
}

main() 에 정의한 변수와 메서드의 매개변수(파라미터)의 이름이 둘다 number 로 같다.
하지만 main() 의 number 와 changeNumber() 의 number 는 서로 다른 변수이다.

메서드 호출과 값 반환받기

메서드를 사용해서 값을 변경하기
<MethodValue3.java>

package method;

public class MethodValue3 {
    public static void main(String[] args) {
        int num =5;
        System.out.println("1. changeNum 호출 전, num1 : "+num);
        num = changeNum(num);
        System.out.println("2. changeNum 호출 후, num1 : "+num);
    }
    public static int changeNum(int num){
        num *= 2;
        return num;
    }
}

메서드와 형변환

명시적 형변환

<MethodCasting1.java>

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);
    }
}

자동 형변환

int < long < double

package method;

public class MethodCasting2 {
    public static void main(String[] args) {
        int number = 100;
        printNumber(number); // int에서 double로 자동 형변환
    }
    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)

<OverLoading1.java>

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));
    }
    
    // 첫 번째 add 메서드: 두 정수를 받아서 합을 반환한다.
    public static int add(int a, int b) {
        System.out.println("1번 호출");
        return a + b;
    }
    
    // 두 번째 add 메서드: 세 정수를 받아서 합을 반환한다.
    // 첫 번째 메서드와 이름은 같지만, 매개변수 목록이 다르다.
    public static int add(int a, int b, int c) {
        System.out.println("2번 호출");
        return a + b + c;
    }

}

<OverLoading2.java>

package method;

public class OverLoading2 {
    public static void main(String[] args) {
        myMethod(1, 1.2);
        myMethod(1.2, 2);
    }
    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.java>

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));
    }
    
    // 첫 번째 add 메서드: 두 정수를 받아서 합을 반환한다.
    public static int add(int a, int b) {
        System.out.println("1번 호출");
        return a + b;
    }
    
    // 두 번째 add 메서드: 두 실수를 받아서 합을 반환한다.
    // 첫 번째 메서드와 이름은 같지만, 매개변수의 유형이 다르다.
    public static double add(double a, double b) {
        System.out.println("2번 호출");
        return a + b;
    }
    
    //첫번째 add 메서드를 지운다 해도 실행이된다. 
    // int 거 double 로 자동 형변환이 이루어지기 때문에!
}

문제와 풀이1

<MethodEx1.java>

package method.ex;

public class MethodEx1 {
    public static void main(String[] args) {
        double average = avg(1,2,3);
        System.out.println("평균값: " + average);

        System.out.println("평균값: " + avg(15,25,35));
    }

    public static double avg(int a, int b, int c){
        int sum = a+b+c;
        double average = sum / 3.0;
        return average;
    }
}

<MethodEx2.java>

package method.ex;

public class MethodEx2 {
    public static void main(String[] args) {
       comment(3);
        System.out.println("----");
       comment(5);
        System.out.println("----");
       comment(7);
    }

    public static void comment(int num){
        String message = "Hello, world!";
        for(int i =0; i<num; i++){
            System.out.println(message);
        }
    }
//
//    public static void printMessage(String message, int times) {
//        for (int i = 0; i < times; i++) {
//            System.out.println(message);
//        }
//    }
}

<MethodEx3.java>

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;
    }
}

문제와 풀이2

<MethodEx4.java>

package method.ex;

import java.util.Scanner;

public class MethodEx4 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int balance = 0;

        while(true){
            System.out.print("선택 : ");
            int option = input.nextInt();

//            if(option==1){
//                System.out.print("입금액 : ");
//                int depositamount = input.nextInt();
//                balance = deposit(balance,depositamount);
//            } else if (option ==2) {
//                System.out.print("출금액 : ");
//                int withdrawAmount = input.nextInt();
//                balance = withdraw(balance,withdrawAmount);
//            } else if (option ==3) {
//                System.out.println("현재 잔액 : " +balance);
//            } else if (option==4) {
//                System.out.println("시스템을 종료합니다.");
//                break;
//            }

            int amount;
            switch (option){
                case 1 :
                    System.out.print("입금액 : ");
                    amount = input.nextInt();
                    balance = deposit(balance,amount);
                    break;
                case 2 :
                    System.out.print("입금액 : ");
                    amount = input.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;
    }
}

정리

• 메서드명은 일반적으로 동사로 시작한다.
• 메서드 사용의 장점

  • 코드 재사용 : 메서드는 특정 기능을 캡슐화하므로 필요할 때 마다 사용가능
  • 코드 가독성
  • 모듈성 : 큰 프로젝트, 관리 가능한 부분으로 나눌 수 있다. 이는 코드의 가독성향상 및 디버깅을 쉽게 만든다.
  • 코드유지관리
  • 코드 재사용성과 확장성
  • 추상화 : 프로그램의 다른 부분에서는 복잡한 내부작업에 대해 알 필요가 없다.
  • 테스트와 디버깅 용이성 : 개별 메서드는 독립적으로 테스트하고 디버그 할 수 있다. 이는 신속하게 찾고 수정하는데 도움이 된다.