Day6:面向对象------异常

异常：java程序在 运行 时期发生的不正常情况(问题)。

    java就按照面向对象的思想对不正常情况进行描述和对象的封装。

问题分两种：
Throwable:定义了对于问题的共性的功能。
    |--Error:由系统底层发生的，告诉jvm，jvm告诉使用者。不做针对性处理。直接修改代码。
    |--Exception:jvm发生，并告诉给使用者。可以进行针对性的处理。
    
    

总结：
1，运行时发生。
2，符合面向对象，将问题描述并封装成对象。
3，error和exception的区别。

异常的处理。

两种：
1，遇到问题不进行具体的处理，而是继续抛给调用者。
    其实就是在函数上通过throws关键字声明异常。告诉调用者处理。


2，针对性的处理方式：捕获！
try
{
    //有可能发生异常的代码。
}
catch(异常类  变量)
{
    //这是真正的捕获，处理异常的代码;
}
finally
{
    //一定会被执行的代码。
}




throw和throws有什么区别呢？

1，位置不同。
throws用在函数上，后面跟的是异常类，可以跟多个。
throw用在函数内，后面跟的是异常对象。

2，功能不同。
throws用来声明异常，让调用者只知道该功能有可能出现的问题，并由调用者可以给出预先的处理方式。
throw抛出具体问题对象。执行到throw功能就已经结束了，跳转到调用者。并将具体的问题对象也抛给调用者。

也就说throw语句独立存在时，下面不要定义其他语句。因为执行不到。

异常体系的特殊情况：
Excpetion
    |--Error
    |--Exception
异常体系最大的特点就是体系中的类以及类产生的对象，都具备这可抛性，可抛性的意思是可以被throws和throw所操作。

class Demo
{
    /*
    在编写功能时，编写者知道该功能有可能发生问题。而这个问题很容易来自于调用者传递的参数。
    而导致功能无法运行。这时发生的问题就应该让调用者知道。并最好让调用有预先的处理方式。
    所以在定义功能时，需要在功能上对有可能发生的问题进行声明。
    声明问题需要使用关键字。throws 异常类,  声明的目的:就是让调用者可以进行处理。
    */
    int div(int a,int b)throws Exception//声明异常。
    {
        
        if(b==0)
            throw new ArithmeticException("除零了，废了！");//抛出异常对象。
        return a/b;//throw new ArithmeticException("/ by zero")抛给调用者。
    }
}
class ExceptionDemo2 
{
    public static void main(String[] args) //throws Exception
    {
        Demo d = new Demo();
        try
        {
            int num = d.div(4,0);
            System.out.println("num="+num);
        }
        catch (Exception e)//Exception e = new ArithmeticException("/ by zero");
        {
            //处理这个对象。可以使用该对象的方法。
            System.out.println("异常啦！");
            System.out.println(e.getMessage());//异常信息
            System.out.println(e.toString());//异常名称+异常信息
            e.printStackTrace();//名字+信息+位置。jvm默认处理收到异常就是调用这个方法。将信息显示在屏幕上。
        }
        
        System.out.println("over");
    }
}

异常的原则：
1，功能内部有异常throw抛出，功能上一定要throws声明。
    内部抛什么，功能上就声明什么。
    声明的目的就是为了让调用者处理，如果调用者不处理，编译失败。

2，特殊情况:
    当函数内通过throw抛出了RuntimeException及其子类的异常对象时，函数上可以不用throws声明。
    不声明的目的就是不让调用者处理。让调用者的程序停止。要对代码进行修改。


    Exception分两种：
    1，编译时会被检测的异常。
    2，运行时异常(编译时不检测)RuntimeException

/*
在自定义的程序中，如果有了问题。也可以像java中的异常一样。
对问题进行描述。

举例：
定义一个功能可以实现除法运算。但是除数不可以为负数。
*/
//将负数为除数的问题描述,自定义异常。
class FuShuException extends RuntimeException
{
    private int num;
    FuShuException()
    {
        super();
    }
    FuShuException(String message)
    {
        super(message);
    }
    FuShuException(String message,int num)
    {
        super(message);
        this.num = num;
    }

}


class Demo
{
    int div(int a,int b)
    {
        if(b<0)
            throw new FuShuException("负数不可以作为除数",b);

        if(b==0)
            throw new ArithmeticException(" 被零除了。");

        return a/b;
    }
}

小节：
异常：其实就将问题封装成对象。并抛给调用者。
    如果声明了，就需要调用者处理(继续声明or捕获)。
    什么时候声明，什么时候捕获?
    功能内部可以解决，就捕获，不能解决，或者解决了还必须告诉调用者问题这时就应该声明。

