常用类和异常

常用类和异常

回顾

1 包装类:
  byte- Byte
  short-Short
  int-Integer
  long -Long
  float-Float
  double-Double
  char- Character
  boolean -Boolean

   Integer 
   1 如果使用 Integer 创建对象，数据在堆中存放
   2 Integer i=100;  Integer i2=100;//是同一个对象 ，Integer中有缓冲区
   3 装箱  基本类型转成包装类 拆箱 包装类转成基本类型
2 基本类型和字符串之间 
   2.1基本类型转成字符串
        int i=5;
        String s=i+"";
        String.valueof(i);
   2.2字符串转成基本类型
       String s="12";
       int i=Integer.parseInt(s);
3 字符串操作
	（1）存储常量池中（串池），不允许有重复
	（2）不可变性
	（3）new String("xxx"); 数据存储在堆中
    String s="xxx"; //串池
    String s2=new String("xxx");//在堆中
    //长度
    s.length();
    //查找位置
    indexOf
    lastIndexOf
    //截取
    subString();
    //追加
    concat();
    //替换
    replace();
    //相等比较
    equals()
    //比较
    compareTo()
    //拆分
    split()
    //去调空格
    trim()
4 StringBuffer 增强的String,  追加 插入 替换  
  StringBuilder  jdk1.5  
  区别:
  1 功能一样
  2 StringBuffer线程安全，StringBuilder线程不安全
  3 StringBuilder效率高
5 正则表达式
   a
  [abc]
  [^abc]
  [a-z]
  [a-zA-Z]
  \d 0-9
  \w a-zA-Z_0-9
  
  .任意字符 
  ^ 表示开始
  $ 表示结束
  
  * 0次或多次
  + 1次或多次
  ? 0或1次
  {n} n次
  {n,} 大于等于n次
  {n,m} 大于等于n次，小于等于m次
 
 1 匹配 matches(reg)
 2 拆分 split();
 3 获取 
 4 替换 replaceAll(reg,replace);
  
Pattern 正则表达式类 Pattern.compile("正则表达式");
	Pattern p=Pattern.compile(reg);
	Matcher matcher=p.matcher(str);
	boolean b=matcher.matches();
	
	Pattern.matchers(reg,str);
	
Matcher 匹配器类

今天任务

1.常用基础类
	1.1 Date类
	1.2 Calendar类
	1.3 SimpleDateFormat类
	1.4 Math类
	1.5 Random类
	1.6 System类
	1.7 Runtime类
2.枚举
	2.1 什么是枚举
	2.2 枚举结合switch的使用
3.异常
	3.1异常的概念
	3.2异常的分类
	3.3异常处理

教学目标

1.了解常用类的作用
2.掌握常用类中的常用方法
3.了解枚举的使用
4.掌握异常处理

第一节 常用基础类

1.1 Date类

Date表示特定的瞬间，精确到毫秒。Date类中的大部分方法都已经被Calendar类中的方法所取代。

Date类中的构造方法：

方法名	描述
Date()	分配Date对象并初始化此对象，以表示分配它的时间（精确到毫秒）。
Date(long date)	分配Date对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。

Date类中的成员方法：

​ 1.判断两个日期对象的前后

		Date date1 = new Date();//获取当前系统时间
		Date date2 = new Date(10000);//获取从标准基准时间起10000毫秒的时间点
		boolean boo1 = date1.after(date2);//若date1在date2之后，则返回true，否则返回false
		boolean boo2 = date1.before(date2);//若date1在date2之前，则返回true，否则返回false

​ 2.比较两个日期对象

		Date date1 = new Date();
		Date date2 = new Date(10000);
		int i = date1.compareTo(date2);

​ 3.获取时间

		Date date = new Date();
		long l = date.getTime();

​ 4.修改时间

		Date date = new Date();
		date.setTime(1000);

1.2 Calendar类

Calendar类是一个抽象类，它为特定瞬间与一组诸如YEAR、MONTH、DAY_OF_MONTH、HOUR
等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。瞬间可用毫秒值来表示，它是距历元（即格林威治标准时间 1970 年 1 月 1 日的 00:00:00.000，格里高利历）的偏移量。

Calendar类时抽象类不能创建对象，可以通过Calendar类中的静态getInstance方法获取对象（一个费抽象子类对象）.

Calendar类中的常用静态常量属性：

