java 学习System，Integer，Math类的学习及其源码观看后的分析

这三个类的代码实在是有些复杂，真的是很难看懂自己现在只能把自己现在看懂的东西给写下来，现在先占坑，以后肯定会继续写的。
现在先看了System的源码，他的公有的数据类型有很多，比如

 public final static InputStream in = null;
     public final static PrintStream out = null;
        public final static PrintStream err = null;

他有三个公有的属性 ，现在这三个属性分析一下
in 对象是一个输入流对象
InputStream的作用是用来表示那些从不同数据源产生输入的类
简单来说就是从一个对象中获取到信息
out 是一个输入流的对象
将基本的数据类型的数据或引用数据类型的对象格式化成字符串后再输出。使用该类不必书写转化成字符串的操作方法，可以直接输出。
也可以说从你将你输入流中的东西提取出来，然后写入对象中。
err也是一个输出流的对象，但是我自己试了一下err的输出的时候，他和out还是有一点区别的，最简单来说，他输出的东西是红色的 ，然后我看了一下网上对他的解说这个对象主要用来输出错误的信息。
因为他基本所有的方法都是静态的，所以使用System类的时候不需要实例化一个对象，只需要调用他的方法就好。
Math源码

 public static final double E = 2.7182818284590452354;
  public static final double PI = 3.14159265358979323846;

这是里面的两个数据自然常数和π的值，应该是做具体的运算要用到
举个栗子

    public static double sin(double a) {
        return StrictMath.sin(a); // default impl. delegates to StrictMath
    }

这是sin函数的源码
这里还是用了一个 StrictMath类的cin函数，当我进一步查看， StrictMath类的时候

    public static native double sin(double a);

只有一个接口，我上网查了一下
native 关键字

在网上搜了一些资料

使用native关键字说明这个方法是原生函数，也就是这个方法是用C/C++语言实现的，并且被编译成了DLL，由java去调用。
这些函数的实现体在DLL中，JDK的源代码中并不包含，你应该是看不到的。对于不同的平台它们也是不同的。
这也是java的底层机制，实际上java就是在不同的平台上调用不同的native方法实现对操作系统的访问的。

好吧底层的
再看一个栗子
返回0-1的随机数随机数的最底层的代码
public double nextDouble() { return (((long)(next(26)) << 27) + next(27)) * DOUBLE_UNIT; }

求绝对值
其实有几种，用了继承和多态 基本原理一样，只是接受的函数和返回值变了。
public static int abs(int a) { return (a < 0) ? -a : a; }
Math太难了

最后说Integer类吧

public static final int MAX_VALUE = 0x7fffffff;
MIN_VALUE = 0x80000000;

`public static String toString(int i, int radix) {
if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
radix = 10;

    /* Use the faster version */
    if (radix == 10) {
        return toString(i);
    }

    char buf[] = new char[33];
    boolean negative = (i < 0);
    int charPos = 32;

    if (!negative) {
        i = -i;
    }

    while (i <= -radix) {
        buf[charPos--] = digits[-(i % radix)];
        i = i / radix;
    }
    buf[charPos] = digits[-i];

    if (negative) {
        buf[--charPos] = '-';
    }

    return new String(buf, charPos, (33 - charPos));
}

toString源码，看不太懂== ==

转换进制的源码

public static int parseInt(String s, int radix)
                throws NumberFormatException
    {
        /*
         * WARNING: This method may be invoked early during VM initialization
         * before IntegerCache is initialized. Care must be taken to not use
         * the valueOf method.
         */

        if (s == null) {
            throw new NumberFormatException("null");
        }

        if (radix < Character.MIN_RADIX) {
            throw new NumberFormatException("radix " + radix +
                                            " less than Character.MIN_RADIX");
        }

        if (radix > Character.MAX_RADIX) {
            throw new NumberFormatException("radix " + radix +
                                            " greater than Character.MAX_RADIX");
        }

        int result = 0;
        boolean negative = false;
        int i = 0, len = s.length();
        int limit = -Integer.MAX_VALUE;
        int multmin;
        int digit;

        if (len > 0) {
            char firstChar = s.charAt(0);
            if (firstChar < '0') { // Possible leading "+" or "-"
                if (firstChar == '-') {
                    negative = true;
                    limit = Integer.MIN_VALUE;
                } else if (firstChar != '+')
                    throw NumberFormatException.forInputString(s);

                if (len == 1) // Cannot have lone "+" or "-"
                    throw NumberFormatException.forInputString(s);
                i++;
            }
            multmin = limit / radix;
            while (i < len) {
                // Accumulating negatively avoids surprises near MAX_VALUE
                digit = Character.digit(s.charAt(i++),radix);
                if (digit < 0) {
                    throw NumberFormatException.forInputString(s);
                }
                if (result < multmin) {
                    throw NumberFormatException.forInputString(s);
                }
                result *= radix;
                if (result < limit + digit) {
                    throw NumberFormatException.forInputString(s);
                }
                result -= digit;
            }
        } else {
            throw NumberFormatException.forInputString(s);
        }
        return negative ? result : -result;
    }
    public static Integer valueOf(String s, int radix) throws NumberFormatException {
        return Integer.valueOf(parseInt(s,radix));
    }

以及求int values函数

    public static Integer valueOf(String s, int radix) throws NumberFormatException {
        return Integer.valueOf(parseInt(s,radix));
    }

以及转换类型

    public double doubleValue() {
        return (double)value;
    }

就这样 以后多看懂一些再来补充