/*
try
catch
finally


finally作用的是：无论是否有异常发生，都要对资源进行释放。
资源释放动作就定义在finally代码块中。
*/


class ExceptionDemo5 
{
    public static void main(String[] args) 
    {
        try
        {
            int num = 4/0;
            System.out.println("num="+num);
        }
        catch (Exception e)
        {
            System.out.println(e.toString());
//            return ;
//            System.exit(0);//推出jvm。只有这种情况，finally也不执行。
        }
        finally
        {
            System.out.println("finally");
        }
        
        System.out.println("over");

    }
}

异常的针对性处理方式;
try
{
    
}
catch ()
{
}
finally
{}
的几种组合方式。


1，有资源需要释放。仅仅是处理异常。
try
{
    
}
catch ()
{
}

2，一个try多个catch，一般对应的是被调用的函数，抛出多个异常的情况。分别处理。
try
{
    
}
catch ()
{
}
catch ()
{
}
catch ()
{
}
注意：在多catch语法上特殊的地方，如果catch中的异常类存在子父类。
父类的catch一定要放子类的下面。否则编译失败。

3，不一定要处理异常，但是有资源需要释放。
try
{
    
}
finally
{
    
}


void show()throws Exception
{
    try
    {
        throw new Exception ();
    }
    finally
    {
        
    }
}


class ExceptionDemo6 
{
    public static void main(String[] args) 
    {
        System.out.println("Hello World!");
    }
}

/*
Exception
    |--AException
        |--AAException
    |--BException


覆盖时：
子类方法覆盖父类方法只能抛出父类方法异常或者该异常的子类。
如果父类方法抛出多个异常，子类只能抛出父类异常的子集
原则：就是子类的异常必须要在父类的异常处理控制中。


注意：有一种情况，只能try不能throws。
被覆盖的方法没有抛出异常。
那么子类在覆盖时，子类方法中发生了异常，就只能try 无法throws声明。

interface Inter
{
    void show();
}
class Demo implements Inter
{
    public void show()
    {
        try
        {
            throw new Exception();
        }
        catch(Exception e)
        {
            throw new RuntimeException("");//将编译时检测异常，转换成运行时异常。这样就不用声明。
        }
    }
}

异常练习

/*
关键字:try catch finally throw throws 


1,异常思想：
    1，将问题封装成对象。(异常的名称，异常的信息，异常的位置 printStackTrace())
    2，是在程序不正常时才会用到。
    3，异常都具备可抛性。throws throw
    4，异常的好处：可以将功能中的问题封装后抛给调用者，
        如果是throws声明，可以让调用预先建立问题的处理方式(继续throws，捕获catch)
        如果没有throws声明，而且仅在功能中通过throw抛出了RuntimeException,
        让调用者在运行时终止，让调用者修改代码。


2，异常处理的原则：
    1，功能内部通过throw抛出，功能上必须throws声明，throw什么，throws什么(RuntimeException除外)
    2，调用到throws声明异常的函数，如果进行try catch处理，那么声明几个，就定义几个对应的catch。
    3，将本层异常在本层处理后，可以抛出让调用者可以处理的其他异常，异常转换。
    4，如果有资源的调用，并需要释放，一定要定义finally代码块。


3，异常try catch finally代码块的几种结合方式。一定要明确好处和区别。


4，异常在继承时需要注意的问题？




*/
//既然矩形的面积。
/*
描述长方形。
*/
class NotValueException extends RuntimeException
{
    NotValueException()
    {
        super();
    }
    NotValueException(String message)
    {
        super(message);
    }
}
class Rec
{
    private int length;
    private int width;
    Rec(int length,int width)
    {
        if(length<=0 || width<=0){
            throw new NotValueException("数值非法！");
        }
        this.length = length;
        this.width = width;
    }
    //定义面积函数。
    public double getArea()
    {
        return length*width;
    }
}

//老师用电脑上课的示例，使用考虑异常情况。
class RecDemo 
{
    public static void main(String[] args) 
    {
        Rec r = new Rec(-4,5);
        double area = r.getArea();
        System.out.println(area);
    }
}


class Fu
{
    void show()
    {}
}
class Zi extends Fu
{
    void show()
    {
        try{
        throw new Exception();
        }catch(Exception e)
        {
            throw new RuntimeException();
        }
    }
}



面向对象总结：

1，三个特征。
封装：

继承：

多态：自己的理解，代码证明自己的理解是对的。USB.

//this:代表当前对象。
this.name = name;

抽象类和接口。

内部类，匿名内部类。

异常。

class Person
{
}