팩토리 메소드 패턴 | 디자인패턴, Factory Method Pattern, 팩토리 패턴 21911 명이 이 답변을 좋아했습니다

당신은 주제를 찾고 있습니까 “팩토리 메소드 패턴 – 디자인패턴, Factory Method Pattern, 팩토리 패턴“? 다음 카테고리의 웹사이트 ro.taphoamini.com 에서 귀하의 모든 질문에 답변해 드립니다: https://ro.taphoamini.com/wiki. 바로 아래에서 답을 찾을 수 있습니다. 작성자 코드없는 프로그래밍 이(가) 작성한 기사에는 조회수 4,302회 및 좋아요 75개 개의 좋아요가 있습니다.

팩토리 메서드 패턴(Factory technique sample)은 객체지향 디자인 패턴이다. Factory method는 부모(상위) 클래스에 알려지지 않은 구체 클래스를 생성하는 패턴이며. 자식(하위) 클래스가 어떤 객체를 생성할지를 결정하도록 하는 패턴이기도 하다.

Table of Contents

팩토리 메소드 패턴 주제에 대한 동영상 보기

여기에서 이 주제에 대한 비디오를 시청하십시오. 주의 깊게 살펴보고 읽고 있는 내용에 대한 피드백을 제공하세요!

여기에서 동영상 보기

d여기에서 디자인패턴, Factory Method Pattern, 팩토리 패턴 – 팩토리 메소드 패턴 주제에 대한 세부정보를 참조하세요

유료강의: https://www.youtube.com/channel/UCHcG02L6TSS-StkSbqVy6Fg/join
챕터List : https://www.youtube.com/playlist?list=PLDV-cCQnUlIYcAmW4j27i8aYPbja9HePm
Code: https://colab.research.google.com/github/NoCodeProgram/DesignPatterns/blob/main/Creational/FactoryMethodP.ipynb

팩토리 메소드 패턴 주제에 대한 자세한 내용은 여기를 참조하세요.

[Design Pattern] 팩토리 메서드 패턴이란

팩토리 메서드 패턴이란 · 즉, 객체의 생성 코드를 별도의 클래스/메서드로 분리함으로써 객체 생성의 변화에 대비하는 데 유용하다. · 특정 기능의 구현은 …

+ 여기를 클릭

Source: gmlwjd9405.github.io

Date Published: 12/8/2022

팩토리 메소드 패턴 (Factory Method Pattern) – velog

팩토리 메소드 패턴(Factory Method Pattern)은 객체를 생성하기 위해 인터페이스를 만듭니다. 어떤 클래스의 인스턴스를 만들지를 서브클래스에서 …

+ 자세한 내용은 여기를 클릭하십시오

Source: velog.io

Date Published: 1/9/2021

팩토리 메소드 패턴(Factory Method Pattern) – 개발하는만두

객체의 생성을 캡슐화 하는 패턴이다. 구체적인 객체의 생성 과정을 ‘팩토리’로 모듈화 하여 구체적인 부분이 아닌 추상적인 부분에 의존할 수 있도록 …

+ 여기를 클릭

Source: dev-youngjun.tistory.com

Date Published: 12/9/2022

팩토리 메소드 패턴과 추상 팩토리 패턴의 차이 알아보기

팩토리 패턴은 한 종류의 객체를 만들기 위해서 해당 객체를 생성하는 … 의 차이 알아보기 : Factory Method Pattern, Abstract Factory Pattern.

+ 여기에 표시

Source: kotlinworld.com

Date Published: 11/15/2022

팩토리 메소드 패턴(Factory Method Pattern) | ‍ Tech Interview

팩토리 메소드 패턴(Factory Method Pattern). 객체를 만드는 부분을 Sub 에 맡기는 패턴. Robot (추상 클래스) – TremendousRobot – EnergyRobot …

+ 자세한 내용은 여기를 클릭하십시오

Source: gyoogle.dev

Date Published: 6/20/2022

팩토리 메소드 패턴(Factory Method Pattern) :: JDM’s Blog

팩토리 메소드 패턴(Factory Method Pattern). Design Patterns│2015-07-22. We 확대 축소 목차 …

+ 여기에 더 보기

Source: jdm.kr

Date Published: 2/6/2022

Factory Method Pattern 팩토리 메소드 패턴 – 방구의 개발냄새

객체 지향을 공부하다보면 마주하는 팩토리 메소드란 정확인 무엇일까? SOILD 원칙을 잘 지키면서, 확장가능하고, 수정이 용이한 패턴,. 다형성, 상속, …

+ 더 읽기

Source: bangu4.tistory.com

Date Published: 6/22/2022

[디자인 패턴] 팩토리 메소드 패턴 – 밤둘레

팩토리 메소드 패턴이란? 객체를 생성하기 위한 인터페이스를 정의하고, 어떤 클래스의 인스턴스를 생성할지에 대한 처리는 서브클래스가 결정하는 …

+ 여기에 더 보기

Source: bamdule.tistory.com

Date Published: 1/16/2022

주제와 관련된 이미지 팩토리 메소드 패턴

주제와 관련된 더 많은 사진을 참조하십시오 디자인패턴, Factory Method Pattern, 팩토리 패턴. 댓글에서 더 많은 관련 이미지를 보거나 필요한 경우 더 많은 관련 기사를 볼 수 있습니다.

주제에 대한 기사 평가 팩토리 메소드 패턴

Author: 코드없는 프로그래밍
Views: 조회수 4,302회
Likes: 좋아요 75개
Date Published: 2021. 9. 22.
Video Url hyperlink: https://www.youtube.com/watch?v=ejXUhFKcbIU

팩토리 메서드 패턴

팩토리 메서드 패턴(Factory technique sample)은 객체지향 디자인 패턴이다. Factory method는 부모(상위) 클래스에 알려지지 않은 구체 클래스를 생성하는 패턴이며. 자식(하위) 클래스가 어떤 객체를 생성할지를 결정하도록 하는 패턴이기도 하다. 부모(상위) 클래스 코드에 구체 클래스 이름을 감추기 위한 방법으로도 사용한다.

Factory Method라는 패턴 이름이 적절하지 못한데, 이름으로 인해 객체를 생성하는 메소드를 Factory method라 오해하는 개발자가 많이 있다(Allen Holub의 말을 인용.) 이런 생성 메소드가 모두 Factory technique 패턴을 사용하는 것은 아니다. Template Method의 생성 패턴 버전으로 볼 수 있는데 Template Method를 알지 못한다면 그 패턴을 먼저 이해하는 것이 Factory Method를 이해하기 수월할 것이다.