属性	描述（这些都是特定与日历的值）
public static final int YEAR	指示年的字段数字
public static final int MONTH	指示月份的字段数字
public static final int DATE	指示一个月中的某天
public static final int DAY_OF_MONTH	指示一个月中的某天
public static final int DAY_OF_WEEK	指示一周中的某天
public static final int DAY_OF_WEEK_IN_MONTH	指示当月中的第几个星期
public static final int DAY_OF_YEAR	指示一年中的某天

Calendar类中常用的成员方法：

​ 1.获取一个Calendar对象：

		Calendar c = Calendar.getInstance();//getInstance方法是一个静态的方法，直接通过类名调用
		System.out.println(c);

​ 2.获取某个日历对象的指定属性的值：

		/*
		get(int field)	参数就是指定的属性，可以使用静态常量属性名代替int值
		*/
		//注意：获取日期属性，不能直接用c.DATE，DATE属性时静态常量，所有Calendar类对象都共享并相同的值
		Calendar c = Calendar.getInstance();
		System.out.println(c.get(Calendar.DATE));//获取c对象所表示日历的日期属性值

​ 3.修改某个日历对象的指定属性值：

		/*
		set(int field, int value) 第一个参数表示属性，第二个参数表示修改的值
		*/
		Calendar c = Calendar.getInstance();	
		c.set(Calendar.YEAR, 2017);

​ 4.获取某个属性所表示的最大、最小值

		/*
		getMaximum(int field)		获取属性的最大值
		getMinimum(int field)		获取属性的最小值
		*/
		Calendar c = Calendar.getInstance();
		int max = c.getMaximum(Calendar.DATE);//获取日期的最大值,无论c表示几月份,max的值都是31
		int min = c.getMinimum(Calendar.DATE);//获取日期的最小值,无论c表示几月份,min的值都是1

​ 5.获取指定Calendar对象的指定属性的最大、最小值

		/*
		getActualMaximum(int field)	获取指定日历的指定属性的最大值
		getActualMinimum(int field)	获取指定日历的指定属性的最小值
		*/
		Calendar c = Calendar.getInstance();
		int max = c.getActualMaximum(Calendar.DATE);
		//若c表示的1月，则max值为31；若c表示的4月，则max值为30；
		int min = c.getActualMimimum(Calendar.DATE);//无论c表示几月份，min值都是1

1.3 SimpleDateFormat类

SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类。

它允许进行格式化（日期 -> 文本）、解析（文本 -> 日期）和规范化。

通过SimpleDateFormat类将字符串和日期相互转换时，需要使用一些时间模式字母，常用的时间模式字母：

字母	日期或时间元素	示例
y	年	1996;96
M	年中的月份	July;Jul;07
w	年中的周数	27
D	年中的天数	189
d	月份中的天数	10
a	Am/pm 标记	PM
H	一天中的小时数（0-23）	0
h	am/pm 中的小时数（1-12）	12
m	小时中的分钟数	30
s	分钟中的秒数	55
S	毫秒数 1秒=1000毫秒 =1000000微秒=1000000000毫微秒(纳秒)	978

​ 1.格式化日期：

		/*
		format(Date date)	将date对象格式化成指定格式的日期字符串
		*/
		String format = "yyyy-MM-dd a hh:mm:ss";
		SimpleDateFormat sdf = new SimpleDateFormat(format);
		Date date = new Date();
		String dateStr = sdf.format(date);

​ 2.解析日期：

		/*
		parse(String str)	将str对象解析成一个日期对象
		*/
		String dateStr = "2017-12-01 上午 10:10:10";
		String format = "yyyy-MM-dd a hh:mm:ss";
		SimpleDateFormat sdf = new SimpleDateFormat(format);
		Date date = sdf.parse(dateStr);

1.4 Math类

Math类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。

Math类中的静态常量属性

属性	描述
public static final E	比任何其他值都更接近 e（即自然对数的底数）的double值。
public static final PI	比任何其他值都更接近 pi（即圆的周长与直径之比）的double值。

Math类中常用的成员方法：

​ 1.绝对值

		int a = -5;
		System.out.println(Math.abs(a));//输出的结果是5

​ 2.最大、最小值

		int a = 5;
		int b = 10;
		System.out.println(Math.max(a,b));//输出结果为10
		System.out.println(Math.min(a,b));//输出结果为5

​ 3.幂运算

		int a = 3;
		int b = 4;
		System.out.println(Math.pow(a,b));//结果为3*3*3*3的结果

​ 4.平方根、立方根

		int a = 8;
		System.out.println(Math.sqrt(a));//结果为8的正平方跟
		System.out.println(Math.cbrt(a));//结果为8的立方根

