Top 11 컴포지션 패턴 Top 49 Best Answers

You are looking for information, articles, knowledge about the topic nail salons open on sunday near me 컴포지션 패턴 on Google, you do not find the information you need! Here are the best content compiled and compiled by the Chewathai27.com/to team, along with other related topics such as: 컴포지션 패턴 Javascript 컴포지트 패턴, 중재자 패턴, 컴포지트 뜻, 데코레이터 패턴, 컴포지트 패턴 예제, 컴포지트 패턴 장단점, 복합체 패턴, Policy pattern

---

디자인패턴, Composite Pattern, 콤포짓 콤포지트 패턴

디자인패턴, Composite Pattern, 콤포짓 콤포지트 패턴

---

[자바 디자인 패턴] 구조패턴 – 컴포짓 패턴

• Article author: know-one-by-one.tistory.com
• Reviews from users: 41349 Ratings
• Top rated: 4.3
• Lowest rated: 1
• Summary of article content: Articles about [자바 디자인 패턴] 구조패턴 – 컴포짓 패턴 구조패턴 목록 어댑터 패턴 (Adapter Pattern) 브릿지 패턴 (Brge Pattern) 컴포짓 패턴 … 컴포지션의 객체에 대한 인터페이스를 선언합니다. …
• Most searched keywords: Whether you are looking for [자바 디자인 패턴] 구조패턴 – 컴포짓 패턴 구조패턴 목록 어댑터 패턴 (Adapter Pattern) 브릿지 패턴 (Brge Pattern) 컴포짓 패턴 … 컴포지션의 객체에 대한 인터페이스를 선언합니다. 구조패턴 목록 어댑터 패턴 (Adapter Pattern) 브릿지 패턴 (Bridge Pattern) 컴포짓 패턴 (Composite Pattern) 데코레이터 패턴 (Decorator Pattern) 퍼사드 패턴 (Facade Pattern) 플라이웨이트 패턴 (Flyweight..
• Table of Contents:

[자바 디자인 패턴] 구조패턴 – 컴포짓 패턴

티스토리툴바

Read More

[Design Pattern] Composition Pattern

• Article author: beomseok95.tistory.com
• Reviews from users: 15586 Ratings
• Top rated: 4.9
• Lowest rated: 1
• Summary of article content: Articles about [Design Pattern] Composition Pattern Composition Pattern이란? … 객체들의 관계를 트리 구조로 구성하여 부분-전체 계층을 표현하는 패턴으로,. 사용자가 단일 객체와 복합 객체 모두 동일 … …
• Most searched keywords: Whether you are looking for [Design Pattern] Composition Pattern Composition Pattern이란? … 객체들의 관계를 트리 구조로 구성하여 부분-전체 계층을 표현하는 패턴으로,. 사용자가 단일 객체와 복합 객체 모두 동일 … [Design Pattern] Composition Pattern Composition Pattern이란? 컴포지트 패턴(Composite pattern)이란 객체들의 관계를 트리 구조로 구성하여 부분-전체 계층을 표현하는 패턴으로, 사용자가 단일 객체와 복합..
• Table of Contents:

[Design Pattern] Composition Pattern

태그

관련글

댓글0

최근글

인기글

태그

전체 방문자

티스토리툴바

Read More

[GoF Design Patterns] 디자인 패턴을 알아보자! (8) Composite – Jinia’s LOG’

• Article author: www.jiniaslog.co.kr
• Reviews from users: 16991 Ratings
• Top rated: 4.2
• Lowest rated: 1
• Summary of article content: Articles about [GoF Design Patterns] 디자인 패턴을 알아보자! (8) Composite – Jinia’s LOG’ 컴포지트 패턴은 객체들의 관계를 트리구조로 표현하는 패턴으로, 사용자가 단일 객체와 복합 객체를 모두 동일하게 다룰수 있도록 구조화한 패턴이다. …
• Most searched keywords: Whether you are looking for [GoF Design Patterns] 디자인 패턴을 알아보자! (8) Composite – Jinia’s LOG’ 컴포지트 패턴은 객체들의 관계를 트리구조로 표현하는 패턴으로, 사용자가 단일 객체와 복합 객체를 모두 동일하게 다룰수 있도록 구조화한 패턴이다. Composite 란? 컴포지트 패턴의 정의, Intend 컴포지트 패턴은 객체들의 관계를 트리구조로 표현하는 패턴으로, 사용자가 단일 객체와 복합 객체를 모두 동일하게 다룰수 있도록 구조화한 패턴이다.
• Table of Contents:

컴포지트 패턴의 정의 Intend

왜 필요한가 Pros

문제점은 Cons

설명

Read More

컴포지트 패턴 – 위키백과, 우리 모두의 백과사전

• Article author: ko.wikipedia.org
• Reviews from users: 5062 Ratings
• Top rated: 4.1
• Lowest rated: 1
• Summary of article content: Articles about 컴포지트 패턴 – 위키백과, 우리 모두의 백과사전 컴포지트 패턴(Composite pattern)이란 객체들의 관계를 트리 구조로 구성하여 부분-전체 계층을 표현하는 패턴으로, 사용자가 단일 객체와 복합 객체 모두 동일하게 … …
• Most searched keywords: Whether you are looking for 컴포지트 패턴 – 위키백과, 우리 모두의 백과사전 컴포지트 패턴(Composite pattern)이란 객체들의 관계를 트리 구조로 구성하여 부분-전체 계층을 표현하는 패턴으로, 사용자가 단일 객체와 복합 객체 모두 동일하게 …
• Table of Contents:

구조[편집]

예[편집]

Read More

컴포지트 패턴 | revdevblog

• Article author: reverince.github.io
• Reviews from users: 30627 Ratings
• Top rated: 3.4
• Lowest rated: 1
• Summary of article content: Articles about 컴포지트 패턴 | revdevblog 구현하지 않은 순수 가상 함수가 있으면 추상 클래스가 된다. 컴포지션(composition; 복합 연관 관계): 멤버로서 다른 객체를 가지며, 멤버를 갖는 객체가 … …
• Most searched keywords: Whether you are looking for 컴포지트 패턴 | revdevblog 구현하지 않은 순수 가상 함수가 있으면 추상 클래스가 된다. 컴포지션(composition; 복합 연관 관계): 멤버로서 다른 객체를 가지며, 멤버를 갖는 객체가 … ※ 참조 《모던 C++ 디자인 패턴》 by 드미트리 네스터룩 위키백과 Composite pattern 문서 SOLID 원칙을 더 잘 준수하면서 코드의 범용성과 유지보수성을 높이기 위해 몇 가지 구조 패턴들이 고안되었다. 그 중 하나인 컴포지트 패턴은 여러 객체를 마치 하나의 인스턴스처럼 다루는 디자인 패턴이다. 객체들을 트리 구조로 구성해 사용자가 각각의 객체나 구성(composition)을 같은 방법으로 사용할 수 있게 하는 것이다.reverince, revdevblog, 레버, Jekyll, NexT
• Table of Contents:

Read More

[디자인패턴] 상속보다는 컴포지션을 사용하자!!!

• Article author: developer-ping9.tistory.com
• Reviews from users: 44185 Ratings
• Top rated: 3.5
• Lowest rated: 1
• Summary of article content: Articles about [디자인패턴] 상속보다는 컴포지션을 사용하자!!! [디자인패턴] 상속보다는 컴포지션을 사용하자!!! Studying Ping9_ 2022. 2. 17. 17:56. 320×100. 현업자들이 모여있는 오픈톡방에서 상속과 컴포지션에 대한 이야기가 … …
• Most searched keywords: Whether you are looking for [디자인패턴] 상속보다는 컴포지션을 사용하자!!! [디자인패턴] 상속보다는 컴포지션을 사용하자!!! Studying Ping9_ 2022. 2. 17. 17:56. 320×100. 현업자들이 모여있는 오픈톡방에서 상속과 컴포지션에 대한 이야기가 … 현업자들이 모여있는 오픈톡방에서 상속과 컴포지션에 대한 이야기가 흘러나왔다. ㅎㅎ …;;; 정말 난 모르는게 많구나….  이제라도 알아가면 되지 뭐!!! 아래의 블로그포스팅을 쓰신분이 여러블로그와 책을..
• Table of Contents:

Read More

컴포지션(Composition) 패턴 : 네이버 블로그

• Article author: m.blog.naver.com
• Reviews from users: 20567 Ratings
• Top rated: 3.7
• Lowest rated: 1
• Summary of article content: Articles about 컴포지션(Composition) 패턴 : 네이버 블로그 컴포지션(Composition) 패턴 … 상속은 캡슐화를 위반한다. 상속 용도가 아닌 클래스 즉 상속을 위해 특별히 구현, 설계 되지 않고 문서화 되지 않은 … …
• Most searched keywords: Whether you are looking for 컴포지션(Composition) 패턴 : 네이버 블로그 컴포지션(Composition) 패턴 … 상속은 캡슐화를 위반한다. 상속 용도가 아닌 클래스 즉 상속을 위해 특별히 구현, 설계 되지 않고 문서화 되지 않은 …
• Table of Contents:

카테고리 이동

ㅡ_ㅡ

이 블로그 
Technic
 카테고리 글

카테고리

이 블로그 
Technic
 카테고리 글

Read More

API 컴포지션 패턴 – AWS규범적 지침

• Article author: docs.aws.amazon.com
• Reviews from users: 39377 Ratings
• Top rated: 3.5
• Lowest rated: 1
• Summary of article content: Articles about API 컴포지션 패턴 – AWS규범적 지침 API 컴포지션 패턴 … 이 패턴은 API 컴포저 (aggregator) 를 사용하여 데이터를 소유한 개별 마이크로서비스를 호출하여 쿼리를 구현합니다. 그런 다음 인메모리 조인을 … …
• Most searched keywords: Whether you are looking for API 컴포지션 패턴 – AWS규범적 지침 API 컴포지션 패턴 … 이 패턴은 API 컴포저 (aggregator) 를 사용하여 데이터를 소유한 개별 마이크로서비스를 호출하여 쿼리를 구현합니다. 그런 다음 인메모리 조인을 … 이 패턴은 API 컴포저 (aggregator) 를 사용하여 데이터를 소유한 개별 마이크로서비스를 호출하여 쿼리를 구현합니다. 그런 다음 인메모리 조인을 수행하여 결과를 결합합니다.AWS 규범적 지침,모노리스,마이크로서비스,모노리스 분해,현대화
• Table of Contents:

Read More

모던 C++ 디자인 패턴: 객체 지향 소프트웨어 디자인을 재사용하는 방법 – 드미트리 네스터룩 – Google Sách

• Article author: books.google.com.vn
• Reviews from users: 3193 Ratings
• Top rated: 3.1
• Lowest rated: 1
• Summary of article content: Articles about 모던 C++ 디자인 패턴: 객체 지향 소프트웨어 디자인을 재사용하는 방법 – 드미트리 네스터룩 – Google Sách Updating …
• Most searched keywords: Whether you are looking for 모던 C++ 디자인 패턴: 객체 지향 소프트웨어 디자인을 재사용하는 방법 – 드미트리 네스터룩 – Google Sách Updating 새로운 기능으로 풍부해진 C++로 다시 배운다 C++는 C++11/14/17을 거치면서 강력한 언어로 발전했으며, 표현력이 풍부해졌다. GoF의 전통적인 디자인 패턴을 표현력이 풍부해진 모던 C++로 새롭게 학습한다. 또한, 모던 C++을 디자인 패턴에 활용하는 방법을 통해 모던 C++을 응용하는 방법도 학습할 수 있다. 객체 지향 소프트웨어 디자인을 학습한다GoF의 디자인 패턴은 기본! 객체 지향 소프트웨어의 디자인 원칙은 SOLID 원칙, CRTP 패턴, Mixin 상속, 모나드 패턴을 학습하면서 객체 지향 소프트웨어 디자인의 기본을 학습한다. 점진적인 설계로 패턴의 장단점을 살핀다패턴의 구현을 단순히 나열하지 않았다. 각 패턴을 간단하게 구현해보고 기술적 복잡도에 따라 패턴을 발전시켜가면서 각 복잡도 단계에 따라 발생하는 장단점을 면밀하게 설명했다.
• Table of Contents:

Read More

---

See more articles in the same category here: Chewathai27.com/to/blog.

[자바 디자인 패턴] 구조패턴

SMALL

구조패턴 목록

객체와 객체 사이의 연관관계가 계층으로 표현해야 하고, 같은 계층에서 다른 역할을 구현할 필요가 있다면 이 패턴이 필요할 것 같다.

장점

– 기본적이고 복잡한 객체를 포함하는 클래스 계층을 정의합니다.

– 새로운 종류의 구성 요소를 쉽게 추가할 수 있습니다.

– 관리 가능한 클래스 또는 인터페이스로 구조의 유연성을 제공합니다.

사용법

– 객체의 전체 또는 부분 계층을 나타내려는 경우

– 다른 개체에 영향을 주지 않고 개별 개체에 책임을 동적으로 추가해야하는 경우

UML

Component Class : Employee

– 컴포지션의 객체에 대한 인터페이스를 선언합니다

– 모든 클래스에 공통인 인터페이스의 기본동작을 적절하게 구현합니다

– 자식 구성요소에 엑세스하고 관리하기위한 인터페이스를 선언합니다

public interface Employee { public int getId(); public String getName(); public double getSalary(); public void print(); public void add(Employee employee); public void remove(Employee employee); public Employee getChild(int i); }

Leaf Class : Accountant, Cashier

– 자식 구성요소가 없습니다

– 컴포지션에서 리프객체를 나타냅니다

– 컴포지션에서 기본 객체의 동작을 정의합니다

public class Accountant implements Employee{ private int id; private String name; private double salary; public Accountant(int id,String name,double salary) { this.id=id; this.name = name; this.salary = salary; } @Override public void add(Employee employee) {} @Override public Employee getChild(int i) {return null;} @Override public int getId() { return id; } @Override public String getName() { return name; } @Override public double getSalary() { return salary; } @Override public void print() { System.out.println(“=========================”); System.out.println(“Id =”+getId()); System.out.println(“Name =”+getName()); System.out.println(“Salary =”+getSalary()); System.out.println(“=========================”); } @Override public void remove(Employee employee) {} }

public class Cashier implements Employee{ private int id; private String name; private double salary; public Cashier(int id,String name,double salary) { this.id=id; this.name = name; this.salary = salary; } @Override public void add(Employee employee) {} @Override public Employee getChild(int i) {return null;} @Override public int getId() { return id; } @Override public String getName() { return name; } @Override public double getSalary() { return salary; } @Override public void print() { System.out.println(“=========================”); System.out.println(“Id =”+getId()); System.out.println(“Name =”+getName()); System.out.println(“Salary =”+getSalary()); System.out.println(“=========================”); } @Override public void remove(Employee employee) {} }

Composite Class : BankManager

– 자식 구성요소가 존재합니다

– 컴포넌트 인터페이스에서 하위 관련 조작을 구현합니다

public class BankManager implements Employee { private int id; private String name; private double salary; List employees = new ArrayList(); public BankManager(int id,String name,double salary) { this.id=id; this.name = name; this.salary = salary; } @Override public void add(Employee employee) { employees.add(employee); } @Override public Employee getChild(int i) { return employees.get(i); } @Override public void remove(Employee employee) { employees.remove(employee); } @Override public int getId() { return id; } @Override public String getName() { return name; } @Override public double getSalary() { return salary; } @Override public void print() { System.out.println(“==========================”); System.out.println(“Id =”+getId()); System.out.println(“Name =”+getName()); System.out.println(“Salary =”+getSalary()); System.out.println(“==========================”); Iterator it = employees.iterator(); while(it.hasNext()) { Employee employee = it.next(); employee.print(); } } }

Operation Class : CompositePatternDemo

– 컴포넌트 인터페이스를 통해 컴포지션의 객체를 조작합니다

public class CompositePatternDemo { public static void main(String args[]){ Employee emp1=new Cashier(101,”Sohan Kumar”, 20000.0); Employee emp2=new Cashier(102,”Mohan Kumar”, 25000.0); Employee emp3=new Accountant(103,”Seema Mahiwal”, 30000.0); Employee manager1=new BankManager(100,”Ashwani Rajput”,100000.0); manager1.add(emp1); manager1.add(emp2); manager1.add(emp3); manager1.print(); } }

출처 : https://www.javatpoint.com/

LIST

[Design Pattern] Composition Pattern

[Design Pattern] Composition Pattern

Composition Pattern이란?

컴포지트 패턴(Composite pattern)이란

객체들의 관계를 트리 구조로 구성하여 부분-전체 계층을 표현하는 패턴으로,

사용자가 단일 객체와 복합 객체 모두 동일하게 다루도록 하는 패턴입니다.

component 컴포지션의 모든 개체에 대한 기본 인터페이스입니다. 하위 컴포지트를 관리하는 공통 메서드가 있는 인터페이스 또는 추상 클래스 여야 합니다. 즉, Leaf 클래스와 전체에 해당하는 Composite클래스의 공통 인터페이스를 작성합니다,

leaf 기본 구성 요소의 기본 동작을 구현합니다. 다른 객체에 대한 참조는 포함되어 있지 않습니다. 구체적인 부분 클래스 Composite 객체의 부품으로 설정합니다.

composite

전체 클래스입니다. Leaf를 요소로 가집니다. 복수개의 Leaf, 복수개의 Composite객체를 부분으로 가질 수 있습니다.

client – ​​기본 구성 요소 개체를 사용하여 컴포지션 요소에 액세스 할 수 있습니다.

Composition Pattern with Java

ex1) Graphic

