day07

异常

error错误

系统，java虚拟机错误

exception异常

规则：不要使用庞大的try代码块，最好只有出错的部分捕捉异常。

runtime exception

不用try catch
不运行到就不知道会发生的错误

try catch finally

try/catch 后面加入finally可以保证fianlly代码块一定运行
catch块 异常错误范围大的在下面，范围小的在上面

throws

向上反映异常，在main方法下还是用try、catc来处理

异常代码示例：

public class MyException extends Exception{

    @Override
    public void printStackTrace(){
        System.err.println("不让别人取名叫张三");
        super.printStackTrace();
    }

}

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class Person {
    private String name;
    private int id;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) throws MyException{
        if(name.equals("张三")){
            throw new MyException();
        }
        this.name = name;
    }
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return this.name;
    }
    @Override
    public boolean equals(Object obj) {
        // TODO Auto-generated method stub
        return ((Person)obj).getId()==this.id;
    }
    public void getStudent() throws IOException{
        FileInputStream f = new FileInputStream("d//321.txt");
        f.read();
    }
}

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class ExceptionTest {

    public static void main(String[] args) {
        Person p = new Person();
        try{
        System.out.println(p.getId());
        }catch(NullPointerException e){
            e.printStackTrace();
            System.out.println("报错1");
        }
        System.out.println("运行");
        try {
            p.getStudent();
        } catch (IOException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
        try {
            FileInputStream s = new FileInputStream("d://123.txt");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("报错2");
        }catch(IOException e){
            e.printStackTrace();
            System.out.println("报错3");
        }
        System.out.println("yunxing");  
    }
}

import java.io.IOException;

public class Test {
    public static void main(String[] args) throws MyException {
        Person zhangsan = new Person();
        Person lisi = new Person();
        Person a = new Person();
        a.setId(1);
        zhangsan.setId(1);
        zhangsan.setName("张三");
        lisi.setId(2);
        lisi.setName("李四");
        System.out.println(zhangsan);
        System.out.println(zhangsan.equals(lisi));
        System.out.println(zhangsan.equals(a));

        try {
            a.setName("张三");
        } catch (MyException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}

运行结果：

自定义异常

一定不要抛出异常，因为抛出异常会让异常交给上级处理，自己就无法看到自定义的异常了。
步骤：
1.创建自定义异常的类
2.继承于exception
3.重写printStrack（）方法
4.在要出现异常的地方改写方法，并规定异常出现的条件。
5.应用方法的时候用try catch捕捉异常。

Object类

java所有的引用数据类型，全部继承于Object类

equals（）

比较

hashCode（）

返回一个hash码

toString（）

转换成字符串

IO流

File

canRead（）是否可读
canWrite（）是否可写
mkdir()创建文件夹

InputStream

InputStream类是抽象类，所以不能建立对象，要根据它的子类来创建相应的对象

import java.io.*;

public class InputSteamTest {
    public static void main(String[] args) {
        File f = new File("e://321.txt");
        try {
            byte[] arr = new byte[600];
            InputStream is = new FileInputStream(f);
            int readindex = is.read(arr);
            System.out.println(new String(arr));
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }catch(IOException e){
            e.printStackTrace();
        }
    }
}

运行结果：

补充昨天的四则运算程序设计

import java.util.Scanner;

public class Math0 {
    public static void main(String[] args) {
        String str = ""; 
        String digest = "";
        MyStackChar fuhao = new MyStackChar();
        MyStackNum num = new MyStackNum();
        Scanner scanner = new Scanner(System.in);
        str = scanner.nextLine();
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);//获取字符串的每一个字符
            if(Character.isDigit(c)){
                digest += c;//将连续的数字组成字符串
            }else{
                int in =Integer.parseInt(digest);
                num.push(in);//数字进栈
                if(c=='='){
                    int latter = num.out();
                    char c0 = fuhao.out();
                    int former = num.out();
                    num.push(jisuan(former,c0,latter));
                    if(fuhao.getIndex()==-1){
                        System.out.println(num.out());
                    }else{
                        liucheng(fuhao, num, c);
                        System.out.println(num.out());
                    }
                }else{
                    digest="";
                    if(fuhao.getIndex()==-1){//判断符号栈内是否为空
                        fuhao.push(c);
                    }else{
                        liucheng(fuhao, num, c);
                    }
                }
            }
        }
    }
    private static void liucheng(MyStackChar fuhao, MyStackNum num, char c) {
        if (fuhao.getIndex() == -1) {
            fuhao.push(c);
            return;
        }
        char top = fuhao.getTop();
        if(youxianji(c,fuhao.getTop())){//判断符号的优先级true进栈，false计算
            fuhao.push(c);
        }else{
            int latter = num.out();
            char c0 = fuhao.out();
            int former = num.out();
            num.push(jisuan(former,c0,latter));
            liucheng(fuhao, num, c);
        }
    }
    public static int jisuan(int former,char c,int latter){
        int sum0 = 0;
        switch (c) {
        case '*':
            sum0=former*latter;
            break;
        case '/':
            sum0=former/latter;
            break;
        case '+':
            sum0=former+latter;
            break;
        case '-':
            sum0=former-latter;
            break;
        }
        return sum0;
    }
    public static boolean youxianji(char a,char b){
        if(a == '*'||a == '/'){
            if(b=='*'||b=='/'){
                return false;
            }
            return true;
        }
        return false;

    }
}

public class MyStackChar {
    private char []array = new char[20];
    private int index = -1;
    public void push(char c){
        index++;
        array[index] = c;
    }
    public char out(){
        char j = array[index];
        index--;
        return j;
    }
    public char getTop(){
        return array[index];    
    }
    public int  getIndex(){
        return index;
    }
}

public class MyStackNum {
    public int[] getArray() {
        return array;
    }
    private int []array = new int[20];
    private int index = -1;
    public void push(int i){
        index++;
        array[index] = i;
    }
    public int out(){
        int j = array[index];
        index--;
        return j;
    }
    public int getTop(){
        return array[index];
    }
    public int  getIndex(){
        return index;
    }
}

程序流程简述：初始化两个数组模拟栈的使用–>用户控制台输入想要计算的式子–>字符串的遍历–>循环中如果是数字的话走（1），如果是字符串的话走（2）
（1）连接数字成字符串，下次循环如果还是数字连接字符串。
（2）不是数字时，先把前面数字连接的字符串转换成int类型然后进入数字的栈–>先获取符号栈的目录，如果为-1，则把得到的字符进入符号栈，如果结果不是-1就进入一个判断–>判断运算符号的优先级，将符号栈内最外面的符号和遍历字符串得到的符号进行比较（这里要写一个比较的方法，乘法除法优先级大于加法减法）–>如果优先级前者较大，则前者进入符号栈，不是前者优先级大，那么开始运算–>将运算结果进入到数字栈。
如果判定到‘=’符号，那么数字栈出栈两个，符号栈出栈一个，进行运算，运算完成后，再次判断符号栈是否为空，如果不为空，将剩下的运算完成就可以了。
输出结果: