一、System 类

1、概述：

1、System类是描述系统一些信息的类，不可以实例化，也无构造函数。

2、System类中的方法和属性都是静态的。
in ：标准输入流，默认是键盘。
out：标准输出流，默认是控制台。

2、方法：

1、获取系统的属性信息：

Properties getProperties();

说明：
1）此方法返回的双列集合，即键值对；因为Properties是Hahstable的子类，也就是Map集合的一个子类对象，那么通过Map方法取出该集合中的元素。
2）该集合存储的都是字符串，没有泛型定义

2、获取指定属性信息：

String System.getProperty(String key);

3、在系统内定义特有信息：

void System.setProperty(String key,String value);

4、如何在jvm启动时，加载一些属性信息：
通过命令：java -D<name>=<value> 可以设置特有的系统属性信息

示例：

......
String s = getProperty("os.name");  
System.out.println("os.name|:" + s);  
System.setProperty("name----:","xixi");  
System.out.println("-------------------------");  
String v = System.getProperty("myName");  
System.out.println("v = " + v);  
Properties pop = System.getProperties();  
for(Object obj : pop.keySet())  
{  
    String value = (String)pop.get(obj);  
    out.println(obj + ":" + value);  
}  
......

二、Runtime 类

1、概述：

1、每个java应用程序都有一个Runtime类实例，使用应用程序能与其中运行的环境相连接，应用程序不能创建自己的Runtime类的实例，是由系统底层自己创建的。

2、该类并未提供构造函数：说明不可以new对象，那么会直接想到该类中的方法都是静态的。查阅API文档发现，该类中还有非静态方法，说明该类中肯定会提供方法获取该类对象，并且该方法是静态的，且返回值类型是该类类型。

3、由这个特点可以看出该类使用了单例设计模式。

2、方法：

1、获取本类对象：

static Runtime getRuntime();

2、在单独的进程中执行指定字符串命令：

Process exec(String command);

3、在Process中有一个杀掉子进程的方法，可将exec方法开启的进程杀掉

void destroy();

示例：

......  
Runtime r = Runtime.getRuntime();  
Process p = r.exec("winmine.exe");  
//System.out.println(r);  
Thread.sleep(6000);  
p.destroy();  
......  

三、时间类

1、Date类

1、概述：
java中默认的格式如：Sun Jan 16 10:20:48 CST 2011
这样的格式不一定满足每个人的需求，那么就需要自定义格式，需要格式化模式。

具体步骤：
1）创建Date对象
2）将模式封装到SimpleDateFormat对象中
3）调用format方法让模式格式化指定Date对象

示例：

......  
Date d = new Date();  
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 E hh:mm:ss");  
String time = sdf.format(d);  
System.out.println("Time =" + time);  
......  

2、Calendar类

1、概述：
1）Calendar是一个抽象类，它为特定瞬间与一组诸如YEAR、MONTH、DAY_OF_MONTH等日历字段之间的转换提供了一些方法。
2）Calendar可以对年月日等时间进行获取。并提供了相应的子段值。可参阅API文档。

2、方法：
2.1、基本获取时间
1）获取年份：Calendar.YEAR
2）获取月份：Calendar.MONTH
3）获取日期：Calendar.DAY_OF_MONTH
4）获取星期：Calendar.DAY_OF_WEEK
5）获取小时：Calendar.HOUR_OF_DAY
6）获取分钟：Calendar.MINUTE
7）获取秒数：Calendar.SECOND

2.2、设置时间：
1）为给定的日历字段添加或减去指定的时间值： ---> void add(int field,int amount);
2）获取指定的日历字段对应的时间值： ---> int get(int field);
3）将给定日历字段对应的时间值设置为给定值： ---> void set(int field,int value);
设置日历字段 YEAR、MONTH和DAY_OF_MONTH的值： ---> void set(int year,int month,int date);

3、关于Calendar中的常量值理解：
当我在获取时间的时候，会少写get方法，而直接写的是Calendar.DAY_OF_MONTH，结果发现不是自己想要的值，而是一个固定为5的值，为什么呢？

今天我翻阅了api文档，查看了一下关于Calendar中的DAY_OF_MONTH字段数字，没错，它被称为get 和 set 的字段数字，而且你细心一点就会发现，它是这样被定义的：