/** “Component” */ interface Graphic { public void print(); }

/** “Composite” */ class CompositeGraphic implements Graphic { private List mChildGraphics = new ArrayList(); public void print() { for (Graphic graphic : mChildGraphics) { graphic.print(); } } public void add(Graphic graphic) { mChildGraphics.add(graphic); } public void remove(Graphic graphic) { mChildGraphics.remove(graphic); } }

/** “Leaf” */ class Ellipse implements Graphic { public void print() { System.out.println(“Ellipse”); } }

public class Program { public static void main(String[] args) { Ellipse ellipse1 = new Ellipse(); Ellipse ellipse2 = new Ellipse(); Ellipse ellipse3 = new Ellipse(); Ellipse ellipse4 = new Ellipse(); CompositeGraphic graphic = new CompositeGraphic(); CompositeGraphic graphic1 = new CompositeGraphic(); CompositeGraphic graphic2 = new CompositeGraphic(); graphic1.add(ellipse1); graphic1.add(ellipse2); graphic1.add(ellipse3); graphic2.add(ellipse4); graphic.add(graphic1); graphic.add(graphic2); //Prints the complete graphic (four times the string “Ellipse”). graphic.print(); } }

ex2) Computer

Memory , Proccessor, HardDrive는 Leaf입니다.

Leaf와 Composite는 component(Equipment)를 상속합니다.

Composite를 상속하는 PersonalComputer는 여러 개의 Leaf 혹은 복수개의 composite를 가질 수 있습니다.

public abstract class Equipment { private int price; private String name; Equipment(int price, String name) { this.price = price; this.name = name; } public int getPrice() { return price; } public void setPrice(int price) { this.price = price; } public String getName() { return name; } public void setName(String name) { this.name = name; } }

public class HardDrive extends Equipment { public HardDrive(int price, String name) { super(price, name); } }

public class Processor extends Equipment { public Processor(int price, String name) { super(price, name); } }

public class Memory extends Equipment { public Memory(int price, String name) { super(price, name); } }

public class Composite extends Equipment { ArrayList equipments = new ArrayList<>(); Composite(String name) { super(0, name); } @RequiresApi(api = Build.VERSION_CODES.N) @Override public int getPrice() { return equipments.stream() .map(Equipment::getPrice) .mapToInt(p -> (int) p) .sum(); } public void add(Equipment equipment) { equipments.add(equipment); } }

public class PersonalComputer extends Composite { public PersonalComputer(String name) { super(name); } }

public class CompositeTest { @Test public void compositionTest() { PersonalComputer pc = new PersonalComputer(“PC”); pc.add(new Processor(1000, “Intel”)); pc.add(new Memory(500, “8GB”)); pc.add(new HardDrive(800, “SSD”)); Assert.assertThat(pc.getName(), CoreMatchers.is(“PC”)); Assert.assertThat(pc.getPrice(), CoreMatchers.is(2300)); } }

Composition Pattern with Kotlin

ex1) 컴퓨터

