단순 공장, 공장 방법과 추상적인 공장 모델

단순 공장, 공장 방법과 추상적인 공장 모델
단순 공장에 대해서 말하자면, 그것의 공장은 단지 이 모양일 뿐이다

public class SimplyFactory { 
/**
*       
*/
public static Prouct factory(String which) throw NoSuchProductExcption
{ 

    if(which.equalIgnoreCase("product1"))
    { 
    return new Product1();
    }
    else if(which.equalsIgnoreCase("product2"))
       {   
         return new Product2(); 
       }
   else if(which.equalsIgnoreCase("product3"))
       {   
         return new Product3(); 
       }
   else throw   NoSuchProductExcption("NoSuchProduct");
   }
}
}

제품 Product1, Product2, Product3에 대해서는 인터페이스 Product를 실행할 수도 있고 인터페이스 Product를 실행하지 않을 수도 있다. 이 Product 인터페이스는 추상적이고 구체적인 Product를 위한 것일 뿐이다.

public interface Product
{ 
   void productMethod1();      //    
   void productMethod2();
   void productMethod3();
}

공장에 대해 말하자면 이런 제품이 있으면 보통 공장에서 생산하는 방법이 있어야 한다. 그렇지 않으면 이상을 던지고 공장에서 생산하려면 반드시 어떤 제품을 생산하라는 명령을 내려야 한다. 적어도 공장에 신호를 보내서 공장이 어떤 제품을 생산해야 하는지 충분히 구분할 수 있도록 해야 한다. 그렇지 않으면 공장은 어떤 제품을 생산해야 하는지 모른다.
단순 공장에 대해 말하자면 공장에서 모든 제품을 일일이 열거해야 하기 때문에 단순 공장은 여전히 매우 멍청하다.
if(which.equal IgnoreCase("product1"))는 단지 어떤 제품을 생산하는지를 구분하는 데 사용되는 표기값일 뿐이다. (제품의 다른 속성에 따라 판단할 수도 있다. 예를 들어 제품 유형, 제품 크기, 어쨌든 어떤 제품의 속성인지, 또는 제품 속성과 관련된 변수인지를 구분할 수 있다) 또는 표기값이 A이고 A제품을 생산하거나 공장에서 정의한 것이 그렇지 않다. 나는 하필 B제품을 생산하려고 한다.아니면 좀 더 특별하게 제가 하필 A 제품+B 제품을 생산해야 한다면 Return new ProductA()+new ProductB()를 만들어야 합니다.
이렇게 하면 우리는 간단한 공장에서 생산될 수 있다면 반드시 간단한 공장에서 생산할 수 있는 방법의 정의가 있어야 한다. 물론 이 구체적인 제품류의 정의가 필요하다. 바로class가 대응해야 한다. 이렇게 하면 간단한 공장에서 new가 있을 때 NoSuchProduct의 Exception을 내놓지 않도록 확보한다.
공장 방법에 대해 말하자면
실질적으로 그것은 공장으로 하여금 추상적인 공장 인터페이스를 실현하게 했다. 그것은 구체적으로 어떤 물건을 어떻게 생산하는지를 구체적인 공장에 놓고 실현했다. 이른바'자류로 늦추어 실현한다'는 것이다.

public interface Creator
{ 
   public Prouct factory();
}

public SubCreator1 implent Creator
{ 
    public Prouct factory()
   { 
    return new ConcreteProduct1();
   }
}

public SubCreator2 implent Creator
{ 
    public Prouct factory()
   { 
     return new ConcreteProduct2();
   }
}

주의하세요: 되돌아오는 유형은 Product형입니다!!
이렇게 클라이언트 호출은 new의 구체적인 공장의 실례를 직접 사용한 다음에 그것을 생산하라고 명령한 것이다. 그러나 구체적인 공장의 부류(공장 인터페이스, 인터페이스는 완전히 부류로 바꾸어 부류를 계승하여 실현할 수 있지만 이렇게 하면 좋지 않고 OO의 원칙에 부합되지 않는다)에 대해 어떤 제품이 생산되었는지 전혀 모른다. 심지어 그 구체적인 공장이 실례화되었는지도 모른다.
추상 공장 모델
추상적인 공장 모델은 주로 구체적인 제품이 몇 가지 제품 묶음의 문제를 해결하는 데 쓰인다

public interface Creator
{ 
    public ProuctA factoryA();
    public ProuctB factoryB();
}

public interface ProductA      //ProductA   
{ 
}

public interface ProductB      //ProductB   
{ 
}


