基础学习day10--异常、包

一、异常

1.1、异常定义

异常：--不正常,程序在运行时出现不正常情况

异常由来：其实也是现实生活中一个具体的事物，马可以通过JAVA的类的形式表现描述，并封装成类。

Java对不正常情况描述后的，对象体现。

异常：两种.

一种是严重的问题：java通过Error类进行描述

对于Error一般不编写针对必的代码对其进行处理

对与非严重的:java通过Exception类进行描述

对于Exception可以使用针对必的处理方式进行处理。

示例：

package com.day10.demo1;

public class Demo1 {

    public static void main(String[] args) {

        System.out.println(div(5,0));
        System.out.println("over");

    }

    public static int div(int a,int b){
        return a/b;
    }

}

结果：

Exception in thread "main" java.lang.ArithmeticException: / by zero
at com.day10.demo1.Demo1.div(Demo1.java:14)
at com.day10.demo1.Demo1.main(Demo1.java:7)

算术异常，因为除数为0，所以，有异常了

1.2、异常体系结构

Java 提供了两类主要的异常:runtime exception 和checked exception。所有的checked exception 是从java.lang.Exception 类衍生出来的，而
runtime exception 则是从java.lang.RuntimeException 或java.lang.Error类衍生出来的。

它们的不同之处表现在两方面:机制上和逻辑上

runtime exceptions:

• 在定义方法时不需要声明会抛出runtime exception
• 在调用这个方法时不需要捕获这个runtime exception
• runtime exception 是从java.lang.RuntimeException 或
• java.lang.Error 类衍生出来的。

checked exceptions:

• 定义方法时必须声明所有可能会抛出的checked exception
• 在调用这个方法时，必须捕获它的checked exception，不然就得
• 把它的exception 传递下去
• checked exception 是从java.lang.Exception 类衍生出来的

从逻辑的角度来说，checked exceptions 和runtime exception 是有不同的使用目的的。

checked exception 用来指示一种调用方能够直接处理的异常情况。checked exception 迫使你捕获它并处理这种异常情况。

而runtime exception 则用来指示一种调用方本身无法处理或恢复的程序错误。

1.3、异常使用语句

try{
    // 有可能出现异常的语句
}catch(异常类 异常对象){
    // 编写异常的处理语句
}[ catch(异常类 异常对象){
    // 编写异常的处理语句
} catch(异常类 异常对象){
    // 编写异常的处理语句
} …. ]
[finally{
    一定会运行到的程序代码 ；
}

主要搭配:try-catch、try-catch-finally、try-finally三种形式

1.4、使用try--catch

没有使用异常

package com.day10.exception.demo1;

public class Demo1 {

    public static void main(String[] args) {

        int x=5;
        int y=0;
        int index=div(x,y);
        System.out.println("执行完成");

    }
     public static int div(int a,int b){
            return a/b;
        }
}

结果：

Exception in thread "main" java.lang.ArithmeticException: / by zero

最后输出语句没有执行

使用try--catch

package com.day10.exception.demo1;

public class Demo1 {

    public static void main(String[] args) {

        int x=5;
        int y=0;
        try {
            int retsult=x/y;
        } catch (Exception e) {

            e.printStackTrace();
        }

        System.out.println("执行完成");

    }

}

结果：

java.lang.ArithmeticException: / by zero
at com.day10.exception.demo1.Demo1.main(Demo1.java:10)
执行完成

异常代码块后面的代码被执行了。

try-中的代码发生异常后，跳转到相就的 catch块中，捕获异常，完成后，执行异常块后面的代码

1.5、try-catch-finally

package com.day10.exception.demo1;

public class Demo1 {

    public static void main(String[] args) {

        int x=5;
        int y=0;
        try {
            int retsult=x/y;
            System.out.println("执行到我说明没有异常");
        } catch (Exception e) {
            System.out.println("发生异常了");
            e.printStackTrace();
        }finally{
            System.out.println("我一定会被执行");
        }

        System.out.println("执行完成");

    }

}

结果：

发生异常了
我一定会被执行
执行完成
java.lang.ArithmeticException: / by zero
at com.day10.exception.demo1.Demo1.main(Demo1.java:10)

1.6、finally中的代码不执行

package com.day10.exception.demo1;

public class Demo1 {

    public static void main(String[] args) {

        int x=5;
        int y=0;
        try {
            int retsult=x/y;
            System.out.println("执行到我说明没有异常");
        } catch (Exception e) {
            System.out.println("发生异常了");
            e.printStackTrace();
            System.exit(0); //或者-1
        }finally{
            System.out.println("我一定会被执行");
        }

        System.out.println("执行完成");

    }

}

发生异常了
java.lang.ArithmeticException: / by zero
    at com.day10.exception.demo1.Demo1.main(Demo1.java:10)

1.7、如果有return 怎么执行

try中有return

package com.day10.exception.demo1;

public class Demo2 {

    public static void main(String[] args) {

        System.out.println(getException());
    }
    public static int getException(){

        try {
            int x=5;
            System.out.println("try return");
            return x;
        } catch (Exception e) {
            System.out.println("catch return");
        }finally{
            System.out.println("finally return");
        }
        return 0;
    }

}

结果：

try return
finally return
5

try中的return并不会影响finally中的代码执行

catch中有return

package com.day10.exception.demo1;

public class Demo2 {

    public static void main(String[] args) {

        System.out.println(getException());
    }
    public static int getException(){
        int x=5;
        try {
            int result=x/0;
            System.out.println("try return");
            return x;
        } catch (Exception e) {
            System.out.println("catch return");
            return ++x;
        }finally{
            System.out.println("finally return");
        }
    }

}

结果：

catch return
finally return
6

catch中的return也不会影响finally中的执行，但是返回结果会是catch中的return结果，会将try中的结果覆盖

finally中有return

package com.day10.exception.demo1;

public class Demo2 {

    public static void main(String[] args) {

        System.out.println(getException());
    }
    public static int getException(){
        int x=5;
        try {
            int result=x/0;
            System.out.println("try return");
            return x;
        } catch (Exception e) {
            System.out.println("catch return");
            return ++x;
        }finally{
            System.out.println("finally return");
            return ++x;
        }
    }

}

结果:

catch return
finally return
7

finally中的return也不会影响finally中的执行，但是返回结果会是finally中的return结果，会将try和catch中的结果覆盖

1.8、多个catch块

exception异常 一定要放在最扣，不然下方的异常无法执行到，只会执行父类执行而子类的异常不会被捕获

package com.day10.exception.demo1;

import java.util.InputMismatchException;
import java.util.Scanner;
/*
 * 求2个整数的商 当异常发生时，程序如何处理
 */
public class Demo2 {

    public static void main(String[] args) {

        // 从键盘获得输入
        try {
            Scanner input = new Scanner(System.in);
            System.out.println("请输入被除数:");
            int num1 = input.nextInt();
            System.out.println("请输入除数:");
            int num2 = input.nextInt();
            int result = num1 / num2;
            System.out.println(num1 + "与" + num2 + "的商:   " + result);
        } catch (InputMismatchException e) {
            System.out.println("输入的不是数字");
            e.printStackTrace();

        } catch (ArithmeticException e) {
            System.out.println("除数不能为0");
            e.printStackTrace();
        } catch (Exception e) {
            System.out.println("其它错误!");
            e.printStackTrace();
        } finally {
            System.out.println("谢谢使用!");
        }

    }

}

结果1:

请输入被除数:
fsd
输入的不是数字
谢谢使用!
java.util.InputMismatchException

结果2

请输入被除数:
9
请输入除数:
0
除数不能为0
谢谢使用!
java.lang.ArithmeticException: / by zero

结果3：

请输入被除数:
7
请输入除数:
3
7与3的商: 2
谢谢使用!

1.9、自定义异常

自定义异常只需要继承Exception类就

定义异常类，只需要继承Exception类即可。

当然可以继承其它的如:Exception,Throwable,RuntimeException及其子类,其中继承Exception,Throwable,效果，如果不要求调用者一定要处理抛出的异常可以继承RuntimeException及其子类

调用时只需要throw new 自定义异常名(信息)

package com.day10.exception.demo1;
/**
 * 自定义异常
 * @author denny
 *
 */
public class MyException extends Exception {

    public MyException() {
        super();
    }

    public MyException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);

    }

    public MyException(String message, Throwable cause) {
        super(message, cause);

    }

    public MyException(String message) {
        super(message);

    }

    public MyException(Throwable cause) {
        super(cause);
    }

}