open class Equipment( open val price: Int, val name: String )

open class Composite(name: String) : Equipment(0, name) { private val equipments = ArrayList() override val price: Int get() = equipments.map { it.price }.sum() fun add(equipment: Equipment) = apply { equipments.add(equipment) } }

/** Composite*/ class PersonalComputer : Composite(“PC”)

/** Leaf*/ class Processor : Equipment(1070, “Processor”)

/** Leaf*/ class Memory : Equipment(280, “Memory”)

/** Leaf*/ class HardDrive : Equipment(250, “Hard Drive”)

class CompositeTest { @Test fun Composite() { val pc = PersonalComputer() .add(Processor()) .add(HardDrive()) .add(Memory()) println(pc.price) assertThat(pc.name).isEqualTo(“PC”) assertThat(pc.price).isEqualTo(1600) } }

ex2) 플레이

interface IMedia { fun play() fun displaySubtitle() fun setPlaySpeed(speed:Float) fun getName() :String }

class Movie(val title:String): IMedia { private var speed = 1f override fun play() { println(“Now playing: ${title}…”) } override fun displaySubtitle() { println(“display subtitle”) } override fun setPlaySpeed(speed:Float) { this.speed = speed println(“current play speed set to: $speed”) } override fun getName(): String { return title } }

class PlayList(val title:String): IMedia { var movieList:MutableList = mutableListOf() fun addNewMedia(media: IMedia) = movieList.add(media) fun removeMedia(media: IMedia){ movieList = movieList.filter{ it.getName() != media.getName() }.toMutableList() } override fun play() { movieList.forEach { it.play() } } override fun displaySubtitle() { println(“display certain subtitle”) } override fun setPlaySpeed(speed: Float) { movieList.forEach { it.setPlaySpeed(speed) } } override fun getName(): String { return title } }

