1 函数题 1~6
//判断字符串内容相同
//choice.equals("xxxx")
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
String choice = sc.next();
try {
if (choice.equals("number"))
throw new NumberFormatException();
//数字格式异常
else if (choice.equals("illegal")) {
throw new IllegalArgumentException();
//非法参数异常，还要有new关键字
} else if (choice.equals("except")) {
throw new Exception();
} else
break;
}
/*这里放置你的答案*/
catch(Exception e){
if (choice.equals("number"))
System.out.println ("number format exception");
if (choice.equals("illegal"))
System.out.println ("illegal argument exception");
if (choice.equals("except"))
System.out.println ("other exception");
System.out.println (e);
//输出详细异常信息
}
}//end while
sc.close();
}
2,
public Integer push(Integer item) throws FullStackException {
if(this.size() >= this.arrStack.length )throw new FullStackException();
if (item == null)
return null;
//要特殊处理null,stack其实是一个类
this.arrStack[this.top] = item;
this.top++;
//用的是this调用
return item;
}//如果item为null，则不入栈直接返回null。如果栈满，抛出`FullStackException`。
public Integer pop() throws EmptyStackException {
if(this.empty()) throw new EmptyStackException();
if (this.arrStack[top-1] == null)
//top指向栈顶的下一个位置， 通常指向下一个可放置元素的位置
return null;
this.top--;
return this.arrStack[top];
}//出栈。如果栈空，抛出EmptyStackException。否则返回
public Integer peek() throws EmptyStackException {
if(top == 0) throw new EmptyStackException();
if (arrStack[top-1] == null) return null;
return arrStack[top-1];
}//获得栈顶元素。如果栈空，抛出EmptyStackException。
3，自定义异常
import java.util.Scanner;
public class Main {
public static void main(String args[ ]) {
double s=0;
Scanner sr=new Scanner(System.in);
double r=sr.nextDouble();
sr.close();
try{
Circle c1=new Circle(r);
s = c1.area();
System.out.printf("%.1f",s);
}
catch (NumRangeException e){
e.print();
}
}
}
/* 请在这里填写答案 */
class Circle{
double r;
public Circle(double r){
this.r=r;
}
//这里表示声明异常可能发生
public double area() throws NumRangeException{//这个方法可能抛出异常，需要用关键字throw
if(r<0)
throw new NumRangeException(r);//半径为负数抛出异常
//这里是异常实际发生了
else
return r*r*3.14;
}
}
class NumRangeException extends Exception{//自定义异常类
double r;
public NumRangeException(double r){//构造方法
this.r=r;
}
public void print(){
System.out.printf("错误:圆半径%.1f为负数",r);
}
}
2 编程题 1~6
1,try_catch
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
int []arr = new int [5];
Scanner input = new Scanner(System.in);
while (input.hasNext()){
String a = input.next();
if (a.equals("arr")){
int b = input.nextInt();
try {
int d = arr[b];
}catch (Exception e){
System.out.println(e.toString());
}
}else if (a.equals("num")){
String b = input.next();
try{
int d = Integer.parseInt(b);
//将字符串转化为整数
}catch (Exception e){
System.out.println(e.toString());
}
}else if (a.equals("cast")){
try {
Object str = new String("cast");
System.out.println((Integer)(str));
}catch (Exception e){
System.out.println(e.toString());
}
}else if (a.equals("null")){
try {
String t = null;
int l = t.length();
}catch (Exception e){
System.out.println(e.toString());
}
}else {
System.exit(0);
//结束程序
}
}
}
}
2,
Arrays.toString(a)
//[1, 2, 4, 5, 3]输出数组
3，
import java.util.Scanner;
class IllegalScoreException extends RuntimeException {
String message;
public IllegalScoreException() {
}
//无参构造器
public IllegalScoreException(String message) {
this.message = message;
}
//有参构造器
@Override
public String toString() {
return "IllegalScoreException: score out of range, score=" + message;
}
//重写输出方法
}
class IllegalNameException extends RuntimeException {
String message;
public IllegalNameException() {
}
public IllegalNameException(String message) {
this.message = message;
}
@Override
public String toString() {
return "IllegalNameException: the first char of name must not be digit, name=" + message;
}
}
class Student {
private String name;
private int score;
public Student(){
this.score = 0;
}
//无参构造器，初始化参数
@Override
public String toString() {
return "Student [" +
"name=" + name +
", score=" + score +
']';
}
public String getName() {
return name;
}
public void setName(String name) throws IllegalNameException{
if (name.charAt(0) >= '0' && name.charAt(0) <= '9'){
throw new IllegalNameException(name);
}
this.name = name;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public int addScore(int score) throws IllegalScoreException{
if (this.score + score < 0||this.score + score > 100){
throw new IllegalScoreException(Integer.toString(this.score + score));
//Integer.toString(this.score + score)将整数转化为字符串
}
//如果能加上，则调用set
setScore(this.score + score);
return this.score;
}
}
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
while (scanner.hasNext()){
String str = scanner.next();
if (!str.equals("new")){
scanner.close();
System.out.println("scanner closed");
//不再输入则关闭scanner，打印scanner closed。
break;
}
Student stu = new Student();
scanner.nextLine();
String nameAndScore = scanner.nextLine();
String[] arr = nameAndScore.split("\\s+");
/*
"\\s+": 这是一个正则表达式，用于匹配一个或多个空白字符（包括空格、制表符等）。
双反斜杠 \\ 是因为在 Java 字符串中，反斜杠需要被转义"\\s+":
这是一个正则表达式，用于匹配一个或多个空白字符（包括空格、制表符,换行，回车等）。
双反斜杠 \\ 是因为在 Java 字符串中，反斜杠需要被转义*/
try{
String name = arr[0];
int score = Integer.parseInt(arr[1]);
//字符串转为数字
stu.setName(name);
stu.addScore(score);
System.out.println(stu);
}catch (IllegalNameException | IllegalScoreException e){
System.out.println(e);
}catch (Exception e){
System.out.println("java.util.NoSuchElementException");
//其他非定义异常
}
}
}
}
4，自己写的，综合
import java.util.*;
class OutScoreException extends Exception{
int score;
public OutScoreException(){
}
public OutScoreException(int score){
this.score=score;
}
@Override
public String toString()
//没有参数
{
return this.score+"invalid!";
}
}
class Student{
public Student(){
}
// 有参数的构造函数
public Student(int score, String name) {
this.name = name;
try {
setScore(score); // 尝试设置分数，可能会抛出异常
} catch (OutScoreException e) {
System.out.println(e.toString());
this.score = 0; // 如果分数无效，设置为默认值
}
}
String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getScore() {
return score;
}
public void setScore(int score) throws OutScoreException{
if(score<0||score>100)
throw new OutScoreException(score);
else
this.score = score;
}
int score;
}
public class Main {
public static void main(String[] args) {
int jg = 0;
int bjg = 0;
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
for (int i = 1; i <= n; i++) {
Student stu = new Student();
int s = sc.nextInt();
try {
stu.setScore(s);
if (s >= 60)
jg++;
else
bjg++;
} catch (OutScoreException e) {
i--;
System.out.println(e.toString());
}
/*如果使用有参构造器则无需再处理异常，已经处理过在学生类
Student stu = new Student(s, "Student" + i);
try {
// 如果分数有效，检查及格与否
if (stu.getScore() >= 60) {
jg++;
} else {
bjg++;
}
} catch (OutScoreException e) {
// 在这里不需要再次捕获异常，因为已在构造函数中处理
}
*/
}
System.out.println(jg);
System.out.println(bjg);
}
}
5,
String[] str=s.split("\\s+");
try {
sum+=Integer.parseInt(str[i]);
}
catch(Exception e)
{
continue;
}
3 判断题
Throwable
├── Error
└── Exception
├── RuntimeException
└── (其他异常类，如 IOException, SQLException等)
1,检查异常”必须在程序中处理
2,一个异常处理中 finally语句块可以不出现，也可以出现一次。
3，
所有异常类（包括可检查异常和运行时异常）都是 java.lang.Throwable 的子类，而不是所有的异常类都直接是 Exception 的子类。只有Throwable 的子类中的 Exception 才是用于表示可捕获的异常。
所有异常都是 java.lang.Throwable 的子类，但并不是所有的异常都是 Exception 的子类。
4 选择题
1，
2，throw和throws
throws用于声明一个方法可能抛出的异常
throw用于抛出一个异常实例
3,
4,
try 块后面确实需要至少有一个 catch 块或者一个 finally 块。
如果后面没有catch，则应该有finally
5，catch 块的顺序是重要的。当你有多个 catch 块时，更具体的异常类型必须放在更一般的异常类型之前
6，
public class Test {
public static void main(String[] args) {
try {
System.out.println("Welcome to Java");
int i = 0;
int y = 2 / i;
System.out.println("Welcome to HTML");
}
finally {
System.out.println("The finally clause is executed");
}
}
}
7，在 try 块中，如果某条语句抛出异常，那么这条语句之后的所有代码都不会被执行，控制流将立即转到相应的 catch 块（如果有的话），或者直接跳到 finally 块（如果有的话），或者终止程序执行（如果没有处理该异常的 catch 块）
8，
5 多选题
1，
NullPointerException（空指针异常）在 Java 中是一个常见的运行时异常，它通常在试图访问或操作一个为 null 的对象时抛出
表达式 s == null 不会抛出 NullPointerException。这是因为该表达式只是在检查变量 s 是否为 null，而不是尝试访问或操作 s 所指向的对象
||如果左侧成立，右侧不会执行
|两侧都会执行
2，
如果程序抛出异常而没有捕获处理，程序将中断执行并终止，但finally语句仍然会执行。
当 try 块中的某个语句抛出异常时，异常发生后 try 块中该语句后面的所有语句将不会被执行。程序将立即跳转到相应的 catch 块（如果有）来处理该异常。
3，