上面为算定义异常,使用构造方法重载即可

1.10、throw和throws抛出异常

使用上面的算定义异常

package com.day10.exception.demo1;

public class Person {

    private String name;
    private int age;
    private String gender;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age >= 0 && age <= 150) {
            this.age = age;
        } else {
            try {
                throw new MyException("年龄只能在0-150岁之间");
            } catch (MyException e) {
                e.printStackTrace();
            }
        }
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) throws MyException {//
        if(gender.equals("男")||gender.equals("女")){
        this.gender = gender;
        }else{
            throw new MyException("性别只能是男或者女!");
            /*
            throw可以在方法体内抛出异常，但必须捕获或者
            在方法体上用throws抛出
            */
        }
    }
     public void printSelf(){
         System.out.println("姓名:"+this.name+"             性别:"+this.gender+"     年龄:"+this.age);
     }

}

测试类

package com.day10.exception.demo1;

public class PersonTest {

    public static void main(String[] args) {
        Person p=new Person();

        try {
            p.setName("张三");
            p.setAge(200);
            p.setGender("人妖");
        } catch (MyException e) {
            e.getMessage();//获取异常信息
        }finally{

        }

    }

}

结果：com.day10.exception.demo1.MyException: 年龄只能在0-150岁之间

因为在执行age赋值时，已经发生异常，所以下面的性别赋没有执行

package com.day10.exception.demo1;

public class PersonTest {

    public static void main(String[] args) {
        Person p=new Person();

        try {
            p.setName("张三");
            p.setAge(20);
            p.setGender("人妖");
            p.printSelf();
        } catch (MyException e) {
            //System.out.println(e.getMessage());//获取异常信息
            e.printStackTrace();
        }finally{

        }

    }

}

结果：

com.day10.exception.demo1.MyException: 性别只能是男或者女!

二、包

2.1、包的含义

对文件进行分类管理，类似于windows中的文件夹，同一包同一层

给类提供多层命名空间，同一个文件夹文件名不相同，层次关系，

写在程序文件的第一行

类名的全称是包名.类名.

包也是一种封装形式

2.2、包的定义

package 包名,

包名必须小写，可以使用.小数点来定义多层次包

必须放在代码的第一行

javac -d  .   java文件名.java  .代表当前文件夹目录

包的出现可以把java的class文件和源文件相分离,只需要将 class文件复制出来运行就可以

定义包名不要重复

2.3、包的导入

import 包名.类名

2.4、包与包之间的访问权限