Javaコード、複数のif文を整理する

Question

私はJavaコードを整理して、たくさんのものを取り除いていますが、何か別のものがあれば、多分if文を取り除いて、このコード？彼らは1つの 'if'にそれらを積み重ねるために非常に異なっているので、それを理解しているように見えることはできません。何か案は？

public class Calc { 
      // employee types 
      public static final int SELLER; 
      public static final int COOK; 
      public static final int CHIEF; 



     public static void main(final String[] args) { 
       Calc c = new Calc(); 
       System.err.println(c.pay(CHIEF) + " should be 66"); 
     } 

     private int pay(final int type, final int h) { 
       int Sum = 0; 
       if (type == SELLER) { 
        if (h > 8) { 
          Sum = 20 * (h - 8); 
          Sum += 80; 
        } else { 
          Sum += 10 * h; 
        } 
       } 
       if (type == COOK) { 
        if (h > 8) { 
          Sum = 30 * (h - 8); 
          Sum += 15 * 8; 
        } else { 
          Sum += 15 * h; 
        } 
       } 
       if (type == CHIEF) { 
        if (h > 8) { 
          Sum = 66 * (h - 8); 
          Sum += 22 * 8; 
        } else { 
          Sum += 22 * h; 
        } 
       } 
       if (h > 20) { 
        if (type == SELLER) { 
          Sum += 10; 
        } 
        if (type == COOK) { 
          Sum += 20; 
        } 
        if (type == CHIEF) { 
          Sum += 30; 
        } 
       } 
       return Sum; 
     } 
} 

Answer 1

あなたが書いたコードは純粋に手続きで、Javaなどのオブジェクト指向言語で書いている間、ほとんどの場合、悪い習慣と考えられています。あなたがポリモーフィズムのパワーについて学ぶ必要がありますし、手動で型チェックを実行しないでください。

if (type == COOK) { //Avoid doing this in OO languages! 

をオブジェクトと従業員のそれぞれの具体的なタイプは賃金を計算するための独自のルールを定義することができるようあなたのドメインエンティティ（従業員）を考える必要があります。

はのは、単一の抽象メソッドint calculatePay(int h)と抽象クラスの従業員を作成してみましょう：

public abstract class Employee { 
    abstract int calculatePay(int h); 
} 

ワード抽象が、この方法は、実際の実装を持っていないが、賃金を計算するためのすべてのロジックは、サブクラスの販売に置かれることを意味し、クックとチーフ：

public class Cook extends Employee { 

    public Cook() {} 

    int calculatePay(int h) { 
     int sum = (h > 20) ? 20 : 0; 
     if (h > 8) { 
      sum = 30 * (h - 8); 
      sum += 15 * 8; 
     } else { 
      sum += 15 * h; 
     } 
     return sum; 
    } 
} 

注ライン：

int sum = (h > 20) ? 20 : 0; 

これはの3進演算子です。時には、式の条件付き代入にも適しています。したがってhが20より大きい場合はsum変数を20で初期化し、それ以外の場合は0で初期化します。今度は、私たちのメソッドの最後に余分なifステートメントを使用しません。

今、各従業員が自分自身のために賃金を計算するための責任があるとPayCalculatorクラスに型チェックを実行する必要はありません - それは実行時に動的に解決されたパラメータの種類に基づいて実行するコード：

public class PayCalculator { 

    int pay(Employee e, int hours) { 
     return e.calculatePay(hours); 
    } 

    public static void main(String[] args) { 
     Seller seller = new Seller(); 
     Cook cook = new Cook(); 
     Chief chief = new Chief(); 

     PayCalculator calc = new PayCalculator(); 

     System.out.println("Seller is payed " + calc.pay(seller, 15)); 
     System.out.println("Cook is payed " + calc.pay(cook, 10)); 
     System.out.println("Chief is payed " + calc.pay(chief, 22)); 
    } 
} 

これはポリモニズムと呼ばれます。この用語は、あなたに新しいものである場合、あなたはOOPの基本でOracleのチュートリアルを読むことができます：ブルース・Eckel氏によるhttps://docs.oracle.com/javase/tutorial/java/concepts/index.htmlのJavaに考える

本は、基本的なOOPの概念の良い説明があります。

Answer 2

java.util.Mapは、if /他の多くを保存、およびJava 8でユーザー

public class X { 

    public enum Type { 
     SELLER, COOK, CHIEF 
    } 

    private Map<Type, Integer> constantValue1; 
    private Map<Type, Integer> constantValue2; 
    private Map<Type, Integer> additionalValue; 

    public X() { 
     initialConstantValue1(); 
     initialConstantValue2(); 
     initialAdditionalValue(); 
    } 

    private void initialConstantValue1() { 
     constantValue1 = new HashMap<>(); 
     constantValue1.put(Type.SELLER, 20); 
     constantValue1.put(Type.COOK, 30); 
     constantValue1.put(Type.CHIEF, 66); 
    } 

    private void initialConstantValue2() { 
     constantValue2 = new HashMap<>(); 
     constantValue2.put(Type.SELLER, 10); 
     constantValue2.put(Type.COOK, 15); 
     constantValue2.put(Type.CHIEF, 22); 
    } 

    private void initialAdditionalValue() { 
     additionalValue = new HashMap<>(); 
     additionalValue.put(Type.SELLER, 10); 
     additionalValue.put(Type.COOK, 20); 
     additionalValue.put(Type.CHIEF, 30); 
    } 

    int pay(final Type type, final int h) { 
     int sum = 0; 
     if (h > 8) { 
      sum = constantValue1.get(type) * (h - 8); 
      sum += constantValue2.get(type) * 8; 
     } 
     else { 
      sum += constantValue2.get(type) * h; 
     } 
     if (h > 20) { 
      sum += additionalValue.get(type); 
     } 
     return sum; 
    } 

} 

Answer 3

の選択肢としてEnumを使用し、言語は、クリーンアップの機能の種類のために使用することができる様々な機能のビットを取得しました。

import java.util.EnumMap; 
    import java.util.function.IntFunction; 

    public class Calc8 { 

     public enum Employee { 
      SELLER, COOK, CHIEF; 
     } 

     private final EnumMap<Employee, IntFunction<Integer>> map = new EnumMap<>(Employee.class); 

     public Calc8() { 
      map.put(Employee.SELLER, h -> { 
       int sum = h > 8 ? 20 * (h - 8) + 80 : 10 * h; 
       return h > 20 ? sum + 10 : sum; 
      }); 
      map.put(Employee.COOK, h -> { 
       int sum = h > 8 ? 30 * (h - 8) + (15 * 8) : 15 * h; 
       return h > 20 ? sum + 20 : sum; 

      }); 
      map.put(Employee.CHIEF, h -> { 
       int sum = h > 8 ? 66 * (h - 8) + (22 * 8) : 22 * h; 
       return h > 20 ? sum + 30 : sum; 
      }); 
     } 

     public int evaluate(Employee e, int value) { 
      return map.get(e).apply(3); 
     } 

     public static void main(final String[] args) { 
      Calc8 c = new Calc8(); 
      System.err.println(c.evaluate(Employee.CHIEF, 3) + " should be 66"); 
     } 
    }