들어가며: 메서드가 대체 뭐길래 이렇게 호들갑이야?

안녕! 코딩의 세계에 발을 들인 걸 환영해. 아마 변수, 조건문, 반복문 같은 걸 배우면서 '오, 이제 좀 뭐가 되는데?' 싶었을 거야. 근데 코드를 짜다 보면 슬슬 이런 생각이 들지. "아니, 이 코드 저기서도 썼는데 또 쓰고 있네?", "코드가 너무 길어서 어디가 어딘지 모르겠다!"

바로 이럴 때 우리를 구원해 줄 슈퍼히어로가 등장하는데, 그 이름은 바로 **메서드(Method)**야. 다른 언어에서는 **함수(Function)**라고도 부르는데, C#에서는 클래스 안에 정의된 함수를 보통 메서드라고 불러. 뭐, 일단은 둘이 거의 같은 개념이라고 생각해도 좋아. 앞으로는 '메서드'라고 통일해서 부를게.

메서드는 쉽게 말해 '특정 작업을 수행하는 코드 덩어리에 이름을 붙여놓은 것'이야. 마치 레고 블록 같아. 똑같은 모양의 블록을 여러 개 만들어두고 필요할 때마다 가져다 쓰는 거지. 매번 똑같은 블록을 처음부터 만들 필요 없이 말이야.

예를 들어볼까? 게임을 만드는데 캐릭터가 점프하는 코드를 짰다고 해봐. 점프할 때마다 캐릭터의 y좌표를 바꾸고, 점프 소리를 내고, 점프 애니메이션을 재생하는 코드가 필요하겠지? 이걸 '점프' 버튼 누를 때, '장애물' 만났을 때, '아이템' 먹었을 때... 매번 똑같이 복사-붙여넣기 한다고 생각해봐. 끔찍하지? 코드도 길어지고, 나중에 점프 높이를 살짝 바꾸고 싶으면 수십 군데를 다 찾아서 고쳐야 해. 완전 대참사야.

