/*
*
* 关于try..catch中的finally字句：
* 1、在finally字句中的代码是最后执行的，并且是一定会执行的，几时try语句块中的代码出了异常
* finally必须和try一共出现，不能单独出现
* 2、finally语句通常使用在哪些情况下？
* 通常在finally语句块中完成资源的释放/关闭
* 因为finally中的代码比较有保障
* 即使try语句块中的代码出现异常，finally中代码也会正常执行
*
* */
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class Test07 {
public static void main(String[] args) throws IOException {
FileInputStream fis = null;
try{
//创建输入流对象
fis = new FileInputStream("I:\\project\\java进阶\\5.包\\Test\\src\\com\\bj\\javase\\test\\Test01.java");
//开始读文件
String s = null;
s.toString();
//这里一定会出现空指针异常
//流使用完需要关闭，因为流是占用资源
//即使以上程序出现异常，流也要关闭
//放在这里流就可能执行不了
System.out.println("helli world");
//这个close也是抛出异常的，是继承IOException的
}catch (FileNotFoundException e){
e.printStackTrace();
}catch (NullPointerException e){
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
System.out.println("finally方法执行");
if (fis != null) {
fis.close();
}
//避免空指针异常，如果直接写fis.close(),可能会出现异常
/* 流的关闭放在这里比较保险
* finally中的代码一定会执行的
* 即使try中出现了异常
* */
}
}
}
/*
*
* finally语句
* 放在finally中的语句，一定会执行的
* */
public class Test08 {
public static void main(String[] args) {
/*
* try finally 没有catch可以吗？
* 可以
* 先执行try，再finally，return最后
*
* */
try{
System.out.println("try........");
System.exit(0);//退出JVM
//退出JVM，finally中的语句就不再执行了
//这个跟Test09里的不一样，没有return，直接把JVM干死了
}finally {
System.out.println("finally.....");
}
//这里无法到达，Unreachable statement
// System.out.println("hello world");
}
}
/*
* finally面试题
* */
public class Test09 {
public static void main(String[] args) {
int result = doSome();
System.out.println(result);
}
/*
java语法规则，有些规则是不能被破坏的
方法体中的代码必须遵循自上而下顺序依次逐行执行（恒古不变的语法）
java中还有一条语法规则：
return语句一旦执行，整个方法必须结束（恒古不变的语法）
*/
public static int doSome(){
int i = 100;
try{
/*
* 这行代码出现在int i = 100的下面，所以最终结果必须是返回100
* return语句必须保证是最后执行的，一旦执行，整个方法结束
* 根据下面反编译之后的代码可以看出：
* 1、它既按照java代码从上而下执行，返回的值是100（将i赋予另一被变量，返回这个变量）
* 2、又执行了finally，因为finally是要执行的，return语句一旦执行，方法就得结束
* 所以底层是这样的方式
*
* 规则： return语句是最后执行的
* 方法体的代码还得从上而下依次执行
*
* 套路了，本来以为是101呢，原来是这个原因
* */
return i;
}finally {
i++;
}
}
}
/*
* 反编译之后的代码：
* public static int m(){
* int i = 100;
* int j = i;
* i++;
* return j;
* */
/*
* final finally finalize有什么区别？
* */
public class Test10 {
public static void main(String[] args) {
// final 关键字，表示最终的，不可变的,
// 修饰的类无法继承，修饰的方法无法覆盖，修饰的变量无法重新赋值
final int i = 100;
// finally也是一个关键字，和try联用，在异常处理中使用
// finally语句块中的语句一定回执行
try{
}finally {
}
// finalize()是Object类中的一个方法，作为方法名出现
// 这个方法是由垃圾回收器GC负责调用的
// 所以finalize是标识符（方法名就是标识符）
// @Deprecated(since="9")
// protected void finalize() throws Throwable { }
// }
Object obj;
}
}
import java.io.IOException;
/*
* 之前方法覆盖的时候，有一个问题：
* 重写后的方法不能比重写之前的方法抛出更多的异常，只能更少
* */
public class Test11 {
public static void main(String[] args) {
}
}
class Animal{
public void doSome() {
}
}
class Cat extends Animal{
// 子类不抛可以
/*public void doSome(){
}*/
//父类不抛，子类不能抛
/* public void doSome() throws Exception{
}*/
//父类抛，子类可抛，可不抛
/* public void doSome() throws Exception{
}*/
//父类不抛，子类运行时异常可以抛
public void doSome() throws RuntimeException{
}
/*异常中的五个关键字：
* try catch 捕捉
* finally
*
* throw 手动抛异常
* throws 在方法声明位置上使用，把异常抛给调用者
* */
}