java 基础学习 异常的处理和自定义 学习总结

　　异常的处理和自定义

　

　　　　异常：异常就是Java程序在运行过程中出现的错误

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

　　　　其实就是Java对不正常情况进行描述后的对象体现。 我们见过的异常,角标越界异常,空指针异常

　　　　

　　　　异常分类

异常的处理：　jvm发现运算是已经违反了数学运算规则,java将这种常见的问题进行描述,并封装成了对象叫做ArithmeticException 当除0运算发生后,jvm将该问题打包成了一个异常对象. 并将对象抛给调用者main函数,new ArithmeticException("/by zero"); main函数收到这个问题时,有两种处理方式:

1,自己将该问题处理,然后继续运行

2,自己没有针对的处理方式,只有交　给调用main的jvm来处理 jvm有一个默认的异常处理机制,就将该异常进行处理.并将该异常的名称,异常的信息.异常出现的位置打印在了控制台上 同时将程序停止运行

　　　　常见的异常处理方式，代码如下：

　　　　try{}...catch(){}方法

  2 
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.text.ParseException;
import java.text.SimpleDateFormat;

/*
 * JVM默认处理异常的方式：
 *     终止程序
 *     将异常的错误信息打印到控制台
 * 
 * 自己的处理方式：
 *     try{
 *         可能会发送异常的代码;
 *     }catch(异常的类名 对象名){
 *         处理方式;
 *     }
 * 
 * 运行时期异常的处理方案：
 *         更改代码（更常用）
 *         使用具体的语句进行处理
 * 编译时期异常：只能使用具体的语句进行处理
 */
public class ExceptionDemo2 {
    public static void main(String[] args) {
        test5();
        System.out.println("over");
    }
    //开发中的一般处理方式
    private static void test5() {
        try {
            int i = 1 / 0;
            new SimpleDateFormat().parse("");
            new FileInputStream(new File(""));
        } catch (Exception e) {
            // System.out.println("除数为零了");
            e.printStackTrace();
        }
    }

    //JDK1.7新特性：异常1|异常2|...
    private static void test4() {
        try {
            int i = 1 / 0;
            new SimpleDateFormat().parse("");
            new FileInputStream(new File(""));
        } catch (ArithmeticException|ParseException|FileNotFoundException e) {
            // System.out.println("除数为零了");
            e.printStackTrace();
        }
    }

    //异常中存在子父类关系时，父类的异常捕获必须放在最后面的位置
    private static void test3() {
        try {
            int i = 1 / 0;
            new SimpleDateFormat().parse("");
            new FileInputStream(new File(""));
        } catch (ArithmeticException e) {
            // System.out.println("除数为零了");
            e.printStackTrace();
        }catch (ParseException e) {
            // System.out.println("要解析的文本日期格式不正确");
            e.printStackTrace();
        }catch (Exception e) {//其余的任何异常，我都可以捕获
            e.printStackTrace();
        }
    }

    //异常合并处理
    private static void test2() {
        try {
            int i = 1 / 0;
            new SimpleDateFormat().parse("");
        } catch (ArithmeticException e) {
            // System.out.println("除数为零了");
            e.printStackTrace();
        }catch (ParseException e) {
            // System.out.println("要解析的文本日期格式不正确");
            e.printStackTrace();
        }
    }

    //异常单独处理
    private static void test() {
        try {
            int i = 1 / 0;
        } catch (ArithmeticException e) {
            // System.out.println("除数为零了");
            e.printStackTrace();
        }
        try {
            new SimpleDateFormat().parse("");
        } catch (ParseException e) {
            // System.out.println("要解析的文本日期格式不正确");
            e.printStackTrace();
        }
    }
}

　　　　Throwable中的方法：

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

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

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

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

import java.io.PrintWriter;
import java.text.SimpleDateFormat;
import java.util.Date;

public class ExceptionDemo3 {
    public static void main(String[] args) {
        try {
            System.out.println(new SimpleDateFormat().format(new Date()));
            new SimpleDateFormat().parse("18-1-15 上午9:45");
            int i = 1 / 0;
        } catch (Exception e) {
            // public String getMessage()返回此 throwable 的详细消息字符串
            //System.out.println(e.getMessage());/// by zero

            //public String toString()返回此 throwable 的简短描述
            //System.out.println(e.toString());//java.lang.ArithmeticException: / by zero
            
            //public void printStackTrace()将此 throwable 及其追踪输出至标准错误流
            e.printStackTrace();
            
            //public void printStackTrace(PrintWriter s)将此 throwable 及其追踪输出到指定的 PrintWriter
            //PrintWriter可以将字符串输出到一个文件中
            try {
                PrintWriter pw = new PrintWriter("D:/error.txt");
                e.printStackTrace(pw);
                pw.close();
            } catch (Exception e1) {
                e1.printStackTrace();
            }
        }
        System.out.println("over");
    }
}

　　编译时异常和运行时异常的区别：

　　java中的异常被分为两大类：编译时异常和运行时异常。

　　所有的RuntimeException类及其子类的实例被称为运行时异常。

　　其他的异常就是编译时异常 编译时异常 Java程序必须显示处理，否则程序就会发生错误，无法通过编译 运行时异常 无需显示处理，也可以和编译时异常一样处理

　　

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;

