[Design Patterns] 데코레이터와 컴포지트: 재귀적 아름다움

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// 재귀의 수학적 아름다움 예시: 피보나치 수열
int fibonacci(int n) {
    if (n <= 1) return n;                    // 기저 조건
    return fibonacci(n-1) + fibonacci(n-2);  // 재귀적 정의
}

// 팩토리얼: 또 다른 재귀의 예
int factorial(int n) {
    if (n <= 1) return 1;                    // 기저 조건
    return n * factorial(n-1);               // 재귀적 정의
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// 현실에서 마주치는 문제 상황
public class TextProcessor {
    public String processText(String text) {
        // 문제: 텍스트 처리 기능을 동적으로 조합하고 싶음
        
        // 요구사항들:
        // 1. 대문자 변환
        // 2. HTML 태그 제거
        // 3. 공백 정규화
        // 4. 암호화
        // 5. 압축
        // 6. 로깅
        
        // 하지만 모든 조합이 항상 필요한 것은 아님
        // 어떤 때는 1+3+6만, 어떤 때는 2+4+5만 필요
        // 상속으로는 불가능한 조합의 폭발...
        
        String result = text;
        if (needsUpperCase) result = result.toUpperCase();
        if (needsHtmlStrip) result = stripHtml(result);
        if (needsNormalization) result = normalizeWhitespace(result);
        if (needsEncryption) result = encrypt(result);
        if (needsCompression) result = compress(result);
        if (needsLogging) log(result);
        
        return result;
        // 문제: 조합이 복잡해질수록 if문이 폭발적으로 증가
        // 새로운 기능 추가 시마다 기존 코드 수정 필요
    }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105

// 텍스트 처리의 기본 인터페이스
interface TextProcessor {
    String process(String text);
}

// 기본 구현체 (ConcreteComponent)
class PlainTextProcessor implements TextProcessor {
    @Override
    public String process(String text) {
        return text; // 아무 처리도 하지 않음
    }
}

// Decorator의 기본 클래스
abstract class TextProcessorDecorator implements TextProcessor {
    protected final TextProcessor wrapped;
    
    protected TextProcessorDecorator(TextProcessor processor) {
        this.wrapped = processor;
    }
    
    @Override
    public String process(String text) {
        return wrapped.process(text); // 기본 동작은 위임
    }
}

// 구체적인 Decorator들
class UpperCaseDecorator extends TextProcessorDecorator {
    public UpperCaseDecorator(TextProcessor processor) {
        super(processor);
    }
    
    @Override
    public String process(String text) {
        String result = wrapped.process(text); // 먼저 이전 처리 수행
        return result.toUpperCase();           // 추가 기능 적용
    }
}

class HtmlStripDecorator extends TextProcessorDecorator {
    public HtmlStripDecorator(TextProcessor processor) {
        super(processor);
    }
    
    @Override
    public String process(String text) {
        String result = wrapped.process(text);
        return result.replaceAll("<[^>]*>", ""); // HTML 태그 제거
    }
}

class WhitespaceNormalizeDecorator extends TextProcessorDecorator {
    public WhitespaceNormalizeDecorator(TextProcessor processor) {
        super(processor);
    }
    
    @Override
    public String process(String text) {
        String result = wrapped.process(text);
        return result.replaceAll("\\s+", " ").trim(); // 공백 정규화
    }
}

class EncryptionDecorator extends TextProcessorDecorator {
    private final String key;
    
    public EncryptionDecorator(TextProcessor processor, String key) {
        super(processor);
        this.key = key;
    }
    
    @Override
    public String process(String text) {
        String result = wrapped.process(text);
        return encrypt(result, key); // 암호화 적용
    }
    
    private String encrypt(String text, String key) {
        // 간단한 암호화 (실제로는 더 복잡한 알고리즘 사용)
        return Base64.getEncoder().encodeToString(text.getBytes());
    }
}

class LoggingDecorator extends TextProcessorDecorator {
    private final String loggerName;
    
    public LoggingDecorator(TextProcessor processor, String loggerName) {
        super(processor);
        this.loggerName = loggerName;
    }
    
    @Override
    public String process(String text) {
        long startTime = System.currentTimeMillis();
        System.out.println("[" + loggerName + "] Processing started: " + text.substring(0, Math.min(50, text.length())));
        
        String result = wrapped.process(text);
        
        long endTime = System.currentTimeMillis();
        System.out.println("[" + loggerName + "] Processing completed in " + (endTime - startTime) + "ms");
        
        return result;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

public class DecoratorExample {
    public static void main(String[] args) {
        // 기본 텍스트
        String htmlText = "<html><body><h1>Hello World!</h1>  <p>This is   a   test.</p></body></html>";
        
        // 1. 단순한 처리
        TextProcessor simple = new PlainTextProcessor();
        System.out.println("Simple: " + simple.process(htmlText));
        
        // 2. HTML 태그 제거 + 공백 정규화
        TextProcessor htmlStrip = new WhitespaceNormalizeDecorator(
            new HtmlStripDecorator(
                new PlainTextProcessor()
            )
        );
        System.out.println("HTML Strip + Normalize: " + htmlStrip.process(htmlText));
        
        // 3. 완전한 체인: HTML 제거 → 공백 정규화 → 대문자 변환 → 암호화 → 로깅
        TextProcessor fullChain = new LoggingDecorator(
            new EncryptionDecorator(
                new UpperCaseDecorator(
                    new WhitespaceNormalizeDecorator(
                        new HtmlStripDecorator(
                            new PlainTextProcessor()
                        )
                    )
                ), "secret-key"
            ), "FullProcessor"
        );
        System.out.println("Full Chain: " + fullChain.process(htmlText));
        
        // 4. 다른 순서의 체인: 대문자 변환 → HTML 제거 → 공백 정규화
        TextProcessor differentOrder = new WhitespaceNormalizeDecorator(
            new HtmlStripDecorator(
                new UpperCaseDecorator(
                    new PlainTextProcessor()
                )
            )
        );
        System.out.println("Different Order: " + differentOrder.process(htmlText));
    }
}

/*
출력 결과:
Simple: <html><body><h1>Hello World!</h1>  <p>This is   a   test.</p></body></html>

HTML Strip + Normalize: Hello World! This is a test.

[FullProcessor] Processing started: <html><body><h1>Hello World!</h1>  <p>This is
[FullProcessor] Processing completed in 2ms
Full Chain: SEVMTE8gV09STEQhIFRISVMgSVMgQSBURVNULg==

Different Order: HELLO WORLD! THIS IS A TEST.
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

// 함수형 스타일의 Decorator 구현
@FunctionalInterface
interface TextTransformer extends Function<String, String> {
    
    // 체이닝을 위한 헬퍼 메서드
    default TextTransformer then(TextTransformer after) {
        return text -> after.apply(this.apply(text));
    }
    
    // 조건부 적용
    default TextTransformer when(Predicate<String> condition) {
        return text -> condition.test(text) ? this.apply(text) : text;
    }
}

// 함수형 변환기들
public class TextTransformers {
    
    public static final TextTransformer TO_UPPER = String::toUpperCase;
    public static final TextTransformer TO_LOWER = String::toLowerCase;
    public static final TextTransformer STRIP_HTML = text -> text.replaceAll("<[^>]*>", "");
    public static final TextTransformer NORMALIZE_WHITESPACE = text -> text.replaceAll("\\s+", " ").trim();
    public static final TextTransformer REVERSE = text -> new StringBuilder(text).reverse().toString();
    
    public static TextTransformer encrypt(String key) {
        return text -> Base64.getEncoder().encodeToString(text.getBytes());
    }
    
    public static TextTransformer addPrefix(String prefix) {
        return text -> prefix + text;
    }
    
    public static TextTransformer addSuffix(String suffix) {
        return text -> text + suffix;
    }
    
    public static TextTransformer log(String loggerName) {
        return text -> {
            System.out.println("[" + loggerName + "] Processing: " + text);
            return text;
        };
    }
}

// 함수형 스타일 사용법
public class FunctionalDecoratorExample {
    public static void main(String[] args) {
        String htmlText = "<html><body><h1>Hello World!</h1></body></html>";
        
        // 1. 체이닝을 통한 조합
        TextTransformer pipeline1 = TextTransformers.STRIP_HTML
            .then(TextTransformers.NORMALIZE_WHITESPACE)
            .then(TextTransformers.TO_UPPER)
            .then(TextTransformers.addPrefix(">>> "))
            .then(TextTransformers.addSuffix(" <<<"));
        
        System.out.println("Pipeline 1: " + pipeline1.apply(htmlText));
        
        // 2. 조건부 적용
        TextTransformer conditionalPipeline = TextTransformers.STRIP_HTML
            .then(TextTransformers.TO_UPPER.when(text -> text.length() < 50))
            .then(TextTransformers.REVERSE.when(text -> text.contains("HELLO")));
        
        System.out.println("Conditional: " + conditionalPipeline.apply(htmlText));
        
        // 3. Stream과의 조합
        List<String> texts = Arrays.asList(
            "<p>First text</p>",
            "<div>Second text</div>",
            "<span>Third text</span>"
        );
        
        TextTransformer batchProcessor = TextTransformers.STRIP_HTML
            .then(TextTransformers.TO_UPPER)
            .then(TextTransformers.addPrefix("Processed: "));
        
        List<String> processed = texts.stream()
            .map(batchProcessor)
            .collect(Collectors.toList());
        
        processed.forEach(System.out::println);
    }
}

/*
출력:
Pipeline 1: >>> HELLO WORLD! <<<
Conditional: !DLROW OLLEH
Processed: FIRST TEXT
Processed: SECOND TEXT
Processed: THIRD TEXT
*/

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225

// Java I/O는 Decorator 패턴의 교과서적 예시
public class JavaIODecoratorExample {
    
    public void demonstrateIODecorators() throws IOException {
        // 1. 기본 파일 읽기
        try (InputStream basicInput = new FileInputStream("data.txt")) {
            // 기본 기능만 사용
        }
        
        // 2. 버퍼링 추가 (성능 향상)
        try (InputStream bufferedInput = new BufferedInputStream(
                new FileInputStream("data.txt")
        )) {
            // 버퍼링으로 성능 개선
        }
        
        // 3. 압축 해제 추가
        try (InputStream compressedInput = new GZIPInputStream(
                new FileInputStream("data.gz")
        )) {
            // GZIP 압축 파일 읽기
        }
        
        // 4. 완전한 체인: 파일 → GZIP 해제 → 버퍼링 → 데이터 스트림
        try (DataInputStream dataInput = new DataInputStream(
                new BufferedInputStream(
                    new GZIPInputStream(
                        new FileInputStream("data.gz")
                    )
                )
        )) {
            // 압축된 파일에서 구조화된 데이터 읽기
            int value = dataInput.readInt();
            String text = dataInput.readUTF();
        }
        
        // 5. 네트워크 + 암호화 + 버퍼링
        try (InputStream networkInput = new BufferedInputStream(
                new CipherInputStream(
                    new URL("https://example.com/data").openStream(),
                    createDecryptCipher()
                )
        )) {
            // 네트워크에서 암호화된 데이터를 버퍼링하며 읽기
        }
    }
    
    // 사용자 정의 Decorator 추가
    public static class LoggingInputStream extends FilterInputStream {
        private final String name;
        private int bytesRead = 0;
        
        public LoggingInputStream(InputStream in, String name) {
            super(in);
            this.name = name;
        }
        
        @Override
        public int read() throws IOException {
            int result = super.read();
            if (result != -1) {
                bytesRead++;
                if (bytesRead % 1024 == 0) {
                    System.out.println("[" + name + "] Read " + bytesRead + " bytes");
                }
            }
            return result;
        }
    }
    
    // 체인에 로깅 추가
    public void useCustomDecorator() throws IOException {
        try (InputStream loggingInput = new LoggingInputStream(
                new BufferedInputStream(
                    new GZIPInputStream(
                        new FileInputStream("large-data.gz")
                    )
                ), "DataReader"
        )) {
            byte[] buffer = new byte[1024];
            while (loggingInput.read(buffer) != -1) {
                // 데이터 처리
            }
        }
    }
    
    private Cipher createDecryptCipher() {
        // 암호화 설정 구현
        return null;
    }
}

## Composite 패턴: 트리 구조의 우아한 통일성

### 패턴의 동기와 철학

Composite 패턴은 **"부분-전체 계층구조"**를 나타내는 가장 우아한 방법입니다. 개별 객체와 객체들의 집합을 동일하게 다룰 수 있게 해주어, 클라이언트가 복잡성을 의식하지 않고 트리 구조를 다룰 수 있습니다.

```java
// 수학 표현식 계산기 - Composite의 완벽한 예시
abstract class Expression {
    public abstract double evaluate();
    public abstract String toString();
    
    // Composite 전용 메서드들 (기본 구현)
    public void add(Expression expression) {
        throw new UnsupportedOperationException("Leaf node cannot add children");
    }
    
    public void remove(Expression expression) {
        throw new UnsupportedOperationException("Leaf node cannot remove children");
    }
    
    public List<Expression> getChildren() {
        throw new UnsupportedOperationException("Leaf node has no children");
    }
}

// Leaf - 숫자
class Number extends Expression {
    private final double value;
    
    public Number(double value) {
        this.value = value;
    }
    
    @Override
    public double evaluate() {
        return value;
    }
    
    @Override
    public String toString() {
        return String.valueOf(value);
    }
}

// Composite - 연산자
abstract class BinaryOperation extends Expression {
    protected Expression left;
    protected Expression right;
    protected final String operator;
    
    public BinaryOperation(Expression left, Expression right, String operator) {
        this.left = left;
        this.right = right;
        this.operator = operator;
    }
    
    @Override
    public String toString() {
        return "(" + left.toString() + " " + operator + " " + right.toString() + ")";
    }
    
    @Override
    public List<Expression> getChildren() {
        return Arrays.asList(left, right);
    }
}

class Addition extends BinaryOperation {
    public Addition(Expression left, Expression right) {
        super(left, right, "+");
    }
    
    @Override
    public double evaluate() {
        return left.evaluate() + right.evaluate();
    }
}

class Multiplication extends BinaryOperation {
    public Multiplication(Expression left, Expression right) {
        super(left, right, "*");
    }
    
    @Override
    public double evaluate() {
        return left.evaluate() * right.evaluate();
    }
}

class Division extends BinaryOperation {
    public Division(Expression left, Expression right) {
        super(left, right, "/");
    }
    
    @Override
    public double evaluate() {
        double rightValue = right.evaluate();
        if (rightValue == 0) {
            throw new ArithmeticException("Division by zero");
        }
        return left.evaluate() / rightValue;
    }
}

// 사용 예시: (3 + 4) * (2 / 1)
public class ExpressionExample {
    public static void main(String[] args) {
        // 복잡한 수식 구성
        Expression expr = new Multiplication(
            new Addition(new Number(3), new Number(4)),     // (3 + 4)
            new Division(new Number(2), new Number(1))      // (2 / 1)
        );
        
        System.out.println("Expression: " + expr);           // (3.0 + 4.0) * (2.0 / 1.0)
        System.out.println("Result: " + expr.evaluate());    // 14.0
        
        // 더 복잡한 중첩 구조
        Expression complex = new Addition(
            new Multiplication(
                new Number(2),
                new Addition(new Number(3), new Number(4))
            ),
            new Division(
                new Number(10),
                new Number(2)
            )
        );
        
        System.out.println("Complex: " + complex);          // (2.0 * (3.0 + 4.0)) + (10.0 / 2.0)
        System.out.println("Result: " + complex.evaluate()); // 19.0
    }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365

// GUI 컴포넌트 시스템
abstract class UIComponent {
    protected String name;
    protected int x, y, width, height;
    protected boolean visible = true;
    
    public UIComponent(String name, int x, int y, int width, int height) {
        this.name = name;
        this.x = x;
        this.y = y;
        this.width = width;
        this.height = height;
    }
    
    // 모든 컴포넌트가 구현해야 하는 기본 메서드들
    public abstract void render(Graphics g);
    public abstract void handleEvent(Event event);
    public abstract Rectangle getBounds();
    
    // Composite 전용 메서드들
    public void add(UIComponent component) {
        throw new UnsupportedOperationException("Cannot add children to leaf component");
    }
    
    public void remove(UIComponent component) {
        throw new UnsupportedOperationException("Cannot remove children from leaf component");
    }
    
    public List<UIComponent> getChildren() {
        return Collections.emptyList();
    }
    
    // 공통 기능
    public void setVisible(boolean visible) {
        this.visible = visible;
    }
    
    public boolean isVisible() {
        return visible;
    }
    
    public String getName() {
        return name;
    }
}

// Leaf 컴포넌트들
class Button extends UIComponent {
    private String text;
    private Runnable clickHandler;
    
    public Button(String name, int x, int y, String text) {
        super(name, x, y, 100, 30);
        this.text = text;
    }
    
    @Override
    public void render(Graphics g) {
        if (!visible) return;
        
        g.drawRect(x, y, width, height);
        g.drawString(text, x + 10, y + 20);
        System.out.println("Rendering button: " + text + " at (" + x + "," + y + ")");
    }
    
    @Override
    public void handleEvent(Event event) {
        if (!visible) return;
        
        if (event.getType() == EventType.CLICK && 
            event.getX() >= x && event.getX() <= x + width &&
            event.getY() >= y && event.getY() <= y + height) {
            
            System.out.println("Button clicked: " + text);
            if (clickHandler != null) {
                clickHandler.run();
            }
        }
    }
    
    @Override
    public Rectangle getBounds() {
        return new Rectangle(x, y, width, height);
    }
    
    public void setClickHandler(Runnable handler) {
        this.clickHandler = handler;
    }
}

class Label extends UIComponent {
    private String text;
    
    public Label(String name, int x, int y, String text) {
        super(name, x, y, text.length() * 8, 20);
        this.text = text;
    }
    
    @Override
    public void render(Graphics g) {
        if (!visible) return;
        
        g.drawString(text, x, y + 15);
        System.out.println("Rendering label: " + text + " at (" + x + "," + y + ")");
    }
    
    @Override
    public void handleEvent(Event event) {
        // 라벨은 이벤트를 처리하지 않음
    }
    
    @Override
    public Rectangle getBounds() {
        return new Rectangle(x, y, width, height);
    }
}

// Composite 컴포넌트들
class Panel extends UIComponent {
    private List<UIComponent> children = new ArrayList<>();
    private Color backgroundColor;
    
    public Panel(String name, int x, int y, int width, int height) {
        super(name, x, y, width, height);
    }
    
    @Override
    public void add(UIComponent component) {
        children.add(component);
    }
    
    @Override
    public void remove(UIComponent component) {
        children.remove(component);
    }
    
    @Override
    public List<UIComponent> getChildren() {
        return new ArrayList<>(children);
    }
    
    @Override
    public void render(Graphics g) {
        if (!visible) return;
        
        // 자신의 배경 렌더링
        if (backgroundColor != null) {
            g.setColor(backgroundColor);
            g.fillRect(x, y, width, height);
        }
        g.drawRect(x, y, width, height);
        System.out.println("Rendering panel: " + name + " at (" + x + "," + y + ")");
        
        // 모든 자식 컴포넌트 렌더링 (재귀적)
        for (UIComponent child : children) {
            child.render(g);
        }
    }
    
    @Override
    public void handleEvent(Event event) {
        if (!visible) return;
        
        // 이벤트를 모든 자식에게 전달 (재귀적)
        for (UIComponent child : children) {
            child.handleEvent(event);
        }
    }
    
    @Override
    public Rectangle getBounds() {
        return new Rectangle(x, y, width, height);
    }
    
    public void setBackgroundColor(Color color) {
        this.backgroundColor = color;
    }
}

class Window extends UIComponent {
    private List<UIComponent> children = new ArrayList<>();
    private String title;
    private boolean minimized = false;
    
    public Window(String name, int x, int y, int width, int height, String title) {
        super(name, x, y, width, height);
        this.title = title;
    }
    
    @Override
    public void add(UIComponent component) {
        children.add(component);
    }
    
    @Override
    public void remove(UIComponent component) {
        children.remove(component);
    }
    
    @Override
    public List<UIComponent> getChildren() {
        return new ArrayList<>(children);
    }
    
    @Override
    public void render(Graphics g) {
        if (!visible) return;
        
        // 윈도우 프레임 렌더링
        g.drawRect(x, y, width, height);
        g.fillRect(x, y, width, 25); // 타이틀 바
        g.drawString(title, x + 5, y + 18);
        System.out.println("Rendering window: " + title + " at (" + x + "," + y + ")");
        
        if (minimized) return;
        
        // 클라이언트 영역의 자식 컴포넌트들 렌더링
        for (UIComponent child : children) {
            child.render(g);
        }
    }
    
    @Override
    public void handleEvent(Event event) {
        if (!visible || minimized) return;
        
        // 타이틀 바 클릭 확인
        if (event.getType() == EventType.CLICK &&
            event.getX() >= x && event.getX() <= x + width &&
            event.getY() >= y && event.getY() <= y + 25) {
            
            System.out.println("Window title bar clicked: " + title);
            return;
        }
        
        // 이벤트를 자식들에게 전달
        for (UIComponent child : children) {
            child.handleEvent(event);
        }
    }
    
    @Override
    public Rectangle getBounds() {
        return new Rectangle(x, y, width, height);
    }
    
    public void minimize() {
        this.minimized = true;
    }
    
    public void restore() {
        this.minimized = false;
    }
}

// 복잡한 GUI 구조 생성 예시
public class GUIExample {
    public static void main(String[] args) {
        // 메인 윈도우 생성
        Window mainWindow = new Window("mainWindow", 100, 100, 400, 300, "My Application");
        
        // 상단 패널 (버튼들)
        Panel topPanel = new Panel("topPanel", 10, 35, 380, 50);
        topPanel.add(new Button("saveBtn", 10, 10, "Save"));
        topPanel.add(new Button("loadBtn", 120, 10, "Load"));
        topPanel.add(new Button("exitBtn", 230, 10, "Exit"));
        
        // 중앙 패널 (내용)
        Panel centerPanel = new Panel("centerPanel", 10, 95, 380, 150);
        centerPanel.add(new Label("titleLabel", 10, 10, "Document Title:"));
        centerPanel.add(new Label("contentLabel", 10, 40, "Content goes here..."));
        
        // 하단 패널 (상태)
        Panel bottomPanel = new Panel("bottomPanel", 10, 255, 380, 30);
        bottomPanel.add(new Label("statusLabel", 10, 5, "Ready"));
        
        // 윈도우에 패널들 추가
        mainWindow.add(topPanel);
        mainWindow.add(centerPanel);
        mainWindow.add(bottomPanel);
        
        // 중첩된 윈도우 추가
        Window dialogWindow = new Window("dialog", 200, 150, 200, 150, "Settings");
        Panel dialogPanel = new Panel("dialogPanel", 10, 35, 180, 80);
        dialogPanel.add(new Label("settingLabel", 10, 10, "Setting:"));
        dialogPanel.add(new Button("okBtn", 10, 40, "OK"));
        dialogPanel.add(new Button("cancelBtn", 100, 40, "Cancel"));
        dialogWindow.add(dialogPanel);
        
        // 전체 화면 렌더링
        Graphics mockGraphics = new MockGraphics();
        
        System.out.println("=== Rendering Main Window ===");
        mainWindow.render(mockGraphics);
        
        System.out.println("\n=== Rendering Dialog Window ===");
        dialogWindow.render(mockGraphics);
        
        // 이벤트 처리 테스트
        System.out.println("\n=== Event Handling Test ===");
        Event clickEvent = new Event(EventType.CLICK, 120, 110); // Save 버튼 클릭
        mainWindow.handleEvent(clickEvent);
    }
}

// 재귀적 구조 순회 유틸리티
public class CompositeUtils {
    
    // 깊이 우선 탐색으로 모든 컴포넌트 찾기
    public static List<UIComponent> findAll(UIComponent root, Predicate<UIComponent> condition) {
        List<UIComponent> result = new ArrayList<>();
        findAllRecursive(root, condition, result);
        return result;
    }
    
    private static void findAllRecursive(UIComponent component, Predicate<UIComponent> condition, List<UIComponent> result) {
        if (condition.test(component)) {
            result.add(component);
        }
        
        for (UIComponent child : component.getChildren()) {
            findAllRecursive(child, condition, result);
        }
    }
    
    // 특정 이름으로 컴포넌트 찾기
    public static Optional<UIComponent> findByName(UIComponent root, String name) {
        return findAll(root, comp -> comp.getName().equals(name))
                .stream()
                .findFirst();
    }
    
    // 트리 구조 출력
    public static void printTree(UIComponent root) {
        printTreeRecursive(root, 0);
    }
    
    private static void printTreeRecursive(UIComponent component, int depth) {
        String indent = "  ".repeat(depth);
        System.out.println(indent + component.getClass().getSimpleName() + ": " + component.getName());
        
        for (UIComponent child : component.getChildren()) {
            printTreeRecursive(child, depth + 1);
        }
    }
    
    // 총 컴포넌트 개수 계산
    public static int countComponents(UIComponent root) {
        return 1 + root.getChildren().stream()
                .mapToInt(CompositeUtils::countComponents)
                .sum();
    }
    
    // 최대 깊이 계산
    public static int maxDepth(UIComponent root) {
        if (root.getChildren().isEmpty()) {
            return 1;
        }
        
        return 1 + root.getChildren().stream()
                .mapToInt(CompositeUtils::maxDepth)
                .max()
                .orElse(0);
    }
}