fun main() { val actionMoviePlayList = PlayList(“Action Movies”) val movieB: IMedia = Movie(“The Dark Knight”) val movieC: IMedia = Movie(“Inception”) val movieD: IMedia = Movie(“The Matrix”) actionMoviePlayList.apply { addNewMedia(movieB) addNewMedia(movieC) addNewMedia(movieD) } val dramaPlayList = PlayList(“Drama Play List”) val movie1: IMedia = Movie(“The Godfather”) val movie2: IMedia = Movie(“The Shawshank Redemption”) dramaPlayList.apply { addNewMedia(movie1);addNewMedia(movie2) } val myPlayList = PlayList(“My Play List”) myPlayList.apply { addNewMedia(actionMoviePlayList) addNewMedia(dramaPlayList) } myPlayList.play() }

Movie : Leaf

Compotie : PlayList

정리

Composite Pattern은

단일 객체와 복합 객체를 동일하게 컨트롤할 수 있게끔 도와주는 패턴이다.

컴포지트 패턴은 3가지의 요소에 의해 이루어진다.

Component, Leaf, Composite

샘플 보러 가기

https://github.com/qjatjr1108/DesignPattern

참고

https://blog.seotory.com/post/2017/09/java-composite-pattern

[GoF Design Patterns] 디자인 패턴을 알아보자! (8) Composite