하지만 이걸 `Jump()`라는 메서드로 만들어두면 어떨까? 그냥 `Jump();` 이 한 줄만 호출하면 돼. 수정이 필요하면 `Jump()` 메서드 안의 코드 딱 한 군데만 고치면 끝! 이게 바로 우리가 메서드를 써야 하는 이유야. **코드의 재사용성**을 높이고, **가독성**을 좋게 만들고, **유지보수**를 쉽게 만들어주거든. 이걸 전문용어로 DRY(Don't Repeat Yourself) 원칙이라고 해. "반복하지 마!"라는 뜻이지.

이 글에서는 C# 메서드의 기초부터 심화까지, 아주 그냥 뼛속까지 탈탈 털어볼 거야. 이 글만 다 읽으면 너도 어디 가서 "아, C# 메서드? 그거 완전 내 손바닥 안이지"라고 말할 수 있게 될 걸? 자, 그럼 지금부터 C# 메서드의 세계로 함께 떠나보자고!

메서드 문법, 완전 쌩기초부터 파헤치기

자, 이제 본격적으로 메서드를 어떻게 만드는지 알아볼 시간이야. 처음 보면 `public static void Main(string[] args)`처럼 외계어 같아서 쫄 수 있는데, 하나씩 뜯어보면 별거 아니야. 진짜로!

C# 메서드의 기본 구조는 이렇게 생겼어.

[접근 제한자] [반환 타입] [메서드 이름]([매개변수 목록])
{
    // 메서드가 수행할 코드 (메서드 몸통, Body)
    // ...
}

어때? 아직도 외계어 같아? 괜찮아. 지금부터 하나씩 해부해 줄게.

1. 접근 제한자 (Access Modifier)

이름 그대로 '누가 이 메서드에 접근할 수 있는지'를 정하는 규칙이야. 약간 클럽 가드 같은 역할이지. "너는 들어와도 돼", "너는 안돼" 하고 정해주는 거야.

• `public`: **공개 모드.** 가장 관대한 가드. 클래스 외부, 내부 어디서든 자유롭게 접근할 수 있어. 완전 오픈!
• `private`: **비공개 모드.** 가장 빡빡한 가드. 메서드가 선언된 바로 그 클래스 안에서만 쓸 수 있어. 외부에서는 있는지 없는지조차 몰라.
• `protected`: `private`이랑 비슷한데, 상속받은 자식 클래스에서는 쓸 수 있게 해주는 조금 더 유연한 가드.
• `internal`: 같은 프로젝트(어셈블리) 안에서만 `public`처럼 쓸 수 있게 해줘.

지금은 `public`과 `private` 두 개만 확실히 알아도 충분해. 보통 다른 클래스에서 가져다 써야 하는 중요한 기능은 `public`으로, 그 기능을 구현하기 위해 내부적으로만 사용되는 자잘한 기능들은 `private`으로 만들어.

2. 반환 타입 (Return Type)

메서드가 일을 마친 후에 '결과물'을 돌려줄지, 돌려준다면 어떤 종류(타입)의 결과물을 줄지 정하는 부분이야. 레시피로 치면 '완성된 요리' 같은 거지.

• `int`, `string`, `bool` 등: 메서드가 일을 끝내고 각각 정수, 문자열, 참/거짓 같은 값을 돌려준다는 뜻. `return` 키워드를 사용해서 값을 반환해야 해.
• `void`: "텅 비었다"는 뜻이야. 즉, **아무것도 돌려주지 않는다**는 의미. 그냥 시키는 일만 하고 끝내는 거야. "안녕하세요"라고 화면에 출력만 하고 끝나는 메서드처럼 말이지.

3. 메서드 이름 (Method Name)

말 그대로 메서드의 이름이야. 이 이름으로 메서드를 호출(실행)할 수 있어. 이름을 지을 때는 몇 가지 규칙이 있어.

• **파스칼 표기법(PascalCase)**을 사용하는 게 C#의 국룰이야. 단어의 첫 글자를 모두 대문자로 쓰는 거지. 예를 들면 `CalculateSum`, `PrintReport` 처럼.
• 이름만 봐도 **무슨 일을 하는지 알 수 있게** 짓는 게 제일 중요해. `DoSomething()` 이나 `Func1()` 같은 이름은 최악이야! `CalculatePlayerScore()` 처럼 구체적으로 짓는 습관을 들이자.

4. 매개변수 목록 (Parameter List)

메서드가 일을 할 때 필요한 '재료'를 받는 부분이야. 괄호 `()` 안에 `(자료형 변수이름)` 형태로 선언해. 재료가 여러 개 필요하면 쉼표(`,`)로 구분해서 나열하면 돼. 재료가 필요 없으면 그냥 괄호를 비워두면 되고. `()`

예를 들어, 두 숫자를 더하는 메서드라면 `(int number1, int number2)` 처럼 두 개의 정수를 재료로 받겠지?

5. 메서드 몸통 (Method Body)

중괄호 `{}` 안에 있는 모든 코드를 말해. 여기가 바로 메서드가 실제로 수행할 작업들이 적혀있는 '레시피의 조리 과정'이야. 여기서 매개변수로 받은 재료들을 요리조리 가공해서 결과를 만들거나, 특정 동작을 수행하는 거지.

자, 그럼 이 모든 걸 조합해서 아주 간단한 메서드를 만들어볼까?

// "Hello, World!"를 콘솔에 출력하는 메서드
public void SayHelloWorld()
{
    Console.WriteLine("Hello, World!");
}

// 이 메서드를 사용(호출)하려면?
SayHelloWorld(); // 이렇게 이름만 불러주면 돼!

어때? 이렇게 하나씩 뜯어보니까 별거 아니지? 이제 너도 메서드의 기본 구조를 마스터한 거야. 축하해! 다음 챕터에서는 이 '재료'에 해당하는 매개변수에 대해 좀 더 깊게 파고들어 볼게.

재료를 넣어보자! 매개변수(Parameter)와 인수(Argument) 완전 정복

앞에서 메서드가 일을 할 때 필요한 '재료'가 매개변수(Parameter)라고 했지? 이번엔 이 재료를 어떻게 주고받는지, 그리고 어떤 종류의 재료들이 있는지 자세히 알아볼 거야. 여기서 은근히 헷갈리는 용어가 있는데, 바로 **매개변수(Parameter)**와 **인수(Argument)**야.

* **매개변수(Parameter):** 메서드를 *정의할 때* 괄호 안에 선언하는 변수. "우리는 이런 종류의 재료를 받을 거야~" 하고 알려주는, 레시피에 적힌 '재료 목록' 같은 거야. * **인수(Argument):** 메서드를 *호출할 때* 괄호 안에 실제로 넣어주는 값. 레시피를 보고 요리할 때 실제로 넣는 '설탕 한 스푼', '소금 두 꼬집' 같은 '실물 재료'지.

// 여기서 name은 '매개변수(Parameter)'
public void SayHello(string name) 
{
    Console.WriteLine($"안녕, {name}!");
}

// 메서드를 호출할 때
// 여기서 "철수"는 '인수(Argument)'
SayHello("철수"); 

이 둘을 구분하는 건 코딩 인터뷰에서도 가끔 물어보는 기본 중의 기본이니까 꼭 기억해둬! 이제 다양한 매개변수 사용법을 알아보자.

1. 기본 매개변수 (값 전달 vs. 참조 전달)

C#에서 매개변수를 전달하는 방식은 크게 두 가지야. **값에 의한 전달(Pass by Value)**과 **참조에 의한 전달(Pass by Reference)**. 이건 초보자들이 처음 겪는 큰 벽 중 하나인데, 개념만 잘 잡으면 쉬워.

* **값에 의한 전달 (Pass by Value):** `int`, `double`, `bool`, `struct` 같은 '값 타입' 변수를 인수로 넘길 때 사용돼. 이건 변수가 가진 '값'만 복사해서 메서드에 전달하는 거야. 메서드 안에서 그 값을 아무리 바꿔도, 메서드 바깥에 있는 원래 변수에는 *아무런 영향이 없어*. 마치 원본 서류를 복사해서 사본을 넘겨준 것과 같아. 사본에 아무리 낙서해도 원본은 깨끗하잖아?

void ChangeValue(int number)
{
    number = 100; // 메서드 안에서 값을 100으로 변경
    Console.WriteLine($"메서드 안: {number}"); // 출력: 메서드 안: 100
}

int myNumber = 10;
ChangeValue(myNumber);
Console.WriteLine($"메서드 밖: {myNumber}"); // 출력: 메서드 밖: 10 (!!!)

봐봐. `ChangeValue` 메서드 안에서 `number`를 100으로 바꿨지만, 원래 변수였던 `myNumber`는 여전히 10이야. 값이 복사되어 전달됐기 때문이지.

* **참조에 의한 전달 (Pass by Reference):** `class`, `array`, `string` 같은 '참조 타입' 변수를 인수로 넘길 때 기본적으로 이렇게 동작해. 이건 변수의 '값'이 아니라, 데이터가 실제로 저장된 메모리의 '주소(참조)'를 복사해서 전달하는 거야. 그래서 메서드 안에서 그 주소를 통해 데이터에 접근해서 내용을 바꾸면, 메서드 바깥의 원본 변수도 *똑같이 바뀌어*. 이건 원본 서류가 있는 위치를 알려준 것과 같아. 어디서든 그 위치로 찾아가서 서류 내용을 바꾸면 원본이 바뀌는 거지.

하지만 여기서 잠깐! `string`은 참조 타입이지만 좀 특별해. 얘는 불변(immutable) 타입이라서 수정하려고 하면 새로운 메모리 공간에 새 문자열을 만들고 참조를 바꿔버려. 그래서 값 타입처럼 동작하는 것처럼 보일 때가 많아. 이건 나중에 더 깊게 공부해보자. 일단은 배열(array)로 예를 들어볼게.

void ChangeArray(int[] arr)
{
    arr[0] = 999; // 배열의 첫 번째 요소를 변경
    Console.WriteLine($"메서드 안: {arr[0]}"); // 출력: 메서드 안: 999
}

int[] myArray = { 1, 2, 3 };
ChangeArray(myArray);
Console.WriteLine($"메서드 밖: {myArray[0]}"); // 출력: 메서드 밖: 999 (!!!)

메서드 안에서 배열의 내용을 바꿨더니, 원본 배열인 `myArray`의 내용도 바뀌었지? 이게 바로 참조 전달이야.

void GetSumAndProduct(int a, int b, out int sum, out int product)
{
    sum = a + b;
    product = a * b;
}

int mySum, myProduct; // 초기화 안 해도 됨
GetSumAndProduct(10, 5, out mySum, out myProduct);
Console.WriteLine($"합: {mySum}, 곱: {myProduct}"); // 출력: 합: 15, 곱: 75

2. 선택적 매개변수 (Optional Parameters)

메서드를 정의할 때 매개변수에 **기본값(default value)**을 지정해 줄 수 있어. 이렇게 하면 메서드를 호출할 때 해당 인수를 생략할 수 있어. 생략하면 기본값이 자동으로 사용돼. 완전 편리하겠지?

단, 중요한 규칙이 있어. 선택적 매개변수는 반드시 필수 매개변수들보다 뒤에 와야 해.

// level 매개변수에 기본값 1을 지정
void CreateCharacter(string name, int level = 1)
{
    Console.WriteLine($"캐릭터 '{name}' 생성! (레벨: {level})");
}

CreateCharacter("전사"); // level 인수를 생략. 기본값 1이 사용됨.
// 출력: 캐릭터 '전사' 생성! (레벨: 1)

CreateCharacter("마법사", 5); // level 인수를 직접 지정.
// 출력: 캐릭터 '마법사' 생성! (레벨: 5)

3. 명명된 인수 (Named Arguments)

메서드를 호출할 때 매개변수의 순서가 헷갈릴 때가 있어. 특히 매개변수가 많을 때 더 그렇지. 이럴 때 `매개변수이름: 값` 형태로 인수를 전달할 수 있어. 이걸 명명된 인수라고 해.

명명된 인수를 쓰면 좋은 점은, **순서를 지키지 않아도 된다**는 거야! 가독성도 훨씬 좋아지지.

void PrintProfile(string name, int age, string job)
{
    Console.WriteLine($"이름: {name}, 나이: {age}, 직업: {job}");
}

// 일반적인 호출 (순서 지켜야 함)
PrintProfile("홍길동", 30, "의적");

// 명명된 인수를 사용한 호출 (순서 상관 없음)
PrintProfile(age: 25, name: "성춘향", job: "열녀");
PrintProfile(job: "개발자", age: 35, name: "이몽룡");

선택적 매개변수랑 같이 쓰면 더 강력해. 특정 매개변수 값만 지정하고 나머지는 기본값을 쓰고 싶을 때 아주 유용해.

void SendMessage(string to, string message, string from = "관리자", bool isUrgent = false)
{
    // ... 메시지 보내는 로직 ...
    Console.WriteLine($"To: {to}, From: {from}, Urgent: {isUrgent}, Msg: {message}");
}

// 'isUrgent'만 true로 바꾸고 싶을 때
SendMessage(to: "User123", message: "서버 점검 안내", isUrgent: true);
// from은 기본값 "관리자"가 사용됨

4. `params` 키워드: 가변 개수의 인수 받기

가끔 메서드가 몇 개의 인수를 받을지 미리 알 수 없을 때가 있어. 1개를 받을 수도, 100개를 받을 수도 있는 거지. 예를 들어, "주어진 숫자들을 모두 더해라" 같은 메서드를 만든다고 생각해봐. 이럴 때 `params` 키워드가 구세주처럼 등장해.

`params`는 메서드 시그니처에서 **단 한 번만, 그리고 가장 마지막 매개변수로만** 사용할 수 있어. `params` 뒤에는 배열 타입을 지정해주면 돼.

// 몇 개의 숫자가 오든 모두 더해서 반환하는 메서드
int SumAll(params int[] numbers)
{
    int total = 0;
    foreach (int n in numbers)
    {
        total += n;
    }
    return total;
}

int sum1 = SumAll(1, 2, 3); // 3개 인수
int sum2 = SumAll(10, 20, 30, 40, 50); // 5개 인수
int sum3 = SumAll(); // 인수가 없어도 됨 (결과는 0)

Console.WriteLine(sum1); // 출력: 6
Console.WriteLine(sum2); // 출력: 150
Console.WriteLine(sum3); // 출력: 0

`params` 덕분에 `SumAll` 메서드는 마치 여러 버전으로 오버로딩(Overloading, 바로 뒤에 배울 거야!)된 것처럼 유연하게 사용할 수 있게 됐어. 정말 강력한 기능이지?

요리 완성! 결과물 돌려주기 (Return)

메서드가 '일'을 하는 거라고 했지? 일이 끝나면 결과물을 보고해야 할 때가 많아. 두 숫자를 더하는 메서드라면 '더한 결과값'을, 사용자 정보를 조회하는 메서드라면 '사용자 정보 객체'를 돌려줘야겠지. 이 '결과물 보고'를 담당하는 키워드가 바로 `return`이야.

앞에서 배운 **반환 타입(Return Type)**이 바로 이 `return`과 아주 밀접한 관련이 있어. 반환 타입이 `void`가 아니라면, 메서드 몸통 안에는 **반드시 `return` 키워드를 사용해서 해당 타입의 값을 반환하는 코드가 있어야 해.** 안 그러면 컴파일러가 "야, 너 결과물 준다며 왜 안 줘!" 하고 에러를 뿜어낼 거야.

1. 기본 `return` 사용법

가장 기본적인 형태는 `return 반환할값;` 이야. 이 코드가 실행되는 순간, 메서드는 **즉시 종료**되고 `반환할값`을 들고 자기를 호출했던 곳으로 돌아가.

`return` 아래에 있는 코드는 절대 실행되지 않아. 그래서 컴파일러가 "Unreachable code detected" (도달할 수 없는 코드 발견!) 라고 경고를 주기도 해.

// 두 정수를 더한 결과를 반환하는 메서드
public int Add(int a, int b)
{
    int sum = a + b;
    return sum; // 계산된 sum 값을 반환하고 메서드 종료
    
    // Console.WriteLine("이 코드는 절대 실행되지 않아요!"); // Unreachable code
}

// 메서드 호출 및 반환값 사용
int result = Add(5, 7); // Add 메서드가 12를 return하고, 그 값이 result 변수에 저장됨
Console.WriteLine(result); // 출력: 12

조건문과 함께 사용하면 특정 조건에 따라 다른 값을 반환할 수도 있어.

// 나이를 받아서 성인인지 아닌지 bool 값으로 반환하는 메서드
public bool IsAdult(int age)
{
    if (age >= 19)
    {
        return true; // 19세 이상이면 true를 반환하고 종료
    }
    else
    {
        return false; // 그렇지 않으면 false를 반환하고 종료
    }
}

// 위 코드는 더 간단하게 이렇게 쓸 수도 있어.
public bool IsAdultSimple(int age)
{
    return age >= 19; // 'age >= 19' 라는 비교 연산의 결과(true 또는 false)가 바로 반환됨
}

2. `void` 메서드에서의 `return`

"어? 반환 타입이 `void`면 `return` 못 쓴다면서요?" 라고 생각했다면, 반은 맞고 반은 틀려. `void` 메서드에서는 값을 반환하는 `return 값;` 형태는 쓸 수 없어. 하지만 **메서드를 중간에 강제로 종료시키는 목적**으로 `return;` 은 사용할 수 있어!

특정 조건이 만족되면 더 이상 뒤의 코드를 실행할 필요가 없을 때 아주 유용하게 쓰여. 이걸 '조기 반환(Early Return)' 또는 '가드 클로즈(Guard Clause)' 패턴이라고도 불러.

// 메시지를 출력하되, 메시지가 비어있으면 아무것도 안 하는 메서드
public void PrintMessage(string message)
{
    // 가드 클로즈: message가 비어있거나 null이면,
    // 여기서 메서드를 바로 종료시켜 버린다!
    if (string.IsNullOrEmpty(message))
    {
        return; // 여기서 끝! 아래 코드는 실행 안 됨.
    }

    // 위 조건을 통과한 경우에만 아래의 핵심 로직이 실행됨
    Console.WriteLine("===== 메시지 도착 =====");
    Console.WriteLine(message);
    Console.WriteLine("======================");
}

PrintMessage("안녕하세요!"); // 정상 출력
PrintMessage(""); // 아무 일도 일어나지 않음

만약 저 `return;`이 없다면 `if-else`로 코드를 감싸야 해서 코드가 한 단계 더 깊어지고 복잡해졌을 거야. 이렇게 `return;`을 잘 활용하면 코드가 훨씬 깔끔하고 읽기 좋아져.

3. 여러 값 반환하기: 튜플(Tuple)의 등장

예전에는 메서드에서 여러 개의 값을 반환하려면 `out` 매개변수를 쓰거나, 여러 값을 담는 전용 클래스나 구조체를 만들어서 반환해야 했어. 좀 번거로웠지. 하지만 C# 7.0부터 **튜플(Tuple)**이라는 아주 멋진 기능이 생겼어.

튜플을 사용하면 괄호 `()` 안에 반환할 값들을 묶어서 아주 간단하게 여러 값을 반환할 수 있어.

// 숫자 배열을 받아서 최댓값과 최솟값을 동시에 반환하는 메서드
public (int max, int min) FindMinMax(int[] numbers)
{
    // 예외 처리: 배열이 비어있으면 안 됨
    if (numbers == null || numbers.Length == 0)
    {
        throw new ArgumentException("배열이 비어있습니다.");
    }

    int max = numbers[0];
    int min = numbers[0];

    foreach (int n in numbers)
    {
        if (n > max) max = n;
        if (n < min) min = n;
    }

    return (max, min); // 튜플 형태로 두 값을 반환!
}

// 메서드 호출 및 튜플 값 사용하기
int[] myNumbers = { 5, 1, 99, -4, 32 };
var result = FindMinMax(myNumbers); // result 변수는 (int max, int min) 튜플

Console.WriteLine($"최댓값: {result.max}"); // 출력: 최댓값: 99
Console.WriteLine($"최솟값: {result.min}"); // 출력: 최솟값: -4

// 이렇게 분해해서 받을 수도 있어 (Deconstruction)
(int maximum, int minimum) = FindMinMax(myNumbers);
Console.WriteLine($"최댓값: {maximum}, 최솟값: {minimum}");

튜플 덕분에 이제 여러 값을 반환하는 게 훨씬 직관적이고 깔끔해졌어. `out` 매개변수보다 가독성도 좋아서 많은 개발자들이 선호하는 방식이야. 너도 앞으로 여러 값을 반환해야 할 땐 튜플을 적극적으로 활용해봐!

이름은 같은데 기능은 다르다고? 메서드 오버로딩의 마법

코딩을 하다 보면 이름은 같지만, 들어오는 재료(매개변수)에 따라 약간씩 다르게 동작해야 하는 기능이 필요할 때가 있어. 예를 들어 '더하기'라는 기능은 숫자 두 개를 더할 수도 있고, 숫자 세 개를 더할 수도 있고, 심지어는 글자 두 개를 이어 붙일 수도 있잖아?

이럴 때 `AddTwoNumbers()`, `AddThreeNumbers()`, `ConcatenateStrings()` 처럼 메서드 이름을 다 다르게 만들면 너무 피곤하겠지? 개발자는 게을러야 미덕이라고 했어! (좋은 의미로!) 그래서 C#은 **메서드 오버로딩(Method Overloading)**이라는 아주 스마트한 기능을 제공해.

메서드 오버로딩은 **하나의 클래스 안에서 이름이 똑같은 메서드를 여러 개 정의하는 것**을 말해. "아니, 이름이 똑같은데 컴퓨터가 어떻게 구분해?" 싶지? 바로 **매개변수 시그니처(Signature)**로 구분해.

시그니처는 쉽게 말해 '메서드의 주민등록증' 같은 거야. 여기에는 **매개변수의 개수, 타입, 순서** 정보가 담겨있어. C# 컴파일러는 이 시그니처를 보고 우리가 호출한 메서드가 어떤 버전인지 정확하게 찾아내.

**중요!** 메서드 오버로딩의 조건은 오직 **매개변수 시그니처**야. **반환 타입(Return Type)이나 접근 제한자는 오버로딩의 조건이 될 수 없어!** 이름은 같고 매개변수도 똑같은데 반환 타입만 다르면? 그건 오버로딩이 아니라 그냥 에러야.

오버로딩의 대표적인 예: `Console.WriteLine()`

사실 넌 이미 오버로딩을 매일 쓰고 있었어. 바로 `Console.WriteLine()` 메서드야!

Console.WriteLine(123); // int를 받아서 출력
Console.WriteLine(3.14); // double을 받아서 출력
Console.WriteLine(true); // bool을 받아서 출력
Console.WriteLine("Hello"); // string을 받아서 출력

우리는 그냥 `WriteLine`이라고만 썼는데, 인수로 뭘 넣느냐에 따라 알아서 다르게 동작했지? 이게 바로 `Console` 클래스 안에 `WriteLine`이라는 이름으로, 하지만 매개변수 타입이 각각 `int`, `double`, `bool`, `string` 등으로 다른 여러 메서드가 오버로딩되어 있기 때문이야.

직접 만들어보는 오버로딩

자, 그럼 우리도 직접 '더하기' 기능을 오버로딩으로 만들어보자.

public class Calculator
{
    // 1. 정수 두 개를 더하는 Add 메서드
    public int Add(int a, int b)
    {
        Console.WriteLine("정수 + 정수 버전 호출됨");
        return a + b;
    }

    // 2. 정수 세 개를 더하는 Add 메서드 (매개변수 개수가 다름)
    public int Add(int a, int b, int c)
    {
        Console.WriteLine("정수 + 정수 + 정수 버전 호출됨");
        return a + b + c;
    }

    // 3. 실수 두 개를 더하는 Add 메서드 (매개변수 타입이 다름)
    public double Add(double a, double b)
    {
        Console.WriteLine("실수 + 실수 버전 호출됨");
        return a + b;
    }

    // 4. 문자열 두 개를 이어 붙이는 Add 메서드 (매개변수 타입이 다름)
    public string Add(string a, string b)
    {
        Console.WriteLine("문자열 + 문자열 버전 호출됨");
        return a + b;
    }

    /*
    // 이건 에러! 매개변수는 똑같은데 반환 타입만 다름
    public double Add(int a, int b) 
    {
        return (double)(a + b);
    }
    */
}

// 사용 예시
Calculator calc = new Calculator();

int result1 = calc.Add(10, 20); // 1번 호출
Console.WriteLine(result1); // 출력: 30

int result2 = calc.Add(10, 20, 30); // 2번 호출
Console.WriteLine(result2); // 출력: 60

double result3 = calc.Add(3.5, 2.1); // 3번 호출
Console.WriteLine(result3); // 출력: 5.6

string result4 = calc.Add("Hello, ", "World!"); // 4번 호출
Console.WriteLine(result4); // 출력: Hello, World!

어때? `Add`라는 똑같은 이름으로 호출했지만, 우리가 전달한 인수의 개수와 타입에 따라 C# 컴파일러가 알아서 척척 맞는 메서드를 골라서 실행해줬지? 이게 바로 오버로딩의 힘이야.

메서드 오버로딩은 코드를 더 유연하고, 직관적이고, 사용하기 쉽게 만들어주는 아주 중요한 기술이야. "하나의 이름, 다양한 얼굴"이라고 기억해두면 좋아. 이제 메서드의 기본기는 거의 다 마스터했어. 다음 챕터에서는 조금 더 깊이 들어가서, '찐고수'들이 사용하는 메서드 심화 스킬들을 배워보자!

이제 너도 C# 중급! 찐고수들만 아는 메서드 심화 스킬

자, 지금까지 메서드의 기본기를 탄탄하게 다졌어. 이제부터는 너를 'C# 좀 할 줄 아는 사람'에서 'C# 꽤 잘하는 사람'으로 레벨업 시켜줄 심화 스킬들을 배워볼 거야. 처음에는 조금 낯설 수 있지만, 한번 익혀두면 너의 코드가 훨씬 더 세련되고 효율적으로 바뀔 거야. 준비됐지?

1. 정적 메서드 (Static Method) vs. 인스턴스 메서드 (Instance Method)

이건 C#의 객체 지향 프로그래밍(OOP)에서 가장 중요한 개념 중 하나야. 지금까지 우리가 만든 메서드는 대부분 **인스턴스 메서드**였어.

* **인스턴스 메서드 (Instance Method):** * **객체(인스턴스)를 먼저 만들어야만** 호출할 수 있는 메서드. * `new` 키워드로 클래스의 인스턴스를 생성한 후에, `인스턴스이름.메서드이름()` 형태로 사용해. * 인스턴스에 속한 데이터(멤버 변수)를 사용하거나 조작할 수 있어. * **비유:** '자동차'라는 *설계도(클래스)*가 있을 때, '내 차(인스턴스)'를 실제로 만들어야만 '시동을 걸(메서드 호출)' 수 있는 것과 같아. 내 차의 시동을 거는 거지, 그냥 허공에 대고 시동을 걸 순 없잖아?

public class Car
{
    public int Speed { get; set; } // 인스턴스 속성

    // 인스턴스 메서드
    public void Accelerate()
    {
        this.Speed += 10;
        Console.WriteLine($"속도 증가! 현재 속도: {this.Speed}");
    }
}

Car myCar = new Car(); // 1. 인스턴스 생성
myCar.Accelerate();    // 2. 인스턴스를 통해 메서드 호출
myCar.Accelerate();

* **정적 메서드 (Static Method):** * `static` 키워드를 붙여서 만드는 메서드. * **객체(인스턴스)를 만들 필요 없이**, `클래스이름.메서드이름()` 형태로 바로 호출할 수 있어. * 인스턴스에 속한 데이터(멤버 변수)에는 접근할 수 없어. 왜냐하면 어떤 특정 인스턴스에 소속된 게 아니니까! * **비유:** '수학'이라는 *개념(클래스)*이 있을 때, '두 수 중 더 큰 값을 구하는 기능(메서드)'은 굳이 '나의 수학', '너의 수학' 같은 객체를 만들 필요가 없지? 그냥 '수학.최댓값구하기(5, 10)'처럼 바로 쓸 수 있으면 편하잖아.

우리가 자주 썼던 `Console.WriteLine()`이나 `Math.Max()`가 바로 대표적인 정적 메서드야. `new Console()` 같은 거 한 적 없잖아?

public class Calculator
{
    // 정적 메서드
    public static int Add(int a, int b)
    {
        return a + b;
    }
}

// 인스턴스 생성 없이 바로 클래스 이름으로 호출
int result = Calculator.Add(100, 200); 
Console.WriteLine(result); // 출력: 300

**언제 뭘 쓸까?**
- **인스턴스 메서드:** 객체의 상태(속성)와 관련된 동작을 할 때. (예: `player.Attack()`, `file.Read()`)
- **정적 메서드:** 객체의 상태와는 상관없이, 입력값만으로 결과를 만들어내는 순수한 기능일 때. 이런 걸 **유틸리티(Utility) 함수**라고도 해. (예: `Math.Abs()`, `string.IsNullOrEmpty()`)

2. 재귀 함수 (Recursive Function)

재귀는 메서드가 **자기 자신을 다시 호출하는** 프로그래밍 기법이야. 처음 들으면 "무한 루프에 빠지는 거 아냐?" 싶겠지만, 제대로 만들면 아주 우아하고 강력한 코드를 작성할 수 있어.

재귀 함수는 두 가지 필수 요소가 있어.

1. **종료 조건 (Base Case):** 더 이상 자기 자신을 호출하지 않고 빠져나올 수 있는 조건. 이게 없으면 스택 오버플로우(Stack Overflow) 에러와 함께 프로그램이 뻗어버려!
2. **재귀 호출 (Recursive Step):** 문제를 더 작은 단위로 쪼개서 자기 자신을 호출하는 부분.

팩토리얼(!) 계산이 재귀 함수의 대표적인 예시야.
5! = 5 * 4 * 3 * 2 * 1
이걸 재귀적으로 표현하면, 5! = 5 * 4! 이고, 4! = 4 * 3! ... 이렇게 쪼갤 수 있지. 그리고 1! = 1 이라는 종료 조건에 도달하면 계산이 끝나.

public long Factorial(int n)
{
    // 1. 종료 조건 (Base Case)
    if (n <= 1)
    {
        return 1;
    }
    // 2. 재귀 호출 (Recursive Step)
    else
    {
        return n * Factorial(n - 1); // n과 (n-1)의 팩토리얼 결과를 곱함
    }
}

// Factorial(4) 호출 과정
// 1. Factorial(4) -> 4 * Factorial(3)
// 2. Factorial(3) -> 3 * Factorial(2)
// 3. Factorial(2) -> 2 * Factorial(1)
// 4. Factorial(1) -> 1 (종료 조건!)
// 5. 결과: 4 * 3 * 2 * 1 = 24

재귀는 복잡한 문제를 단순하게 표현할 수 있게 해주지만, 너무 깊게 들어가면 성능이 저하될 수 있으니 꼭 필요할 때 현명하게 사용해야 해.

3. 확장 메서드 (Extension Method)

이건 진짜 C#의 치트키 같은 기능이야. 확장 메서드를 사용하면, **기존에 있던 클래스의 코드를 직접 수정하지 않고도** 마치 원래 있던 것처럼 새로운 메서드를 추가할 수 있어! `string`이나 `int` 같은 기본 타입에도 내가 만든 기능을 붙일 수 있다는 거야. 대박이지?

확장 메서드를 만드는 규칙은 간단해.

1. **정적(static) 클래스** 안에 만들어야 해.
2. 메서드도 **정적(static)**으로 선언해야 해.
3. 첫 번째 매개변수 앞에 `this` 키워드를 붙이고, 확장하고 싶은 타입을 적어줘. 이 `this` 매개변수가 바로 확장 메서드를 호출하는 주체(인스턴스)가 돼.

예를 들어, 문자열이 숫자로만 이루어져 있는지 확인하는 `IsNumeric()` 메서드를 `string` 타입에 추가해볼까?

// 1. 반드시 static 클래스 안에 만들어야 함
public static class StringExtensions
{
    // 2. static 메서드로, 첫 매개변수에 'this string'을 사용
    public static bool IsNumeric(this string s)
    {
        if (string.IsNullOrEmpty(s))
        {
            return false;
        }
        return double.TryParse(s, out _);
    }
}

// 이제 모든 string 변수에서 IsNumeric() 메서드를 쓸 수 있어!
string a = "12345";
string b = "123a45";
string c = null;

Console.WriteLine(a.IsNumeric()); // 출력: True
Console.WriteLine(b.IsNumeric()); // 출력: False
Console.WriteLine(c.IsNumeric()); // 출력: False

마치 `string` 클래스를 내가 직접 수정해서 `IsNumeric` 메서드를 넣은 것처럼 자연스럽게 쓸 수 있지? 라이브러리를 만들거나, 반복적으로 사용하는 유틸리티 함수를 특정 타입에 붙여서 쓰고 싶을 때 정말 유용해. 너만의 확장 메서드 라이브러리를 만들어보는 것도 좋은 공부가 될 거야.

4. 로컬 함수 (Local Function) & 람다 식 (Lambda Expression)

최신 C#으로 올수록 코드를 더 간결하게 작성할 수 있는 기능들이 많이 추가됐어. 그중 대표적인 게 로컬 함수와 람다 식이야.

* **로컬 함수 (Local Function, C# 7.0+):** * 메서드 *안에* 선언하는 또 다른 메서드야. * 오직 그 부모 메서드 안에서만 호출할 수 있어. * **왜 쓸까?** 특정 메서드 안에서만 사용되는 헬퍼(helper) 함수가 필요할 때 좋아. 클래스 전체를 더럽히지 않고, 필요한 곳에만 딱 정의해서 쓸 수 있거든. 가독성도 높아지고, 부모 메서드의 변수에도 바로 접근할 수 있어서 편리해.

public void ProcessOrders(IEnumerable<Order> orders)
{
    foreach (var order in orders)
    {
        // 로컬 함수 정의
        void LogOrder(string status)
        {
            // 부모 메서드의 변수 'order'에 바로 접근 가능!
            Console.WriteLine($"주문 ID: {order.Id}, 상태: {status}");
        }

        LogOrder("처리 시작");
        // ... 주문 처리 로직 ...
        LogOrder("처리 완료");
    }
}

* **람다 식 (Lambda Expression) & 식 본문 멤버 (Expression-bodied Member):** * `=>` (goes to) 연산자를 사용해서 함수를 아주 간결하게 표현하는 방법이야. * 특히 LINQ나 이벤트 핸들러에서 많이 쓰여. * 메서드도 내용이 아주 간단한 한 줄짜리 코드라면, 이 람다 식처럼 축약해서 표현할 수 있어. 이걸 **식 본문 멤버(Expression-bodied Member)**라고 해.

// 일반적인 메서드
public int Add(int a, int b)
{
    return a + b;
}

// 식 본문 멤버로 표현한 메서드 (C# 6.0+)
public int AddShort(int a, int b) => a + b;

// void 메서드도 가능 (C# 7.0+)
public void Print(string message) => Console.WriteLine(message);

코드가 훨씬 짧고 간결해졌지? 처음엔 어색해도 익숙해지면 코딩 속도가 엄청나게 빨라질 거야.

코잘알(코드 잘 아는 사람)로 거듭나기! 클린 코드 메서드 작성법

자, 이제 C# 메서드의 거의 모든 것을 배웠어. 문법도 알고, 심화 스킬도 익혔지. 하지만 기술을 아는 것과 '잘' 사용하는 것은 다른 문제야. 똑같은 레고 블록을 줘도 누구는 멋진 성을 만들고, 누구는 그냥 블록 더미를 쌓는 것처럼 말이야. 마지막으로 너의 메서드를 '명품'으로 만들어 줄 클린 코드 작성 원칙 몇 가지를 알려줄게. 이건 정말 평생 가는 자산이 될 거야.

1. SRP: 단일 책임 원칙 (Single Responsibility Principle)

이건 객체 지향 설계의 5대 원칙(SOLID) 중 하나인데, 메서드에도 똑같이 적용돼. 아주 간단해. **"메서드는 단 하나의 기능만 책임져야 한다."**

만약 네가 만든 메서드의 이름이 `GetUserAndValidateAndSave()` 라면, 그건 100% 잘못된 메서드야. '유저 정보 가져오기', '유효성 검사하기', '저장하기'라는 세 가지 책임을 한 번에 지고 있잖아. 이런 메서드는 재사용하기도 어렵고, 수정하기도 까다롭고, 테스트하기도 힘들어.

이렇게 바꿔야 해.

• `User GetUser(int userId)`
• `bool IsValid(User user)`
• `void SaveUser(User user)`

이렇게 잘게 쪼개진 메서드들은 각자의 역할이 명확해서 이해하기 쉽고, 다른 곳에서도 필요한 부분만 가져다 쓰기 좋아. 메서드를 만들 때 항상 "이 메서드가 딱 한 가지 일만 하고 있나?"라고 스스로에게 물어보는 습관을 들여봐.

2. 이름, 이름, 이름! (Descriptive Naming)

앞에서도 잠깐 얘기했지만, 정말 아무리 강조해도 지나치지 않아. 메서드 이름은 그 자체로 주석이 되어야 해. 이름만 보고도 "아, 이 메서드는 이런 매개변수를 받아서 이런 일을 하겠구나" 하고 예측할 수 있어야 베스트야.

• **나쁜 이름 👎:** `Process()`, `HandleData()`, `Check()`, `a()`
• **좋은 이름 👍:** `CalculateTotalPrice()`, `ValidateEmailFormat()`, `ActivateUserAccount()`

동사를 사용해서 **무엇을 하는지(What it does)** 명확하게 표현해줘. `Is...`, `Has...`, `Can...` 으로 시작하는 이름은 `bool` 값을 반환할 거라는 걸 암시해서 좋아. (예: `IsValid()`, `HasPermission()`) 좋은 이름 짓기는 코딩의 절반이야. 진짜로!

3. 짧고 간결하게 (Keep it Short)

전설적인 프로그래머 로버트 C. 마틴(엉클 밥)은 "함수의 첫 번째 규칙은 '작아야 한다'는 것이고, 두 번째 규칙은 '더 작아야 한다'는 것이다"라고 말했어. 한 메서드가 스크롤 없이 한눈에 들어오는 게 가장 이상적이야. 보통 20~30줄을 넘지 않도록 노력하는 게 좋아.

메서드가 너무 길어진다는 건, 아마도 너무 많은 일을 하고 있다는 신호일 거야 (SRP 위반!). 그럴 땐 주저하지 말고 의미 있는 단위로 메서드를 더 작게 분리해. (이걸 '메서드 추출 리팩토링'이라고 해.)

4. 주석보다는 코드로 말하기 (Self-documenting Code)

"주석을 잘 달아야 좋은 코드 아닌가요?" 물론 주석은 중요해. 하지만 가장 좋은 주석은 **필요 없는 주석**이야. 코드가 너무 복잡하고 어려워서 주석 없이는 이해할 수 없다면, 그건 주석을 달기 전에 코드를 더 읽기 쉽게 리팩토링해야 한다는 신호일 수 있어.

하지만 '왜' 이 코드를 이렇게 짰는지, 비즈니스 로직상 특이한 예외 케이스가 있는지 등을 설명하는 주석은 아주 가치 있어. C#에서는 특히 **XML 문서 주석**을 사용하는 습관을 들이면 좋아.

/// <summary>
/// 사용자의 전체 이름을 생성합니다.
/// </summary>
/// <param name="firstName">사용자의 이름</param>
/// <param name="lastName">사용자의 성</param>
/// <returns>성과 이름이 조합된 전체 이름 문자열</returns>
public string GetFullName(string firstName, string lastName)
{
    return $"{lastName} {firstName}";
}

메서드 위에 슬래시(`/`)를 세 번 치면 자동으로 생성되는데, 이렇게 주석을 달아두면 나중에 Visual Studio에서 해당 메서드를 사용할 때 툴팁으로 설명이 딱! 떠서 아주 편리해.