​ 5.四舍五入

		double a = 3.6;
		System.out.println(Math.round(a));//结果为4

​ 6.随机数

		//产生一个3~9之间的随机数
		int a = (int)(Math.random()*(9-3+1)+3);

​ 7 .ceil floor

		System.out.println(Math.ceil(3.2)); //大于或等于这个数字的最小正数
		System.out.println(Math.floor(2.5));//小于或等于这个数字的最大正数

1.5 Random类

此类的实例用于生成伪随机数流。此类使用 48 位的种子，使用线性同余公式 (linear congruential form) 对其进行了修改所得。

如果用相同的种子创建两个Random实例，则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列。

Random类中的构造方法：

方法名	描述
Random()	创建一个新的随机数生成器。此构造方法将随机数生成器的种子设置为某个值，该值与此构造方法的所有其他调用所用的值完全不同。
Random(long seed)	使用单个 long 种子创建一个新的随机数生成器。该种子是伪随机数生成器的内部状态的初始值.

​ 注意：若long种子确定，则在不同程序中，相同次数产生的随机数是相同的。

Random类中的常用方法：

​ 1.产生随机数

		Random random = new Random(10);//以10为种子，使用线性同余公式产生伪随机数
		int i1 = random.nextInt();//产生一个随机整数
		int i2 = random.nextInt(10);//产生一个10以内的随机整数
		double d = random.nextDouble();//产生一个随机double值
		boolean b = random.nextBoolean();//产生一个随机boolean值

​ 2.修改种子

		Random random = new Random(10);
		random.setSeed(20);//将随机数种子设置为20

1.6 System类

System类包含一些有用的类字段和方法。它不能被实例化。

System类中的常见属性：
| 属性 | 描述 |
| ----------------------------------- | ------- |
| public static fianl PrintStream err | 标准错误输出流 |
| public static final InputStream in | 标准输入流 |
| public static final PrintStream out | 标准输出流 |

System类中的常见方法：

​ 1.获取系统时间

		long time1 = System.currentTimeMillis();//获取当前时间，毫秒数
		long time2 = System.nanoTime();//获取当前时间，毫微秒
时间单位:秒--毫秒-->微秒--->纳秒(毫微秒)
  1秒=1000毫秒
  1毫秒=1000微秒
  1微秒=1000纳秒

​ 2.强制退出虚拟机

		System.exit();//强制退出当前正在执行的虚拟机0  非0

​ 3.垃圾回收处理机制：

​ gc()： 运行垃圾回收器。

举例说明

package day14;

public class Person {
	private String name;
	private int age;
	
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	
	@Override
	protected void finalize() throws Throwable {
		System.out.println("垃圾回收器回收了...."+name);
	}
	
}

public static void main(String[] args) {
		//垃圾回收,相当于匿名对象
		Person person=new Person("张三1", 20);
		new Person("张三2", 20);
		new Person("张三3", 20);
		//回收下垃圾
		System.gc();
		new Person("张三4", 20);
		new Person("张三5", 20);
		new Person("张三6", 20);
	}

1.7 Runtime类

每个 Java 应用程序都有一个Runtime类实例，使应用程序能够与其运行的环境相连接。可以通过
getRuntime方法获取当前运行时。

1 exec（command） 在单独的进程中执行指定的字符串命令。

	//1创建Runtime对象
		Runtime runtime=Runtime.getRuntime();
		//2exec 启动一个进程 
		Process process=runtime.exec("notepad");
		//3关闭进程
		//程序休眠
		Thread.sleep(5000);
		process.destroy();

2 exit(int status) 退出jvm System.exit(); 内部调用runtime.exit();

Runtime runtime=Runtime.getRuntime();
runtime.exit(0);

3获取jvm的内存

返回类型	方法名
long	totalMemory() 返回 Java 虚拟机中的内存总量。
long	freeMemory() 返回 Java 虚拟机中的空闲内存量
long	maxMemory() 返回 Java 虚拟机试图使用的最大内存量。

public static void runtime2() {
		Runtime runtime=Runtime.getRuntime();
		long totalMemory=runtime.totalMemory();
		long freememory=runtime.freeMemory();
		long maxmemory=runtime.maxMemory();
		System.out.println("totalMemory:"+(totalMemory/1024/1024));
		System.out.println("freememory:"+(freememory/1024/1024));
		System.out.println("maxmemory:"+(maxmemory/1024/1024));
}

修改jvm内存 
1 修改堆初始内存大小
	-Xms300m
