05 메소드

메소드(Method)

메소드는 쉽게 말해서 특정 기능을 하는 코드 블록입니다.

main 밖에 작성해야 합니다.

메소드의 구조

static int add(int num1, int num2){
	return num1 + num2;
}

static: 정적 메소드(클래스 메소드)에서 호출하려면 붙어야함

int: 반환값의 자료형의 위치이며 반환값의 자료형이 없으면 void 라고 작성

add: 메소드의 이름

(int num1, int num2): 매개변수(parameter)이며 각각 자료형과 변수명을 적음. 없을 시 빈 괄호

• 호출시 넣는 값을 인수(argument)라고 함

return: 반환하는 값이 있을 때, 맨 마지막에 붙임

즉, return 이 존재하면 자료형을 붙여주고 없으면 void로 작성

반복을 최소화하기 위한 메소드

코드를 작성하다 보면 같은 작업을 여러 번 반복해야 하는 경우가 있습니다. 이럴 때, 그 작업을 메소드로 만들어서 필요한 곳에서 메소드를 호출하면 반복을 줄일 수 있습니다.

예시: 여러 번 숫자를 출력하는 코드

PrintNumberMethodExample.java

반복되는 작업을 메소드로 만들어서 호출하면 코드가 더 깔끔해집니다.

public class PrintNumberMethodExample {
    // 숫자를 출력하는 메소드
    public static void printNumber(int number) {
        System.out.println("숫자: " + number);
    }

    // 메소드 사용 예시
    public static void main(String[] args) {
        printNumber(5);  // 숫자: 5
        printNumber(10); // 숫자: 10
        printNumber(20); // 숫자: 20
    }
}

이 예시에서는 printNumber라는 메소드를 만들어서 숫자를 출력하는 반복 작업을 메소드로 처리했습니다. 그 결과, 숫자를 출력하는 부분에서 같은 코드를 반복하지 않고 메소드를 호출하는 방식으로 간단하게 처리할 수 있습니다.

함수의 기능을 갖는 메소드

함수의 기능을 갖는 메소드는 어떤 값을 받아서 결과를 반환하는 역할을 합니다. 함수처럼 동작하는 메소드는 입력값(매개변수)을 받아서 계산한 후 결과값을 반환합니다. 예를 들어, 두 숫자를 더하는 기능을 메소드로 만들어서 값을 계산할 수 있습니다.

예시: 두 숫자를 더하는 함수 기능 메소드

AddNumberMethodExample.java

public class AddNumberMethodExample {
    // 두 숫자를 더해서 결과를 반환하는 메소드
    public static int add(int a, int b) {
        return a + b;  // 두 수를 더한 값을 반환
    }

    // 메소드 사용 예시
    public static void main(String[] args) {
        int result = add(3, 4);  // 3과 4를 더한 결과를 반환받음
        System.out.println("더한 결과: " + result);  // 출력: 더한 결과: 7
    }
}

이 메소드는 a와 b라는 두 개의 숫자를 입력받고, 그 값을 더한 후 결과를 반환하는 기능을 합니다. 이처럼 함수처럼 작동하는 메소드는 결과를 계산한 후 반환하는 기능을 갖고 있습니다.

정리

• 반복을 최소화하기 위한 메소드: 여러 번 반복되는 코드를 메소드로 만들어 호출함으로써 중복을 줄이고 코드의 가독성을 높입니다.

• 함수의 기능을 갖는 메소드: 값을 입력받아 결과를 계산하고 반환하는 메소드입니다. 이는 함수와 같은 역할을 합니다.

매개변수의 개수가 정해지지 않은 메소드

매개변수의 개수가 정해지지 않은 메소드는 가변 인자(Varargs)를 사용하여 정의할 수 있습니다. 가변 인자는 메소드에서 전달할 매개변수의 개수가 몇 개인지 모를 때 사용되며, 매개변수를 배열 형태로 처리합니다.

기본 구조

리턴타입 메소드이름(타입... 변수명) {
    // 실행할 코드
}

