Java学习第十天

1：包装类：
　　byte 　　　　 byte
　　short 　　　　short
　　int 　　　　　 nteger
　　long 　　　　  long
　　char 　　　　  character
　　boolean 　　　boolean
　　double 　　　  double
　　float 　　　　  float

2.基本类型转成字符串类型
　　string.valueof()
　　string ss =integer.tostring(7)
　　string str=double.tostring(6.6)

3字符串类型转成基本类型：常用
　　int a = integer.parseint("88");
　　double d=double.parsedouble("99.99");

4.十进制转成其它进制

　　string num = integer.tohexstring(60);
　　string n =integer.tooctalstring(24);
　　string m = integer.tobinarystring(6);

5.其它进制转十进制
　　int x = integer.parseint("3c",16); //第一个参数是被转的数，第二个参数说明第一个参数的进制
　　int x = integer.parseint("30",8);
　　int x = integer.parseint("110",2);

6: 装箱和拆箱
　　

 1 integer tt=6;// new integer(6) ---自动装箱
 2 　　tt=tt+2;// tt.intvalue()---6 自动拆箱 6+2==8 new integer(8) 自动装箱
 3 
 4 
 5 　　integer m=127;
 6 　　integer n=127;
 7 
 8 　　sop(m==n);//true jdb1.5开始
 9 
10 　　m=128;
11 　　n=128;
12 
13 　　sop(m==n);//false
14 　　//如果一个数在byte的范围之内(-128---127)，之前已经定义过，再定义时使用已经定义的

7：异常:程序在运行过程中出现的特殊情况，
　　java把程序在运行时出现的不正常情况，提取属性和行为描述(异常名称，异常发生的位置，异常具体信息)
　　从而出现了异常，从而实现了异常的面向对象

8.异常体系: (继承object类)throwable
　　　　　　　　(throwable的子类)--| error：严重的错误，没办法处理的
　　　　　　　　(throwable的子类)--| exception:异常,程序运行时可处理的问题
9.异常特点：具备可抛性

　　默认的异常处理方式：系统创建异常类对象，因为main方法不能处理异常，抛给了jvm，jvm调用异常类对象的printstacktrace()方法，
　　输出异常名，异常信息，异常发生的位置，然后程序中断

　　try{

　　}catch(exception e){
　　}

　　throws声明可能会出现的异常
　　必须处理：1：使用 try{}catch(){} 2:使用throws继续声明抛出

10.多重异常：

1 try{
2 
3 }catch(xxx e){
4 
5 }catch(yyy ee){
6 
7 }

　　子类异常要写在父类异常的上边

11.自定义异常：

1 class myexception extends exception{
2 
3 myexception(){}
4 
5 myexception（string message）
6 {
7 super(message);
8 }
9 }

 

　　对于自定义异常，系统不会自动创建异常类对象，所以需要使用throw 手动创建异常类对象

12.throw:用于手动抛出异常类对象
　　用了throw，必须处理，处理方式有2种：
　　　　1.使用try{}catch{}
　　　　2:使用throws继续声明抛出

13.throw和throws对比：
　　1.throw用在方法内部，throws用在方法后边
　　2.throw后边是异常类对象，throws后边是异常类

14.java把异常分为两类：
　　非运行时异常：编译时检测的异常，必须接收处理
　　运行时异常：编译时不检测的异常-------runtimeexception及其子类，编译不检测，即使使用了throws或throw，不处理，编译照样通过
　　　　　　原因：java认为出现运行时异常，程序就该中断，不该处理
　　　　　　　　　运行时异常都是因为数据传送出错造成的，程序就该中断，修改错误数据，然后再执行

 

 1 例子：
 2 class mymath
 3 {
 4 　　public int div(int a,int b)
 5 　　{
 6 　　　　return a/b;// throw new arithmeticexception()
 7 　　}
 8 }
 9 class demo5 
10 {
11 　　public static void main(string[] args) //不用try{}catch(){} 可以，只不过是程序异常时会中断
12 　　{
13 　　　　mymath mymath=new mymath();
14 　　　　//检测异常
15 　　　　try
16 　　　　{
17 　　　　　　int m = mymath.div(5,0); //new arithmeticexception()
18 　　　　　　system.out.println(m); //不执行
19 
20 　　　　}catch(exception e)//捕获 exception e=new arithmeticexception() 多态
21 　　　　{
22 　　　　　　system.out.println(e.getmessage());//异常信息
23 　　　　　　system.out.println(e.tostring());//异常类名：异常信息
24 　　　　　　e.printstacktrace(); //异常类名：异常信息 异常发生的位置
25 
26 　　　　　　system.out.println("除数为0了");
27 　　　　}
28 　　　　system.out.println("hehe")    
29 　　}
30 }

 

　　注意：对于程序来说，最好把问题提前到编译时期，也就是说运行时可能发生的异常，在编译时期就能知道

15.finally中的代码在return之前执行的

 1 system.exit()退出jvm虚拟机，finally中的代码不能执行
 2 
 3 try{}catch(){}
 4 
 5 try{}catch(){}finally{}
 6 
 7 try{}finally{必须执行的语句}
 8 
 9 特殊情况：
10 class mymath
11 {
12 　　public int div(int a,int b)
13 　　{
14 　　return a/b;
15 　　}
16 }
17 class demo11 
18 {
19 　　public static void main(string[] args)
20 　　{
21 　　　　mymath mymath=new mymath();
22 
23 　　try{
24 
25 　　　　int m = mymath.div(5,0); 
26 　　　　system.out.println(m);
27 
28 　　}catch(exception e)
29 　　{
30　　 　　system.out.println(e.getmessage());
31 　　　　//return;
32 　　　　system.exit(1);//退出jvm finally中的代码不能执行
33 　　}finally
34 　　{
35 　　　　system.out.println("哈哈");//finally中的代码在return之前执行
36 　　}
37 　　}
38 }