黑马程序员 JAVA基础-面向对象（三）

                                               -----------android培训、java培训、java学习型技术博客、期待与您交流！------------

               在此，分享一下自己学习JAVA的学习心得。有不对的地方请帮忙改正，也希望对想学java的同学有帮助！

JAVA语言基础

面向对象——（异常）

定义：异常就是程序运行时出现不正常情况。

异常由来：问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述。并封装成对象。其实就是java对不正常情况进行描述后的对象体现。



异常体系：

Throwable: (1)Error : 通常出现重大问题如：运行的类不存在或者内存溢出等。 

                      对于Error不编写针对代码对其处理。 

           (2)Exception :在运行时运行出现的一起情况，可以通过try catch finally。  

           Exception和Error的子类名都是以父类名作为后缀。

基本语法格式：

   try{

  //可能出现异常的代码

    //并且我们希望处理这种异常

    //出异常了-->虚拟机-->找到对应的异常类，实例化异常对象

   }catch(异常类名称    变量名){

    //当出现这种异常时，需要做的事情；

    //当虚拟机封装了异常对象后，发现我们自己想捕获这样的异常。

    //-->(虚拟机)找到对应的异常类，实例化异常对象-->将这个对象交给我的catch代码-->执行catch内的代码

   }

   当Java虚拟机执行完catch后，将执行catch的后续代码；

  

   执行顺序：

   

   1.如果没有异常：执行try-->catch的后续代码；

   2.如果出现异常：执行try-->catch-->catch的后续代码；
 

Throwable对异常对象进行常见方法操作：

1）getMessage() ：获取异常信息，返回字符串。  

2）toString()： 获取异常类名和异常信息，返回字符串。  

3）printStackTrace() ：获取异常类名和异常信息，以及异常出现在程序中的位 置。返回值 void。  

4）printStackTrace(PrintStream s) ：通常用该方法将异常内容保存在日志文件中，以便查阅。



Java练习代码：

<span style="font-size:18px;"><span style="font-size:18px;"><span style="font-size:18px;">class ZeroException
{
int demo(int a,int b)//在功能上通过throws的关键字申明了该功能有可能会出现的问题
{
int m = a / b;

return m;
}
}

class exception
{

public static void main(String[] args)
{
ZeroException ze = new ZeroException();//实例化对象

int a = 4;
int b = 0;
try
{
int shang = ze.demo(a , b);//调用demo方法，并对其进行异常捕获
System.out.println("a / b="+shang);
}
catch (Exception e)
{
if( b==0){

System.out.println("除数为零了");

System.out.println(e.toString());//异常名称：异常信息  java.lang.ArithmeticException: / by zero

System.out.println(e.getMessage());//by zero;

e.printStackTrace();//异常名称，异常信息，异常出现的位置
//其实jvm默认的异常处理机制，就是在调用printStackTrace方法
//打印异常的堆栈的跟踪信息。
}
//finally
//System.out.println("Hello World!");
}
}
}</span><span style="font-size: 18px;">
</span></span></span>

throws和throw的用法：

1)throws用于标识函数暴露出的异常。

2)throw用于抛出异常对象。 

 
throws与throw的区别： 1)throws定义在函数上，用于抛出异常类，可以抛出多个用逗号隔开。

                        2)throw定义在函数内，用于抛出异常对象。 

注意：1）当函数内容有throw抛出异常对象，并未进行try处理。必须要在函数上声明，都在编译失败。

      2）RuntimeException除外。也就说，函数内如果抛出的RuntimeExcpetion异常，函数上可以不用声明。

如果函数声明了异常，调用者需要进行处理。处理方法可以throws可以try。

异常有两种：
编译时被检测异常
该异常在编译时，如果没有处理(没有抛也没有try)，编译失败。
该异常被标识，代表这可以被处理。
运行时异常(编译时不检测)
在编译时，不需要处理，编译器不检查。
该异常的发生，建议不处理，让程序停止。需要对代码进行修正。

finally关键字：

   finally关键字：不论是否出现异常，finally中的代码都会被执行；

   

   1.属于异常处理的语法关键字：

   2.格式：

    try{

   //可能出现异常的代码

    }catch(){

    //如果出现异常，处理异常的代码；

    }finally{

    //不论是否出现异常，都会执行的代码；

    }

    或者：

    try{

    }finally{

   }

   3.为什么需要finally:

     1).如果try中有多条语句，第一条语句就异常了，后面的语句就得不到执行；

      try{

                如果第一条语句：打开文件；

          后面的语句：使用文件；

          最后语句：关闭文件；

            }

         

         如果"打开文件"时出现异常了."关闭文件"肯定不会被执行；

        如果"使用文件"时出现异常，"关闭文件"也不会被执行；

         如果文件被打开，那么就永远关闭不了，直到程序结束。这时我们不想看到的情况；

     2).我们可以利用finally的特点，将"关闭文件"放到finally中；

      如果没有发生异常：finally中的代码会被执行；

    如果出现异常：finally中的代码也会被执行；

  

final,finally和finalize的区别：

   final:最终的。可以修饰：
   
类：最终类，不能被继承；
   