2 修改堆最大内存大小
	-Xmx4000m
3 修改栈空间大小	
	-Xss2m   jdk1.5之前256k  jdk1.5之后1m  

Elipse修改 右击java程序 "Demo8.java" --->Run as--->Run Configurations---> Arguments --vm arguments
	
命令行 java -Xms500m -Xmx3000m com.qf.day14.Demo8	

扩展 : 修改程序运行参数：通过程序运行参数输入数据

Elipse修改 右击java程序 "Demo8.java" --->Run as--->Run Configurations---> Arguments -- program arguments

aaa
bbb
ccc

命令行 java com.qf.day14.Demo9 aaa bbb ccc

第二节 枚举

Java中引用类型：数组、类、接口、枚举、注解

2.1 什么是枚举

枚举是一个引用类型，枚举就是一个规定了取值范围的变量类型。

枚举变量不能使用其他的数据，只能使用枚举中常量赋值。提高程序安全性

声明枚举：

​ 格式：

​ public enum 枚举名{

​ //枚举的取值范围

​ //枚举中可以生命方法

​ }

		//声明一个表示季节的枚举
		public enum Season{
		   SPRING,
          	SUMMER,
          	AUTUMN,
          	WINTER;
          	public void fun(){}
		}

​ 注意：

• 枚举中的成员是此枚举的取值范围;
• 所有的值之间使用逗号分隔，最后一个值后可以加分号也可以不加分号;
• 在枚举中可以声明方法，但是必须在所有的取值之后声明，而且最后一个值后必须使用分号隔开.

1 枚举的本质：其实就是终止类，并继承Enum抽象类。

2 枚举中的变量，其实就是一个当前类型的静态常量。

2.2 枚举结合switch结构使用

代码实现：

	public class TestSeasonEnmu{
            public static void main(String[]args){
              	//声明一个枚举变量
                Season season = Season.SPRING;
              	//switch小括号中的表达式类型可以是枚举类型
                switch(season){
                  //每个case后的常量直接写枚举的取值范围
                  case SPRING:
                    System.out.println("春天");
                    break;
                  case SUMMER:
                    System.out.println("夏天");
                    break;
                  case FULL:
                    System.out.println("秋天");
                    break;
                  case WINTER:
                    System.out.println("冬天");
                    break;
                }
            }
        }

第三节 异常

3.1 异常的概念

生活中面对各种异常，比如堵车、撞车等，通常会怎样处理，根据不同的异常进行相应的处理，而不会就此中断我们的生活。
程序中异常：在程序执行过程中由于设计或设备原因导致的程序中断的异常现象叫做异常。
异常处理：Java编程语言使用异常处理机制为程序提供了异常处理的能力。

异常演示：

public class Test1 {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		System.out.print("请输入被除数:");
		int num1 = in.nextInt();
		System.out.print("请输入除数:");
		int num2 = in.nextInt();
		System.out.println(num1/num2);
		System.out.println("感谢使用本程序！");
	}
}

3.2 异常的分类

运行时异常

运行时异常：（RuntimeException）在编译过程不会发现（没有语法错误），但是在执行程序过程中，由于重大的逻辑错误导致的程序中断。
所有的RuntimeException的子类包括RuntimeException都属于运行时异常

常见的运行时异常

NullPointerException		空指针异常（一个对象没有初始化调用方法）
ArrayIndexOutOfBoundsException	下标越界异常
ClassCastException			类型转换异常（对象类型转换时）
NumberFormatException		数字格式异常
ArithmeticException			算术异常

编译时异常

编译异常或检查异常，在程序设计过程中，编译时就会被发现，但是执行时可能发生也可能不发生的异常，为了程序不报错可以执行，那么这一类异常必须进行相应的处理。
Exception的子类包括Exception，除了RuntimeExcption之外都属于编译时异常。

Exception类：异常的父类。

Error类：错误，错误比较严重的问题，不属于异常，程序员无法处理。

​ StackOverflowError 、OutOfMemoryError

3.3 异常处理

Java的异常处理是通过5个关键字来实现的：

• try：执行可能产生异常的代码
• catch：捕获异常 ，并处理
• finally：无论是否发生异常，代码总能执行
• throw： 手动抛出异常
• throws：声明方法可能要抛出的各种异常

3.3.1 try-catch块

使用try-catch块捕获异常，分为三种情况

第一种情况：正常情况

public void method(){
      try
            // 代码段(此处不会产生异常)
      }catch(异常类型ex){
            // 对异常进行处理的代码段
      }
	 //代码段
}