• 타입... 변수명 형태로 매개변수를 선언하면, 이 변수는 0개 이상의 인자를 배열처럼 처리할 수 있습니다.

• 가변 인자는 메소드의 마지막 매개변수로만 올 수 있습니다.

예시: 가변 인자를 사용하는 메소드

SumMethodExample.java

여러 개의 숫자를 더하는 메소드를 가변 인자를 사용해 정의할 수 있습니다.

public static int sum(int... numbers) {
    int total = 0;
    for (int num : numbers) {
        total += num;  // 모든 숫자를 더함
    }
    return total;
}

위의 메소드는 sum(int... numbers)와 같이 가변 인자를 사용하여 여러 개의 정수를 받을 수 있습니다. 내부에서는 numbers가 배열처럼 동작하므로, for-each 문을 사용해 모든 숫자를 더합니다.

가변 인자를 사용한 메소드 호출

SumMethodExample.java

public static void main(String[] args) {
    System.out.println(sum(1, 2, 3));     // 결과: 6
    System.out.println(sum(10, 20, 30));  // 결과: 60
    System.out.println(sum(5));           // 결과: 5 (매개변수가 하나일 때도 동작)
    System.out.println(sum());            // 결과: 0 (매개변수가 없을 때도 동작)
}

• sum(1, 2, 3)처럼 호출하면, 1, 2, 3이 numbers 배열로 전달되어 더해집니다.

• 매개변수를 몇 개 전달하든지, 또는 전달하지 않아도 오류 없이 동작합니다.

가변 인자와 다른 매개변수 함께 사용

PrintNumbersMethodExample.java

가변 인자 외에도 다른 매개변수를 같이 사용할 수 있습니다. 단, 가변 인자는 항상 마지막에 와야 합니다.

public static void printNumbers(String message, int... numbers) {
    System.out.println(message);
    for (int num : numbers) {
        System.out.print(num + " ");
    }
    System.out.println();
}

사용 예시

PrintNumbersMethodExample.java

public static void main(String[] args) {
    printNumbers("숫자 목록:", 1, 2, 3, 4);  // 출력: 숫자 목록: 1 2 3 4
    printNumbers("한 개의 숫자:", 7);        // 출력: 한 개의 숫자: 7
    printNumbers("숫자가 없습니다.");         // 출력: 숫자가 없습니다.
}

이처럼 가변 인자를 사용하면, 메소드가 다양한 개수의 매개변수를 처리할 수 있어 유연성이 높아집니다.

메소드 오버로딩(Method Overloading)

메소드 오버로딩(Method Overloading)은 Java에서 같은 이름의 메소드를 여러 개 정의할 수 있는 기능입니다. 단, 메소드의 매개변수의 타입, 개수 또는 순서가 달라야 합니다. 오버로딩된 메소드를 사용하면 같은 기능을 수행하지만 입력값이 다른 경우, 하나의 이름으로 다양한 상황을 처리할 수 있습니다.

메소드 오버로딩의 조건

1. 매개변수의 개수가 다를 때

2. 매개변수의 타입이 다를 때

3. 매개변수의 순서가 다를 때 (타입이 다른 경우에만 해당)

리턴 타입이 다르다고 해서 오버로딩이 허용되지는 않습니다. 반드시 매개변수의 개수나 타입이 달라야 합니다.

메소드 오버로딩의 예시

1. 매개변수의 개수가 다른 경우

DifferentNumber.java

public class DifferentNumber {
    // 두 수를 더하는 메소드
    public int add(int a, int b) {
        return a + b;
    }

    // 세 수를 더하는 메소드 (매개변수 개수 다름)
    public int add(int a, int b, int c) {
        return a + b + c;
    }

    public static void main(String[] args) {
        DifferentNumber differentNumber = new DifferentNumber();

        // 매개변수의 개수가 다른 경우
        System.out.println(differentNumber.add(2, 3)); 
        // 출력: 5 (두 개의 숫자를 더함)
        System.out.println(differentNumber.add(1, 2, 3)); 
        // 출력: 6 (세 개의 숫자를 더함)
    }
}

