디자인 모델 - 단순 공장 응용 자바

자바 대상 을 실현 하려 면 간단 한 공장 을 써 서 자바 의 패 키 징, 계승, 재 활용 을 실현 하 는 예 를 들 어 함수 식 간단 한 공장 도 실현 합 니 다.
1. 단순 공장 (비 함수 식)
1. 우선 우 리 는 통용 되 는 속성 합 법 을 일반 클래스 에 넣 습 니 다.

/**
 * Created by LK on 2016/5/8.
 */
public class Operation {
    private double numberA = 0;
    private double numberB = 0;

    public double getNumberA() {
        return numberA;
    }

    public void setNumberA(double numberA) {
        this.numberA = numberA;
    }

    public double getNumberB() {
        return numberB;
    }

    public void setNumberB(double numberB) {
        this.numberB = numberB;
    }

    public double getResult(){
        double result = 0;
        return result;
    }
}

2. 만약 에 우리 가 지금 알고리즘 의 덧셈 과 곱셈 을 실현 하려 면 우 리 는 각각 해당 하 는 클래스 계승 위의 일반 클래스 를 만 듭 니 다.
덧셈:
4. 567913. 감법:

/**
 * Created by LK on 2016/5/8.
 */
public class OperationsAdd extends Operation {
    public double getResult(){
        double result = 0;
        result = getNumberA() + getNumberB();
        return result;
    }
}

곱셈:

/**
 * Created by LK on 2016/5/8.
 */
public class OperationSub extends Operation{
    public double getResult(){
        double result = 0;
        result = getNumberA() - getNumberB();
        return result;
    }
}

나눗셈:

/**
 * Created by LK on 2016/5/8.
 */
public class OperationMul extends Operation {
    public double getResult(){
        double result = 0;
        result = getNumberA() * getNumberB();
        return result;
    }
}

3. 현재 각 알고리즘 은 이미 실현 되 었 습 니 다. 그들 은 매우 분산 되 어 있 기 때문에 우 리 는 이 몇 가지 알고리즘 을 집중 적 으로 관리 해 야 합 니 다. 이것 은 공장 에 사용 되 고 공장 으로 그들 을 가두 어야 합 니 다.

/**
 * Created by LK on 2016/5/8.
 */
public class OperationDiv extends Operation {
    public double getResult(){
        double result = 0;
        if(getNumberB() == 0){
            System.out.println("     0！");
        }
        result = getNumberA() / getNumberB();
        return result;
    }
}

4. 지금 은 모든 것 이 준비 되 어 있 고 공장장 의 부 름 만 빚 지고 있 습 니 다.

/**
 * Created by LK on 2016/5/8.
 */
public class OperationFactory {
    public static Operation createOperate(String operate){
        Operation oper = null;
        switch (operate){
            case "+":
                oper = new OperationsAdd();
                break;
            case "-":
                oper = new OperationSub();
                break;
            case "*":
                oper = new OperationMul();
                break;
            case "/":
                oper = new OperationDiv();
                break;
        }
        return oper;
    }
}

2. 단순 공장 (함수 식)
실현 류 의 생 성 을 간소화 하기 위해 서 우 리 는 함수 식 방법 으로 실현 하 는 것 을 고려 할 수 있다.
1. 함수 식 인 터 페 이 스 를 만 듭 니 다.

/**
 * Created by LK on 2016/5/8.
 */
public class FactoryClient {
    public static void main(String[] args) {
        /**
         *       ，   
         */
        Operation operation = OperationFactory.createOperate("/");
        operation.setNumberA(2);
        operation.setNumberB(1);
        double result = operation.getResult();
        System.out.println(result);
        /**
         *       ，   
         */
        /*String oper = "/";
        IOperationFunction operationFunction = OperationFunction.getOperationFunctionStrategy(oper);
        double result1 = operationFunction.createOperation(2,1,oper);
        System.out.println(result1);*/
    }
}

2. 함수 식 인터페이스의 실현 을 만 듭 니 다. 우 리 는 이 가감 승제 알고리즘 을 모두 이 실현 클래스 에 쓰 고 클래스 를 불 러 올 때 초기 화 합 니 다. 이렇게 하면 나중에 직접 호출 하면 됩 니 다.

/**
 * Created by LK on 2016/5/8.
 */
@FunctionalInterface  public interface IOperationFunction {
    public double createOperation(double numberA,double numberB,String oper);
}

현재 비 함수 식 과 의 차 이 는 바로 우리 가 많은 실현 을 만 들 필요 가 없고 네 가지 종 류 를 적 게 만 들 었 다 는 것 이다.
3. 지금도 공장장 님 의 부 름 만 받 았 습 니 다.

/**
 * Created by LK on 2016/5/8.
 */
public class OperationFunction {
    private static Map<String,IOperationFunction> operationFunctionMap = new ConcurrentHashMap<>();

    static{
        /**
         *     
         */
        operationFunctionMap.put("+",(numberA,numberB,oper) ->{
            double result = numberA + numberB;
            return result;
        });

        /**
         *     
         */
        operationFunctionMap.put("-",(numberA,numberB,oper) ->{
            double result = numberA - numberB;
            return result;
        });

        /**
         *     
         */
        operationFunctionMap.put("*",(numberA,numberB,oper) -> {
            double result = numberA * numberB;
            return result;
        });

        /**
         *     
         */
        operationFunctionMap.put("/",(numberA,numberB,oper) -> {
            double result = numberA / numberB;
            return result;
        });
    }

    public static IOperationFunction getOperationFunctionStrategy(String oper){
        return operationFunctionMap.get(oper);
    }
}