공장 모델 과 추상 적 인 공장 모델

최근 에 디자인 모델 을 뜯 고 있 는데 이 글 은 디자인 모델 의 첫 번 째 편 이 니 계속 쓸 수 있 기 를 바 랍 니 다.
      공장 모델 과 추상 적 인 공장 모델 은 모두 창설 형 모델 로 창설 대상 에 사용 된다.프로그램 은 대상 을 만 드 는 작업 (예 를 들 어 각종 new) 을 단독 인터페이스 에서 추출 하여 인터페이스의 하위 클래스 로 대상 의 생 성 작업 을 완성 하여 대상 의 생 성과 업무 논리 적 결합 을 실현 합 니 다.여기 서 말 하 는 인 터 페 이 스 는 interface 도 포함 하고 추상 류 도 포함한다.
      다음은 '만두' 를 예 로 들 어 이 두 가지 모델 의 용법 을 설명 한다. 만 두 는 우리 가 생산 해 야 할 제품 이 고 공장 은 우리 가 만 두 를 생산 하 는 도구 이다.만두 속 의 맛 은 매우 많은 데 여기 에는 부추, 생 고기, 무 세 가지 만 들 어 있다.
1. 공장 모델
      공장 모델 의 방법 은 모든 제품 이 하나의 공장 에 대응 하고 공장 에서 대응 하 는 제품 의 건설 업 무 를 책임 지 며 공장 모델 은 제품 을 생 성 하 는 임 무 를 구체 적 인 하위 클래스 에 맡 겨 완성 하고 구체 적 인 제품 류 와 의 결합 을 실현 하 는 것 이다.
      먼저 제품 인 터 페 이 스 를 정의 합 니 다.

1 public interface Dumpling{
2     String getFlavor();  //          
3 }

      다음은 세 가지 구체 적 인 맛의 만두:

 1 public class FreshmeatDumpling implements Dumpling{
 2     String flavor = "      ";
 3 
 4     @Override
 5     public String getFlavor(){
 6         return flavor;
 7     }
 8 }
 9 
10 public class LeekDumpling implements Dumpling{
11     String flavor = "      ";
12 
13     @Override
14     public String getFlavor(){
15         return flavor;
16     }
17 }
18 
19 public class RadishDumpling implements Dumpling{
20     String flavor = "      ";
21 
22     @Override
23     public String getFlavor(){
24         return flavor;
25     }
26 }

      제품 이 정 의 된 후에 공장 을 정의 하여 이 제품, 즉 만 두 를 생산 해 야 한다.
      먼저 공장 인터페이스 정의:

1 public interface DumplingFactory{
2     Dumpling createDumpling();  //    
3 }

      다음은 모든 만두 에 해당 하 는 공장 을 정의 합 니 다.

 1 public class FreshmeatDumplingFactory implements DumplingFactory{
 2     public Dumpling createDumpling(){
 3         return new FreshmeatDumpling();  //         
 4     }
 5 }
 6 
 7 public class LeekDumplingFactory implements DumplingFactory{
 8     public Dumpling createDumpling(){
 9         return new LeekDumpling();  //         
10     }
11 }
12 
13 public class RedishRDumplingFactory implements DumplingFactory{
14     public Dumpling createDumpling(){
15         return new RedishDumpling();  //         
16     }
17 }

      자, 모든 준비 작업 이 끝 났 으 니 이제 즐겁게 주문 할 수 있 습 니 다 ^ ^.

1 public static void main(String[] args){
2     DumplingFactory factory = new LeekDumpingFactory();
3     Dumpling dumpling = factory.createDumpling();
4     System.out.println(dumpling.getFlavor());  //      
5 
6     factory = new RedishDumplingFactory();
7     dumpling = factory.createDumpling();
8     System.out.println(dumpling.getFlavor());  //      
9 }

2. 추상 공장 모델
      추상 적 인 공장 모델 의 직책 은 하나의 제품 클 러 스 터 를 만 드 는 것 이다. 이것 은 흔히 다양한 유형의 제품 을 만 드 는 것 을 의미 하고 공장 모델 은 단일 제품 만 만 만 드 는 것 을 책임 진다.
      만두 의 경우 소 를 제외 하고 보통 재 료 를 넣는다. 예 를 들 어 파, 생강, 마늘 등 이다. 그러면 이때 우 리 는 재료 공장 에서 이런 재 료 를 전문 적 으로 생산 해 야 한다.이런 재 료 는 서로 다른 제품 학과 에 속 하 는데 그들 이 합 쳐 만 두 를 구성 하 는 재 료 를 말한다. 우 리 는 재료 와 유사 한 일련의 제품 을 제품 클 러 스 터 라 고 부른다. 분명히 공장 모델 은 이 생산 임 무 를 완성 할 수 없 기 때문에 추상 적 인 공장 모델 을 사용 해 야 한다.실제로 추상 적 인 공장 이 모든 제품 을 생 성 할 때 사용 하 는 것 은 공장 모델 의 원리 이다.
      우선, 배합 인터페이스 와 구체 적 인 배합 서브 클래스 를 정의 합 니 다.
      배합 인터페이스:

 1 //  
 2 public interface Scallion{
 3     String getName();  
 4 }
 5 
 6 //  
 7 public interface Ginger{
 8     String getName();  
 9 }
