---
id: wiki-2026-0508-pull-up-method
title: Pull Up Method
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Pull Up Refactoring, Method Hoisting]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [refactoring, oop, inheritance]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: java
  framework: refactoring
---

# Pull Up Method

## 매 한 줄
> **"매 duplicated method 매 sibling subclasses 안 — 매 superclass 로 hoist"**. Fowler의 Refactoring (1999, 2nd ed 2018) 매 catalog item. 매 Extract Superclass / Replace Inheritance with Delegation 와 매 짝.

## 매 핵심

### 매 trigger
- 매 두 개 이상 sibling subclass 가 매 identical (or near-identical) method body 보유.
- 매 fields 도 같이 pull up 가능 — `Pull Up Field`.
- 매 constructor body 도 — `Pull Up Constructor Body`.

### 매 mechanics
- 매 step 1: 매 method bodies 매 inspect — 매 truly identical 인지.
- 매 step 2: 매 differences 매 parameterize — 매 identical 로 만들기.
- 매 step 3: 매 superclass 매 method 작성, 매 subclasses 매 method 삭제.
- 매 step 4: 매 test — 매 polymorphic dispatch 매 correct 인지.

### 매 응용
1. ORM entity hierarchy — 매 `BaseEntity` 매 `id`, `createdAt` pull up.
2. UI component class hierarchy — 매 common rendering logic.
3. Service layer — 매 audit/logging method pull up.

## 💻 패턴

### Java — Pull Up Method
```java
// Before
class Salesman extends Employee {
    String getName() { return name; }
}
class Engineer extends Employee {
    String getName() { return name; }
}

// After
class Employee {
    protected String name;
    String getName() { return name; }
}
class Salesman extends Employee {}
class Engineer extends Employee {}
```

### Pull Up Field
```java
// Before
class Salesman extends Employee {
    private String name;
}
class Engineer extends Employee {
    private String name;
}

// After
class Employee {
    protected String name;
}
```

### Pull Up Constructor Body
```java
class Employee {
    protected String name;
    protected Employee(String name) { this.name = name; }
}
class Manager extends Employee {
    private int grade;
    Manager(String name, int grade) {
        super(name);  // pulled up
        this.grade = grade;
    }
}
```

### Python — pull up via ABC
```python
from abc import ABC

class Shape(ABC):
    def describe(self) -> str:
        return f"Shape with area {self.area():.2f}"

class Circle(Shape):
    def __init__(self, r): self.r = r
    def area(self): return 3.14159 * self.r ** 2

class Square(Shape):
    def __init__(self, s): self.s = s
    def area(self): return self.s ** 2
```

### TypeScript — abstract class
```typescript
abstract class Animal {
    constructor(protected name: string) {}
    describe(): string {  // pulled up from Dog/Cat
        return `${this.name} is a ${this.constructor.name}`;
    }
    abstract makeSound(): string;
}
class Dog extends Animal { makeSound() { return "Woof"; } }
class Cat extends Animal { makeSound() { return "Meow"; } }
```

### Refactoring with parameterization
```java
// Before — almost identical
class A { int charge() { return base * 1.05; } }
class B { int charge() { return base * 1.10; } }

// Step: parameterize
class A extends Billing { int charge() { return calc(1.05); } }
class B extends Billing { int charge() { return calc(1.10); } }

// Pull up
class Billing { protected int calc(double rate) { return base * rate; } }
```

## 매 결정 기준
| 상황 | Approach |
|---|---|
| 매 identical method 매 2+ sibling | Pull Up Method |
| 매 similar but different method | Form Template Method 먼저 |
| 매 only 1 subclass uses | Don't pull up |
| 매 deep inheritance (>3 levels) | Composition 고려 |
| 매 LSP 위반 risk | Don't — Extract Class instead |

**기본값**: 매 2+ siblings 매 identical body — Pull Up. 매 그 외 — composition.

## 🔗 Graph
- 부모: [[Refactoring_Best_Practices|Refactoring]]
- Adjacent: [[Composition over Inheritance]]

## 🤖 LLM 활용
**언제**: 매 sibling classes 매 duplication detection — LLM 매 structural similarity 매 잘 detect. 매 IDE refactor (IntelliJ, Rider) 매 mechanical transform 자동.
**언제 X**: 매 cross-cutting concern (logging, auth) — Pull Up 대신 매 aspect / decorator.

## ❌ 안티패턴
- **Forced inheritance**: 매 unrelated classes 매 method 공유 위해 매 fake superclass — composition 사용.
- **God superclass**: 매 너무 많이 pull up — base class 가 매 dumping ground 가 됨.
- **LSP violation**: 매 pulled-up method 가 매 some subclass 에서 매 invalid — split.

## 🧪 검증 / 중복
- Verified (Fowler — Refactoring 2nd ed, 2018, ch 12).
- 신뢰도 A.

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — full refactoring catalog entry |
