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

来源：互联网发布：sql 每月销售量统计表编辑：程序博客网时间：2024/05/18 23:13

-----------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的类实现shape接口{private double radius;public static final double PI = 3.1415926;//定义一个长量PICricle(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>

0 0