10 
11 //  
12 public interface Garlic{
13     String getName();  
14 }

      구체 적 인 배합:

 1 public class GreenChineseonion implements Scallion{
 2     private String name = "  ";
 3     public String getName(){
 4         return name;
 5     }
 6 }
 7 
 8 public class Shallot implements Scallion{
 9     private String name = "  ";
10     public String getName(){
11         return name;
12     }
13 }
14 
15 public class RedGinger implements Ginger{
16     private String name = "  ";
17     public String getName(){
18         return name;
19     }
20 }
21 
22 public class YellowGinger implements Ginger{
23     private String name = "  ";
24     public String getName(){
25         return name;
26     }
27 }
28 
29 public class WhiteGarlic implements Garlic{
30     private String name = "   ";
31     public String getName(){
32         return name;
33     }
34 }
35 
36 public class PurpleGarlic implements Garlic{
37     private String name = "   ";
38     public String getName(){
39         return name;
40     }
41 }

      다음은 재 료 를 생산 하 는 공장 을 정의 한다.

1 public interface IngredientsFactory{
2     Scallion createScallion();  //   
3     Ginger createGinger();      //   
4     Garlic createGarlic();        //   
5 }

      그리고 구체 적 인 배합 공장 을 정의 한다.

 1 //         
 2 public class FreshMeatDumplingIngredientsFactory implements IngredientsFactory{
 3     public Scallion createScallion(){
 4         return new Shallot();
 5     }
 6 
 7     public Ginger createGinger(){
 8         return new RedGinger();
 9     }
10 
11     public Garlic createGarlic(){
12         return new WhiteGarlic();
13     }
14 }
15 
16 //         
17 public class LeekDumplingIngredientsFactory implements IngredientsFactory{
18     public Scallion createScallion(){
19         return new Shallot();
20     }
21 
22     public Ginger createGinger(){
23         return new RedGinger();
24     }
25 
26     public Garlic createGarlic(){
27         return new PurpleGarlic();
28     }
29 }
30 
31 //         
32 public class RadishDumplingIngredientsFactory implements IngredientsFactory{
33     public Scallion createScallion(){
34         return new GreenChineseonion();
35     }
36 
37     public Ginger createGinger(){
38         return new YellowGinger();
39     }
40 
41     public Garlic createGarlic(){
42         return new Garlic
43     }
44 }

      그리고 양념 을 해서 간 을 맛 볼 수 있 습 니 다.

1 public static void main(String[] args){
2     IngredientsFactory ingredientsFactory = new RadishDumplingIngredientsFactory();
3     System.out.println(ingredientsFactory.createScallion().getName);
4     System.out.println(ingredientsFactory.createGinger().getName);
5     System.out.println(ingredientsFactory.createGarlic().getName);
6 }

3. 단순 공장
      일반적으로 공장 모델 을 언급 할 때 간단 한 공장 을 언급 합 니 다. 간단 한 공장 은 모든 제품 의 건설 임 무 를 한 가지 유형 에 두 고 완성 하 는 것 입 니 다. 새로운 제품 이 있 으 면 간단 한 공장 안의 생산 논 리 를 수정 해 야 합 니 다.
      만두 에 대해 간단 한 공장 은 다음 과 유사 할 수 있다.

 1 public class SimpleDumplingFactory{
 2     public Dumpling createDumpling(String type){
 3         switch(type){
 4             case "freshMeat":
 5               return new FreshMeatDumpling();
 6               break;
 7             case "leek":
 8               return new LeekDumpling();
 9               break;
10             case "radish":
11               return new RadishDumpling();
12               break;
13             default:
14               return new FreshMeatDumpling();
15               break;
16         } 
17      }
18 }        

4. 총화
      간단 한 공장 은 구체 적 인 유형 으로 모든 제품 을 생산 하 는 것 을 책임 집 니 다. 새로운 제품 이 생 겼 을 때 생산 제품 의 논 리 를 수정 해 야 합 니 다. '확장 개방, 수정 폐쇄' 의 원칙 에 부합 되 지 않 습 니 다.공장 모델 은 모든 제품 에 대응 하 는 공장 을 만 들 고 새로운 제품 이 나 올 때 새로운 공장 만 늘 리 면 된다.추상 적 인 공장 은 하나의 제품 클 러 스 터 를 만 들 수 있 는데 그 중의 모든 제품 을 생산 하 는 방법 은 공장 모델 을 이용 한 것 이다.
 5. 참고
<>