/*
 * throw：抛出一个具体的异常对象，用在方法的内部，只能抛出一个异常对象，表示一定发送了某个异常
 * 	原则:如果该功能内部可以将问题处理,用try,如果处理不了,交由调用者处理,这是用throws
	区别:
		后续程序需要继续运行就try
		后续程序不需要继续运行就throws
 */
public class ExceptionDemo6 {
	public static void main(String[] args) throws FileNotFoundException {
		// 运行时期异常
		//test();

		//编译时期异常
		test2();
		
		System.out.println("over");
	}

	private static void test2()throws FileNotFoundException {
		try {
			new FileInputStream(new File(""));
		} catch (FileNotFoundException e) {
			throw new FileNotFoundException("文件路径不正确");
		}
	}

	private static void test() {
		// 先捕获这个异常吧，然后自己再处理抛出
		try {
			int i = 1 / 0;
		} catch (Exception e) {
			// public ArithmeticException(String s)构造具有指定详细消息的
			// ArithmeticException
			throw new ArithmeticException("除数为0了");
		}
	}
}

　　

　

　　子类重写父类方法出现异常的处理方式

　　1.子类重写父类方法时，子类的方法必须抛出相同的异常或父类异常的子类。

　　2.如果父类抛出了多个异常,子类重写父类时,只能抛出相同的异常或者是他的子集,子类不能抛出父类没有的异常

　　3.如果被重写的方法没有异常抛出,那么子类的方法绝对不可以抛出异常,如果子类方法内有异常发生,那么子类只能try,不能throws

import java.io.FileNotFoundException;
import java.text.ParseException;
import java.text.SimpleDateFormat;

public class ExceptionDemo7 {
	public static void main(String[] args) {

	}
}

class Father{
	public void test()throws NullPointerException,FileNotFoundException,ParseException{
		
	}
	
	public void run(){
		
	}
}

class Son extends Father{
	// 子类重写父类方法时，子类的方法必须抛出相同的异常或父类异常的子类。
	// 如果父类抛出了多个异常,子类重写父类时,只能抛出相同的异常或者是他的子集,子类不能抛出父类没有的异常
	@Override
	public void test() throws ArrayStoreException, FileNotFoundException, ParseException {
		super.test();
	}
	
	// 如果被重写的方法没有异常抛出,那么子类的方法绝对不可以抛出异常,如果子类方法内有异常发生,那么子类只能try,不能throws
	@Override
	public void run() {
		try {
			new SimpleDateFormat().parse("");
		} catch (ParseException e) {
			e.printStackTrace();
		}
	}
}

　　异常总结：

　　

　　　　finally的特点作用：

　　　　finally的特点 被finally控制的语句体一定会执行 特殊情况：在执行到finally之前jvm退出了(比如System.exit(0))

　　　　finally的作用 用于释放资源，在IO流操作和数据库操作中会见到

　　　　throws：定义功能方法时，需要把出现的问题暴露出来让调用者去处理。那么就通过throws在方法上标识。

　　　　throw： 在功能方法内部出现某种情况，程序不能继续运行，需要进行跳转时，就用throw把异常对象抛出。

　　throws和throw的区别：

　　throws 用在方法声明后面，跟的是异常类名

　　　　　　可以跟多个异常类名,用逗号隔开 表示抛出异常

　　　　　　由该方法的调用者来处理 throws表示出现异常的一种可能性，

　　　　　　并不一定会发生这些异常

　　throw 用在方法体内，跟的是异常对象名 只能抛出一个异常对象名 表示抛出异常，

　　由方法体内的语句处理 throw则是抛出了异常，执行throw则一定抛出了某种异常 

　　　　我们到底该如何处理异常呢?

　　　　原则:如果该功能内部可以将问题处理,用try,如果处理不了,交由调用者处理,这是用throws

　　　　 区别:

　　　　　　 后续程序需要继续运行就try

　　　　　　 后续程序不需要继续运行就throws

　　自定义异常:

　　　　人的年龄必须在1-260之间

　　　　很明显java没有对应的异常，

　　　　需要我们自己来做一个异常 自定义异常 继承自Exception 继承自RuntimeException

public class CustomException {
    public static void main(String[] args) {
        Person p = new Person("张三", 18, '男');
        System.out.println(p);
    }
}

public class AgeException extends RuntimeException {
    @Override
    public String getMessage() {
        return "人的年龄必须在1-260之间";
    }
}

/*
 *     人的年龄必须在1-260之间
        很明显java没有对应的异常，需要我们自己来做一个异常
    自定义异常
        继承自Exception
        继承自RuntimeException
 */
public class Person {
    private String name;
    private int age;
    private char sex;
    public Person() {
        super();
    }
    public Person(String name, int age, char sex) {
        super();
        this.name = name;
        this.sex = sex;
        checkAge(age);
        this.age = age;
    }
    private void checkAge(int age) {
        if(age<0 || age>260){
            //抛出异常
            throw new AgeException();
        }
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        checkAge(age);
        this.age = age;
    }
    public char getSex() {
        return sex;
    }
    public void setSex(char sex) {
        this.sex = sex;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + ", sex=" + sex + "]";
    }
}