异常(父类对象ani instanceof是不是 子类Cat 的实例)

类型

为什么需要

java中错误的信息也会被包装到对象里面。对象就是包装数据，组织数据的，那错误也是数据。

大部分异常都有这两个构造器
string s表示详细消息。

Throwable类
Error（错误）不需要程序猿处理

#checked exception 被编译器已检查过的exception，必须要捕获，否则编译通不过 
Thread.sleep(3000);
#unchecked exception 这样异常太频繁,RuntimeException
int i = 1/0;

一个题5、. error和exception有什么区别?

error 表示一种严重问题。不可能指望程序能处理这样的情况。例如，说内存溢出和线程死锁等系统问题

exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况。

编译器强制checked异常必须try..catch处理或用throws声明继续抛给上层调用方法处理。。
unchecked异常或者RuntimeException不强制处理。

常见的RuntimeException：

对象a instanceof 类B：对象a不是类B的一个实例，是就返回true并转回

Dog dog = new Dog();
Animal ani = dog; //向上转型无风险
Dog dog2 = (Dog)ani; //大转小，编译器会报错，要强转
但如果Cat cat = (Cat)ani;  //运行会报错，ani编译的时候是cat类型，运行时是dog类型，真正开趴的ani是Dog类型
解决方法：
if(ani instanceof Cat){
    Cat cat = (Cat)ani;
}   

package cn.bjsxt.exception.test;
import java.io.File;
import java.io.FileNotFoundException;

public class TestException {
    public static void main(String[] args) {
//      int i = 1/0;
//      Computer c  = null;  运行时栈里面有，但是没有值
        //正常情况之下，把堆里面的对象引用赋给栈，这个对象就有了，就可以调用方法了。
        //而空指针：栈里面的引用是空的，没有指向任何东西（空指向），这个时候调用方法就报错
        //第几行报错，就找出这一行空的对象。遇到空指针，一般前面加个判断即可
//      if(c!=null){
//          c.start();   //百分十八十情况下空指针是：对象是null，调用了对象方法或属性！
//      }

//      String str = "1234abcf"; 
//      Integer i = new Integer(str);

//      try{
//          Thread.sleep(3000);
//      }catch(Exception e){
//          e.printStackTrace();
//      }finally{
//          System.out.println("aaa");
//      }

        File f = new File("c:/tt.txt");
        if (!f.exists())  {
            try {
                throw new FileNotFoundException("File can't be found!"); 
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }
    }
}

class Computer{
    void start(){
        System.out.println("计算机启动！");
    }
}

处理方式1：捕获

未遇到：1 2 4跳过catch
2遇到异常： 1 2 4 5 .finally之后的代码会走


catch
空指针异常也是，都是继承来自Throwable的方法
catch中，越是父类越放下面。子类放下面那代码块永远执行不到



例如：

重要：执行顺序 。。给返回值赋值后不立即返回，finally之后再返回。原理可以分析内存。

finally里如果写return就会把try里面的return覆盖了。。 因为return两个作用：一返回二结束语句

处理方式2：声明异常throws

谁调方法，谁处理异常

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class TestReadFile {
    public static void main(String[]  args) throws FileNotFoundException, IOException {
    //main中不处理就抛给JRE了，但这样不推荐
        String str;
        str = new TestReadFile().openFile();
        System.out.println(str);
    } 

    String openFile() throws FileNotFoundException,IOException { 
        FileReader reader = new FileReader("d:/a.txt");
        char c = (char)reader.read();
        System.out.println(c);
        return ""+c;  //数字相加转成字符串相加了
    }
}

这里指的是类型不能比原有方法多。看下面代码

import java.io.FileNotFoundException;
import java.io.IOException;
import java.text.ParseException;
    class A {   
        public void method() throws IOException {   }
    }

    //FileNotFoundException是IOException的子类，可以抛出
    class B extends A {     public void method() throws FileNotFoundException { }
    }

    //不抛出也行
    class C extends A {     public void method() {  }
    }

//  class D extends A {     public void method() throws Exception { }     //超过父类异常的范围，会报错！
//  }

    //没有超出范围
    class E extends A {     public void method() throws IOException, FileNotFoundException {    }
    }

    //ArithmeticException是RunntimeException，可以
    class F extends A {     public void method() throws IOException, ArithmeticException {      }
    }

    //ParseException不是RunntimeException，超过了父类的Exceptuion的范围。类型超出了
//  class G extends A {     public void method() throws IOException, ParseException {   }
//  }

处理方式3：手动抛出异常，throw

eclipse中ctrl+T，打开类的层次

自定义异常：

//IO相关就继承于IOException
public class MyException extends Exception {

    public MyException(){

    }

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

}

//main也可以位于普通的类
class TestMyException{
    void test()throws MyException{
        ///
    }

    public static void main(String[] args) {
        try {
            new TestMyException().test();
        } catch (MyException e) {
            e.printStackTrace();
        }
    }
}

总结：