위 코드는 add라는 이름의 메소드가 두 개 정의되어 있습니다. 하나는 두 개의 숫자를 더하고, 다른 하나는 세 개의 숫자를 더합니다. 같은 이름의 메소드이지만, 매개변수의 개수가 다르기 때문에 오버로딩이 가능합니다.

2. 매개변수의 타입이 다른 경우

DifferentType.java

public class DifferentType {

    // 매개변수의 타입이 다른 경우
    // 두 개의 정수형 수를 더하는 메소드
    public int add(int a, int b) {
        return a + b;
    }

    // 두 개의 실수형 수를 더하는 메소드 (매개변수 타입 다름)
    public double add(double a, double b) {
        return a + b;
    }

    public static void main(String[] args) {
        DifferentType differentType = new DifferentType();

        // 매개변수의 타입이 다른 경우
        System.out.println(differentType.add(2, 3));        
        // 출력: 5 (int형 더하기)
        System.out.println(differentType.add(2.5, 3.7));    
        // 출력: 6.2 (double형 더하기)
    }
}

위 코드에서는 add 메소드의 매개변수 타입이 다릅니다. 하나는 정수(int)를, 다른 하나는 실수(double)를 더하는 메소드입니다.

3. 매개변수의 순서가 다른 경우

DifferentOrder.java

public class DifferentOrder {
    // 순서: 정수, 문자열
    public void printInfo(int id, String name) {
        System.out.println("ID: " + id + ", Name: " + name);
    }

    // 순서: 문자열, 정수 (매개변수 순서 다름)
    public void printInfo(String name, int id) {
        System.out.println("Name: " + name + ", ID: " + id);
    }

    public static void main(String[] args) {
        DifferentOrder differentOrder = new DifferentOrder();
        differentOrder.printInfo(123, "John");  // 출력: ID: 123, Name: John
        differentOrder.printInfo("Alice", 456); // 출력: Name: Alice, ID: 456
    }
}

이 예시에서는 매개변수의 개수와 타입이 같지만, 순서가 다릅니다. 하나는 정수형 ID가 먼저 오고, 다른 하나는 문자열 이름이 먼저 옵니다. 이와 같은 경우도 오버로딩이 가능합니다.

주의 사항

• 메소드의 리턴 타입만 다를 경우에는 오버로딩이 되지 않습니다. 반드시 매개변수의 타입이나 개수, 순서가 달라야 합니다.

  예를 들어, 다음 두 메소드는 리턴 타입이 다르지만 매개변수가 같기 때문에 오버로딩이 불가능합니다.

public int add(int a, int b) {
    return a + b;
}

public double add(int a, int b) {
    return a + b;
}

메소드 오버로딩의 장점

1. 코드의 가독성 향상: 같은 동작을 하는 메소드를 이름으로 일관성 있게 유지할 수 있습니다.

2. 유연성 제공: 다양한 형태의 입력을 처리할 수 있으므로 코드의 유연성이 높아집니다.

3. 코드 중복 제거: 같은 기능을 하는 메소드를 여러 개 만들지 않고, 메소드 이름을 재사용할 수 있어 코드 중복을 줄일 수 있습니다.

정리

• 메소드 오버로딩은 동일한 메소드 이름으로 여러 메소드를 정의할 수 있는 기능입니다.

• 매개변수의 개수, 타입, 순서가 다를 때 오버로딩을 사용할 수 있습니다.

• 리턴 타입만 다른 메소드는 오버로딩할 수 없습니다.

원시형 매개변수와 참조형 매개변수

원시형 매개변수 (Primitive Type Parameters)

원시형 매개변수는 기본 데이터 타입(예: int, float, boolean)을 메소드에 전달할 때 사용됩니다. Java에서는 원시형 데이터가 값에 의한 호출(Call by Value)로 전달됩니다. 즉, 메소드에 전달된 원시형 변수의 값이 복사되어 메소드 내부에서 사용되며, 원래의 변수 값에는 영향을 미치지 않습니다.