Composite 란?

컴포지트 패턴의 정의, Intend

컴포지트 패턴은 객체들의 관계를 트리구조로 표현하는 패턴으로, 사용자가 단일 객체와 복합 객체를 모두 동일하게 다룰수 있도록 구조화한 패턴이다.

Composition?

컴포지션은 패턴이라기보다는 설계 개념, 컨셉으로서 하나의 객체가 다른 객체를 품고있는 경우를 일반적으로 말한다.

여기서 조금 더 나아가, 컴포지션의 가장 밖에 위치한 객체 = Wrapper 객체는 내부에 품고있는 객체와 생명주기가 강결합되어있는편이다.

What is Composition over Inheritance

자바나 OOP에 대해 공부하다보면 어느순간 상속보다는 결합( composition )을 사용하라는 말을 듣게된다. 나 역시 이펙티브 자바, Object 등을 공부하면서 해당 구문을 읽었고, 이번에 컴포지트 패턴을 공부하면서도 듣게 되었다.

해당 내용은 다형성의 구현에 있어서 상속은 부모클래스가 구현하는 내용을 자식 클래스가 모두 물려받다보니, 하위클래스에서 정작 쓰이지 않는 메서드도 갖게되고, 부모클래스의 변화에 따라 자식클래스도 크게 영향을 받게되므로

