Combate real si, si no, demasiada explicación detallada

1. El código de ejemplo en este artículo es solo dos pequeños ejemplos.

paquete com.example.demo.pattern.ifElse; 


importar java.util.HashMap; 
import java.util.LinkedHashMap; 
import java.util.Map; 
import java.util.function.Consumer; 
import java.util.function.Function; 

/ ** 
* 如何 解决 解决 类似
* 1 if (condición1) { 
* 2 
* 3} más if (condición2) { 
* 4 
* 5} else if (condición3) { 
* 6 
* 7} else if (condición4) { 
* 8 
* 9} else { 
* 10 
* 11} 
* 
* 1 if (param.equals (value1)) { 
* 2 doAction1 (someParams); 
* 3} else if (param.equals (value2)) { 
* 4 doAction2 (someParams);
* 5} else if (param.equals (value3)) { 
* 6 doAction3 (someParams); 
* 7} 
* 8 
* / 
public class SolveIfElseOne { 
     // Definir la estructura pertenece al modo de fábrica 
    static static final Map <String, Consumer <String> > map = new HashMap <> (); 
    // LinkedHashMap se utiliza para garantizar el pedido de 
    un mapa estático privado final <Integer, Function <Integer, Double >> map1 = new LinkedHashMap <> (); 
    // Datos iniciales 
    estáticos { 
        map .put ("1", (param) -> {doAction1 (param);}); 
        map.put ("2", (param) -> {doAction2 (param);}); 
        map.put ("3" , (param) -> {doAction3 (param);}); 

        map1.put (2200, (param) -> {return doAction2200 (param);}); 
        map1.put (2700,(param) -> {return doAction2700 (param);});
        map1.put (3200, (param) -> {return doAction3200 (param);}); 
    } 


    / ** 
     * 未 重构 前
     * / 
    public void handle (String param) { 
        if (param.equals ("1")) { 
            doAction1 (param); 
        } else if (param.equals ("2")) { 
            doAction2 (param); 
        } else if (param.equals ("3")) { 
            doAction3 (param); 
        } 
    } 

    public static void doAction1 (String param) { 
        System.out.println (param); 
    } 

    public static void doAction2 (String param) { 
        System.out.println (param); 
    } 

    public static void doAction3 (Parámetros de cadena) {
        System.out.println (param); 
    } 

    // 未 重构 前
    / * 1 si el ingreso <= 2200 
            2 impuesto = 0 
            3 más si el ingreso <= 2700 
            4 impuesto = 0.14 * (ingreso - 2200) 
            5 más si el ingreso <= 3200 
            6 impuesto = 70 + 0.15 * (ingreso - 2700) 
            7 más si ingreso <= 3700 
            8 impuesto = 145 + 0.16 * (ingreso - 3200) 
            9 ...... 
            10 más 
            11 impuesto = 53090 + 0.7 * (ingreso - 102200) * / 



    público doble estático doAction2200 (int ingreso) { 
        doble impuesto = 0; 
        impuesto de devolución = 0; 
    } 

    public static double doAction2700 (int ingresos) {
        doble impuesto = impuesto = 0.14 * (ingreso - 2200); 
        impuesto de devolución; 
    } 

    public static double doAction3200 (int ingreso) { 
        double tax = 70 + 0.15 * (ingreso - 2700); 
        impuesto de devolución; 
    } 


    // 重构 后 只 需要 循环 一次 即可
     public static double getTax (int ingresos) { 
        double res = 0; 
        for (Entero entero: map1.keySet ()) { 
               if (ingreso <= entero) { 
                   System.out.println (entero + ""); 
                   res = map1.get (entero) .apply (ingreso); 
                   System.out.println (map1.get (entero) .apply (ingreso) + ""); 
                   rotura; 
               } 
        }
        volver res; 
     } 






    public static void main (String [] args) { 
        SolveIfElseOne.map.get ("1"). accept ("1"); 

        System.out.println (getTax (3200)); 

    } 

}