java基础学习（七）
（一）异常
异常体系:
Throwable:error(错误)：系统设备无法执行
Exception(异常):RuntimeException(运行异常)
非RuntimeException(编译异常)
异常处理:程序出现错误时,java默认会停止程序的运行,就会影响其他代码的执行
为了不影响其他代码的执行,要进行异常处理
格式1:try-catch:
把可能出现异常的代码放到try之中,交给catch进行匹配
格式2:try-catch-catch...-catch
例如:try{
sout(10/0);
}catch(StringIndexOutOfBoundsException e){
sout("异常");
}catch(IndexOutOfBoundsException e){
sout("异常")
}
注意:像try-catch-catch...-catch这个格式,不能匹配所有的异常,通常写为try{
}catch(Exception e){
}
格式3:try-catch-finally
例如:try{
sout(10/0);
}catch(Exception e){
sout("这是异常");
}finally{
sout("无论是否有异常都会去执行")
}
注意:try-catch只会捕获出现第一个异常 并处理
Exception中的方法:public String getMessage() 返回异常的详细信息
public String toString() 返回可输出的简短描述
public void printStackTrace() 把异常信息输出到控制台
Exception中的方法通常使用printStackTrace
使用try{}catch(){}finnally{}语句
try {}中代码块一旦异常，try后面的代码块将不在执行
catch{}中的代码只有出现异常时才执行
finally{}中的代码，除非程序退出，或者必将执行
注意：finally、catch必须要与try{}连用，不能单独使用
异常处理throws:一般用于自己定义的异常，系统中没有对应的处理方法
try-catch处理异常有局限性,try-catch有的异常可能无法处理,所以使用throws进行抛出
格式:throws 异常类
通常使用在方法之后例如:
public static void test()throws Exception{}
异常抛出:调用这个方法时,就表示当前这个方法是一个可能出现问题的代码
异常抛出之后必须处理,处理的两种方式
方式1:try-catch，如果有异常catch中的代码和finally中的代码还需要执行
方式2:继续抛出,抛出异常后，后面的代码将不在执行
注意:谁调用这个方法,谁去处理
谁调用谁处理,如果使用的是抛出的方式,调用者抛出的异常类不能比方法上的异常类低
自定义异常:java中提供了异常类不能满足所有的需要
1.自己创建一个类继承Exception或RuntimeException
2.一个无参构造 一个参数为String的构造
throw进行抛出:通常和异常类的对象一起使用
格式:throw new 异常类();
注意:throw写在方法之中,肯定抛出异常
throws和throw的区别
throws throw
用在方法声明后，跟的是异常类 用在方法内，跟的是异常对象
表示抛出异常，由调用的调用者处理 表示抛出异常，由当前方法处理
表示出现异常的可能性，不一定会出现 肯定抛出异常
- 代码演示系统中可以处理的异常try{}catch(){}finally{}处理
// 执行流程:
// 程序从try开始执行,之后执行try中的代码
//如果出现异常,会生成一个异常类,然后交给catch中去匹配,
//匹配成功执行处理异常的代码，匹配失败程序报错
// 如果没有出现异常,catch不会执行
//finally有没有异常，都将执行
public class Demo1 {
public static void main(String[] args){
show1();
try{
show2();
show3();//show（）2有异常，后续代码将不在执行
}
catch (Exception e){
//为了能匹配所得异常类，一般给父类
e.printStackTrace();
}
finally {
System.out.println("有没有异常都执行");
}
show4();
}
public static void show1(){
System.out.println(10+20);
}
public static void show2(){
System.out.println(10/0);
}
public static void show3(){
System.out.println("134".charAt(2));
}
public static void show4(){
System.out.println("结束");
}
}
- 不是控制台，一输出红色，就是异常，可以控制输出代码的颜色，代码演示
public class Demo1 {
public static void main(String[] args) {
System.err.println("输出红色，不代表出现异常");
}
}
- 自定义异常try{}catch{}捕获
class Myexception extends Exception{
public Myexception(){
super();}
public Myexception(String s){
super(s);
}
}
class Student{
private String name;
private int age;
public Student (){
}
public Student(String name,int age)throws Myexception{
this.name=name;
setAge(age);
}
public void setAge(int age)throws Myexception{
if (age>0&&age<120){
this.age=age;
}
else {
throw new Myexception("输入的年龄应在0-120之间才合理");
}
}
}
class Myexceptiontest {
public static void main(String[] args) {
try{
Student student = new Student("zs", 233);}
catch (Myexception e){
e.printStackTrace();
}
System.out.println("结束");
}
}
- 自定义异常throws抛出
class Myexception extends Exception{
public Myexception(){
super();}
public Myexception(String s){
super(s);
}
}
class Myexceptiontest {
public static void main(String[] args) throws Myexception {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入分数");
int a = scanner.nextInt();
if (a < 0 || a > 100) {
throw new Myexception("分数必须在0-100之间");
} else {
System.out.println("分数为" + a);
}
System.out.println("结束");
}
}
（二）Object
Object:是所有的类的顶级父类,所有类都直接或间接继承Object,
子类构造中默认调用父类的无参构造,因为最顶级的父类Object只有无参构造
1.为什么直接输出数组结果是地址值,而直接输出ArrayLisy结果是内容,因为ArrayLisy(ArrayList父类的父类重写的)重写了父类中的toString方法
2.equals用于做判断String是否相等,String重写了Object中equals方法
（三） 集合
集合体系:Collection(单列): List(可重复):ArrayLIst
LinkedList
Set(不可重复):HashSet
TreeSet
Map(双列)：HashMap
Collection Map List Set都是接口，不能创建实例，创建对象时要创建子类对象
创建Collection对象:通过多态的方式
new具体的实现类
集合专用的遍历方式迭代器:每个集合都有一个iterator()的方法
Iterator中的常用方法:
hasNext():判断迭代器中还有没有元素
next():从迭代器中取出(按顺序取下一个)一个元素
迭代器的遍历格式:Iterator<> iter=集合对象.iterator()
while(iter.hasNext()){
sout(iter.next())
}
- 迭代器代码演示
//遍历输出学生成员
//查找最大年龄的学生
//查找名为张三的学生
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
class Student{
private String name;
private int age;
public Student(String name,int age){
this.name=name;
this.age=age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Student(){
}
}
public class Collectiontest {
public static void main(String[] args) {
Student s1 = new Student("zs", 23);
Student s2 = new Student("ls", 22);
Student s3 = new Student("ww", 24);
Student s4 = new Student("zl", 20);
Collection<Student> coll = new ArrayList<Student>();
coll.add(s1);
coll.add(s2);
coll.add(s3);
coll.add(s4);
System.out.println("迭代器打印学生姓名");
printStudent1(coll);
System.out.println("==========================");
System.out.println("下转型打印学生");
printStudent2(coll);
System.out.println("==========================");
System.out.println("迭代器查找学生 zs");
findStudent1(coll, "zs");
System.out.println("===========================");
System.out.println("下转型查找学生 zs");
findStudent2(coll, "zs");
System.out.println("==========================");
System.out.println("迭代器查找学生 lm");
findStudent1(coll, "lm");
System.out.println("===========================");
System.out.println("下转型查找学生 lm");
findStudent2(coll, "lm");
System.out.println("==========================");
System.out.println("迭代器查找年龄最大的学生");
findStudent1(coll, findMax1(coll).getName());
System.out.println("===========================");
System.out.println("下转型查找年龄最小的学生");
findStudent2(coll, findMin1(coll).getName());
}
//打印学生 方法一 迭代器
public static void printStudent1(Collection<Student> c) {
Iterator<Student> iterator = c.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next().getName());
}
}
//打印学生 方法二 数组集合 可以重复
public static void printStudent2(Collection<Student> c) {
ArrayList<Student> arrayList = (ArrayList<Student>) c;
for (Student student : arrayList) {
System.out.println(student.getName());
}
}
//查找学生 方法一 迭代器
public static void findStudent1(Collection<Student> c, String string) {
Iterator<Student> iterator = c.iterator();
boolean b = false;
while (iterator.hasNext()) {
Student student = iterator.next();
if (student.getName().equals(string)) {
b = true;
System.out.println(student.getAge() + "=============>" + student.getName());
break;
} else {
b = false;
}
}
if (!b) {
System.out.println("没有找到该学生");
}
}
//查找学生 方法二 下转型
public static void findStudent2(Collection<Student> c, String string) {
ArrayList<Student> arrayList = (ArrayList<Student>) c;
boolean b = false;
for (int i = 0; i < arrayList.size(); i++) {
if (string.equals(arrayList.get(i).getName())) {
b = true;
System.out.println(arrayList.get(i).getAge() + "================>" + arrayList.get(i).getName());
break;
}
}
if (!b) {
System.out.println("没有找到该学生");
}
}
//迭代器查找年龄最大学生
public static Student findMax1(Collection<Student> c) {
Iterator<Student> iterator = c.iterator();
Student student1 = iterator.next();
while (iterator.hasNext()) {
Student student2 = iterator.next();
if (student1.getAge() < student2.getAge()) {
student1 = student2;
}
}
return student1;
}
//下转型查找年龄最小的学生
public static Student findMin1(Collection<Student> c){
ArrayList<Student> arrayList = (ArrayList<Student>) c;
Student student1=arrayList.get(0);
for(int i=1;i<arrayList.size();i++){
if(student1.getAge()>arrayList.get(i).getAge()){
student1=arrayList.get(i);
}
}
return student1;
}
}
习题
一、填空题
1._____异常处理_____机制是一种非常有用的辅助性程序设计方法。采用这
种方法可以使得在程序设计时将程序的正常流程与错误处理分开，有利于代
码的编写和维护。
2.在Java异常处理中可以使用多个catch子句，此时包含异常类的父类
Exception的catch子句的位置应该是在___最后_________。
3.异常处理中finally块可确保无论是否发生异常，该块中代码总能被执行。
finally块不执行的唯一情况是在异常处理代码中执行
System.exit()____________语句退出Java虚拟机。
4.异常是由Java应用程序抛出和处理的非严重错误，比如所需文件没有找
到、零作除数，数组下标越界等，可分为两类：Checked异常和_____运行
时异常_____________。
5.在Java中对于程序可能出现的检查时异常，要么用try…catch语句捕获并处
理它，要么使用______throws______语句抛出它，由上一级调用者来处理。
6.Java异常处理中，如果一个方法中出现了多个Checked异常，可以在方法
声明中使用关键字_____throws_________声明抛出，各异常类型之间使用
逗号分隔。
二、选择题
1. 以下关于异常的代码的执行结果是（ C）。（选择一项）
public class Test {
public static void main(String args[]) {
try {
System.out.println("try");
return;
} catch(Exception e){
System.out.println("catch");
}finally {
System.out.println("finally");
}
}
}
A. try
catch
finally
B. catch
finally
C. try
finally
D. try
2. 在异常处理中，如释放资源、关闭文件等由（ C ）来完成。（选择一项）
A try子句
B. catch子句
C. finally子句
D. throw子句
3. 编译并运行如下Java程序，将输出（ D ）。（选择一项）
public static void main(String[] args) {
try {
int num1 = 2; int num2 = 0;
int result = num1 / num2;
System.out.println(result);
throw new NumberFormatException( );
} catch (ArrayIndexOutOfBoundsException e) {
System.out.print("1");
} catch (NumberFormatException e) {
System.out.print("2");
} catch (Exception e) {
System.out.print("3");
} finally {
System.out.print("4");
}
System.out.print("5");
}
A 134
B. 2345
C. 1345
D. 345
4. 阅读如下Java代码,其中错误的行是（AC ）。（选择二项）
public class Student {
private String stuId;
public void setStuId(String stuId) throws Exception { // 1
if (stuId.length() != 4) { // 2
throws new Exception("学号必须为4位!"); // 3
} else {
this.stuId = stuId; //4
}
}
}
A 1
B. 2
C. 3
D. 全部正确
5. 下面选项中有关Java异常处理模型的说法错误的是（ AD ）。（选择二项）
A 一个try块只能有一条catch语句
B. 一个try块中可以不使用catch语句
C. catch块不能单独使用，必须始终与try块在一起
D. finally块可以单独使用，不是必须与try块在一起
6. 下面选项中属于运行时异常的是（ BC ）。（选择二项）
A Exception和SexException
B. NullPointerException和InputMismatchException
C. ArithmeticException和ArrayIndexOutOfBoundsException
D. ClassNotFoundException和ClassCastException
7. 阅读如下Java代码，在控制台输入"-1",执行结果是（B）。（选择一项）
public class Demo {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("请输入数字：");
try {
int num = input.nextInt();
if (num < 1 || num > 4) {
throw new Exception("必须在1-4之间！");
}
} catch (InputMismatchException e) {
System.out.println("InputMismatchException");
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}
A 输出：InputMismatchException
B. 输出：必须在1-4之间！
C. 什么也没输出
D. 编译错误
三、简答题
1.Error和Exception的区别
答：
Exception是程序正常运行中预料到可能会发生的错误，并且应该被捕获并进
行相应的处理，是一种异常。
Error是正常情况下不可能发生的错误，会导致JVM处以一种不可恢复的状态
2.Checked异常和Runtime异常的区别。
答：
编译时异常（可检查异常Checked）表示编译器检测到这段代码在运行
时可能会发生异常，要求我们对异常进行处理。
运行时异常（不可检查异常unckecked）表示运行时出现的异常，通常是编
码时的逻辑错误，不会强制要求编译器处理
3.Java异常处理中，关键字try、catch、finally、throw、throws分别代表什么
含义？
答：
try块表示程序正常的业务执行代码。如果程序在执行try块的代码时出现了“非
预期”情况，JVM将会生成一个异常对象，这个异常对象将会被后面相应的
catch块捕获。
catch块表示一个异常捕获块。当程序执行try块引发异常时，这个异常对象将
会被后面相应的catch块捕获。
throw用于手动地抛出异常对象。throw后面需要一个异常对象。
throws用于在方法签名中声明抛出一个或多个异常类，throws关键字后可以
紧跟一个或多个异常类。
finally块代表异常处理流程中总会执行的代码块。
对于一个完整的异常处理流程而言，try块是必须的，try块后可以紧跟一个或
多个catch块，最后还可以带一个finally块。
try块中可以抛出异常。
4.throws和throw的区别
答：
throws：
1）用在方法声明后面，跟的是异常类名。
2）可以跟多个类名，用逗号隔开
3）表示抛出异常由该方法的调用者来处理。
throw：
1）在方法体内，跟的是异常对象名。
2）只能抛出一个异常对象名
3）表示抛出异常由该方法体内语句处理。
四、编码题
1.编写程序接收用户输入分数信息，如果分数在0—100之间，输出成绩。如果成绩不在该范围内，抛出异常信息，提示分数必须在0—100之间。
import java.util.Scanner;
class ScoreScopeException extends Exception{
public ScoreScopeException(){
super();}
public ScoreScopeException(String s){
super(s);}
}
public class Test {
public static void main(String[] args) throws ScoreScopeException{
Scanner scanner=new Scanner(System.in);
System.out.println("请输入分数");
int score=scanner.nextInt();
if (score<100&&score>0){
System.out.println("分数为"+score);
}
else {
throw new ScoreScopeException("输入的分数不在0-100之间");
}
}
}
2.写一个方法void isTriangle(int a,int b,int c)，判断三个参数是否能构成一个三角形， 如果不能则抛出异常IllegalArgumentException，显示异常信息 “a,b,c不能构成三角形”，如果可以构成则显示三角形三个边长，在主方法中得到命令行输入的三个整数， 调用此方法，并捕获异常。
class IllegalArgumentException extends Exception{
public IllegalArgumentException(){
super();}
public IllegalArgumentException(String s){
super(s);
}
}
public class MyExceptiontest2 {
public static void main(String[] args) throws IllegalArgumentException{
System.out.println("请输入三个整数");
Scanner scanner=new Scanner(System.in);
int a=scanner.nextInt();
int b=scanner.nextInt();
int c=scanner.nextInt();
isTriangle(a,b,c);
}
public static void isTriangle(int a,int b,int c) throws IllegalArgumentException{
if(a+b>c&&a+c>b&&c+b>a){
System.out.println("三角形三边长为"+a+'\t'+b+'\t'+c);
}
else {
throw new IllegalArgumentException("a,b,c不能构成三角形");
}
}
}
3.编写一个计算N个整数平均值的程序。程序应该提示用户输入N的值，如何必须输入所有N个数。如果用户输入的值是一个负数，则应该抛出一个异常并捕获，提示“N必须是正数或者0”。并提示用户再次输入该数
import java.util.Scanner;
public class TestException {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
System.out.println("要计算几个整数的平均值：");
int n=scanner.nextInt();
int sum=0;
int num=0;
for(int i=0;i<n;i++){
System.out.println("请输入第"+(i+1)+"个数");
try{
num=scanner.nextInt();
if (num<0){
throw new Exception("N必须是正数或者0");
}
sum+=num;
}catch (Exception e){
System.out.println(e.getMessage());
i--;
}
}
System.out.println("一共"+n+"个数"+"和为"+sum+",平均值为"+sum/n);
}
}
java入门基础学习（一）
java入门基础学习（二）
java入门基础学习（三）
java入门基础学习（四）
java入门基础学习（五）
java入门基础学习（六）
java进阶之常见对象（一）
java进阶之常见对象（二）
java进阶之冒泡排序
java进阶之选择排序
java进阶之面向对象（封装）
java进阶之面向对象（代码块、继承）