Factory Method가 중첩되기 시작하면 굉장히 복잡해 질 수 있다. 또한 상속을 사용하지만 부모(상위) 클래스를 전혀 확장하지 않는다. 따라서 이 패턴은 extends 관계를 잘못 이용한 것으로 볼 수 있다. extends 관계를 남발하게 되면 프로그램의 엔트로피가 높아질 수 있으므로 Factory Method 패턴의 사용을 주의해야 한다.

예 [ 편집 ]
Pizza instance:

public summary class Pizza { public summary decimal GetPrice (); public enum PizzaSort { HamMushroom , Deluxe , Seafood } public static Pizza PizzaFactory ( PizzaSort pizzaType ) { swap ( pizzaType ) { case PizzaSort . HamMushroom : return new HamAndMushroomPizza (); case PizzaSort . Deluxe : return new DeluxePizza (); case PizzaSort . Seafood : return new SeafoodPizza (); } throw new System . NotSupportedException ( “The pizza type ” + pizzaType . ToString () + ” is not recognized.” ); } } public class HamAndMushroomPizza : Pizza { personal decimal worth = 8.5 M ; public override decimal GetPrice () { return worth ; } } public class DeluxePizza : Pizza { personal decimal worth = 10.5 M ; public override decimal GetPrice () { return worth ; } } public class SeafoodPizza : Pizza { personal decimal worth = 11.5 M ; public override decimal GetPrice () { return worth ; } } // Somewhere within the code … Console . WriteLine ( Pizza . PizzaFactory ( Pizza . PizzaSort . Seafood ). GetPrice (). ToString ( “C2” ) ); // $11.50 …

자바스크립트 [ 편집 ]
Pizza instance:

//Our pizzas operate HamAndMushroomPizza (){ var worth = 8.50 ; this . getPrice = operate (){ return worth ; } } operate DeluxePizza (){ var worth = 10.50 ; this . getPrice = operate (){ return worth ; } } operate SeafoodPizza (){ var worth = 11.50 ; this . getPrice = operate (){ return worth ; } } //Pizza Factory operate PizzaFactory (){ this . createPizza = operate ( sort ){ swap ( sort ){ case “Ham and Mushroom” : return new HamAndMushroomPizza (); case “DeluxePizza” : return new DeluxePizza (); case “Seafood Pizza” : return new SeafoodPizza (); default : return new DeluxePizza (); } } } //Usage var pizzaPrice = new PizzaFactory (). createPizza ( “Ham and Mushroom” ). getPrice (); alert ( pizzaPrice );

루비 [ 편집 ]
Pizza instance:

class HamAndMushroomPizza def worth 8 . 50 finish finish class DeluxePizza def worth 10 . 50 finish finish class SeafoodPizza def worth 11 . 50 finish finish class PizzaFactory def create_pizza ( fashion = ” ) case fashion when ‘Ham and Mushroom’ HamAndMushroomPizza . new when ‘DeluxePizza’ DeluxePizza . new when ‘Seafood Pizza’ SeafoodPizza . new else DeluxePizza . new finish finish finish # utilization manufacturing unit = PizzaFactory . new pizza = manufacturing unit . create_pizza ( ‘Ham and Mushroom’ ) pizza . worth #=> 8.5 # bonus formatting formatted_price = sprintf ( “$%.2f” , pizza . worth ) #=> “$8.50” # one liner sprintf ( “$%.2f” , PizzaFactory . new . create_pizza ( ‘Ham and Mushroom’ ) . worth ) #=> “$8.50”

파이썬 [ 편집 ]

[Design Pattern] 팩토리 메서드 패턴이란

Goal

팩토리 메서드 패턴의 개념을 이해한다.

예시를 통해 팩토리 메서드 패턴을 이해한다.

팩토리 메서드 패턴이란

객체 생성 처리를 서브 클래스로 분리 해 처리하도록 캡슐화하는 패턴 즉, 객체의 생성 코드를 별도의 클래스/메서드로 분리함으로써 객체 생성의 변화에 대비하는 데 유용하다. 특정 기능의 구현은 개별 클래스를 통해 제공되는 것이 바람직한 설계다. 기능의 변경이나 상황에 따른 기능의 선택은 해당 객체를 생성하는 코드의 변경을 초래한다. 상황에 따라 적절한 객체를 생성하는 코드는 자주 중복될 수 있다. 객체 생성 방식의 변화는 해당되는 모든 코드 부분을 변경해야 하는 문제가 발생한다. 스트래티지 패턴, 싱글턴 패턴, 템플릿 메서드 패턴을 사용한다. ‘생성(Creational) 패턴’의 하나 (아래 참고)

해 처리하도록 캡슐화하는 패턴

역할이 수행하는 작업 Product 팩토리 메서드로 생성될 객체의 공통 인터페이스 ConcreteProduct 구체적으로 객체가 생성되는 클래스 Creator 팩토리 메서드를 갖는 클래스 ConcreteCreator 팩토리 메서드를 구현하는 클래스로 ConcreteProduct 객체를 생성

팩토리 메서드 패턴의 개념과 적용 방법 객체 생성을 전담하는 별도의 Factory 클래스 이용 스트래티지 패턴과 싱글턴 패턴을 이용한다. 해당 Post에서는 이 방법을 기준으로 팩토리 메서드 패턴을 적용한다. 상속 이용 : 하위 클래스에서 적합한 클래스의 객체를 생성 스트래티지 패턴, 싱글턴 패턴과 템플릿 메서드 패턴을 이용한다. 해당 Post의 맨 하단에 ‘다른 방법으로 팩토리 메서드 패턴 적용하기’를 확인한다.

참고

생성(Creational) 패턴 객체 생성에 관련된 패턴 객체의 생성과 조합을 캡슐화해 특정 객체가 생성되거나 변경되어도 프로그램 구조에 영향을 크게 받지 않도록 유연성을 제공한다.

예시

여러 가지 방식의 엘리베이터 스케줄링 방법 지원하기

작업 처리량(Throughput)을 기준으로 한 스케줄링에 따른 엘리베이터 관리

스케줄링 : 주어진 요청(목적지 충과 방향)을 받았을 때 여러 대의 엘리베이터 중 하나를 선택하는 것을 말한다. 예를 들어 엘리베이터 내부에서 버튼(ElevatorButton)을 눌렀을 때는 해당 사용자가 탄 엘리베이터를 이동시킨다. 그러나 사용자가 엘리베이터 외부, 즉 건물 내부의 층에서 버튼(FloorButton)을 누른 경우에는 여러 대의 엘리베이터 중 하나를 선택해 이동시켜야 한다.

: 주어진 요청(목적지 충과 방향)을 받았을 때 여러 대의 엘리베이터 중 하나를 선택하는 것을 말한다.

