6 java第六章练习---异常

一、SimpleDateFormat练习 String<–>Date转换

String -->Date转换 parse()

String< --Date转换 format()

1、制作一个工具类:DateUtil,进行日期和字符串之间的格式转换.

定义两个方法:
一个用于将字符串日期转为Date类型,并返回该Date类型
一个用于将Date类型转为指定格式的字符串形式,并返回该字符串

package com.ffyc.exceptionpractice;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

public class DateUtil {
    /*
    制作一个工具类:DateUtil,进行日期和字符串之间的格式转换.

      定义两个方法:
    一个用于将字符串日期转为Date类型,并返回该Date类型
    一个用于将Date类型转为指定格式的字符串形式,并返回该字符串
     */
    public static void main(String[] args) {

        System.out.println(StransD());
        System.out.println(DtransS());

    }

    //String --> Date           sdf.prase()
    public static Date StransD(){
        //将字符串日期转为Date类型,并返回该Date类型
        Scanner scanner = new Scanner(System.in);
        System.out.println("请按照此格式输入:yyyy-MM-dd:");
        String str = scanner.nextLine();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Date date= new Date();
        try {
            date = simpleDateFormat.parse(str);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }
    //Date --> String           sdf.format()
    public static String DtransS(){
        //将Date类型转为指定格式的字符串形式,并返回该字符串
        Date date2=new Date();
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd E a HH-mm-ss");
        //String str=date.format(date2);
        return sdf.format(date2);
    }

}

二、Calender 日历 练习 GregorianCalender公历

2、输入你的生日(年月日)，计算你来到这个世界多少天了？

package com.ffyc.exceptionpractice;

import sun.util.resources.CalendarData;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.Scanner;

public class Demo1 {
    /*
     输入你的生日(年月日)，计算你来到这个世界多少天了？
     */
    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        System.out.println("请按此格式 yyyy-MM-dd 输入你的生日：");
        String str = scanner.nextLine();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        try {
            Date date1 = simpleDateFormat.parse(str);

            //获取出生时的毫秒值
            long oldTime = date1.getTime();
            //获取今天的毫秒值
            Date date2 = new Date();
            long newTime = date2.getTime();
            //计算距离今天多少天
            long time = newTime - oldTime;

            //换算
            long day = time/1000/60/60/24;
            System.out.println("今天是你来到这个世界的第："+day+"天");
        } catch (ParseException e) {
            e.printStackTrace();
        }


        //输出
    }

}

三、概述题

1、罗列出学习到目前为止，都接触过了哪些异常类型，分别在什么情况下会出现

• Error

  • 堆溢出 （new 对象） OutOfMemoryError：内存溢出
  • 栈溢出 （方法） StackOverflowError：堆栈溢出

• Exception

  • Arithmeticexception：算术异常 （10/0）
  • ArrayIndexOutOfBoundsException ：数组下标越界异常
  • ClassCastException： 类转换异常
  • NullPointerException：空指针异常
  • NumberFormatException：数字格式化异常
  • UnsupportedEncodingException ：不支持的编码异常（编译期异常）
  • ParseException：解析异常（编译期异常）

2、throws和throw区别

• throw： 在程序中主动抛出异常对象，表示此方法出现了某种异常
• throws：声明异常，表示此方法不处理异常，而是交给方法调用处进行处理

3、final 和 finally{ }区别

• fianl：修饰 类、 属性、方法

  • 修饰类： 类不能被继承 final类中的所有成员方法会被隐式地定义为final方法

  • 修饰属性：static final 表示常量，赋值一次后不能改变，

    ​ 两种初始化方式：①变量声明时初始化

    ​ ②变量声明时不赋初始值，在构造方法中赋初值。

  • 修饰方法：方法能被重写

• finally：异常处理中的一部分， try-catch-finally ，finally {}语句块中的代码是最终一定被执行的部分

4、自定义异常练习 throw

定义三个整数变量a,b,c 判断能否构成一个三角形，如果不能请抛出一个自定义异常

package com.ffyc.exceptionpractice;

import java.util.Scanner;

