🎯 Unit 2.1 — 메서드의 구조
F-lab Java 1주차 / Phase 2 / Unit 2.1 본격 학습 자료
9-섹션 마스터 프롬프트 형식으로 깊이 파헤친다.선수 지식: Unit 1.2 (클래스와 객체의 본질)
다음 Unit: 2.2 — 가변인자 (Varargs)
🌍 1. 세상 속 비유
메서드 = "전자레인지의 버튼"
전자레인지를 떠올려보세요. 전자레인지에는 다양한 버튼이 있습니다:
- "시작" 버튼 — 누르면 데우기 시작 (입력 없음, 결과 없음)
- "+30초" 버튼 — 누르면 시간이 30초 추가 (입력 없음, 시간 변경)
- "해동" 버튼 — 무게를 입력하면 적절한 시간 자동 설정 (입력: 무게, 결과: 설정된 시간)
- "온도 조회" 버튼 — 누르면 현재 음식 온도 표시 (입력 없음, 결과: 온도)
각 버튼은 세 가지 정보를 가집니다:
- 이름 — "해동", "시작", "온도 조회"
- 입력 — 받을 수도, 안 받을 수도 있음
- 결과 — 줄 수도, 안 줄 수도 있음
→ 이게 메서드의 본질입니다. 객체가 가진 "버튼" 들이 메서드.
더 일상적인 비유 — "ATM 기기"
ATM의 메뉴를 보면:
| ATM 버튼 | 입력 | 결과 |
|---|---|---|
| "잔액 조회" | 비밀번호 | 잔액 |
| "출금" | 비밀번호, 금액 | 현금 + 영수증 |
| "입금" | 현금 | 영수증 |
| "화면 종료" | 없음 | 없음 |
각 버튼이 메서드, ATM이 객체 입니다.
당신은 ATM의 내부 동작(데이터베이스 조회, 카드 인증, 현금 카운터 작동...) 을 몰라도, 버튼만 누르면 됩니다.
→ 메서드는 객체에게 일을 시키는 명령 창구.
비유의 핵심 정리
| 비유 요소 | 자바 메서드 |
|---|---|
| 버튼 이름 | 메서드명 |
| 버튼 입력 | 매개변수 |
| 버튼 결과 | 반환값 |
| 버튼 누르는 행위 | 메서드 호출 |
| 누가 누를 수 있나 | 접근 제어자 |
🔥 2. 탄생 배경
메서드가 없던 시절 — 무한 반복 코드
초기 프로그래밍 (어셈블리, 초기 BASIC) 에서는 함수(메서드) 라는 개념이 없거나 약했습니다.
같은 작업을 반복하려면:
[프로그램]
주문 1번 처리:
- 가격 계산 코드 100줄
- 세금 계산 코드 50줄
- 결제 코드 80줄
주문 2번 처리:
- 가격 계산 코드 100줄 ← 똑같은 코드 또 작성
- 세금 계산 코드 50줄 ← 또 작성
- 결제 코드 80줄 ← 또 작성
주문 3번 처리:
- ... 또 똑같이 ...문제:
- 같은 로직을 매번 복사 → 코드 폭증
- 가격 계산 방식 바뀌면? 모든 곳을 수정
- 한 곳이라도 빠뜨리면 버그
- 가독성 X
함수 (Function) 의 등장
이 문제를 해결하려고 "함수" 가 등장:
함수 정의: 가격_계산하기 = (...코드 100줄...)
[프로그램]
주문 1번 처리:
- 가격_계산하기() 호출
- 세금_계산하기() 호출
- 결제하기() 호출
주문 2번 처리:
- 가격_계산하기() ← 같은 함수 재사용
- 세금_계산하기()
- 결제하기()효과:
- 코드 한 번만 작성
- 수정도 한 번만 하면 모든 곳에 반영
- 가독성 ↑
→ 함수는 "재사용 가능한 코드 단위" 라는 혁명적 발명.
메서드 (Method) — 객체지향의 함수
자바 같은 객체지향 언어에서는 함수가 객체에 묶이면서 이름이 메서드(method) 로 바뀝니다.
| 함수 (Function) | 메서드 (Method) | |
|---|---|---|
| 소속 | 독립적 (전역) | 클래스에 속함 |
| 호출 | 함수명() | 객체.메서드명() |
| 데이터 접근 | 인자로 받음 | 자기 객체의 필드 직접 접근 |
| 예 | C의 printf() | 자바의 obj.toString() |
→ 메서드는 "객체의 행동을 정의하는 함수".
핵심 통찰
"메서드는 객체가 할 수 있는 일을 정의한 약속이다."
객체에게 메서드는:
- 자기 능력의 목록 (이 객체는 무엇을 할 수 있나)
- 외부와 소통하는 통로 (외부에서 어떻게 부탁할 수 있나)
- 데이터 보호의 관문 (캡슐화의 핵심 도구)
💣 3. 없으면 생기는 문제
메서드 없이 객체를 만들면?
객체가 데이터(필드)만 있고 메서드가 없다면 어떤 일이 벌어질까요?
// 메서드 없는 빈혈 객체 ❌
public class BankAccount {
public int balance; // 잔액 (public이 문제 더 키움)
}이 객체를 사용하려면 외부에서 모든 일을 직접 해야 합니다:
BankAccount account = new BankAccount();
account.balance = 10000;
// 입금하려면?
account.balance = account.balance + 5000; // 외부에서 직접 계산
// 출금하려면?
if (account.balance >= 3000) {
account.balance = account.balance - 3000; // 외부에서 검증 + 계산
} else {
System.out.println("잔액 부족");
}
// 다른 곳에서도 같은 입금/출금이 필요할 때?
// → 같은 코드 또 작성 ❌문제 1: 모든 사용자가 내부 동작을 알아야 함.
문제 2: 같은 로직이 여러 곳에 중복.
문제 3: 누구나 balance 를 직접 만짐 → 무결성 X.
문제 4: 음수 잔액도 가능 (account.balance = -99999).
메서드를 도입하면
public class BankAccount {
private int balance; // private — 직접 접근 X
public void deposit(int amount) {
if (amount <= 0) {
throw new IllegalArgumentException("입금액은 양수여야 합니다");
}
this.balance += amount;
}
public void withdraw(int amount) {
if (amount <= 0) {
throw new IllegalArgumentException("출금액은 양수여야 합니다");
}
if (this.balance < amount) {
throw new IllegalStateException("잔액 부족");
}
this.balance -= amount;
}
public int getBalance() {
return this.balance;
}
}사용:
BankAccount account = new BankAccount();
account.deposit(10000); // 입금
account.withdraw(3000); // 출금
int current = account.getBalance();
// 안전성 ✅
account.withdraw(99999); // → 예외! 잔액 부족
account.deposit(-100); // → 예외! 양수만 가능
// account.balance = -1; // → 컴파일 에러! private효과 비교
| 메서드 없음 | 메서드 있음 | |
|---|---|---|
| 코드 중복 | 매번 외부에서 작성 | 한 번 정의 후 재사용 |
| 데이터 보호 | 누구나 직접 변경 | 메서드를 통해서만 |
| 검증 로직 | 호출자가 알아서 | 메서드 안에 한 번만 |
| 변경 영향 | 모든 호출자 수정 | 메서드만 수정 |
| 가독성 | 낮음 | 높음 |
→ 메서드는 객체지향의 핵심 도구. 메서드 없이는 캡슐화도, 다형성도 불가능.
✅ 4. 해결책 — 메서드의 구조
메서드 시그니처 (Signature) ⭐
자바 메서드의 표준 형태:
[접근제어자] [기타제어자] 반환타입 메서드명(매개변수목록) [throws 예외] {
// 메서드 본문
return 반환값;
}실제 예시:
public static int calculateTotal(int price, int quantity) throws IllegalArgumentException {
if (price < 0 || quantity < 0) {
throw new IllegalArgumentException("음수 불가");
}
return price * quantity;
}각 부분을 분해해보면:
| 부분 | 예시 | 역할 |
|---|---|---|
| 접근 제어자 | public | 누가 호출할 수 있는가 |
| 기타 제어자 | static | 인스턴스 없이 호출 가능 |
| 반환 타입 | int | 어떤 결과를 주는가 |
| 메서드명 | calculateTotal | 무엇을 하는가 |
| 매개변수 | (int price, int quantity) | 무엇을 입력받는가 |
| 예외 선언 | throws IllegalArgumentException | 어떤 예외를 던질 수 있는가 |
| 본문 | { ... } | 실제 로직 |
| 반환문 | return price * quantity; | 결과를 돌려줌 |
4가지 접근 제어자 ⭐ (면접 단골)
| 제어자 | 같은 클래스 | 같은 패키지 | 자식 클래스 (다른 패키지) | 그 외 |
|---|---|---|---|---|
public | ✅ | ✅ | ✅ | ✅ |
protected | ✅ | ✅ | ✅ | ❌ |
| (default) | ✅ | ✅ | ❌ | ❌ |
private | ✅ | ❌ | ❌ | ❌ |
원칙: 가장 좁은 범위로 시작 → 필요할 때만 넓힘 (캡슐화 원칙)
실무 예시:
public class Fare {
private int amount; // 외부 차단 — 가장 안전
public int getAmount() { ... } // 외부 조회용 — 공개
protected void onAmountChanged() { ... } // 자식만 사용 가능
void internalUpdate() { ... } // 같은 패키지만 (default)
private void validate() { ... } // 클래스 내부만
}암기 팁: public > protected > default > private 순으로 좁아짐.
반환 타입 종류
// 1. 기본형
public int getAge() { return 25; }
public double getPrice() { return 9.99; }
public boolean isActive() { return true; }
// 2. 객체
public String getName() { return "Alice"; }
public Customer getCustomer() { return this.customer; }
// 3. 배열
public int[] getScores() { return new int[]{90, 85, 70}; }
// 4. 컬렉션
public List<String> getTags() { return List.of("a", "b"); }
// 5. 반환 없음
public void doSomething() {
System.out.println("작업 완료");
// return 없음 (자동 종료) 또는 return; 가능
}void 와 return 의 미묘한 관계
void 는 "값을 반환하지 않는다" 는 의미:
public void greet(String name) {
System.out.println("Hello, " + name);
// return 생략 가능 (자동 종료)
}그러나 return; (값 없는 return) 은 사용 가능 — 메서드 즉시 종료용:
public void greet(String name) {
if (name == null) {
return; // ✅ 즉시 종료, 이후 코드 실행 X
}
System.out.println("Hello, " + name); // name이 null이면 실행 안 됨
}return value; 는 불가:
public void doSomething() {
return 42; // ❌ 컴파일 에러: void 메서드는 값 반환 X
}매개변수 (Parameter) vs 인자 (Argument)
자주 헷갈리는 용어:
// 매개변수 (Parameter) — 메서드 정의 시
public int add(int a, int b) { // ← a, b가 매개변수
return a + b;
}
// 인자 (Argument) — 호출 시 전달하는 실제 값
int result = add(3, 5); // ← 3, 5가 인자비유:
- 매개변수 = 음식점 메뉴판의 "옵션" (사이즈: 소/중/대)
- 인자 = 손님이 실제로 선택한 값 ("중 사이즈 주세요")
🏗️ 5. 내부 동작 원리
메서드 호출 시 메모리에서 일어나는 일
public class Calculator {
public int add(int a, int b) {
int sum = a + b;
return sum;
}
}
Calculator calc = new Calculator();
int result = calc.add(3, 5);JVM 내부 흐름 ⭐ :
[Stack 영역] [Heap 영역]
main()
- calc (참조) ───────→ Calculator 인스턴스
- result ↑
│
add() 호출 시 │
┌──────────────────┐ │
│ add() ← 새 스택 프레임 │
│ - this (자기 객체) ──────────┘
│ - a = 3
│ - b = 5
│ - sum = 8
└──────────────────┘
↓ return 후
add() 스택 프레임 제거
result = 8 핵심 동작:
1. add(3, 5) 호출 시 Stack에 새 프레임 생성
2. 매개변수 a=3, b=5 가 새 프레임에 복사 (Pass by Value)
3. 메서드 안의 지역변수 sum 도 새 프레임에 생성
4. return 시 결과값을 반환받는 변수에 복사
5. 메서드 종료 → Stack 프레임 제거
→ 이게 4주차 JVM 메모리 모델의 기초.
this — 메서드 호출의 숨은 주인공
public class Counter {
private int count = 0;
public void increment() {
this.count++; // this = 호출한 객체
}
}
Counter c1 = new Counter();
Counter c2 = new Counter();
c1.increment(); // this = c1, c1.count = 1
c1.increment(); // this = c1, c1.count = 2
c2.increment(); // this = c2, c2.count = 1JVM의 비밀 ⭐ :
c1.increment()는 사실 컴파일러가Counter.increment(c1)으로 변환- 즉, 첫 번째 인자가 자동으로
this로 전달됨 - 우리 눈에는 안 보일 뿐
→ Java가 객체와 메서드를 연결하는 핵심 메커니즘.
메서드 오버로딩 ⭐
"같은 이름, 다른 시그니처"
public class Calculator {
public int add(int a, int b) { return a + b; }
public double add(double a, double b) { return a + b; }
public int add(int a, int b, int c) { return a + b + c; }
public String add(String a, String b) { return a + b; }
}
calc.add(1, 2); // 첫 번째 호출
calc.add(1.5, 2.5); // 두 번째 호출
calc.add(1, 2, 3); // 세 번째 호출
calc.add("Hi", " Bob"); // 네 번째 호출오버로딩 규칙 ⭐ :
- ✅ 메서드명 같음
- ✅ 매개변수 타입 다름 OR
- ✅ 매개변수 개수 다름 OR
- ✅ 매개변수 순서 다름
- ❌ 반환 타입만 다른 건 X
public int foo() { ... }
public String foo() { ... } // ❌ 컴파일 에러왜 반환 타입만 다르면 안 되나?
- 호출 시점에서 컴파일러가 어느 메서드인지 모름
obj.foo();만으로는 int 메서드인지 String 메서드인지 구별 불가
JVM 내부의 메서드 식별 ⭐ :
- JVM은 메서드를 "메서드명 + 매개변수 시그니처" 로 식별
- 반환 타입은 식별에 포함 안 됨
Pass by Value — 자바의 인자 전달 방식
자바는 항상 값으로 전달(Pass by Value) 합니다. (4주차에서 깊이 다룸)
기본형 매개변수:
public void changeNumber(int x) {
x = 100; // 메서드 내부의 x만 변경
}
int num = 10;
changeNumber(num);
System.out.println(num); // 10 (변경 안 됨)객체 매개변수 (참조의 값 전달):
public void changeName(Person p) {
p.setName("Bob"); // 객체 내부 변경 — 외부 영향 ✅
}
public void replacePerson(Person p) {
p = new Person("Bob"); // 메서드 내부의 참조만 변경
}
Person alice = new Person("Alice");
changeName(alice);
System.out.println(alice.getName()); // "Bob" (객체 내부 변경됨)
Person charlie = new Person("Charlie");
replacePerson(charlie);
System.out.println(charlie.getName()); // "Charlie" (참조 변경 안 됨)→ 4주차에서 자세히 다룰 주제. 지금은 "자바는 항상 값 전달" 만 기억.
💻 6. 실전 코드 예시
ILIC 운임 시스템으로 메서드를 다양한 형태로 보겠습니다.
예시 1: 기본 메서드 형태들
public class FareService {
private final FareRepository repository;
// 1. 매개변수 X, 반환 X
public void initialize() {
System.out.println("FareService 초기화");
}
// 2. 매개변수 X, 반환 O
public int getCount() {
return repository.count();
}
// 3. 매개변수 O, 반환 X
public void delete(Long id) {
repository.deleteById(id);
}
// 4. 매개변수 O, 반환 O
public Fare findById(Long id) {
return repository.findById(id)
.orElseThrow(() -> new EntityNotFoundException("운임 없음"));
}
// 5. 여러 매개변수, 복잡한 반환
public List<Fare> search(Long customerId, FareStatus status, LocalDate from, LocalDate to) {
return repository.findByCriteria(customerId, status, from, to);
}
}예시 2: 접근 제어자 활용
public class Fare {
private int amount; // 외부 접근 불가
private FareStatus status;
// public — 외부 API
public void changeAmount(int newAmount) {
validateAmount(newAmount); // 내부 호출
this.amount = newAmount;
notifyChange();
}
// protected — 자식 클래스에서 오버라이드 가능
protected void notifyChange() {
System.out.println("운임 변경됨");
}
// package-private (default) — 같은 패키지만
void internalReset() {
this.amount = 0;
this.status = FareStatus.DRAFT;
}
// private — 클래스 내부만
private void validateAmount(int amount) {
if (amount < 0) {
throw new IllegalArgumentException("음수 불가");
}
}
public int getAmount() { return amount; }
}좋은 설계의 신호:
private가 가장 많음 (내부 구현)public은 명확한 외부 API만protected, default 는 의도적인 경우만
예시 3: 메서드 오버로딩 활용
public class FareCalculator {
// 기본 거리 계산
public int calculate(int distance) {
return distance * 500;
}
// 거리 + 무게
public int calculate(int distance, int weight) {
return distance * 500 + weight * 100;
}
// 거리 + 무게 + 긴급 여부
public int calculate(int distance, int weight, boolean urgent) {
int base = calculate(distance, weight);
return urgent ? base * 2 : base;
}
// FareRequest 객체로
public int calculate(FareRequest request) {
return calculate(
request.getDistance(),
request.getWeight(),
request.isUrgent()
);
}
}
// 사용 — 같은 이름으로 다양한 호출
calc.calculate(100); // 50000
calc.calculate(100, 50); // 55000
calc.calculate(100, 50, true); // 110000
calc.calculate(new FareRequest(100, 50, true)); // 110000효과: 사용자는 calculate 라는 한 이름 만 기억하면 됨. 다양한 시나리오를 한 메서드명으로 처리.
예시 4: void와 return; 의 활용
public class FareValidator {
public void validate(Fare fare) {
// Early Return 패턴 ⭐
if (fare == null) {
return; // 즉시 종료
}
if (fare.getAmount() < 0) {
throw new IllegalArgumentException("음수 운임");
}
if (fare.getStatus() == null) {
throw new IllegalStateException("상태 없음");
}
// 모든 검증 통과
System.out.println("검증 OK");
}
}Early Return 패턴:
- 조건에 안 맞으면 즉시 return
- 중첩 if를 줄여 가독성 향상
Bad (중첩):
public void validate(Fare fare) {
if (fare != null) {
if (fare.getAmount() >= 0) {
if (fare.getStatus() != null) {
// 검증 OK — 들여쓰기 지옥 ❌
}
}
}
}Good (Early Return):
public void validate(Fare fare) {
if (fare == null) return;
if (fare.getAmount() < 0) throw new IllegalArgumentException();
if (fare.getStatus() == null) throw new IllegalStateException();
// 메인 로직 — 평평한 구조 ✅
}⚠️ 7. 주의사항 & 흔한 실수
실수 1: 메서드명을 동사가 아닌 명사로
// ❌ 명사 — 메서드인지 변수인지 모호
public int total() { ... }
public String name() { ... }
// ✅ 동사 — 의도 명확
public int calculateTotal() { ... }
public String getName() { ... }
public boolean isActive() { ... } // 진위형은 is/has/can으로규칙 ⭐ :
- 일반 메서드: 동사 (
calculate,find,save) - 조회 메서드: get (
getName,getAge) - 진위형: is/has/can (
isActive,hasPermission,canDelete)
실수 2: 매개변수가 너무 많음
// ❌ 매개변수 7개
public Fare createFare(
Long customerId,
int amount,
String currency,
LocalDate departureDate,
String origin,
String destination,
boolean urgent
) { ... }문제:
- 호출 시 순서 헷갈림
- 같은 타입이 여러 개면 실수 위험
createFare(1L, 50000, "KRW", date, "서울", "부산", true);
createFare(1L, 50000, "KRW", date, "부산", "서울", true); // 출발-도착 바뀜! ❌해결 — 객체로 묶기:
public Fare createFare(FareCreateRequest request) { ... }
public record FareCreateRequest(
Long customerId,
int amount,
String currency,
LocalDate departureDate,
Route route, // origin, destination 묶음
boolean urgent
) {}원칙: 매개변수 4개 이상이면 객체로 묶기 검토.
실수 3: 매개변수를 메서드 안에서 변경
// ❌ 매개변수를 변경 — 혼란 야기
public int processAmount(int amount) {
amount = amount * 2; // 매개변수 자체를 변경
if (amount > 10000) {
amount = 10000;
}
return amount;
}문제:
- 원래 입력값이 무엇이었는지 추적 어려움
- 디버깅 어려움
해결 — 매개변수는 final, 새 변수 사용:
public int processAmount(final int amount) {
int result = amount * 2;
if (result > 10000) {
result = 10000;
}
return result;
}실수 4: void 메서드인데 결과를 return하려 함
public void doSomething() {
int result = ...;
return result; // ❌ 컴파일 에러
}해결:
- 결과가 필요하면 반환 타입 변경
- 결과가 필요 없으면
return;만 (값 없이)
실수 5: 너무 긴 메서드 (God Method)
// ❌ 메서드 하나가 200줄
public void processOrder(Order order) {
// 1. 검증 (50줄)
// 2. 계산 (50줄)
// 3. 저장 (30줄)
// 4. 알림 (40줄)
// 5. 로깅 (30줄)
}문제:
- 한 메서드가 너무 많은 일을 함 (SRP 위반)
- 테스트 불가능
- 가독성 X
해결 — 작은 메서드로 분리:
public void processOrder(Order order) {
validate(order);
int total = calculate(order);
save(order);
notify(order);
log(order);
}
private void validate(Order order) { ... }
private int calculate(Order order) { ... }
private void save(Order order) { ... }
private void notify(Order order) { ... }
private void log(Order order) { ... }권장: 메서드는 한 화면에 들어오는 정도 (보통 20줄 이내).
실수 6: 오버로딩 남용으로 모호함 발생
public class Calculator {
public void process(int x) { ... }
public void process(Integer x) { ... } // ⚠️ Auto-boxing 모호함
}
calc.process(10); // int? Integer? 컴파일러가 우선순위 결정원칙:
- 오버로딩은 명백히 다른 시나리오 일 때만
- 비슷한 타입(int/Integer, long/Long) 으로 오버로딩은 피하기
🔗 8. 연관 개념 맵
직접 이어지는 학습
[Unit 2.1: 메서드의 구조] ← 지금 여기
↓
[Unit 2.2: 가변인자] — 다음 학습
↓
[Unit 2.3: 상속과 생성자 체이닝]
↓
[Unit 2.4: 다형성] ★ — OOP의 정점이 Unit의 개념이 활용되는 곳
1주차 내:
- Phase 3 (SOLID): SRP — 메서드 하나가 한 가지 일만
- Phase 4 (JVM 메모리): 메서드 호출 시 Stack 프레임 생성
- Phase 5 (GC): 메서드 종료 시 지역변수 소멸
미래 주차:
- 3주차 (제네릭): 메서드에 타입 매개변수 추가 (
<T> T foo(T input)) - 3주차 (람다): 메서드를 값처럼 다루기
- 8-9주차 (AOP): 메서드 호출을 프록시로 가로채기
- 15주차 (Spring MVC): HandlerAdapter가 메서드 시그니처 분석해서 자동 호출
- 18주차 (Security):
@PreAuthorize가 메서드 단위 권한 검증
메서드와 디자인 패턴
| 패턴 | 메서드 활용 |
|---|---|
| Strategy | 인터페이스 메서드를 다양하게 구현 |
| Template Method | 상위 메서드가 흐름, 하위 메서드가 구현 |
| Factory Method | 객체 생성을 메서드로 캡슐화 |
| Builder | 메서드 체이닝으로 객체 구성 |
→ 5주차에서 본격 학습.
면접 단골 질문 매핑
| 질문 | 이 Unit에서의 답 |
|---|---|
| "메서드 오버로딩이 뭔가요?" | 같은 이름, 다른 시그니처 (타입/개수/순서) |
| "오버로딩과 오버라이딩의 차이는?" | 오버로딩=같은 클래스 다른 시그니처, 오버라이딩=상속에서 메서드 재정의 (Unit 2.4) |
| "접근 제어자 4가지 차이는?" | public > protected > default > private |
| "Pass by Value vs Reference?" | 자바는 항상 Pass by Value (4주차에서 자세히) |
| "void에서 return 가능?" | 값 없는 return; 만 가능 |
📝 9. 핵심 요약 — 3줄 정리
1️⃣ 메서드는 "객체의 행동을 정의하는 단위" 다.
절차지향의 함수가 객체에 묶인 형태로, 시그니처(접근제어자 + 반환타입 + 메서드명 + 매개변수) 로 구성된다. 메서드 없이는 캡슐화도 다형성도 불가능하므로, 객체지향의 가장 기본 도구 다.
2️⃣ 접근 제어자로 "누가 호출할 수 있는가" 를 통제한다.
private부터 시작해서 필요할 때만 넓히는 것이 캡슐화의 핵심. public > protected > default > private 순으로 좁아지며, 좁을수록 안전하다. ILIC 같은 큰 시스템에서는 의도적인 접근 제어가 유지보수 비용을 결정한다.3️⃣ 좋은 메서드는 "한 가지 일만, 짧게, 명확한 이름으로" 한다.
매개변수 4개 이상이면 객체로 묶기, 메서드는 한 화면에 들어오게 (20줄 내외), 동사 시작 이름 (
calculate,find,save), 매개변수는 안에서 변경 X — 이 규칙들이 코드 품질을 결정한다.
🎓 학습 자기 점검
기본 이해
- 메서드 시그니처의 5가지 구성 요소를 말할 수 있다
- 4가지 접근 제어자의 차이를 표로 그릴 수 있다
-
void메서드에서return;의 의미를 설명할 수 있다 - 매개변수와 인자의 차이를 정확히 구별한다
실전 적용
- ILIC의 한 클래스를 골라 메서드 시그니처를 분석할 수 있다
- private 메서드를 늘리고 public을 줄이는 리팩토링을 할 수 있다
- 매개변수 5개 이상인 메서드를 객체로 리팩토링할 수 있다
면접 대비 (1-2분 답변)
- "메서드 오버로딩과 오버라이딩의 차이는?" 답변 가능
- "왜 private이 좋은가?" 답변 가능 (캡슐화 관점)
- "메서드 시그니처에 반환 타입은 포함되나?" 답변 가능 (NO — 식별에 미사용)
자기 점검 질문 답변
Q1: void 반환 타입의 메서드에서 return을 쓸 수 있는가?
YES. 단, 값 없는 return; 만 가능. 메서드를 즉시 종료 하는 용도.
public void greet(String name) {
if (name == null) {
return; // ✅ 즉시 종료
}
System.out.println("Hello, " + name);
}
public void doSomething() {
return 42; // ❌ 값이 있는 return 불가
}활용: Early Return 패턴 — 조건에 맞지 않으면 즉시 종료해서 중첩 if 줄이기.
Q2: 매개변수 없는 메서드와 있는 메서드의 호출 방식 차이는?
호출 시 괄호 안에 인자를 넘기느냐의 차이:
// 매개변수 없음 — 빈 괄호
obj.method();
// 매개변수 있음 — 인자 전달
obj.method(arg1, arg2);⚠️ 주의 — 괄호는 항상 필요:
obj.method; // ❌ 메서드 호출 아님 (메서드 참조로 해석되거나 에러)
obj.method(); // ✅ 호출⚠️ 메서드 참조 와의 차이 (3주차 람다와 연결):
list.forEach(System.out::println); // 메서드 참조 (호출 X)
list.forEach(x -> System.out.println(x)); // 람다다음 Unit으로
- 가변인자(Varargs) 를 학습할 준비 완료
- "매개변수 개수가 가변일 때" 의 시나리오가 궁금하다
Software Developer