JavaSE学习总结---异常

异常

异常在java中以类的方式存在，也有搞糟方法，可以创建对象

UML图就是软件设计图，就是类与类之间的关系图。对面向对象编程，starUML，rational rose 画图工具

编译时异常，运行时异常都发生在运行阶段。编译阶段异常是不会发生的，因为编译时异常必须在编译（编写）是预先处理，如果不处理编译器就会报错，因此得名。异常的发生就是在new对象，所以所有的异常都在运行时发生

对异常的两种处理方式
1，在方法声明的位置上，使用throws关键字，抛给上一级
2，try-catch语句捕捉

public class Test1 {
    public static void main(String[] args) {
        /*
        程序执行到此处发生了，Exception in thread "main" java.lang.ArithmeticException: / by zero异常
        底层new了一个ArithmeticException异常对象，然后抛出了，由于是main方法调用的，所以这个异常抛给了main方法
        main方法无法处理，将异常自动抛给JVM，JVM最终终止程序
         */
        System.out.println(100/0);
        System.out.println("hello world");
    }
}

一般不建议在main方法上使用throws，如果方法连续调用，上抛的话要一层一层的抛。
try catch相当于把事拦下了，throws上报，要一层一层报

只要异常没有捕捉，一直上报，此方法后续代码不会执行
try语句中出现异常，该行下面的代码不会执行
try catch捕捉异常之后，后续代码执行
一个方法体当中的代码抛出异常后，如果上报，此方法结束

如果需要调用者处理，则选择上抛
异常对象的两个方法，Exception e
e.getMseeage()和e.printStactTrace,输出异常简短信息

try catch中的finally的语句
finally是最后执行的并且一定执行
通常在finall语句块中执行完成资源的释放和关闭，比如流的关闭，JDBC六大步中的最后一步

public class Test1 {
    public static void main(String[] args) {
      try{
          System.out.println("hello world");
          return;
      }finally {
          System.out.println("1111");
      }
        System.out.println("2222");//不会执行的，因为return已经结束了此方法，finally里的语句会执行
    }
}

public class Test1 {
    public static void main(String[] args) {
      try{
          System.out.println("hello world");
          System.exit(0);//退出jvm，这样finall就不会执行了
      }finally {
          System.out.println("1111");
      }
        System.out.println("2222");
    }
}

面试题

public class Test1 {
    public static void main(String[] args) {
      int result =m();
        System.out.println(result);
    }
    public static int m(){
        int i=100;
        try {
            return i;
        }finally {
            i++;
        }
    }
}/输出结果是100，从上而下执行，return一定是最后执行的

经过反编译软件DJ JAVA查看代码是下面这个

public static int m(){
        int i=100;
        int j=i;
        i++;
        return j;
    }

final finally finalize的区别
final关键字表示最终的，不可变的
finally和try联合使用，在异常处理机制中，里面的代码一定会执行
finalize（）是Object类中的一个方法，finalize是标识符，这个方法是JVM的GC垃圾回收器负责调用

java中自定义异常

/*
第一步，定义一个类继承Exception或者RuntimeException
第二步，提供两个构造方法，一个无参，一个有参
 */
public class MyException extends Exception{//编译时异常，如果继承RuntimeException就是运行时异常
    public MyException(){
        
    }
    public MyException(String s){
        super(s);
    }

}

改进之前进栈程序，用异常代替之前的return方法结束程序

public class   Shuzumonizhan {
    public static void main(String[] args) {
    Object[] a=new Object[4];
        Stack s=new Stack(a);
        Cat c=new Cat();
        Cat c2=new Cat();
        try {
            s.push("SSS");
            s.push(1);
            s.push(2);
            s.push(c);
            s.push(5);
        } catch (MyException e) {
            e.printStackTrace();
        }


        for (int j = a.length-1; j >= 0; j--) {
            System.out.println("栈的数据是： "+a[j]);
        }

        




        for (int j = a.length-1; j >= 0; j--) {
            System.out.println("栈的数据是： "+a[j]);
        }

    }

}

class Stack{
    Object [] objects;
    int index=0;

    public Stack(Object[] objects) {
        this.objects = objects;
    }