第二种情况：出现异常

public void method(){
      try {
            // 代码段 1
            // 产生异常的代码段 2
            // 代码段 3
      } catch (异常类型 ex) {
            // 对异常进行处理的代码段4
      }
	 // 代码段5
}

printStackTrace()：此方法用来显示异常信息。

第三种情况：异常类型不匹配

public void method(){
    try {
         // 代码段 1
         // 产生异常的代码段 2
         // 代码段 3
    } catch (异常类型 ex) {
         // 对异常进行处理的代码段4
    }
	// 代码段5
}
	

3.3.2 try-catch-finally

在try-catch块后加入finally块,finally块的主要作用释放资源。

​ (1)finally块是否发生异常都执行

​ (2)finally块不执行的唯一情况,退出java虚拟机，System.exit(); 0正常退出，非0非正常退出

public void method(){
    try {
         // 代码段 1
         // 产生异常的代码段 2
    } catch (异常类型 ex) {
       // 对异常进行处理的代码段3
         return;
    }finally{
          // 代码段 4
    }
}
		

面试题1 ：try、catch、finally中是否可以包含return? 如果可以包含请说明执行流程?

​ (1) try、catch、finally中可以包含return ,但是finally中最后不要写return，导致不能正确返回。

​ (2) try和catch中都包含return, 先执行finally,才返回结果;try中没有发生异常，执行try中return ,发生异常，执行catch中return。

面试题2：

  //面试题1
    public static int add(int a,int b){
        try{
            int c=a+b;
            //int xxx=10/0;//出现异常
            return c;
        }catch (Exception e) {
            System.out.println(e.getMessage());
            return 0;
        }finally {
            System.out.println("资源释放");
        }
    }
    //面试题2
    public static int getCount(){ //12  11  10
        int i=10;
        try{
            int xxx=10/0;
            return i++;
        }catch (Exception e){
            return i++;
        }finally {
            i++;
            System.out.println("释放资源:"+i);//i=12
            return i++;
        }
    }

3.3.3 多重catch块（try...catch变形）

引发多种类型的异常

​ (1)排列catch 语句的顺序：先子类后父类

​ (2)发生异常时按顺序逐个匹配

​ (3)只执行第一个与异常类型匹配的catch语句

public void method(){
    try {
         // 代码段
         // 产生异常(异常类型2)
    } catch (异常类型1 ex) {
         // 对异常进行处理的代码段
    } catch (异常类型2 ex) {
         // 对异常进行处理的代码段
    } catch (异常类型3 ex) {
         // 对异常进行处理的代码段
    }
    // 代码段
}		

3.3.4 try…finally

try…finally不能捕获异常 ，仅仅用来当发生异常时，用来释放资源。

一般用在底层代码，只释放资源不做异常处理，把异常向上抛出。

public void method(){
    try {
         // 代码段 1
         // 产生异常的代码段 2
    }finally{
          // 代码段 3
    }
}

3.3.5 声明异常

如果在一个方法体中抛出了异常，如何通知调用者？

throws关键字：声明异常

使用原则：底层代码向上声明或者抛出异常，最上层一定要处理异常，否则程序中断。

public static void divide() throws Exception {
		  //可能出现异常的代码
}
public static void main(String[] args) {
		 try {
			divide();
		 } catch (Exception e) {
			e.printStackTrace();
		 }
}
或
public static void main(String[] args) throws Exception {
	 divide();
}

3.3.6 抛出异常

除了系统自动抛出异常外，有些问题需要程序员自行抛出异常。

throw关键字：抛出异常

public class Person {
	private String name = "";   // 姓名
	private int age = 0;   // 年龄
	private String sex = "男";  // 性别
	public void setSex(String sex) throws Exception {
		if ("男".equals(sex) || "女".equals(sex))
			this.sex = sex;
		else {
			throw new Exception(“性别必须是\"男\"或者\"女\"！");
		}
	}
}

上机练习1

在setAge(int age)中对年龄进行判断，如果年龄介于1到100直接赋值，否则抛出异常

在测试类中创建对象并调用setAge(int age)方法，使用try-catch捕获并处理异常

3.4 自定义异常类

创建自定义异常，通常继承自Exception 或其子类，习惯上包装一下父类的构造方法。

1.过程：自定义运行时异常或编译时异常

	i.定义一个类，继承Exception类或RuntimeException

    ii.在此类中定义构造方法，调用父类中的带字符串参数的构造方法（此字符串表示对异常的描述）

	iii.使用异常