캡슐화가 깨지게 된다는 주장이였다.

따라서 is-a 관계인경우에만 상속을 사용하고, 보통은 객체간 결합을 사용해야하며 많은 공감을 받아 현재 OOP 진형의 대표적인 설계기법으로 자리 잡고 있다.

Composition vs Composite pattern?

인터넷의 여러 글을 읽어보고 의문점이 들었는데 컴포지트 패턴은 명확하게 의도가

복잡하게 얽혀있는 데이터 구조를 트리 구조로 하이라이키하게 계층화시키고, 이러한 구조의 노드와 리프들을 모두 같은 인터페이스로 접근하도록 하려는 패턴

인거지, 상속의 한계와 그 해결책으로 나온 패턴이 아니라는 점이다.

이펙티브 자바나 Object책에서 소개된 Composition 으로서의 패턴도 Decorator 패턴이지, 컴포지트 패턴이랑은 거리가 멀었다.

몇몇 블로그글도 그렇고 나 역시도 컴포지트 패턴이 컴포지션-상속 논쟁 의 컴포지션으로 생각했었는데

컴포지트 패턴이 컴포지션의 구조인건 맞지만 그 의도가 위의 내용이랑은 전혀 관계가 없다는걸 깨달았다.

아마도 명칭의 유사성때문에 헤깔리지 않았나 싶은데 이참에 개념을 다시 잡았다.

