深入學習java原始碼之Math.ulp()與 Math.signum()

swtich()變數型別只能是int、short、char、byte和enum型別（JDK 1.7 之後，型別也可以是String了）。當進行case判斷時，JVM會自動從上到小掃描，尋找匹配的case，可能存在以下情況：

當每一個case都不存在break時，匹配成功後，從當前case開始，依次返回後續所有case的返回值。

        int i = 2;
        switch(i){
        case 0:
            System.out.println("0");
        case 1:
            System.out.println("1");
        case 2:
            System.out.println("2");
        default:
            System.out.println("default");
        }

輸出：2
     default
 

若當前匹配成功的case不存在break，則從當前case開始，依次返回後續case的返回值，直到遇到break，跳出判斷。

        int i = 2;
        switch(i){
        case 0:
            System.out.println("0");
        case 1:
            System.out.println("1");
        case 2:
            System.out.println("2");
        case 3:
            System.out.println("3");break;
        default:
            System.out.println("default");
        }


輸出：2
     3
 

default的運用，是當switch語句裡，所有的case語句都不滿足條件時，則執行default語句

default在switch開頭：
若所有case都不滿足條件，則執行default語句，並執行default語句之後的case語句，直到break或結束

default在switch中間：（同上）
若所有case都不滿足條件，則執行default語句，並執行default語句之後的case語句，直到break或結束

default在switch末尾：
若所有case語句都不滿足條件，則執行default語句，結束；若有case滿足，則執行case語句直到遇到break或switch語句結束，所以default在最後一行時break可以省略不寫（但是不建議省略，以求嚴謹）

switch語句當中，用於終止語句

	getDetail:function(type,Id){
			var param = {
					id:Id	
			}
		var url = "";
		switch(type)
		{
			case 0:
				url = "";
				break;
			case 1:
				url = "/";
				break;
		}
	}

java原始碼

public final class Math {

    private Math() {}
	
	public static int getExponent(float f) {
        /*
         * Bitwise convert f to integer, mask out exponent bits, shift
         * to the right and then subtract out float's bias adjust to
         * get true exponent value
         */
        return ((Float.floatToRawIntBits(f) & FloatConsts.EXP_BIT_MASK) >>
                (FloatConsts.SIGNIFICAND_WIDTH - 1)) - FloatConsts.EXP_BIAS;
    }
	
    public static int getExponent(double d) {
        /*
         * Bitwise convert d to long, mask out exponent bits, shift
         * to the right and then subtract out double's bias adjust to
         * get true exponent value.
         */
        return (int)(((Double.doubleToRawLongBits(d) & DoubleConsts.EXP_BIT_MASK) >>
                      (DoubleConsts.SIGNIFICAND_WIDTH - 1)) - DoubleConsts.EXP_BIAS);
    }

    public static double ulp(double d) {
        int exp = getExponent(d);

        switch(exp) {
        case DoubleConsts.MAX_EXPONENT+1:       // NaN or infinity
            return Math.abs(d);

        case DoubleConsts.MIN_EXPONENT-1:       // zero or subnormal
            return Double.MIN_VALUE;

        default:
            assert exp <= DoubleConsts.MAX_EXPONENT && exp >= DoubleConsts.MIN_EXPONENT;

            // ulp(x) is usually 2^(SIGNIFICAND_WIDTH-1)*(2^ilogb(x))
            exp = exp - (DoubleConsts.SIGNIFICAND_WIDTH-1);
            if (exp >= DoubleConsts.MIN_EXPONENT) {
                return powerOfTwoD(exp);
            }
            else {
                // return a subnormal result; left shift integer
                // representation of Double.MIN_VALUE appropriate
                // number of positions
                return Double.longBitsToDouble(1L <<
                (exp - (DoubleConsts.MIN_EXPONENT - (DoubleConsts.SIGNIFICAND_WIDTH-1)) ));
            }
        }
    }

    public static float ulp(float f) {
        int exp = getExponent(f);

        switch(exp) {
        case FloatConsts.MAX_EXPONENT+1:        // NaN or infinity
            return Math.abs(f);

        case FloatConsts.MIN_EXPONENT-1:        // zero or subnormal
            return FloatConsts.MIN_VALUE;

        default:
            assert exp <= FloatConsts.MAX_EXPONENT && exp >= FloatConsts.MIN_EXPONENT;

            // ulp(x) is usually 2^(SIGNIFICAND_WIDTH-1)*(2^ilogb(x))
            exp = exp - (FloatConsts.SIGNIFICAND_WIDTH-1);
            if (exp >= FloatConsts.MIN_EXPONENT) {
                return powerOfTwoF(exp);
            }
            else {
                // return a subnormal result; left shift integer
                // representation of FloatConsts.MIN_VALUE appropriate
                // number of positions
                return Float.intBitsToFloat(1 <<
                (exp - (FloatConsts.MIN_EXPONENT - (FloatConsts.SIGNIFICAND_WIDTH-1)) ));
            }
        }
    }	
	
    public static double signum(double d) {
        return (d == 0.0 || Double.isNaN(d))?d:copySign(1.0, d);
    }

    public static float signum(float f) {
        return (f == 0.0f || Float.isNaN(f))?f:copySign(1.0f, f);
    }

}	

public final class StrictMath {

    private StrictMath() {}

    public static double ulp(double d) {
        return Math.ulp(d);
    }
	
    public static float ulp(float f) {
        return Math.ulp(f);
    }

    public static double signum(double d) {
        return Math.signum(d);
    }

    public static float signum(float f) {
        return Math.signum(f);
    }	

    public static int getExponent(float f) {
        return Math.getExponent(f);
    }
	
    public static int getExponent(double d) {
        return Math.getExponent(d);
    }

}