public class ElevatorSupervisor { personal List controllers; personal ThroughputScheduler scheduler; // 주어진 수만큼의 ElevatorController를 생성함 public ElevatorSupervisor(int controllerCount) { // 엘리베이터의 이동을 책임지는 ElevatorController 객체 생성 controllers = new ArrayList(controllerCount); for (int i=0; i ” + curFloor); } }

/* 엘리베이터 작업 처리량을 최대화시키는 전략의 클래스 */ public class ThroughputScheduler { public int chooseElevator(ElevatorSupervisor supervisor, int vacation spot, Direction route) { return 0; // 임의로 선택함 } }

ElevatorSupervisor 클래스 이동 요청을 처리하는 클래스 엘리베이터를 스케줄링(엘리베이터 선택)하기 위한 ThroughputScheduler 객체를 갖는다. 각 엘리베이터의 이동을 책임지는 ElevatorController 객체를 복수 개 갖는다.

requestElevator() 메서드 요청(목적지 층, 방향)을 받았을 때 우선 ThroughputScheduler 클래스의 chooseElevator() 메서드를 호출해 적정한 엘리베이터를 선택한다. 선택된 엘리베이터에 해당하는 ElevatorController 객체의 gotoFloor() 메서드를 호출해 엘리베이터를 이동시킨다.

문제점 1

다른 스케줄링 전략 을 사용하는 경우 엘리베이터 작업 처리량을 최대화(ThroughputScheduler 클래스)시키는 전략이 아닌 사용자의 대기 시간을 최소화하는 엘리베이터 선택 전략을 사용해야 한다면? 프로그램 실행 중에 스케줄링 전략을 변경, 즉 동적 스케줄링을 지원 해야하는 경우 오전에는 대기 시간 최소화 전략을 사용하고, 오후에는 처리량 최대화 전략을 사용해야 한다면?

문제점 1 해결 방법 public class ElevatorSupervisor { personal List controllers; // 주어진 수만큼의 ElevatorController를 생성함 public ElevatorSupervisor(int controllerCount) { // 엘리베이터의 이동을 책임지는 ElevatorController 객체 생성 controllers = new ArrayList(controllerCount); for (int i=0; i 두 전략의 사용 시간을 서로 바꾸는 경우

해결책

과정 1

주어진 기능을 실제로 제공하는 적절한 클래스 생성 작업을 별도의 클래스/메서드로 분리시켜야 한다.

엘리베이터 스케줄링 전략에 일치하는 클래스를 생성하는 코드를 requestElevator 메서드에서 분리해 별도의 클래스/메서드를 정의한다. 변경 전: ElevatorSupervisor 클래스가 직접 ThroughputScheduler 객체와 ResponseTimeScheduler 객체를 생성 변경 후: SchedulerFactory 클래스의 getScheduler() 메서드가 스케줄링 전략에 맞는 객체를 생성

public enum SchedulingStrategyID { RESPONSE_TIME , THROUGHPUT , DYNAMIC }

public class SchedulerFactory { // 스케줄링 전략에 맞는 객체를 생성 public static ElevatorScheduler getScheduler ( SchedulingStrategyID strategyID ) { swap ( strategyID ) { case RESPONSE_TIME: // 대기 시간 최소화 전략 scheduler = new ResponseTimeScheduler (); break ; case THROUGHPUT: // 처리량 최대화 전략 scheduler = new ThroughputScheduler (); break ; case DYNAMIC: // 동적 스케줄링 // 0..23 int hour = Calendar . getInstance (). get ( Calendar . HOUR_OF_DAY ); // 오전: 대기 시간 최소화, 오후: 처리량 최대화 if ( hour < 12 ) scheduler = new ResponseTimeScheduler (); else scheduler = new ThroughputScheduler (); break ; } return scheduler ; } } 이제 ElevatorSupervisor 클래스의 requestElevator() 메서드에서는 SchedulerFactory 클래스의 getScheduler 메서드를 호출하면 된다. public class ElevatorSupervisor { personal List controllers; personal SchedulingStrategyID strategyID; // 주어진 수만큼의 ElevatorController를 생성함 public ElevatorSupervisor(int controllerCount, SchedulingStrategyID strategyID) { // 엘리베이터의 이동을 책임지는 ElevatorController 객체 생성 controllers = new ArrayList(controllerCount); for (int i=0; i 10 ThroughputScheduler @ 500 c05c2 Elevator [ 1 ] Floor: 1 ==> 10 ThroughputScheduler @ 5 e6a1140 Elevator [ 1 ] Floor: 1 ==> 10

Client 클래스에서는 총 3개의 ElevatorSupervisor 객체를 사용하는데, 세 객체 모두 10층으로 이동 요청을 하지만 서로 다른 엘리베이터가 선택될 수 있다.

과정 2

동적 스케줄링 방식(DynamicScheduler)이라고 하면 여러 번 스케줄링 객체를 생성하지 않고 한 번 생성한 것을 계속해서 사용하는 것이 바람직할 수 있다.

싱글턴 패턴 을 활용한 엘리베이터 스케줄링 전략을 설계 스케줄링 기능을 제공하는 ResponseTimeScheduler 클래스와 ThroughputScheduler 클래스는 오직 하나의 객체만 생성해서 사용하도록 한다. 즉, 생성자를 통해 직접 객체를 생성하는 것이 허용되지 않아야 한다. 이를 위해 각 생성자를 private으로 정의한다. 대신 getInstance() 라는 정적 메서드로 객체 생성을 구현한다.

을 활용한 엘리베이터 스케줄링 전략을 설계

public class SchedulerFactory { // 스케줄링 전략에 맞는 객체를 생성 public static ElevatorScheduler getScheduler ( SchedulingStrategyID strategyID ) { ElevatorScheduler scheduler = null ; // 각 전략에 의해 할당됨 swap ( strategyID ) { case RESPONSE_TIME: // 대기 시간 최소화 전략 scheduler = ResponseTimeScheduler . getInstance (); break ; case THROUGHPUT: // 처리량 최대화 전략 scheduler = ThroughputScheduler . getInstance (); break ; case DYNAMIC: // 동적 스케줄링 // 0..23 int hour = Calendar . getInstance (). get ( Calendar . HOUR_OF_DAY ); // 오전: 대기 시간 최소화, 오후: 처리량 최대화 if ( hour < 12 ) scheduler = ResponseTimeScheduler . getInstance (); else scheduler = ThroughputScheduler . getInstance (); break ; } return scheduler ; } } /* 싱글턴 패턴으로 구현한 ThroughputScheduler 클래스 */ public class ThroughputScheduler { private static ElevatorScheduler scheduler ; // 생성자를 private으로 정의 private ThroughputScheduler () {} // 정적 메서드로 객체 생성을 구현 (싱글턴 패턴) public static ElevatorScheduler getInstance () { if ( scheduler == null ) scheduler = new ThroughputScheduler (); return scheduler ; } public int selectElevator ( ElevatorManager manager , int destination , Direction direction ) { return 0 ; // 임의로 선택함 } } /* 싱글턴 패턴으로 구현한 ResponseTimeScheduler 클래스 */ public class ResponseTimeScheduler { private static ElevatorScheduler scheduler ; // 생성자를 private으로 정의 private ResponseTimeScheduler () {} // 정적 메서드로 객체 생성을 구현 (싱글턴 패턴) public static ElevatorScheduler getInstance () { if ( scheduler == null ) scheduler = new ResponseTimeScheduler (); return scheduler ; } public int selectElevator ( ElevatorManager manager , int destination , Direction direction ) { return 1 ; // 임의로 선택함 } } 출력 결과 ResponseTimeScheduler @ 5878 ae82 Elevator [ 2 ] Floor: 1 ==> 10 ThroughputScheduler @ 5552 bb15 // 동일 객체 Elevator [ 1 ] Floor: 1 ==> 10 ThroughputScheduler @ 5552 bb15 // 동일 객체 Elevator [ 1 ] Floor: 1 ==> 10

이제 단 1개의 ThroughputScheduler와 ResponseTimeScheduler 객체를 사용할 수 있다.

다음과 같이 객체 생성을 전담하는 별도의 Factory 클래스 를 분리하여 객체 생성의 변화에 대비할 수 있다. 이 방법은 스트래티지 패턴과 싱글턴 패턴을 이용하여 팩토리 메서드 패턴을 적용한다.

다른 방법으로 팩토리 메서드 패턴 적용하기

Factory 클래스 이용 SchedulerFactory 클래스에서 3가지 방식(최대 처리량, 최소 대기 시간, 동적 선택)에 맞춰 ThroughputScheduler 객체나 ResponseTimeScheduler 객체를 생성 상속 이용 해당 스케줄링 전략에 따라 엘리베이터를 선택하는 클래스를 ElevatorSupervisor 클래스의 하위 클래스로 정의

상속을 이용

하위 클래스에서 적합한 클래스의 객체를 생성하여 객체의 생성 코드를 분리한다.

이 방법은 스트래티지 패턴, 싱글턴 패턴, 템플릿 메서드 패턴을 이용하여 팩토리 메서드 패턴을 적용한다.

/* 템플릿 메서드를 정의하는 클래스: 하위 클래스에서 구현될 기능을 primitive 메서드로 정의 */ public summary class ElevatorSupervisor { personal List < ElevatorController > controllers ; // 주어진 수만큼의 ElevatorController를 생성함 public ElevatorSupervisor ( int controllerCount ) { // 엘리베이터의 이동을 책임지는 ElevatorController 객체 생성 controllers = new ArrayList < ElevatorController >( controllerCount ); for ( int i = 0 ; i < controllerCount ; i ++) { ElevatorController controller = new ElevatorController ( i + 1 ); controllers . add ( controller ); } } // 팩토리 메서드: 스케줄링 전략 객체를 생성하는 기능 제공 protected summary ElevatorScheduler getScheduler (); // 템플릿 메서드: 요청에 따라 엘리베이터를 선택하고 이동시킴 void requestElevator ( int vacation spot , Direction route ) { // 하위 클래스에서 오버라이드된 getScheduler() 메서드를 호출함 (변경) ElevatorScheduler scheduler = getScheduler (); // primitive 또는 hook 메서드 System . out . println ( scheduler ); // 주어진 전략에 따라 엘리베이터를 선택함 int chosenElevator = scheduler . chooseElevator ( this , vacation spot , route ); // 선택된 엘리베이터를 이동시킴 controllers . get ( chooseElevator ). gotoFloor ( vacation spot ); } } /* 처리량 최대화 전략 하위 클래스 */ public class ElevatorManagerWithThroughputScheduling extends ElevatorSupervisor { public ElevatorManagerWithThroughputScheduling ( int controllerCount ) { tremendous ( controllerCount ); // 상위 클래스 생성자 호출 } // primitive 또는 hook 메서드 @Override protected ElevatorScheduler getScheduler () { ElevatorScheduler scheduler = ThroughputScheduler . getInstance (); return scheduler ; } } /* 대기 시간 최소화 전략 하위 클래스 */ public class ElevatorManagerWithResponseTimeScheduling extends ElevatorSupervisor { public ElevatorManagerWithResponseTimeScheduling ( int controllerCount ) { tremendous ( controllerCount ); // 상위 클래스 생성자 호출 } // primitive 또는 hook 메서드 @Override protected ElevatorScheduler getScheduler () { ElevatorScheduler scheduler = ResponseTimeScheduler . getInstance (); return scheduler ; } } /* 동적 스케줄링 전략 하위 클래스 */ public class ElevatorManagerWithDynamicScheduling extends ElevatorSupervisor { public ElevatorManagerWithDynamicScheduling ( int controllerCount ) { tremendous ( controllerCount ); // 상위 클래스 생성자 호출 } // primitive 또는 hook 메서드 @Override protected ElevatorScheduler getScheduler () { ElevatorScheduler scheduler = null ; // 0..23 int hour = Calendar . getInstance (). get ( Calendar . HOUR_OF_DAY ); // 오전: 대기 시간 최소화, 오후: 처리량 최대화 if ( hour < 12 ) scheduler = ResponseTimeScheduler . getInstance (); else scheduler = ThroughputScheduler . getInstance (); return scheduler ; } } 팩토리 메서드 ElevatorSupervisor 클래스의 getScheduler() 메서드 스케줄링 전략 객체를 생성하는 기능 제공 (즉, 객체 생성을 분리) 참고) 템플릿 메서드 패턴의 개념에 따르면, 하위 클래스에서 오버라이드될 필요가 있는 메서드는 primitive 또는 hook 메서드라고도 부른다. 템플릿 메서드 ElevatorSupervisor 클래스의 requestElevator() 메서드 공통 기능(스케줄링 전략 객체 생성, 엘리베이터 선택, 엘리베이터 이동)의 일반 로직 제공 하위 클래스에서 구체적으로 정의할 필요가 있는 ‘스케줄링 전략 객체 생성’ 부분은 하위 클래스에서 오버라이드 참고) 템플릿 메서드 패턴을 이용하면 전체적으로는 동일하면서 부분적으로는 다른 구문으로 구성된 메서드의 코드 중복을 최소화시킬 수 있다. 즉, 팩토리 메서드를 호출하는 상위 클래스의 메서드는 템플릿 메서드가 된다. 상속을 이용한 팩토리 메서드 패턴 적용 “Product” : ElevatorScheduler 인터페이스 “ConcreteProduct” : ThroughputScheduler 클래스와 ResponseTimeScheduler 클래스 “Creator” : ElevatorSupervisor 클래스 “ConcreteCreator” : ElevatorManagerWithThroughputScheduling 클래스, ElevatorManagerWithResponseTimeScheduling 클래스, ElevatorManagerWithDynamicScheduling 클래스 관련된 Post References

팩토리 메소드 패턴 (Factory Method Pattern)

헤드 퍼스트 디자인 패턴을 읽고 정리한 글입니다.

팩토리 메소드 패턴(Factory Method Pattern)은 객체를 생성하기 위해 인터페이스를 만듭니다. 어떤 클래스의 인스턴스를 만들지를 서브클래스에서 결정하도록 합니다. 팩토리 메소드를 이용하면 인스턴스를 만드는 일을 서브클래스로 미룰 수 있습니다.

https://ko.wikipedia.org/wiki/%ED%8C%A9%ED%86%A0%EB%A6%AC%EB%A9%94%EC%84%9C%EB%93%9C%ED%8C%A8%ED%84%B4

예제 코드

다음은 피자를 주문하는 예제입니다.

먼저 Creator 클래스인 PizzaStore를 만든다. 이 클래스는 createPizza라는 팩토리 메소드를 실행해서 pizza를 생성한다.

public summary class PizzaRetailer { public Pizza orderPizza ( String sort ) { Pizza pizza = createPizza ( sort ) ; pizza . put together ( ) ; pizza . bake ( ) ; pizza . field ( ) ; return pizza ; } summary Pizza createPizza ( String sort ) ; }

PizzaStore를 확장해 각 지점을 만들고 지점마다 피자를 만드는 것을 책임지도록 createPizza 팩토리 메소드를 오버라이딩한다.

public class NYPizzaRetailer extends PizzaRetailer { @Override Pizza createPizza ( String merchandise ) { if ( “cheese” . equals ( merchandise ) ) { return new NYStyleCheesePizza ( ) ; } else if ( “veggie” . equals ( merchandise ) ) { return new NYStyleVeggiePizza ( ) ; } else if ( “clam” . equals ( merchandise ) ) { return new NYStyleClamPizza ( ) ; } else { return null ; } } }

public class ChicagoPizzaRetailer extends PizzaRetailer { @Override Pizza createPizza ( String merchandise ) { if ( “cheese” . equals ( merchandise ) ) { return new ChicagoStyleCheesePizza ( ) ; } else if ( “veggie” . equals ( merchandise ) ) { return new ChicagoStyleVeggiePizza ( ) ; } else if ( “clam” . equals ( merchandise ) ) { return new ChicagoStyleClamPizza ( ) ; } else { return null ; } } }

Product 클래스인 Pizza 를 만들고 이 클래스를 확장해 구상 클래스를 만들어보자.

public summary class Pizza { String identify ; String dough ; String sauce ; void put together ( ) { System . out . println ( “preparing~~ ” + identify ) ; } void bake ( ) { System . out . println ( “baking~~” ) ; } void field ( ) { System . out . println ( “boxing~~” ) ; } public String getName ( ) { return identify ; } }

Product 클래스인 Pizze 를 확장해 3가지 시카고 스타일 피자를 만들었다. (뉴욕 스타일 피자 코드는 생략하였다)

public class ChicagoStyleCheesePizza extends Pizza { public ChicagoStyleCheesePizza ( ) { identify = “ChicagoStyleCheesePizza” ; } }

public class ChicagoStyleClamPizza extends Pizza { public ChicagoStyleClamPizza ( ) { identify = “ChicagoStyleClamPizza” ; } }

public class ChicagoStyleVeggiePizza extends Pizza { public ChicagoStyleVeggiePizza ( ) { identify = “ChicagoStyleVeggiePizza” ; } }

이제 fundamental 메소드에서 예제를 실행해보자.

PizzaRetailer nyStore = new NYPizzaRetailer ( ) ; PizzaRetailer chicagoStore = new ChicagoPizzaRetailer ( ) ; Pizza nyCheesePizza = nyStore . orderPizza ( “cheese” ) ; Pizza nyClamPizza = nyStore . orderPizza ( “clam” ) ; Pizza chicagoCheesePizza = chicagoStore . orderPizza ( “cheese” ) ; Pizza chicagoClamPizza = chicagoStore . orderPizza ( “clam” ) ;

getting ready~~ NYStyleCheesePizza baking~~ boxing~~ getting ready~~ NYStyleClamPizza baking~~ boxing~~ getting ready~~ ChicagoStyleCheesePizza baking~~ boxing~~ getting ready~~ ChicagoStyleClamPizza baking~~ boxing~~

지점과 주어진 타입(cheeze, clam)에 따라 다른 피자를 만드는 걸 볼 수 있다.

팩토리 메소드 패턴(Factory Method Pattern)

1. 팩토리 메소드 패턴이란?

다양한 구현체 (Product)가 있고, 그 중에서 특정한 구현체를 만들 수 있는 다양한 팩토리(Creator)를 제공할 수 있다.

1-1. 정의(Definition)

1-1-1. 팩토리 패턴?

객체의 생성을 캡슐화 하는 패턴이다.

구체적인 객체의 생성 과정을 ‘팩토리’로 모듈화 하여 구체적인 부분이 아닌 추상적인 부분에 의존할 수 있도록 한다.

팩토리 패턴에는 팩토리 메소드 패턴과 추상 팩토리 패턴이 있다.

Pattern 공통점 차이점 팩토리 메소드 패턴 객체의 생성부를 캡슐화하여 결합을 느슨하게 함

구체적인 타입에 의존하지 않도록 함

상속 을 통해 서브 클래스에서 팩토리 메소드를 오버라이딩 하여 객체의 생성부를 구현 추상 팩토리 패턴 객체의 집합을 생성하기 위한 정의를 추상체에 위치시키고 하위의 구현체에서 세부적인 집합 생성 과정을 구현

(Fatory Method를 이용해 구현)

먼저 팩토리 메소드 패턴을 살펴보자.

1-1-2. 팩토리 메소드 패턴?

부모(상위) 클래스에 알려지지 않은 구체 클래스를 생성하는 패턴이며. 자식(하위) 클래스가 어떤 객체를 생성할지를 결정하도록 하는 패턴이기도 하다.

출처 : 인프런 백기선님 강의

1-2. 사용 이유

객체를 생성하기 위해 인터페이스를 정의하지만, 어떤 클래스의 인스턴스를 생성할지에 대한 결정은 서브클래스에서 이루어지도록 하여 재정의 가능한 것으로 설계 하지만, 복잡해지지 않게 한다.

생성할 객체 타입을 예측할 수 없을 때

생성할 객체를 기술하는 책임을 서브클래스에게 정의 하고자 할 때

하고자 할 때 객체 생성의 책임을 서브클래스에 위임시키고 서브클래스에 대한 정보를 은닉하고자 할 때

1-3. 장점과 단점

1-3-1. 장점

기존 코드(인스턴스를 만드는 과정)를 수정하지 않고 새로운 인스턴스를 다른 방법으로 생성하도록 확장 할 수 있다. Product 와 Creator 간의 커플링(결합)이 느슨함 확장에 열려있고 변경에 닫혀있는 객체지향 원칙 을 적용했기 때문에 가능 확장 : 새로운 인스턴스 추가 변경 : 기존 코드를 수정

새로운 인스턴스를 다른 방법으로 할 수 있다. 코드가 간결 해진다.

해진다. 병렬적 클래스 계층도를 연결하는 역할을 담당할 수 있음

✍🏻 팩토리 메소드 패턴을 적용할 때 참고

1. 자바 8의 인터페이스 default 메소드

– 인터페이스에 추상 메소드가 아닌 default 메소드를 통해 기능을 구현할 수 있게 되어서 상속받는 서브클래스의 중복코드를 제거할 수 있다.

2. 자바 9의 인터페이스의 personal 메소드

– 기능 구현이 가능해지면서 인터페이스의 내부 로직을 personal 메소드로 구현하면 읽기 좋은 코드로 작성할 수 있게 된다.

1-3-2. 단점

클래스가 많아진다. (클래스 계층도 커질 수 있다.) 제품 클래스가 바뀔 때마다 새로운 서브클래스를 생성해야 한다.

클라이언트가 creator 클래스를 반드시 상속해 Product를 생성해야 한다.

1-4. 실제 적용 예시

실제 자바코드에 어떻게 적용되어있는지 예시를 살펴보자.

1-4-1. 단순한 팩토리 패턴

매개변수의 값에 따라 또는 메소드에 따라 각기 다른 인스턴스를 리턴하는 단순한 버전 의 팩토리 패턴

java.util.Calendar#getInstance()

public class CalendarExample { public static void fundamental(String[] args) { log.information(“Calendar 예시 : {}”, Calendar.getInstance()); } }

getInstance() 를 호출할 때마다 새로운 Calendar 객체가 생성된다.

를 호출할 때마다 새로운 Calendar 객체가 생성된다. Calendar는 Gregorian형식(우리가 현재 쓰는), Julian 형식이 있는데, 이 두가지 경우를 모두 커버하기 위해 팩토리 메소드 패턴으로 디자인 되었다.

싱글톤(singletone)패턴에서 사용되는 이름 같은데, naming이 약간 잘못 지어진 것 같다.

java.textual content.NumberFormat#getInstance()

BeanFactory xmlFactory = new ClassPathXmlApplicationContext(“config.xml”); String whats up = xmlFactory.getBean(“hello”, String.class); BeanFactory javaFactory = new AnnotationConfigApplicationContext(Config.class); String hello = javaFactory.getBean(“hi”, String.class);

국가에 따라 또는 화폐에 따라 다른 표현 방식을 커버하기 위해 팩토리 메소드 패턴으로 디자인 되었다.

NumberFormat을 구현하는 클래스는 DecimalFormat, ExponentialFormat 등이 있다.

1-4-2. 스프링 BeanFactory

Object 타입의 Product를 만드는 BeanFacotry라는 Creator

BeanFactory manufacturing unit = new XmlBeanFactory( new InputStreamResource( new FileInputStream(“oraclejavacommunity.xml”))); OracleJavaComm ojc = (OracleJavaComm)manufacturing unit.getBean(“oracleJavaBean”);

xml 설정과 java 설정으로 읽어오는 방식이다.

Product에 해당하는 것은 Object

ConcreteProduct에 해당하는 것은 xml 또는 class Bean

1-5. 결론

팩토리 메소드 패턴을 사용하는 이유는 클래스간의 결합도를 낮추기 위한 것 같다.

결합도라는 것은 간단히 말해 클래스의 변경할 부분이 생겼을 때 얼마나 다른 클래스에도 영향을 주는가 이다. 팩토리 메소드 패턴을 사용하는 경우 직접 객체를 생성해 사용하는 것을 방지 하고 서브 클래스에 위임 함으로써 보다 효율적인 코드 제어를 할 수 있고 의존성을 제거한다. 결과적으로 결합도 또한 낮출 수 있다.

Reference

팩토리 메소드 패턴과 추상 팩토리 패턴의 차이 알아보기 : Factory Method Pattern, Abstract Factory Pattern

반응형

팩토리 패턴은 무엇인가?

팩토리 패턴은 한 종류의 객체를 만들기 위해서 해당 객체를 생성하는 팩토리 interface를 구현해서 만드는 것이다.

예를 들어 Item을 만드는 Factory 인터페이스가 있다고 해보자.

interface Factory { enjoyable createItem() : Item }

위 Factory를 CellphoneFactory와 PillFactory로 구현하면 해당 Factory에서는 Item을 팩토리 종류에 따라 다르게 생성한다.

class CellphoneFactory : Factory { override enjoyable createItem(): Item { return .. } }

class PillFactory : Factory { override enjoyable createItem(): Item { return .. } }

추상 팩토리 패턴은 팩토리 패턴과 무엇이 다른가?

팩토리 패턴은 한 종류의 객체를 생성하기 위해 사용되지만, 추상 팩토리 패턴은 연관되거나 의존적인 객체로 이루어진 여러 종류의 객체를 생성하기 위해 사용된다.

또한 팩토리 패턴은 팩토리 인터페이스를 구현하여 그 자체가 하나의 객체를 생성하는데 사용되지만, 추상 팩토리 패턴은 팩토리 객체가 아닌 다른 객체 내부에 구현되어 해당 객체에서 여러 타입의 객체를 생성하기 위해 사용된다.

추상 팩토리 패턴 알아보기

예를 들어 식당에서 음식을 생성하는 FoodAbstractFactory가 있다고 해보자.

interface FoodAbstractFactory { enjoyable createSauce() : Sauce enjoyable createSalad() : Salad enjoyable createStake() : Stake }

이 식당에서는 요리사(Chef)들이 Food들을 생성하므로 FoodAbstractFactory는 다음과 같이 구현될 수 있다.

class ChefAFoodFactory() : FoodAbstractFactory { override enjoyable createSauce(): Sauce { } override enjoyable createSalad(): Salad { } override enjoyable createStake(): Stake { } }

이제 이 ChefAFoodFactory는 음식점(Restaurant)에 변수로 들어가서 주문(order)가 들어오면 해당 값을 생성하는 역할을 한다.

class Restaurant() { val chefA: FoodAbstractFactory = ChefAFoodFactory() val order(meals : Food) { when(meals) { is Sauce -> { chefA.createSauce() } is Salad -> { chefA.createSalad() } is Stake -> { chefA.createStake() } } } }

만약 요리사(Chef)가 ChefA에서 ChefB로 바뀐다고 하면 다음과 같이 FoodAbstractFactory의 구현체만 바꿔주면 된다.

class Restaurant() { personal val chefB: FoodAbstractFactory = ChefBFoodFactory() val order(meals : Food) { when(meals) { is Sauce -> { chefB.createSauce() } is Salad -> { chefB.createSalad() } is Stake -> { chefB.createStake() } } } }

이렇게 Concrete Class의 구현에 의존하지 않고도 서로 연관된 객체로 이루어진 제품군을 생성하는 인터페이스를 구현해 다른 객체 안에 넣어 사용하는 것을 추상 팩토리 패턴이라고 한다.

정리

팩토리 패턴은 그 자체로 하나의 객체를 생성하는 역할을 해서 그 자체가 객체를 생성하는데 사용된다. 하지만 이렇게 객체를 생성할 경우 타입이 다른 다양한 객체를 생성해야 할 경우에 문제가 생기게 되는데, 이를 해결하기 위한 것이 바로 추상 팩토리 패턴이다.

추상 팩토리 패턴은 다양한 요구사항을 interface내부에 메서드로 선언하여 interface를 구현하는 클래스에서 요구사항들을 처리하도록 한다. 또한 그 자체로 사용되는 것이 아닌 다른 객체 내부에서 선언되거나 주입되어 사용된다.

반응형

팩토리 메소드 패턴(Factory Method Pattern)

즉 Robot이라는 클래스를 RobotFactory에서 생성함.

public class TremendousRobotFactory extends RobotFactory { @Override Robot createRobot ( String identify ) { swap ( identify ) { case “super” : return new TremendousRobot ( ) ; case “power” : return new EnergyRobot ( ) ; } return null ; } }

팩토리 메소드 패턴(Factory Method Pattern) :: JDM’s Blog

이번 포스팅은 팩토리 메소드 패턴Factory Method Pattern에 대해 알아보고자 합니다.

Factory Method Pattern

기본적으로 팩토리는 공장이란 뜻을 내포하고 있습니다. 따라서 팩토리 메소드 패턴도 무언가를 위한 공장이라고 보면 됩니다. 일반적으로 팩토리 메소드 패턴은 다음처럼 말할 수 있습니다.

객체를 만들어내는 부분을 서브 클래스Sub-Class에 위임하는 패턴.

즉, new 키워드를 호출하는 부분을 서브 클래스에 위임하는 겁니다. 결국 팩토리 메소드 패턴은 객체를 만들어내는 공장(Factory 객체)을 만드는 패턴이라 이해하면 됩니다.

Example

사실 위의 정의만으로는 알 수 없기 때문에 예제를 진행하고자 합니다. 예제로 쓸 소재는 “로봇”입니다. 여러 종류의 로봇을 생상하는 “공장”도 있어야 할 것입니다. 따라서 로봇과 로봇공장을 만들어서 예제를 돌려봅니다. 예제 코드의 패키지명은 sample.factory입니다. 혹시라도 코드를 그대로 사용하신다면 주의하시기 바랍니다.

Structure

실제로 예제 코드를 작성하기 전에 간략히 구조를 살펴봅니다.

Robot(summary class) ┗ TremendousRobot ┗ EnergyRobot RobotFactory(summary class) ┗ TremendousRobotFactory ┗ ModifiedSuperRobotFactory

두종류의 로봇(TremendousRobot, EnergyRobot)과 두종류의 로봇공장(TremendousRobotFactory, ModifiedSuperRobotFactory)을 만들 예정입니다. 이제부터는 실제 코드를 봅시다.

Robot

로봇 클래스는 다음처럼 작성했습니다. 각각 차례대로 Robot, TremendousRobot, EnergyRobot입니다. 여기서 설명드릴건 딱히 없습니다. 한가지 있다면 추후 클래스의 구별을 위해 개별적으로 이름(identify)을 반환하는 메소드가 작성되어 있습니다.

bundle sample.manufacturing unit; public summary class Robot { public summary String getName(); }

bundle sample.manufacturing unit; public class TremendousRobot extends Robot { @Override public String getName() { return “SuperRobot”; } }

bundle sample.manufacturing unit; public class EnergyRobot extends Robot { @Override public String getName() { return “PowerRobot”; } }

RobotFactory

팩토리 메소드 패턴의 꽃은 역시 팩토리 클래스입니다. 차례대로 봅시다. 첫번째 보이는 코드는 기본 팩토리 클래스입니다.

bundle sample.manufacturing unit; public summary class RobotFactory { summary Robot createRobot(String identify); }

아래 클래스는 기본 팩토리 클래스를 상속 받아 실제 로직을 구현한 팩토리입니다.

bundle sample.manufacturing unit; public class TremendousRobotFactory extends RobotFactory { @Override Robot createRobot(String identify) { swap( identify ){ case “super”: return new TremendousRobot(); case “power”: return new EnergyRobot(); } return null; } }

아래 클래스는 TremendousRobotFactory 클래스와 비슷하지만 내부 구현이 조금 다릅니다. 로봇 클래스의 이름을 String 인자로 받아서 직접 인스턴스를 만들어 냅니다.

bundle sample.manufacturing unit; public class ModifiedSuperRobotFactory extends RobotFactory { @Override Robot createRobot(String identify) { attempt { Class cls = Class.forName(identify); Object obj = cls.newInstance(); return (Robot)obj; } catch (Exception e) { return null; } } }

Test Code

준비가 다 되었다면 메인 프로그램을 작성해서 돌려봅시다.

bundle sample.manufacturing unit; public class FactoryMost important { public static void fundamental(String[] args) { RobotFactory rf = new TremendousRobotFactory(); Robot r = rf.createRobot(“super”); Robot r2 = rf.createRobot(“power”); System.out.println(r.getName()); System.out.println(r2.getName()); RobotFactory mrf = new ModifiedSuperRobotFactory(); Robot r3 = mrf.createRobot(“pattern.factory.SuperRobot”); Robot r4 = mrf.createRobot(“pattern.factory.PowerRobot”); System.out.println(r3.getName()); System.out.println(r4.getName()); } }

TremendousRobot EnergyRobot TremendousRobot EnergyRobot

메인 프로그램에서 new 키워드가 없다는 것을 확인 할 수 있습니다. 객체 생성을 팩토리 클래스에 위임한 결과 입니다. 또한 메인 프로그램은 어떤 객체가 생성 되었는지 신경 쓰지 않고 단지 반환된 객체를 사용만 하면 됩니다. 또한 새로운 로봇이 추가 되고 새로운 팩토리가 추가 된다 하더라도 메인 프로그램에서 변경할 코드는 최소화됩니다.

Summary

팩토리 메소드 패턴을 사용하는 이유는 클래스간의 결합도를 낮추기 위한것입니다. 결합도라는 것은 간단히 말해 클래스의 변경점이 생겼을 때 얼마나 다른 클래스에도 영향을 주는가입니다. 팩토리 메소드 패턴을 사용하는 경우 직접 객체를 생성해 사용하는 것을 방지하고 서브 클래스에 위임함으로써 보다 효율적인 코드 제어를 할 수 있고 의존성을 제거합니다. 결과적으로 결합도 또한 낮출 수 있습니다.

Closing Remarks

팩토리 메소드 패턴에 대해 알아봤습니다. 혹시라도 이슈 될만한 내용이 있다면 코멘트 부탁드립니다. 😀

Factory Method Pattern 팩토리 메소드 패턴

GoF 디자인 패턴

소프트웨어 개발시 OOP에 많이 사용되는 디자인 패턴이 존재한다.

https://www.hanbit.co.kr/channel/category/category_view.html?cms_code=CMS8616098823

그 중에서 반드시 알아야할 팩토리 메소드 패턴에 대해서 정리해보자.

객체 지향을 공부하다보면 마주하는 팩토리 메소드란 정확인 무엇일까?

SOILD 원칙을 잘 지키면서, 확장가능하고, 수정이 용이한 패턴,

다형성, 상속, 추상화, 캡슐화를 모두 담고있는 패턴이다.

좋은 객체지향코드를 위한 SOILD 원칙

1. SRP : 단일책임 원칙대로, 한 클래스는 하나의 책임만 지녀야 한다. (변경시 해당부분만 변경되도록)

2. OCP : 개방-폐쇄 원칙대로, 확장은 열려있고, 변경은 닫혀있어야 한다 (추가시 기존에 영향이 가지않게 추가되도록)

3. LSP : 리스코프 원칙대로, 객체는 하위타입 인스턴스로 바꿀 수 있어야 한다.

4. ISP : 인터페이스 분리원칙대로, 역할과 구현을 분리해야한다.

5. DIP : 의존관계 역전원칙대로, 구현체가 아닌 추상체 타입에 의존해야한다

Factory란?

Factory란 문자적으로 공장 (블랙박스), 무언가(객체)를 생산 해낸다는 뜻.

분리된 생성자를 가지는 부분을 팩터리 라 하며, (SRP, ISP)

다양한 객체를 수정없이 추가 구현할 수 있게 하는 것. (OCP)

인스턴스화 로직을 클라이언트로부터 숨기면서 (캡슐화, 정보은닉)

추상 객체(ISP, DIP)를 참조하는것을 의미한다.

Factory (Method) Pattern

위 팩토리 개념을 정립한 예제를 살펴보자.분리된 클래스를 이용하면 팩토리 패턴, 클래스 내부에 메소드를 이용하여 객체를 생성한다면, 팩터리 메소드 패턴이다.

예시 코드) – 출처

좋은 예시코드가 있어서 발췌해왔다.

Circle, Square, Rectanagle 라는 클래스들을 draw()라는 메소드를 공통으로 가진다.

공통적인 부분을 따로 빼서 인터페이스르 만든다. Shape 상속하도록 구현하는것이 객체 지향적이다.

https://niceman.tistory.com/143

public interface Shape { void draw(); } public class Circle implements Shape{ @Override public void draw() { System.out.println(“Circle – draw() Method.”); } } public class Rectangle implements Shape{ @Override public void draw() { System.out.println(“Rectangle – draw() Method.”); } } public class Square implements Shape{ @Override public void draw() { System.out.println(“Square – draw() Method.”); } }

# 팩터리 패턴의 핵심부분

public class ShapeFactory { //팩토리 메소드 – 객체 생성 후 반환 public Shape getShape(String shapeType){ if(shapeType == null){ return null; } if(shapeType.equalsIgnoreCase(“CIRCLE”)){ return new Circle(); } else if(shapeType.equalsIgnoreCase(“RECTANGLE”)){ return new Rectangle(); } else if(shapeType.equalsIgnoreCase(“SQUARE”)){ return new Square(); } return null; } } # 클라이언트 코드 public class FactoryPatternTest { public static void fundamental(String[] args) { //팩토리 클래스에서 객체를 생성 후 반환 ShapeFactory formFactory = new ShapeFactory(); Shape shape1 = formFactory.getShape(“CIRCLE”); //Circle 메소드 호출 shape1.draw(); Shape shape2 = formFactory.getShape(“RECTANGLE”); //Rectangle 메소드 호출 shape2.draw(); Shape shape3 = formFactory.getShape(“SQUARE”); //Square 메소드 호출 shape3.draw(); } }

여기서 또 다른 메소드나 클래스가 추가되어도, 우리는 클라이언트 코드를 수정할 필요가 없다.

또한, 팩터리 부분을 제외하고는 personal 클래스로 생성되어도 캡슐화를 지원하면서

클라이언트가 팩터리를 통해서 인스턴스를 생성할 수 있다는 장점이 있다.

모두가 Shape이라는 추상타입으로 반환되므로, DIP를 지킨다.

키워드에 대한 정보 팩토리 메소드 패턴

다음은 Bing에서 팩토리 메소드 패턴 주제에 대한 검색 결과입니다. 필요한 경우 더 읽을 수 있습니다.

이 기사는 인터넷의 다양한 출처에서 편집되었습니다. 이 기사가 유용했기를 바랍니다. 이 기사가 유용하다고 생각되면 공유하십시오. 매우 감사합니다!

사람들이 주제에 대해 자주 검색하는 키워드 디자인패턴, Factory Method Pattern, 팩토리 패턴

디자인패턴
OOP
생성 디자인 패턴
생성
공장패턴
팩토리 패턴

디자인패턴, #Factory # #Method #Pattern, #팩토리 #패턴

YouTube에서 팩토리 메소드 패턴 주제의 다른 동영상 보기

주제에 대한 기사를 시청해 주셔서 감사합니다 디자인패턴, Factory Method Pattern, 팩토리 패턴 | 팩토리 메소드 패턴, 이 기사가 유용하다고 생각되면 공유하십시오, 매우 감사합니다.