成员变量：常量。拥有最终的值。其值一旦被设定，不能被更改；
   
成员方法：最终的方法，不能被子类重写；
   finally:
   
try..catch异常处理语法的一部分。不论是否出现异常，finally中的语句一定会被执行；
   finalize:
   
Object类的一个方法；
   
由垃圾回收器，回收一个对象前会去调用。一般也是用于资源释放；
  

自定义异常： 

        定义类继承Exception或者RuntimeException
1,为了让该自定义类具备可抛性。
2，让该类具备操作异常的共性方法。

当要定义自定义异常的信息时，可以使用父类已经定义好的功能。

异常异常信息传递给父类的构造函数。

class MyException extends Exception
{
MyException(String message)
{
super(message);
}

}

异常的处理原则：
1，处理方式有两种：try 或者 throws。
2，调用到抛出异常的功能时，抛出几个，就处理几个。
一个try对应多个catch。
3，多个catch，父类的catch放到最下面。
4，catch内，需要定义针对性的处理方式。不要简单的定义printStackTrace，输出语句。
也不要不写。

当捕获到的异常，本功能处理不了时，可以继续在catch中抛出。

try
{
throw new AException();
}
catch (AException e)
{
throw e;
}

如果该异常处理不了，但并不属于该功能出现的异常。
可以将异常转换后，在抛出和该功能相关的异常。

或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去，
当调用者知道。并处理。也可以将捕获异常处理后，转换新的异常。
try
{
throw new AException();
}
catch (AException e)
{
// 对AException处理。
throw new BException();
}

比如，汇款的例子。

自定义异常：按照java的面向对象思想，将程序中出现的特有问题进行封装。

异常的好处：

1，将问题进行封装。
2，将正常流程代码和问题处理代码相分离，方便于阅读。

RuntimeException 运行时异常：

1）RuntimeException以及其子类如果在函数中被throw抛出，可以不用在函数上声明。  

2）一个方法被覆盖时，覆盖它的方法必须抛出相同的异常或异常的子类。  

3）如果父类抛出多个异常，那么重写（覆盖）方法必须抛出那些异常的一个子集，不能抛出新的异常。  

4）介绍异常在分层设计时的层内封装。

自定义异常时：如果该异常继承的发生，无法在继续进行运算，就让自定义异常RuntimeException.

Java练习代码：

<span style="font-size:18px;"><span style="font-size:18px;">class FuShuException extends RuntimeException</span><pre name="code" class="java"><span style="font-size:18px;">//自定义负数异常</span>

{FuShuException(String msg){super(msg);}}class Demo{int div(int a,int b)throws Exception//throws ArithmeticException{if(b<0)throw new Exception("出现了除数为负数了");if(b==0)throw new ArithmeticException("被零除啦");return a/b;}}class ExceptionDemo4 {public
static void main(String[] args) {Demo d = new Demo();//实例化对象int x = d.div(4,-9);//调用div方法System.out.println("x="+x);System.out.println("over");}}</span>

知识点：子类重写父类方法是异常处理



     父类方法没有声明异常：

      1.子类可以不抛出;      2.子类可以抛出运行时异常;      3.子类不能抛出非运行时异常(编译时异常);     
    父类方法声明了运行时异常：

     1.子类可以不抛出；     2.子类可以抛出任何的运行时异常；     3.子类不能抛出非运行时异常(编译时异常)  
   父类方法声明了抛出非运行时异常(编译时异常)

    1.子类可以不抛出任何异常；    2.子类可以抛出任何运行时异常；    3.子类不能抛出比父类更多的非运行时异常(编译时异常)    总结：  父类方法不论有没有抛出异常：     1.子类方法可以不抛出异常；     2.子类方法可以抛出任何的运行时异常；     3.如果父类方法抛出的是非运行时异常(编译时异常)，子类方法不能抛出比父类方法更多的非运行时异常；  
Java练习代码：

求面积的实例：

<span style="font-size:18px;">class NoValueException extends RuntimeException 自定义异常
{
NoValueException(String message)
{
super(message);
}
}

interface Shape//定义一个接口
{
void getArea();//求面积的方法
}

class Rec implements Shape //长方形Rec类实现shape接口，并重写了其方法
{
private static int width, length;//定义宽和长

Rec(int width, int length) throws NoValueException//构造函数
{
if( width <=0 || length <=0)//判断宽度和长度为负数的情况
throw new NoValueException("非法值");//抛异常
this.width = width;
this.length = length;
}
public void getArea()//求面积方法
{
System.out.println(width*length);
}
}

class Cricle implements Shape//圆Cricle的类实现s
bfbd
hape接口
{
private double radius;

public static final double PI = 3.1415926;//定义一个长量PI

Cricle(double radius)//构造函数
{
if(radius <=0)//判断半径
throw new NoValueException("非法值");
this.radius = radius;
}
public void getArea()//重写求面积方法
{
System.out.println(radius*radius*PI);
}
}
class  ExceptionTest
{
public static void main(String[] args)
{
Rec r = new Rec(3,4);//实例化对象
r.getArea();//求长方形的面积

Cricle c = new Cricle(-2.5);//实例化对象
c.getArea();//求圆的面积
}
}
</span>