package com.qf.day14_4;
/**
 * 性别异常
 * @author wgy
 *
 */
public class SexException extends Exception {

	public SexException() {
		super();
		// TODO Auto-generated constructor stub
	}

	public SexException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
		super(message, cause, enableSuppression, writableStackTrace);
		// TODO Auto-generated constructor stub
	}

	public SexException(String message, Throwable cause) {
		super(message, cause);
		// TODO Auto-generated constructor stub
	}

	public SexException(String message) {
		super(message);
		// TODO Auto-generated constructor stub
	}

	public SexException(Throwable cause) {
		super(cause);
		// TODO Auto-generated constructor stub
	}

	
	
}



使用

	public void setSex(String sex) throws Exception  {
		if(sex.equals("男")||sex.equals("女")) {
			this.sex = sex;
		}else {
			//抛出异常
			throw new SexException("性别有错误"); 
		}
	}

2.自定义运行时异常：

	i.定义一个类，继承RuntimeException类
	ii.在此类中定义构造方法，调用父类中的带字符串参数的构造方法（此字符串表示对异常的描述）
	iii.使用异常

package com.qf.day14_4;
/**
 * 性别异常
 * @author wgy
 *
 */
public class SexException extends RuntimeException {

	public SexException() {
		super();
		// TODO Auto-generated constructor stub
	}

	public SexException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
		super(message, cause, enableSuppression, writableStackTrace);
		// TODO Auto-generated constructor stub
	}

	public SexException(String message, Throwable cause) {
		super(message, cause);
		// TODO Auto-generated constructor stub
	}

	public SexException(String message) {
		super(message);
		// TODO Auto-generated constructor stub
	}

	public SexException(Throwable cause) {
		super(cause);
		// TODO Auto-generated constructor stub
	}

	
	
}


使用

	public void setSex(String sex) {
		if(sex.equals("男")||sex.equals("女")) {
			this.sex = sex;
		}else {
			//抛出异常
			throw new SexException("性别有错误"); 
		}
	}

总结

常用类:
1 Date 表示一个瞬间时间 
   Date date=new Date();
2 Calendar类日历
   Calendar calendar=Calender.getInstance();
   calendar.get(Calendar.YEAR);
   calendar.get(Calender.MONTH);
   
   calender.set();
3 SimpleDateFormat:实现时间和字符串之间的转换。
	3.1把日期格式的字符串转成 时间对象
		String s="2011-10-1";
		SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd");
		Date date=df.parse(s);
	3.2把时间转成某种格式的字符串 
		//  2015/10/1
		SimpleDateFormat df=new SimpleDateFormat("yyyy/MM/dd");
		String s=df.format(date);
4 Math数学类
	静态方法
	扩展BigDecimal  BigInteger  DecimalFormat
5 Random 随机数类
6 System 类
	 arrayCopy()
     exit  退出jvm
     gc  回收垃圾
     currentTimeMills();
7 Runtime 运行时
   Runtime runtime=Runtime.getRuntime();
  
   exec("notepad"); 执行命令 ,返回Process
   freeMemory(); //空闲内存
   totalMemory();//总内存
   maxMemory();//最大内存
   exit();//退出jvm
   
   -XX:+PrintGCDetails
   -Xms  初始大小
   -Xmx  最大大小
   -Xss  栈大小
   
8 枚举：本质就是一个终止类，里面都是静态常量

9 异常：程序中出现不正常的情况。
 在程序执行过程中由于设计或设备原因导致的程序中断的异常现象叫做异常。
  异常处理:
  	try：有可能出现异常的代码
  	catch：捕获异常
  	finally：最终的代码，有没有异常都会执行
  	throw：抛出异常
  	throws：声明异常
  	
  	try{....}catch(){...}
  	try{...}catch(){...}finally{...}
  	多重catch
  	try{...}finally{...}
  	
  	throws 声明抛出异常
  	throw  抛出异常
  	
  	自定义异常： 继承Exception或RuntimeException，调用构造方法
  	
  	
     

课前默写

1.写出String类的常用方法?

2.String和StringBuilder的区别?

作业

1.使用Calendar完成一个万年历

要求：键盘输入一个年份和月份，控制台输出当月的日历

面试题

1.使用Math类产生一个随机数的方法
2.什么是异常？常见的异常有哪些？
3.异常有哪些处理方式，分别需要注意什么问题？
4.try-catch块中存在return语句，是否还执行finally块，如果执行，说出执行顺序