예시: 원시형 매개변수

PrimitiveTypeParametersExample.java

public class PrimitiveTypeParametersExample {
    public void modifyValue(int number) {
        number = 10;  // 전달된 값을 변경해도 원래 변수는 영향을 받지 않음
    }

    public static void main(String[] args) {
        int num = 5;
        PrimitiveTypeParametersExample primitiveTypeParametersExample 
                = new PrimitiveTypeParametersExample();

        System.out.println("Before: " + num);  // 출력: Before: 5
        primitiveTypeParametersExample.modifyValue(num);
        System.out.println("After: " + num);   // 출력: After: 5 (변경되지 않음)
    }
}

위 코드에서 modifyValue() 메소드가 num을 수정하려고 하지만, 실제로 메소드 내에서 사용되는 값은 num의 복사본입니다. 따라서 num의 값은 변경되지 않고 그대로 유지됩니다.

2. 참조형 매개변수 (Reference Type Parameters)

참조형 매개변수는 객체(예: 배열, 클래스 인스턴스)를 메소드에 전달할 때 사용됩니다. Java에서는 객체가 참조에 의한 호출(Call by Reference)로 전달됩니다. 즉, 객체의 참조(주소)가 복사되어 전달되므로, 메소드 내에서 객체의 내용을 변경하면 원래 객체에도 영향을 미칩니다.

예시: 참조형 매개변수

ReferenceTypeParametersExample.java

public class ReferenceTypeParametersExample {
    public void modifyArray(int[] array) {
        array[0] = 10;  // 배열의 첫 번째 요소를 변경
    }

    public static void main(String[] args) {
        int[] numbers = {1, 2, 3};
        ReferenceTypeParametersExample referenceTypeParametersExample 
                = new ReferenceTypeParametersExample();

        System.out.println("Before: " + numbers[0]);  // 출력: Before: 1
        referenceTypeParametersExample.modifyArray(numbers);
        System.out.println("After: " + numbers[0]);   // 출력: After: 10 (변경됨)
    }
}

위 코드에서는 배열 numbers가 메소드에 참조형으로 전달되므로, modifyArray() 메소드에서 배열의 첫 번째 값을 변경하면 원래 배열에도 반영됩니다. 참조형 매개변수는 객체 자체의 내용을 수정할 수 있다는 점이 원시형 매개변수와 다릅니다.

원시형과 참조형 매개변수의 차이

항목	원시형(Primitive)	참조형(Reference)
전달 방식	값에 의한 호출 (값이 복사되어 전달됨)	참조에 의한 호출 (참조가 복사됨)
메소드 내에서의 변경 여부	메소드 내에서 값을 변경해도 원본에는 영향이 없음	메소드 내에서 값을 변경하면 원본에도 반영됨
사용 예	int, float, boolean, char 등	배열, 객체 (클래스 인스턴스)

재귀 메소드

재귀 메소드(Recursive Method)는 메소드가 자기 자신을 호출하는 형태로 작성된 메소드입니다. 재귀는 반복적인 문제를 해결하거나, 문제를 작은 단위로 나누어 처리하는 데 유용합니다. 재귀 메소드는 일반적으로 종료 조건을 가지고 있어, 무한히 호출되지 않고 적절한 시점에 종료됩니다.

재귀 메소드의 기본 개념

재귀 메소드는 다음 두 가지 요소를 반드시 가져야 합니다.

1. 기본 조건 (Base Case): 더 이상 재귀 호출을 하지 않고 메소드를 종료하는 조건입니다. 이를 통해 재귀 호출이 무한히 반복되지 않도록 합니다.

2. 재귀 호출 (Recursive Call): 메소드가 자기 자신을 호출하는 부분입니다. 문제를 점차 작은 문제로 나누어 처리하고, 결국 기본 조건에 도달하면 재귀가 종료됩니다.

재귀 메소드의 동작 원리

