Java面向对象（三）
Java面向对象（三）
1.1异常，断言与日志
1.1.1异常
程序运行中的一些错误：
- 代码错误
- 设备错误
- 用户输入错误
异常的分类：
·
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class CheckExceptionDemo {
/**
*
* @param name
* @return
* @throws FileNotFoundException 告诉编译器可能会出现的异常，异常抛出
*/
public static FileInputStream getFile(String name) throws FileNotFoundException, IOException {
return null;
}
/**
* 什么时候需要抛出异常
* 1.调用一个抛出受查异常的方法的时候；
* 2.程序运行过程中发生错误，医用throw抛出一个受查异常
* 3.程序出错，a[-1] = 0 -- 抛出一个非受查异常
* 4.JVM和java运行时库出现的内部错误
* 在1,2这种情况,需要告诉这个调用方法可能抛出的异常
* 注意,1.抛出受查异常（如果受查异常没有抛出，编译器会发出错误信息），不要抛出非受查异常（不可控）
* 2.Error--内部错误,任何代码都有抛出异常的能力,但是没法控制
*
* 关于父子类的异常：
* 子类重写了父类的一个方法，子类中声明的受查异常不能比父类更通用（<=）（子类可以抛出特定异常，甚至不抛出异常）
* 如果父类没有抛出异常，子类一定不能抛出
*
* 如何抛出一个异常
* 1.找到一个合适的异常类(或者是自定义，或者是API提供的)
* 2.创建一个这个类的对象
* 3将对象抛出
*/
}
public class ArrayExceptionDemo {
public static void main(String[] args) {
int[] a = new int[3];
try {
a[-1] = 0;
}catch (ArrayIndexOutOfBoundsException e){
System.out.println("异常被捕获了");
e.printStackTrace();
}
}
}
import java.io.IOException;
public class MyMsgException extends IOException {
public MyMsgException(){}
public MyMsgException(String msg){
super(msg);
}
}
public class MyExceptionTest {
public static void print(String str) throws MyMsgException{
if ("a".equals(str)){
throw new MyMsgException("a这个参数不合法");
}
System.out.println(str);
}
/**
*
* @param args
* @throws MyMsgException 抛出一个可能出现的异常
*/
public static void main(String[] args){
MyExceptionTest exceptionTest = new MyExceptionTest();
/**
* 捕获异常，出现异常程序会中断
* 可以捕获多个异常
* catch (MyMsgException | IOException e)
*/
// try {
// print("a");
// } catch (MyMsgException e){
// e.printStackTrace();
// //final finally
// } finally {
// System.out.println("你好");
// }
int i = exceptionTest.a();
System.out.println(i);
}
public int a(){
try {
print("a");
//return 3;
}catch (MyMsgException e){
e.printStackTrace();
//return 1;
}finally {
System.out.println("执行结束");
//return 2;
}
return 4;
}
/**
* finally语句块
* 在异常处理后，资源回收的过程
* 通常情况下finally都会执行，不管是否有异常异常
* 1在外部有return的情况下会先执行finally再return
* 2.try或者catch中有return也是先执行finally再return
* 3.try或者catch中有return finally也有return，返回值会被finally覆盖
* 在实际的开发中请避免finally中出现return语句
* ----------------------------------------------------------------
* finally会执行情况
* 1.没有异常
* 2.catch中捕获到异常
* 3代码抛出异常但是没有被catch捕获try/finally
* 注意：严格按照try/catch,try/catch/finally,try/finally的结构组织代码
*/
}
public class NoExecFinally1 {
public static void main(String[] args) {
System.out.println("return value of test(): " + test());
}
public static int test() {
int i = 1;
/**
* finally不会执行，原因finally对应的try语句块并没有得到执行
*/
// if(i == 1)
// return 0;
System.out.println("the previous statement of try block");
/**
* 在执行try语句块签抛出异常，或者程序中断，那么finally也不会执行
*/
i = i / 0;
try {
System.out.println("try block");
return i;
}finally {
System.out.println("finally block");
}
}
}
public class NoExecFinally2 {
public static void main(String[] args) {
System.out.println("return value of test(): " + test());
}
/**
* 如果一个线程在执行try语句块的时候被catch捕获变成terminal，或者被kill掉，finally不会执行
* 或者在线程执行过程中断电司机也不会执行
* @return
*/
public static int test() {
int i = 1;
try {
System.out.println("try block");
/**
* 如果让终止java虚拟机finally不会执行
*/
System.exit(0);
return i;
}finally {
System.out.println("finally block");
}
}
}
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.util.Scanner;
public class TryWithResource {
/**
* try(Resource res =)
* {
* code block
* }
*/
public static void main(String[] args) {
// Scanner in = new Scanner(System.in);
//带资源的try,try语句块结束后自动调用相关方法释放资源
try(Scanner in = new Scanner(new FileInputStream("xxx"));
PrintWriter pw = new PrintWriter("xxx")){
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
}
import java.util.Scanner;
/**
* 异常堆栈分析
*/
public class FactorTest {
//4！
public static int factor(int n){
System.out.println("计算"+n+"的阶乘：");
Throwable throwable = new Throwable();
StackTraceElement[] frames = throwable.getStackTrace();
for (StackTraceElement trace : frames){
System.out.println(trace);
}
int res;
if(n <= 1){
res = 1;
}else {
//画出递归调用树
//补充作业：F(1)=1，F(2)=1, F(n)=F(n - 1)+F(n - 2)，递归图n=5
res = n * factor(n-1);
System.out.println("返回"+res);
}
return res;
}
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
System.out.println("输入一个数：");
int n = in.nextInt();
factor(n);
}
}
1.1.2断言
基于一个boolean条件的判断
public class AssertTest {
public static void method(int x) {
//assert 条件：表达式;
assert x >= 0 : x;
}
public static void main(String[] args) {
int i = 11;
if (i % 3 == 0){
}else if (i % 3 == 1){
}else {
assert i % 3 == 2;
}
}
}
1.1.3日志
记录程序的执行过程，错误。
import java.util.logging.Logger;
public class LoggerTest {
private static final Logger log = Logger.getLogger("com.oop.exception.LoggerTest");
public static void main(String[] args) {
log.info("日志信息");
log.warning("warning");
log.severe("severe");
/**
* 从高到低，默认开启前三个
* SEVERE
* WARNING
* INFO
* CONFIG
* FINE
* FINER
* FINEST
*/
}
}
import java.util.logging.Level;
import java.util.logging.Logger;
public class MathLoggerTest {
//类的全路径
private static final Logger log = Logger.getLogger("com.oop.exception.MathLoggerTest");
public static void main(String[] args) {
int i = 5;
try {
i = i / 0;
}catch (ArithmeticException e){
// e.printStackTrace();
// log.severe("除零");
Logger.getLogger("com.oop.exception.MathLoggerTest").log(Level.WARNING,"运算",e);
}
}
}
2.1其他
递归示例
浙公网安备 33010602011771号