    public void push(Object o) throws MyException {


    if(index<objects.length){
        objects[index]=o;
        index++;
        System.out.println(o +" 进栈成功");
        System.out.println("index的值是 "+index);
    }else {
        //System.out.println("栈满了 "+o+" 进栈失败");
        //return;
        //创建异常对象
        MyException e =new MyException("栈已满，压栈失败");
        //手动抛出去
        throw e;//有异常报错，要么抓要么抛，自己new自己抓没意思，所以抛出去，让调用者知道
        //抛异常就是终止程序了
    }

    }
    public void pop (){
    if(index<=0){
        System.out.println("栈空了");
    }else{
        System.out.println(objects[index-1]+" 出栈成功");

        objects[index-1]=null;
        System.out.println(objects[index-1]);

    }

    index--;
        System.out.println("index的值是 "+index);
    }
}

class Cat{

}

重写方法是不能比父类方法抛出更多的异常

异常作业

public class ZhuCe {
    public static void main(String[] args) {
        System.out.println("请输入用户名，密码");
        UserService user1=new UserService("123433333333333333333335678","123");
        try {
            user1.register();
        } catch (MyException e) {
            e.printStackTrace();
        }
    }
}

class UserService{
    private String id;
    private String password;

    public UserService(String id, String password) {
        this.id = id;
        this.password = password;
    }

   
    public void register() throws MyException {
        if(id==null||(id.length()<=14&&id.length()>=6)){
            System.out.println("注册成功，用户名为："+id+"密码为： "+password);
        }else {
            MyException e =new MyException("用户名的长度不在规定范围之内");
            throw e;
        }
    }
}

数组武器作业
有向下转型，转型实现的方法是接口里面的方法

public class Test {
    public static void main(String[] args) {
        Army army =new Army(4);
        //创建武器对象
        Tank tank1 =new Tank();
        Tank tank2 =new Tank();
        Tank tank3 =new Tank();
        Tank tank4 =new Tank();
        Tank tank5 =new Tank();
        try {
            army.addWeapon(tank1);
            army.addWeapon(tank2);
            army.addWeapon(tank3);
            army.addWeapon(tank4);
            army.addWeapon(tank5);
        } catch (MyException e) {
            e.printStackTrace();
        }
    }
}
class Army{
    private Weapon [] weapons;

    public Army(int i) {
        weapons=new Weapon[i];//构造出来一个i的数组，数组值为null
    }
    public void addWeapon(Weapon weapon) throws MyException {
        for (int i = 0; i <weapons.length ; i++) {
            if(weapons[i]==null){
                weapons[i]=weapon;
              return;
            }else {
                MyException e =new MyException("数组满了，加不进去了");
                throw  e;
            }
        }
    }
    public void attackAll(){
        for (int i = 0; i <weapons.length ; i++) {
            if(weapons[i] instanceof  Shootable){//调用子类特有的方法，向下转型，weapon类是父类调用子类坦克的方法
                Shootable shootable= (Shootable) weapons[i];
                shootable.shoot();
            }
        }
    }
    public void moveAll(){
        for (int i = 0; i <weapons.length ; i++) {
            if(weapons[i] instanceof  Shootable){
                Moveable moveable = (Moveable) weapons[i];
                moveable.move();
            }
        }
    }
}
class Weapon{

}

    class Tank extends Weapon implements Moveable,Shootable{
    @Override
    public void move() {
        System.out.println("坦克在移动");
    }

    @Override
    public void shoot() {
        System.out.println("坦克在射击");
    }
}
    class Gaoshepao extends Weapon implements  Shootable {
        @Override
        public void shoot() {
            System.out.println("高射炮在射击");
        }
    }
    class Wuziche extends Weapon implements Moveable{
        @Override
        public void move() {
            System.out.println("物资车在移动");
        }
    }
    class Zhandouji extends  Weapon implements Moveable,Shootable{
        @Override
        public void move() {
            System.out.println("战斗机在移动");
        }

        @Override
        public void shoot() {
            System.out.println("战斗机在射击");
        }
    }

interface Moveable{
    void move();
}
interface Shootable{
    void shoot();
}