public static finalint DAY_OF_MONTH

发现这些字段数字都是静态的常量值，那为什么还能对其修改呢？还可以使用add，set等方法对其设置呢？我对这个问题开始也很迷惑，百度了之后，才大概有些明白，我的理解是这样的：

你可以把这个Calendar中的YEAR的常量值理解为它的小名，打个比方说，一个人大名叫张三，你可以叫他的小名为小张，这个张三就相当于YEAR，而这个小张就是YEAR的常量值，为什么要这么设置呢？

这就要和字段值相联系了。其实，这些设置的操作是对具体时间的修改，而不是对这些字段值的修改，获取的也是修改后的时间值。之所以称之为字段值，就是应为方便设置：简单地说就是将日期分为几段，如图所示：

YEAR	MONTH	DAY_OF_MONTH	...
1	2	5	...

(相应的字段值请看Calendar的常量值)

那么要是对某一部分进行修改的话，如设置年份为2013年，则为set(1，2013)

set(int code,int value){  
switch(code){  
case 1:  
  修改年代  
}  
}

其中的code就相当于字段值，而value就是所要设置的时间值，那么字段值是常量就不会改变的。而是将字段值（键）这个常量所对应的要修改的时间值（值）进行修改。所以并没有改变这个常量，为何还要写成YEAR这样的单词呢，而不是用1表示呢？当然，这就是静态常量的好处了，设为静态static就是为了加载Calendar这个类的时候就存在了，直接可以用了；而设为常量final就是为了方便识别，用起来方便，名字好记，而不用记那么多数字。（其实就可以理解为相应的数字代表相应的时间名称）。

简单地说，就是你修改的是Calenda中某个字段值的属性，改变的是它的状态，而不是它的时间这个名字。如，不是将YEAR的字段值1改变为2013，而是将这个字段值为1的YEAR所对应的时间值2012年改为2013这个数值。一个是数字（字段值），一个是数值（时间值或称为时间信息）。

示例：

......  
String[] mons = {"一月","二月","三月",  
                "四月","五月","六月","七月",  
                "八月","九月","十月","十一月","十二月"};  