public class Demo2 {
    /*
    定义三个整数变量a,b,c 判断能否构成一个三角形，
    如果不能请抛出一个自定义异常
     */
    public static void main(String[] args) {
        System.out.println("输入三个整数，判断是否构成三角形：");
        Scanner scanner = new Scanner(System.in);
        int a = scanner.nextInt();
        int b = scanner.nextInt();
        int c = scanner.nextInt();
        try {
            isTriangle(a, b, c);
        } catch (TriangleException e) {
            e.printStackTrace();
        }
    }

    //判断三角形
    public static void isTriangle (int a,int b,int c) throws TriangleException {
        //两边之和>第三边 两边之差<第三边
        if(a>0 && b>0 && c>0) {
            if (((a + b) > c && (a - b) < c) && ((a + c) > b && (a - c) < b) && ((b + c) > a && (b - c) < a)) {
                System.out.println("是三角形");
            } else {
                System.out.println("不是三角形");
            }
        }else{
            throw new TriangleException("两边之和必须>第三边，两边之差必须<第三边,否则不能构成三角形");//自定义异常类
        }
        throw new TriangleException("输入的三边必须大于0");
    }
}

//自定义异常类
public class TriangleException extends Throwable {

    public TriangleException() {
    }
    public TriangleException(String message) {
        super(message);
    }
}

运行结果：
输入三个整数，判断是否构成三角形：
 0 1 3
com.ffyc.exceptionpractice.TriangleException: 两边之和必须>第三边，两边之差必须<第三边,否则不能构成三角形
	at com.ffyc.exceptionpractice.Demo2.isTriangle(Demo2.java:33)
	at com.ffyc.exceptionpractice.Demo2.main(Demo2.java:17)

三、try-catch-finally执行顺序

RuntimeException

1、看程序输出结果

public static void main(String[] args) {
try {
int i=100/0;
System.out.println(i);
}catch(Exception e){
System.out.println(1);
throw new RuntimeException();
}finally{
System.out.println(2);
}
System.out.println(3);
}

  1
  2
Exception in thread "main" java.lang.RuntimeException
	at com.ffyc.exceptionpractice.Demo3.main(Demo3.java:10)

throw new Exception

2、写出程序结果

class Demo{
public static void main(String[] args){
try{
showExce();
System.out.println(“A”);
}catch(Exception e){
System.out.println(“B”);
}finally{
System.out.println(“C”);
}
System.out.println(“D”);
}
public static void showExce()throws Exception{
throw new Exception();
}
}

B
C
D
java.lang.Exception
	at com.ffyc.exceptionpractice.Demo4.showExce(Demo4.java:17)
	at com.ffyc.exceptionpractice.Demo4.main(Demo4.java:6)

​

catch中小异常放到大异常前面

3、写出程序结果

class Exc0 extends Exception{}
class Exc1 extends Exc0{}
class Demo{
public static void main(String[] args){
try{
throw new Exc1();
}catch(Exception e){
System.out.println(“Exception”);
}catch(Exc0 e){
System.out.println(“Exc0”); // 小异常放到大异常前面
}
}
}

try{
            throw new Exc1();
        } catch(Exc0 e){
            System.out.println("Exc0");  
            e.printStackTrace();
        } catch(Exception e){
            System.out.println("Exception");
            e.printStackTrace();
        }

Exc0

output

4、写出程序结果

class Test{
public static String output=“1”;
public static void foo(int i){
try{
if(1==i)
throw new Exception();
output+=“1”;
}catch(Exception e){
output+=“2”;
} finally{
output+=“3”;
}
output+=“4”;
}
public static void main(String args[]){
foo(0);
System.out.println(output); //哪里有output就输出
foo(1);
System.out.println(output);
}
}

1134
1134234

try-catch-finally执行顺序

5、写出程序结果

public class ReturnExceptionDemo {
static void methodA() {
try {
System.out.println(“进入方法A”);
throw new RuntimeException(“制造异常”);
} finally {
System.out.println(“用A方法的finally”);
}
}

static int methodB() {
	try {
		System.out.println("进入方法B");
		 throw new Exception();
		//return 1;  //报错 无法访问的语句
	} catch (Exception e) {
		return 3;
	} finally {
		System.out.println("调用B方法的finally");
	}
}

public static void main(String[] args) {
	try {
		methodA();
	} catch (Exception e) {
		System.out.println(e.getMessage());
	}
	int i = methodB();
	System.out.println(i);
}

}

进入方法A
用A方法的finally
制造异常
进入方法B
调用B方法的finally
3