학습 노트: 자바 분류 매 거 와 전략 매 거 (매 거 진 내장)

1. 분류 매 거, 유형 별로 나열.

                ，      ，  （meal）      （Appetizer）、  （MainCourse）、  （Dessert）、  （Coffee）。        ，     ：

public interface Food {

    enum Appetizer implements Food {
        SALAD, SOUP, SPRING_ROLLS;
    }
    enum MainCourse implements Food {
        LASAGNE, BURRITO, PAD_THAI,
        LENTILS, HUMMOUS, VINDALOO;
    }
    enum Dessert implements Food {
        TIRAMISU, GELATO, BLACK_FOREST_CAKE,
        FRUIT, CREME_CARAMEL;
    }
    enum Coffee implements Food {
        BLACK_COFFEE, DECAF_COFFEE, ESPRESSO,
        LATTE, CAPPUCCINO, TEA, HERB_TEA;
    }
}

이렇게 사용:

public static void main(String[] args) {
    Food food = Food.Appetizer.SALAD;//   -->   
    food =     Food.MainCourse.PAD_THAI; 
} 

이렇게 해서 사물 을 분류 하여 나열 하 는 목적 을 실현 하 였 다.
2. 전략 적 매 거, 매 거 된 내장
《 Effective Java 》 의 관련 문장 을 인용 하여,
임금 가방 의 근무 일 수 를 매 거 진 으로 표시 하 는 것 을 고려 하 다.이 매 거 진 방법 은 한 노동자 에 게 주어진 기본급 (시간 당) 과 그날 의 근무 시간 에 따라 그의 당일 보 수 를 계산 하 는 방법 이 있다.5 일 중 정상 8 시간 이 넘 는 근무 시간 에는 초과 근무 임금 이 발생 한다.휴일 에는 모든 업무 에 잔업 수당 이 발생 한다.switch 문 구 를 이용 하면 여러 개의 case 라벨 을 두 개의 코드 세 션 에 각각 적용 하여 이 계산 을 완성 하기 쉽다.간결 하 게 보기 위해 서 이 예제 의 코드 는 double 을 사 용 했 지만 double 은 임금 응용 프로그램 에 적합 한 데이터 형식 이 아 닙 니 다.

 // Enum that switches on its value to share code - questionable
enum PayrollDay {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY,
    private static final int HOURS_PER_SHIFT = 8;

    double pay(double hoursWorked, double payRate) {
        double basePay = hoursWorked * payRate;
        double overtimePay; // Calculate overtime pay
        switch(this) {
            case SATURDAY: case SUNDAY
                overtimePay = hoursWorked * payRate / 2;
            default: // Weekdays
                overtimePay = hoursWorked <= HOURS_PER_SHIFT ?
                0 : (hoursWorked - HOURS_PER_SHIFT) * payRate / 2;
                break;
        }
        return basePay + overtimePay;
    }

}

부인 할 수 없습니다. 이 코드 는 매우 간결 하지만 유지 보수 의 측면 에서 볼 때 매우 위험 합 니 다.만약 에 매 거 진 에서 새로운 요 소 를 추가 해 야 한다 고 가정 합 니 다. 예 를 들 어 설 7 일 에 3 배의 월급 (overtime Pay = hours Worked * pay Rate * 3) 을 추가 해 야 하지만 우 리 는 switch 문구 에 해당 하 는 case 를 추가 하 는 것 을 잊 었 습 니 다.프로그램 은 여전히 컴 파일 할 수 있 지만 페 이 방법 은 조용히 설 임금 을 정상 근무일 과 동일 하 게 계산한다.이 문 제 를 어떻게 해결 합 니까?매 거 에서 overtime Pay 의 계산 방법 을 벗 겨 내 고 하나의 가상 함수 로 정의 한 다음 에 모든 상수 로 이 를 실현 하도록 강요 할 수 있다. 그러면 내 가 매 거 진 요 소 를 증가 할 때마다 컴 파일 러 는 나 에 게 월급 의 계산 방법 을 실현 하 라 고 요구 할 것 이다. 그러나 이렇게 하면 매우 번 거 롭 고 프로그램의 가 독성 을 낮 추 는 동시에 중복 코드 를 많이 증가 하여 오류 의 확률 을 높 일 수 있다.더 생각해 보면 overtime Pay 의 계산 방법 도 분류 할 수 있 고 유한 하 다. 즉, 월급 의 계산 을 하나의 전략 으로 매 거 (strategy enum) 하여 월급 계산 전략 을 형성 한 다음 에 이 전략 을 PayrollDay 구조 기 파라미터 로 전달 할 수 있다.이로써 페 이 롤 데 이 임금 계산 은 임금 계산 전략 에 넘 겨 졌 다.

