item34. int定数の代わりに列挙タイプを使用する

public static final int APPLE_FUJI = 0;
public static final int APPLE_PIPPIN = 0;
public static final int APPLE_GRANNY_SMITH = 0;


public static final int APPLE_NAVEL = 0;
public static final int APPLE_TEMPLE = 0;
public static final int APPLE_BLOOD = 0;

public enum Apple { FUJI, PIPPIN, GRANNY_SMITH }
public enum Orange { NAVEL, TEMPLE, BLOOD }

public enum Planet {
	MERCURY(3.302e+23, 2.439e6),
    VENUS(4.869e+24, 6.052e6),
    EARTH(5.975e+24, 6.378e6),
    MARS(6.419e+23, 3.393e6),
    JUPITER(1.899e+27, 7.149e7),
    SATURN(5.685e+26, 6.027e7),
    URANUS(8.683e+25, 2.556e7),
    NEPTUNE(1.024e+26, 2.477e7);
    
    private final double mass; //질량(단위: 킬로그램)
    private final double radius; //반지름(단위: 미터)
    private final double surfaceGravity; //표면중력(단위: m / s^2)
    
    //중력상수(단위:m^3 / kg s^2)
    private static final double G = 6.67300E-11;
    
    //생성자
    Planet(double mass, double radius) {
    	this.mass = mass;
        this.radius = radius;
        surfaceGravity = G * mass / (radius * radius);
    }
    
    public double mass()	{ return mass; }
    public double radius()	{ return radius; }
    public double surfaceGravity()	{ return surfaceGravity; }
    
    public double surfaceWeight (double mass) {
    	return mass * surfaceGravity;	// F = ma
    }
}

public class WeightTable {
	public static void main(String[] args) {
    	double earthWeight = Double.parseDouble(args[0]);
        double mass = earthWeight / Planet.EARTH.surfaceGravity();
        for (Planet p : Planet.values())
        	System.out.printf("%s에서의 무게는 %f이다. %n",
            	p, p.surfaceWeight(mass));
    }
}

public enum Operation {
	PLUS, MINUS, TIMES, DIVIDE;
    
    //상수가 뜻하는 연산 수행
    public double apply(double x, double y) {
    	switch(this) {
        	case PLUS:	return x + y;
            case MINUS :	return x - y;
            case TIMES : 	return x * y;
            case DIVIDE :	return x / y;
        }
       	throw new AssertionError("알 수 없는 연산 : " + this);
    }
}

public enum Operation {
	PLUS {public double apply(double x, double y){return x + y;}},
    MINUS {public double apply(double x, double y){return x - y;}},
    TIMES {public double apply(double x, double y){return x * y;}},
    DIVIDE {public double apply(double x, double y){return x / y;}},

	public abstract double apply(double x, double y);
}

public enum Operation {
	PLUS("+") {
    	public double apply(double x, double y) { return x + y; }
    },
    MINUS("-") {
    	public double apply(double x, double y) { return x - y; }
    },
    TIMES("*") {
    	public double apply(double x, double y) { return x * y; }
    },
    DIVIDE("/") {
    	public double apply(double x, double y) { return x / y; }
    };
    
    private final String symbol;
    
    Operation(String symbol) { this.symbol = symbol; }
    
    @Override public String toString() { return symbol; }
    public abstract double apply(double x, double y);
}

public static void main(String[] args) {
	double x = Double.parseDouble(args[0]);
    double y = Double.parseDouble(args[1]);
    for (Operation op : Operation.values())
    	System.out.printf("%f %s %f = %f%n",
        	x, op, y, op.apply(x, y));
}

private static final Map<String, Operation> stringToEnum = 
	Stream.of(values()).collect(
    	toMap(Object::toString, e->e));
        
//지정한 문자열에 해당하는 Operation을 (존재한다면) 반환한다.
public static Optional<Operation> fromString(String symbol) {
	return Optional.ofNullable(stringToEnum.get(symbol));
}

enum PayrollDay {
	MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY;
    
    private static final int MINS_PER_SHIFT = 8 * 60;
    
    int pay(int minutesWorked, int payRate) {
    	int basePay = minutesWorked * payRate;
        
        int overtimePay;
        switch(this) {
        	case SATURDAY : case SUNDAY; //주말
            	overtimePay = basePay / 2;
                break;
            defaul : //주중
            	overtimePay = minutesWorked <= MINS_PER_SHIFT ?
                	0 : (minutesWorked - MINS_PER_SHIFT) * payRate / 2;
        }
        
        return basePay + overtimePay;
    }
}

enum PayrollDay {
	MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY(payType.WEEKEND), SUNDAY(PayType.WEEKEND);
    
    private final PayType payType;
    
    PayrollDay(PayType payType) { this.payType = payType; }
    
    int pay(int minutesWorked, int payRate) {
    	return payType.pay(minutesWorked, payRate);
    }
    
    //전략 열거 타입
    enum PayType {
    	WEEKDAY {
        	int overtimePay(int minsWorked, int payRate) {
            	return minsWorked <= MINS_PER_SHIFT ? 0 :
                	(minsWorked - MINS_PER_SHIFT) * payRate / 2;
            }
        },
        WEEKEND {
        	int overtimePay(int minsWorked, int payRate) {
            	return minsWorked * payRate / 2;
            }
        };
        
        abstract int overtimePay(int mins, int payRate);
        private static final int MINS_PER_SHIFT = 8 * 60;
        
        int pay(int minsWorked, int payRate) {
        	int basePay = minsWorked * payRate;
            return basePay + overtimePay(minsWorked, payRate);
        }
    }

}

public static Operation invers(Operation op) {
	switch(op) {
    	case PLUS : return Operation.MINUS;
        case MINUS : return Operation.PLUS;
        case TIMES : return Operation.DIVIDE;
        case DIVIDE : return Operation.TIMES;
        default : throw new AssertionError("알 수 없는 연산 : " + op);
    }
}