요약하자면 컴포지트 패턴은 Compositon over Inheritance 와는 전혀 관련이 없다!

혹시 이견이 있다면 꼭 댓글로 달아주시길

왜 필요한가? Pros

데이터를 다루다보면 계층형 트리 자료구조로 저장되고 이를 다루게되는 경우가 종종 생긴다.

이때 composite패턴을 사용하면 클라이언트측에서 모든 데이터를 모르더라도 복잡한 트리구조를 쉽게 다룰수 있다.

새로운 leaf 로서의 클래스를 추가하더라도 클라이언트는 상위 추상화된 인터페이스만을 바라보기 때문에, OCP 를 준수할 수 있다.

문제점은? Cons

계층형 구조에서 leaf 에 해당하는 객체와 Node 에 해당하는 객체들 모두를 동일한 인터페이스로 다루어야하는데, 이 인터페이스 설계가 어려울 수 있다. 이럴때는 디자인패턴에 억지로 끼워맞추려는것은 아닌지 다시 생각해볼필요가 있다.

구현 코드

public interface Document { void delete(); } public class Folder implements Document { private List contents = new ArrayList<>(); @Override public void delete() { for (Document content : contents) { content.delete(); } } public void addContents(Document content){ contents.add(content); } } public class File implements Document { private String contents; public File(String contents) { this.contents = contents; } @Override public void delete() { System.out.println(“delete contents : ” + contents); } }

설명

최상위 Document 인터페이스가 있고 이를 상속받는 폴더와 파일이 있는 단순한 자료구조를 구현했다.

폴더에는 파일이나 폴더가 담길수 있기때문에 트리구조로 자료가 담기게 되는데, 이때 최상위 root 폴더에 delete() 메서드만 호출하면 재귀적으로 모든 파일들이 다 delete() 메서드를 호출하게되는 구조다.

private static Document buildDocu() { Folder root = new Folder(); Folder subNode1 = new Folder(); Folder subNode2 = new Folder(); root.addContents(subNode1); root.addContents(subNode2); subNode1.addContents(new File(“컨텐츠1”)); subNode1.addContents(new File(“컨텐츠2”)); subNode1.addContents(new File(“컨텐츠3”)); subNode2.addContents(new File(“컨텐츠4”)); Folder subNode3 = new Folder(); subNode2.addContents(subNode3); subNode3.addContents(new File(“컨텐츠5”)); return root; }

위와같은 파일이 주어졌을때 클라이언트 측에서 아래처럼 호출하면

public static void main(String[] args) { Document document = buildDocu(); document.delete(); } //delete contents : 컨텐츠1 //delete contents : 컨텐츠2 //delete contents : 컨텐츠3 //delete contents : 컨텐츠4 //delete contents : 컨텐츠5

트리구조를 손쉽게 다룰수 있게된다.

다른패턴과의 관계

재귀적인 구조를 만들때 Builder패턴을 사용하면 훨씬 가독성이 좋아진다

iterator 패턴이나 visitor 패턴을 composite 패턴 트리에 작동되도록 할수도 있다

leaf노드에 경량패턴을 적용하여 램사용을 줄일수있다.

decorator 패턴과 유사한 구조를 보이는데, decorator 패턴은 래퍼 객체가 추가적인 책임을 갖는다는 점에서 큰 차이가 있다.

References

So you have finished reading the 컴포지션 패턴 topic article, if you find this article useful, please share it. Thank you very much. See more: Javascript 컴포지트 패턴, 중재자 패턴, 컴포지트 뜻, 데코레이터 패턴, 컴포지트 패턴 예제, 컴포지트 패턴 장단점, 복합체 패턴, Policy pattern