재귀 메소드는 각 호출마다 새로운 메소드가 스택(Stack)에 쌓이게 됩니다. 기본 조건을 만나면 스택에 쌓인 메소드들이 차례대로 실행되면서 종료됩니다.

재귀 메소드의 예시

1. 팩토리얼 계산

RecursiveFactorialExample.java

팩토리얼은 1부터 해당 숫자까지의 곱을 구하는 함수입니다. 예를 들어, 5!는 5 * 4 * 3 * 2 * 1 = 120입니다. 팩토리얼을 재귀적으로 계산할 수 있습니다.

public class RecursiveFactorialExample {
    // 팩토리얼을 계산하는 재귀 메소드
    public int factorial(int n) {
        if (n == 1) {
            return 1;  // 기본 조건: n이 1일 때, 재귀 종료
        }
        return n * factorial(n - 1);  // 재귀 호출: n * (n-1)!
    }

    public static void main(String[] args) {
        RecursiveFactorialExample recursiveFactorialExample 
                = new RecursiveFactorialExample();
        int result = recursiveFactorialExample.factorial(5);  
        // 5! = 5 * 4 * 3 * 2 * 1 = 120
        System.out.println("Factorial of 5: " + result);  
        // 출력: Factorial of 5: 120
    }
}

팩토리얼 재귀 메소드의 동작

1. factorial(5)는 5 * factorial(4)을 호출합니다.

2. factorial(4)는 4 * factorial(3)을 호출합니다.

3. 이러한 과정이 반복되다가 factorial(1)에서 기본 조건인 1을 반환합니다.

4. 이후 반환된 값을 차례대로 곱하면서 최종 결과를 얻습니다.

2. 피보나치 수열 계산

RecursiveFibonacciExample.java

피보나치 수열은 각 숫자가 앞의 두 숫자의 합으로 정의됩니다. 예를 들어, 0, 1, 1, 2, 3, 5, 8, ...입니다. 피보나치 수열도 재귀적으로 계산할 수 있습니다.

피보나치 수열 공식

• F(0)=0

• F(1)=1

• F(n)=F(n−1)+F(n−2)(n≥2)

public class RecursiveFibonacciExample {
    // 피보나치 수열을 계산하는 재귀 메소드
    public int fibonacci(int n) {
        if (n == 0) {
            return 0;  // 기본 조건 1
        }
        if (n == 1) {
            return 1;  // 기본 조건 2
        }
        return fibonacci(n - 1) + fibonacci(n - 2);  // 재귀 호출
    }

    public static void main(String[] args) {
        RecursiveFibonacciExample recursiveFibonacciExample 
                = new RecursiveFibonacciExample();
        int result = recursiveFibonacciExample.fibonacci(6);  
        // 6번째 피보나치 수는 8
        System.out.println("Fibonacci of 6: " + result);  
        // 출력: Fibonacci of 6: 8
    }
}

피보나치 재귀 메소드의 동작

1. fibonacci(6)는 fibonacci(5)와 fibonacci(4)를 호출합니다.

2. fibonacci(5)는 fibonacci(4)와 fibonacci(3)를 호출하고, 이렇게 계속 반복됩니다.

3. 결국 fibonacci(0)과 fibonacci(1)에서 기본 조건을 만족하면 차례대로 값을 반환합니다.

재귀 메소드의 장점

1. 문제를 작은 단위로 나눌 수 있음: 재귀는 복잡한 문제를 작은 문제들로 분해하여 해결할 수 있습니다.

2. 코드가 간결해짐: 반복문을 사용하는 것보다 코드가 간결하게 표현될 수 있습니다.

재귀 메소드의 단점

1. 성능 문제: 재귀 메소드가 너무 깊이 호출되면 스택 오버플로우(Stack Overflow)가 발생할 수 있습니다. 특히, 피보나치 수열처럼 많은 중복 호출이 발생하는 경우에는 성능이 저하될 수 있습니다.

2. 메모리 사용: 재귀 호출마다 메모리 스택에 메소드가 쌓이므로, 많은 호출이 필요한 경우 메모리 사용량이 커질 수 있습니다.