public class ConCreator1 implent Creator
{ 
    public ProuctA factoryA()
   { 
    return new ConcreteProductA1();
   }

    public ProuctB factoryB()
   { 
    return new ConcreteProductB1();
   }
}

public class ConCreator2 implent Creator
{ 
    public ProuctA factoryA()
    { 
     return new ProductA2();
    }

    public ProuctB factoryB()
    { 
    return new ProductB2();
    }
}


public class ProductA1 implements   ProductA
{ 
public   ProductA1()
    { 
    }
}
public class ProductA2 implements   ProductA
{ 
public   ProductA2()
    { 
    }
}
public class ProductB1 implements   ProductB
{ 
public   ProductB1()
    { 
    }
}
public class ProductB2 implements   ProductB
{ 
public   ProductB2()
    { 
    }
}

실제로는 이렇습니다.
1, 2개의 Creator1, Creator2 모두 Creator 커넥터
2, ProuctA1, ProductA2 모두 ProductA 커넥터 구현
3, ProuctB1, ProductB2 모두 ProductB 커넥터 구현
4, ConCreator1은 ProductA 유형의 제품을 생산하는 것을 책임진다(ProductA1, ProductB1 포함)
5, ConCreator2는 ProductB 유형의 제품 생산을 책임진다(ProductA2, ProductB2 포함)
6. 공장 방법에도 이러한 특징이 있다. 즉, Creator는 무엇이 생산되는지 모르고 심지어는 ConCreator1인지 ConCreator2인지 실례화되었는지도 모른다. 왜냐하면 client는 그 공장을 기쁘게 조정하기 때문에 그 공장을 조정한다. 즉, 공장이 무엇을 생산할 수 있는지는 고객 측에서 볼 수 있다.심지어 클라이언트가 기뻐서 ProductA1을 생산했다. 나는 ProductA2를 생산하지 않는다. 왜냐하면 위의 예에서 그들은 모두 느슨해서 한데 묶이지 않았기 때문이다.
그래서 또 다른 예를 제시하였는데, 또한 늘 제기하는 컴퓨터 유형의 예이기도 하다
1, 컴퓨터 생산 업체는 인터페이스,
2, CUP는 커넥터,
3, 하드 드라이브는 커넥터,
4, IBM 공장은 IBM 브랜드의 컴퓨터를 제조하는 공장이다
5, 델 공장 은 델 브랜드 의 컴퓨터 를 제조 하는 공장 이다
토론의 편의를 위해 컴퓨터=CUP+하드디스크로 간주한다.
6, 그래서 CUP에는 IBM CPU와 DELL CPU가 있습니다.
7, IBM 하드 드라이브와 DELL 하드 드라이브 모두 동일
8, IBM 공장에서 IBM의 CPU 및 IBM의 하드 드라이브를 생산, DELL의 CPU 또는 DELL의 하드 드라이브를 절대 생산하지 않음
9, DELL 공장도 마찬가지

public interface        
{ 
    public CPU   CPU();
    public        ();
}

public interface CPU
{ 
}

public interface   
{ 
}

public class IBM CPU implements CPU
{ 
    public      IBM CPU();
}

public class IBM    implements   
{ 
     public      IBM   ();
}

public class DELL CPU implements CPU
{ 
     public      DELL CPU();
}

public class DELL    implements   
{ 
    public      DELL   ();
}

//   IBM  
public class   IBM  
{ 
    private CPU IBM CPU    =null;
    private    IBM       =null;
    private CPU   IBMCPU()
   { 
      return   new IBM CPU();
   }
private      IBM  ()
{ 
     return   new IBM CPU();
}
public        IBM  ()
{ 
   try{ 
   IBM CPU    =  IBMCPU();
   IBM       =  IBM  ();
   if(IBM CPU    !=null&&IBM       !=null)
   retrun   (IBM CPU    +IBM       );
     //   IBM  
   }
   catch(Exception e)
     { 
     System.out.println("  IBM    ！");
     }
   }
}
}

이렇게 하면 클라이언트는 명령서를 통해 하나의 CPU를 생산할 수 없다. 이렇게 추상적이어야만 진정으로 완전한 제품의 공장이 된다. 공장에 생산 명령을 내리면 완전한 컴퓨터 한 대가 생산된다. 공장이 어떻게 생산하고 어떤 부품을 생산했는지 외부에서 볼 수 없다. 외부에서 이 공장이 IBM컴퓨터 완성기를 생산하는 공장이라는 것을 알 수 있다.
델컴퓨터 공장처럼.