Java의 간단한 팩토리 패턴

Java의 간단한 팩토리 패턴을 빨리 이해할 수 있도록 두 가지 예를 들어보세요.

누와는 흙으로 인간을 만들었습니다.
"세상이 열릴 때 사람이 없었으니 사람이 없었으니"라는 말이 있습니다. 누와는 흙으로 사람을 만들었다.” 흙으로 사람을 하나하나 만들어야 하는데, 누와가 사람을 만들기 전에는 누와의 생각 속에만 인간이라는 개념이 존재하고 있었다.
누와가 인간을 창조하는 것, 이것이 바로 단순공장 모델의 응용이다.

우선, 인간을 창조한다는 이 사상에는 누와 자신, 인간에 대한 추상적인 개념, 그리고 누와가 창조한 구체적인 인간이라는 몇 가지 중요한 역할이 있다.
1.) 누와(Nuwa)는 단순 팩토리 모델의 핵심 역할을 하는 팩토리 클래스입니다.

2.) 장산, 리시 등을 포함한 구슈의 사람들 각자. 이 사람들은 단순 공장 모델의 구체적인 제품 역할입니다
3.) 추상적인 사람들은 처음에는 누와(Nuwa)의 마음 속에만 존재했던 아이디어입니다. 누와는 이 아이디어를 바탕으로 특정 사람들을 만들었고, 모두 인간에 대한 추상적인 정의에 부합합니다. 존재. 즉 이 추상적인 발상은 특정인 모두가 갖춰야 할 인터페이스(특징이나 기능)를 규정한 것이다.
UML 클래스 다이어그램은 아래와 같다.

이해 이해 후 위의 내용을 이해하고 비교해 봅시다. 이 기사를 읽고 나면 Java 단순 팩토리 패턴을 잘 이해할 수 있을 것입니다.


전문 농장 회사가 있습니다. in 다양한 과일을 시장에 판매하려면 이 시스템에 다음과 같은 과일을 설명해야 합니다. 포도
Stuawberry
사과 Apple
과일은 다른 식물과 다르며 결국 따서 먹을 수 있으므로 자연스러운 접근 농장의 다른 식물과 구별하기 위해 모든 종류의 과일에 적용 가능한 인터페이스를 구축하는 것입니다.

이때, 코드에 표시됨:

    public   interface  Fruit {
        // 生长 
          void  grow();
         // 收获 
          void  harvest();
         // 种植 
          void  plant();
   }

과일 인터페이스는 모든 과일 클래스에 있어야 하는 plant(), Growth() 및 Harvest() 메서드를 포함하여 모든 과일이 구현해야 하는 인터페이스를 지정합니다. ;

Apple 클래스는 과일 클래스의 일종이므로 과일 인터페이스에서 선언한 모든 메소드를 구현합니다. 또한 사과는 다년생 식물이므로 사과나무의 나이를 설명하는 treeAge 속성이 추가로 있습니다. 코드는 다음과 같습니다.

package  fac;

 public   class  Apple  implements  Fruit { // 通过implements实现接口Fruit 
      private   int  treeAge;
    
     public   void  grow() {
        log( " Apple is growing " );
    } 
    
     public   void  harvest() {
        log( " Apple has been harvested " );
    } 
    
     public   void  plant() {
        log( " Apple ha been planted " );
    } 
    
     public   static   void  log(String msg) {
        System.out.println(msg);
    } 
    
     public   int  getTreeAge() {
         return  treeAge;
    } 
    
     public   void  setTreeAge( int  treeAge) {
         this .treeAge = treeAge;
    } 
}

마찬가지로 Grape:

package fac;

public class Grape implements Fruit{
    private boolean seedless;
    public void grow(){
        log("Grape is growing.");
    }
    
    public void harvest(){
        log("Grape has been harvested");
    }
    
    public void plant(){
        log("Grape ha been planted");
    }
    
    public static void log(String msg){
        System.out.println(msg);
    }

    public boolean isSeedless() {
        return seedless;
    }

    public void setSeedless(boolean seedless) {
        this.seedless = seedless;
    }
    

}

Stuawberry:

package fac;

public class Strawberry implements Fruit{
    public void grow(){
        log("Strawberry is growing");
    }
    
    public void harvest(){
        log("Strawberry has been harvested");
    }
    
    public void plant(){
        log("Strawberry has been planted");
    }
    
    public static void log(String msg){
        System.out.println(msg);
    }
}

The farm gardener도 시스템의 일부이며 FruitGardener 클래스라는 클래스로 표현됩니다. 코드는 다음과 같습니다.

package fac;

public class FruitGardener{
    public static Fruit factory(String which)throws Exception{
        if(which.equalsIgnoreCase("apple")){
            return new Apple();
        }else if(which.equalsIgnoreCase("strawberry")){
            return new Strawberry();
        }else if (which.equalsIgnoreCase("grape")){
            return new Grape();
        }else{
            throw new Exception("Bad fruit request");
        }
    }
}

이때 누군가가 과수원에 놀러 와서 정원사에게 말했습니다. 당신의 과일에 대해 우리에게. 그래서 정원사:

package fac;

public class People {

    public static void main(String[] args) throws Exception {
        FruitGardener fg=new FruitGardener();
        Fruit ap=fg.factory("Apple");
        ap.grow();
        Fruit gp=fg.factory("Grape");
        gp.plant();
        
        Fruit dd=fg.factory("ddd");//抛出Bad fruit request异常
    }    

}

(참고: 위 코드는 JDK5.0, Myeclise3.2에서 컴파일되어 전달됩니다.)

두 가지 예, 정원사 누와에 해당하고, 과일은 특정 인물에 해당합니다. 인터페이스 과일 클래스는 누와 같은 사고에 존재하는 추상적인 사람 개념에 해당합니다.

위의 두 가지 예를 통해 간단한 팩토리 패턴은 다음과 같은 역할로 구성되어야 한다는 결론을 내릴 수 있습니다.　　　　　　　　　　　　　　　　　　　　　　　　      by 🎜>
다음 두 예를 이해한 후, 세 번째 예를 살펴보겠습니다.
다음 세 가지 예의 차이점에 주의하세요
예 1:


예 2:

예 3:

package org.jzkangta.factorydemo01;
//定义接口
interface Car{
    public void run();
    public void stop();
}
//具体实现类
class Benz implements Car{
    public void run(){
        System.out.println("Benz开始启动了。。。。。");
    }
    public void stop(){
        System.out.println("Benz停车了。。。。。");
    }
}
//具体实现类
class Ford implements Car{
    public void run(){
        System.out.println("Ford开始启动了。。。");
    }
    public void stop(){
        System.out.println("Ford停车了。。。。");
    }
}
//工厂
class Factory{
    public static Car getCarInstance(){
        return new Ford();
    }
}
public class FactoryDemo01 {

    public static void main(String[] args) {
        Car c=Factory.getCarInstance();
        c.run();
        c.stop();

    }

}

세 가지 예 비교:

package fac;


//定义接口
interface Car{
    public void run();
    public void stop();
}
//具体实现类
class Benz implements Car{
    public void run(){
        System.out.println("Benz开始启动了。。。。。");
    }
    public void stop(){
        System.out.println("Benz停车了。。。。。");
    }
}

class Ford implements Car{
    public void run(){
        System.out.println("Ford开始启动了。。。");
    }
    public void stop(){
        System.out.println("Ford停车了。。。。");
    }
}
//工厂
class Factory{
    public static Car getCarInstance(String type){
        Car c=null;
        if("Benz".equals(type)){
            c=new Benz();
        }
        if("Ford".equals(type)){
            c=new Ford();
        }
        return c;
    }
}


public class FactoryDemo02 {

    public static void main(String[] args) {
        Car c=Factory.getCarInstance("Benz");
        if(c!=null){
            c.run();
            c.stop();
        }else{
            System.out.println("造不了这种汽车。。。");
        }
        

    }

}

인스턴스 1은 간단한 팩토리를 구현했지만 매번 한 종류의 자동차만 교체할 수 있습니다. 공장을 수정하는 것은 너무 불편하지만 두 번째 예에서는 필요에 따라 자동차를 교체할 수 있도록 상황을 변경합니다. 그러나 우리가 교체하려는 자동차는 구현 클래스에 있어야 합니다. 새 자동차를 추가하고 싶어도 공장을 변경해야 합니다. 예 3에서는 반사 메커니즘을 사용하여 자동차 유형을 가져오므로 새 자동차를 추가해야 할 때 수정할 필요가 없습니다. 구현하려는 클래스만 추가하면 됩니다. 즉, 어떤 종류의 자동차를 추가하고 싶다면 공장을 바꾸지 않고 자동차 클래스만 추가하면 됩니다. 따라서 공장 분리의 효과를 달성합니다.

interface Car{
    public void run();
    public void stop();
}

class Benz implements Car{
    public void run(){
        System.out.println("Benz开始启动了。。。。。");
    }
    public void stop(){
        System.out.println("Benz停车了。。。。。");
    }
}

class Ford implements Car{
    public void run(){
        System.out.println("Ford开始启动了。。。");
    }
    public void stop(){
        System.out.println("Ford停车了。。。。");
    }
}

class Toyota implements Car{
    public void run(){
        System.out.println("Toyota开始启动了。。。");
    }
    public void stop(){
        System.out.println("Toyota停车了。。。。");
    }
}

class Factory{
    public static Car getCarInstance(String type){
        Car c=null;
        try {
            c=(Car)Class.forName("org.jzkangta.factorydemo03."+type).newInstance();//利用反射得到汽车类型　
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    
        return c;
    }
}
public class FactoryDemo03 {

    public static void main(String[] args) {
        Car c=Factory.getCarInstance("Toyota");
        if(c!=null){
            c.run();
            c.stop();
        }else{
            System.out.println("造不了这种汽车。。。");
        }
        

    }

}

Java의 Simple Factory 패턴과 관련된 더 많은 글은 PHP 중국어 홈페이지를 주목해주세요!