// The strategy enum pattern
enum PayrollDay {
    MONDAY(PayType.WEEKDAY), TUESDAY(PayType.WEEKDAY),
    WEDNESDAY(PayType.WEEKDAY),THURSDAY(PayType.WEEKDAY),
    FRIDAY(PayType.WEEKDAY),
    SATURDAY(PayType.WEEKEND), SUNDAY(PayType.WEEKEND),
    CHINESE_NEW_YEAR(PayType.CHINESE_NEW_YEAR);

    private PayType payType;

    private PayrollDay(PayType payType){
        this.payType = payType;
    }

    private double pay(double hoursWorked, double payRate) {
        return payType.pay(hoursWorked, payRate);
    }
    // The strategy enum type
    private enum PayType {
        WEEKDAY {
            double overtimePay(double hours, double payRate) {
                return hours <= HOURS_PER_SHIFT ? 0 :
                (hours - HOURS_PER_SHIFT) * payRate / 2;
            }
        },
        WEEKEND {
            double overtimePay(double hours, double payRate) {
                return hours * payRate / 2;
            }
        },
        CHINESE_NEW_YEAR {//           。
            @Override
            double overtimePay(double hours, double payRate) {
                return hours * payRate * 3;
            }
        };
        private static final int HOURS_PER_SHIFT = 8;
        abstract double overtimePay(double hours, double payRate);
        double pay(double hoursWorked, double payRate) {
            double basePay = hoursWorked * payRate;
            return basePay + overtimePay(hoursWorked, payRate);
        }
    }
}

물론 인터페이스 형식 도 사용 할 수 있다.

// The strategy enum pattern
enum PayrollDay {
    MONDAY(OvertimePay.PAY_TYPE.WEEKDAY),TUESDAY(OvertimePay.PAY_TYPE.WEEKDAY),
    WEDNESDAY(OvertimePay.PAY_TYPE.WEEKDAY),THURSDAY(OvertimePay.PAY_TYPE.WEEKDAY),
    FRIDAY(OvertimePay.PAY_TYPE.WEEKDAY),
    SATURDAY(OvertimePay.PAY_TYPE.WEEKEND),SUNDAY(OvertimePay.PAY_TYPE.WEEKEND),
    CHINESE_NEW_YEAR(OvertimePay.PAY_TYPE.CHINESE_NEW_YEAR);

    private OvertimePay overtimePay;
    private PayrollDay(OvertimePay overtimePay){
        this.overtimePay = overtimePay;
    }

    double pay(double hours,double payRate){
        double basePay = hours * payRate;
        return basePay + overtimePay.overtimePay(hours,payRate);
    }
    private interface OvertimePay{
        enum PAY_TYPE implements OvertimePay{
            WEEKDAY {
                @Override
                public double overtimePay(double hours, double payRate) {
                    return hours < HOURS_PER_SHIFT ? 0 : (hours - HOURS_PER_SHIFT)*payRate/2 ;
                }
            },
            WEEKEND {
                @Override
                public double overtimePay(double hours, double payRate) {
                    return hours * payRate / 2;
                }
            },
            CHINESE_NEW_YEAR {
                @Override
                public double overtimePay(double hours, double payRate) {
                    return hours * payRate * 3;
                }
            };
        }
        double overtimePay(double hours,double payRate);
        static final int HOURS_PER_SHIFT = 8;
    }