int m = c.get(Calendar.MONTH);  
String[] weeks = {"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};  
int w = c.get(Calendar.DAY_OF_WEEK);  
sop(c.get(Calendar.YEAR) + "年");  
sop(mons[m]);  
sop(c.get(Calendar.DAY_OF_MONTH) + "日");  
sop(weeks[w]);  
......  
c.add(Calendar.YEAR,5);//当前年份加上5年  
c.add(Calendar.DAY_OF_MONTH,32);//时间是连续的，满当前月则前进或后退相应的天数  
...... 

练习：
1、获取任意年的二月有多少天：
2、获取前一天的现在这个时刻
3、计算有效上课天数，每周六日不上课，计算任意年从九月到十月的有效上课天数

import java.util.*;  
  
class CalendarTest   
{  
    public static void sop(Object obj)  
    {  
        System.out.println(obj);  
    }  
    public static void main(String[] args)   
    {  
        //测试1  
        int n = getFEB(2012);  
        sop("2012年2月的天数：" + n);  
        //测试2  
        String s = getTheTime();  
        sop("昨天的现在这个时刻是：" + s);  
        sop("-----------------");  
        //测试3  
        int m = getValDay(2013,1,3);  
        sop("有效上课天数：" + m);  
  
    }  
    //测试1：创建获取二月的方法  
    public static int getFEB(int year)  
    {  
        Calendar c = Calendar.getInstance();  
        //设置任意年的时间为3月1号  
        c.set(year,2,1);  
        //获取设置后的3月1日，并减去1天，即为二月最后一天  
        c.add(Calendar.DAY_OF_MONTH,-1);  
        //获取最终设置的日期，即为获取到的二月的天数  
        int n = c.get(Calendar.DAY_OF_MONTH);  
        return n;  
    }  
  
    //测试2：获取前一天的现在这个时刻  
    public static String getTheTime()  
    {  
        //获取时间信息  
        Calendar c = Calendar.getInstance();  
        //将日期设置为昨天  
        c.add(Calendar.DAY_OF_MONTH,-1);  
        //获取昨天的现在这个时刻  
        int n = c.get(Calendar.DAY_OF_MONTH);  
        return n + "日 " + c.get(Calendar.HOUR_OF_DAY) + ":" + c.get(Calendar.MINUTE) + ":" + c.get(Calendar.SECOND);  
    }  
  
    //测试3：计算有效上课天数  
    public static int getValDay(int year,int startMON,int endMON)  
    {  
        //获取时间信息  
        Calendar c = Calendar.getInstance();  
        //调用获取天数函数  
        int day = getDay(c,year,startMON,endMON);  
        sop("总天数：" + day);//测试获取的天数  
        //初始化星期  
        int week = 0;  
        //定义计数器  
        int count = 0;  
        //遍历每天一天，判断是否为周六日，f否的话计数器自增  
        for(int i=0;i<day;i++)  
        {  
            //必须要先将天数加1再判断，否则到week为6的时候会一直continue，  
            //而且此处也可以避免下面的week是以星期日为第一天的问题  
            c.add(Calendar.DAY_OF_MONTH,1);  
            //获取当前天数的星期  
            week = c.get(Calendar.DAY_OF_WEEK);  
            sop("星期：" + week);  
            if (week==6 || week==7)  
                continue;  
            count++;  
            sop("有效天数：" + count);  
        }  
        return count;  
    }  
    //获取给定月份的天数  
    public static int getDay(Calendar c,int year,int startMON,int endMON)  
    {  
        //定义天数和变量  
        int sum = 0;  
        //遍历每个月的天数  
        for(int i=0;i<=endMON-startMON;i++)  
        {  
            //设定第二个月的第一天，循环一次后设定下个月为处世月，因为0为一月份所以startMON要加1  
            c.set(year,startMON+i,1);  
            //获取前一个月的天数  
            c.add(Calendar.DAY_OF_MONTH,-1);  
            //将每个月的天数累加  
            sum += c.get(Calendar.DAY_OF_MONTH);  
            //循环后，要相应加上i个月  
            c.add(Calendar.MONTH,i+1);  
        }  
        return sum;  
    }  
}

四、Math 类

1、概述：

Math类中全为静态方法，都是数学中的一些计算方法。

2、方法：

1、double ceil(double d) ---> 返回大于指定数据的最小整数
2、double floor(double d) ---> 返回小于指定数据的最大整数
3、double pow(double a,double b) ---> 返回a的b次方
4、double/float round(double/float m) ---> 返回m四舍五入的值
5、double random() ---> 返回正号的double值，是一个 0<=X<1.0 的随机数X

3、Random类

这是一个java.util中的一个单独的类，获取随机数。与Math中的random是一样的，不过这个类有自身的方法，可以将相应的随机数强转为指定基本数据类型。

如：

int nextInt(int n)

示例：

import java.util.*;  
class  MathDemo  
{  
    public static void sop(Object obj)  
    {  
        System.out.println(obj);  
    }  
    public static void main(String[] args)   
    {  
        double d = 0;  
        int n = 0;  
        //Math类测试  
        sop("-----------Math类测试-------------");  
        d = Math.ceil(15.66);  
        sop("ceil(15.66):" + d);  
        d = Math.floor(15.66);  
        sop("floor(15.66):" + d);  
        d = Math.pow(2,3);  
        sop("pow(2,3):2e3 = " + d);  
        d = Math.round(15.66);  
        sop("round(15.66):" + d);  
        d = Math.round(15.43);  
        sop("round(15.43):" + d);  
  
        for(int i=0;i<5;i++)  
        {  
            d = Math.random();  
            n = (int)(Math.random()*10+1);  
            sop("rondam():" + d + ",(int):" + n);  
        }  
        sop("-----------Random类测试-------------");  
        Random r = new Random();  
  
        for(int i=0;i<5;i++)  
        {  
            n = r.nextInt(10);  
  
            sop("Rondam():" + n);  
        }  
    }  
}

练习：将某一小数保留为指定位数的小数

class MathDemo  
{  
    public static void main(String[] args)   
    {  
        double d = round(15.6745,1);  
        System.out.println("d = " + d);  
    }  
    //保留指定位数为n的小数  
    public static double round(double d,int n)  
    {  
        //将给定数扩大n倍后四舍五入，再缩小相应的倍数  
        return Math.round(d*(Math.pow(10,n)))/(Math.pow(10,n));   
    }  
}