Java第十二天（iead快捷键的使用、异常、try catch处理异常、finall用法、编译期间异常、自定义异常）...

最新推荐文章于 2024-03-05 09:09:23 发布

weixin_33734785

最新推荐文章于 2024-03-05 09:09:23 发布

阅读量590

点赞数

文章标签： java python

原文链接：https://my.oschina.net/u/4110331/blog/3048111

版权

2019独角兽企业重金招聘Python工程师标准>>>

54.iead快捷键的使用

/*
生成主方法快捷键    psvm
生成打印输出快捷键    sout
生成for循环的快捷键盘   fori
生成增强的for循环打印数组   数组名.for
生成流程控制语句    Ctrl+Alt+T
生成构造方法、get和set方法、重写toString()的方法、重写父类的方法等     alt+insert
*/
public class Nut{
//    使用快捷键alt+insert生成构造方法
    public Nut() {
    }

    //  运用快捷键psvm生成主方法
    public static void main(String[] args) {
        System.out.println("运用快捷键sout生成打印输出语句");
        String[] bnuts=new bnuts[]{"碧根果","核桃","杏仁","开心果"};
//   运用快捷键fori生成for循环语句
        for (int i = 0; i < 4; i++) {
            System.out.println(bnuts[i]);
        }
//   使用增强的for循环打印数组，bnuts.for+enter键
        for (String bnut : bnuts) {
            System.out.println(bnut);
        }
        if () {
            System.out.println("使用流程控制语句快捷键Ctrl+Alt+T对光标显示的语句生成流程控制语句");
        } else {
        }

    }
}

Ctrl+B 进入光标所在的方法/变量的接口或是定义处，等效于Ctrl + 左键单击
Ctrl + D  复制光标所在行或复制选择内容，并把复制内容插入光标位置下面
Ctrl + F  在当前文件进行文本查找
Ctrl + H  查看类的继承结构
Ctrl + N  通过类名定位文件
Ctrl + O  快速重写父类方法
Ctrl + X  剪切所选中行
Ctrl + Y  删除光标所在行或删除选中的行
Ctrl + W  递进式选择代码块
Ctrl + Z  撤销
Ctrl + F1 在光标所在的错误代码出显示错误信息
Ctrl + F12  弹出当前文件结构层，可以在弹出的层上直接输入进行筛选
Ctrl + Space  基础代码补全，默认在Windows系统上被输入法占用，需要进行修改，建议修改为Ctrl + 分号(已经修改)
Ctrl + /  注释光标所在行代码，会根据当前不同文件类型使用不同的注释符号
Ctrl+Shift+/   多行注释，如果按第二次就是反注释
Alt + Enter   根据光标所在问题，提供快速修复选择，用的最多的是生成变量
Shift + F3    在查找模式下，定位到上一个匹配处
Ctrl + Alt + B   在某个调用的方法名上使用会跳到具体的实现处
Ctrl + Alt + L   格式化代码 可以对当前文件和整个包目录使用
Ctrl + Alt + T   对选中的代码弹出环绕选项弹出层
Ctrl + Alt + 左方向键   退回到上一个操作的地方，查看源码的时候很方便
Ctrl + Alt + 右方向键   前进到上一个操作的地方，查看源码的时候很方便
Ctrl + Shift + R    根据输入内容替换对应内容，范围为整个项目或指定目录内文件
Ctrl + Shift + U    对选中的代码进行大/小写轮流转换
Ctrl + Shift + Z    取消撤销
Ctrl + Shift + /    代码块注释
Ctrl + Shift + +    展开所有代码
Ctrl + Shift + -    折叠所有代码

55.异常

（1）概念：在我们写程序的时候难免会出现错误，java中的异常机制为了提高我们程序的健壮性和容错性而存在

（2）异常的体系

错误：Error是throwable的子类，他是程序出现了严重的问题，这种问题程序解决不了。

异常：都是用Exception为结尾。我们可以通过程序来处理异常。

异常分为两类：

运行时候的异常：可以编译通过，程序在运行期间报出来的异常。

编译期异常：这个异常必须要处理，否则没法编译通过。

Exception下面的子类除了RuntimeException以外都是编译期的异常

RuntimeException下面的所有的子类都是运行时的异常。

56.try catch处理异常

a/b除法的时候如果要是b=0，那么jvm会给我们创建一个ArithmeticException对象。运行时异常对象会自动的向上抛出，调用端再抛给jvm，jvm打印出来异常信息。异常信息展示是什么异常和调用端和被调用端多少行报的异常。异常后面的代码不能再执行

（1）try catch处理异常

try里面的代码就是有可能产生异常对象的代码

catch(Exception e)用来捕捉到产生的异常对象，catch块就是来处理异常的代码块。

e.printStackTrace();打印异常的信息

try …..catch处理异常的特点：

try内部发生异常下面的代码不会执行
产生的异常对象被catch块里面的参数接收
catch块来处理异常（如何处理要根据具体的业务要求）
如果异常对象被catch来处理就不会向上抛出
由于异常对象被处理了，异常后面的代码就会正常的执行
调用端不会感知到异常的产生（因为没有向上抛出异常对象），后面的代码正常执行

public static void main(String[] args) {
        int result=divide(10,0);
        System.out.println("调用端后面的代码被执行了");
        System.out.println(result);
    }
    public static int divide(int a,int b){
        int c=0;
//        从被调用端处理异常
        try {      //        try里面的代码就是可能产生异常的代码
            c=a/b;
        } catch (Exception e) {      //       catch(Exception e) 用来捕捉产生异常的对象
            System.out.println("发送异常");
            e.printStackTrace();//   打印异常信息
        }
        System.out.println("被调用端后面的代码被执行了");
        return c;
    }
}

public static void main(String[] args) {
        int result= 0;
//        从调用端处理异常
        try {
            result = divide(10,0);//     接受到异常对象
        } catch (Exception e) {
            //处理异常
            String message=e.getMessage();//获得异常信息
            System.out.println(message);
            String s=e.toString();//获得异常的详细信息
            System.out.println(s);
            e.printStackTrace();//打印异常的超级详细的信息
            System.out.println("传错参数");
            result = divide(10,2);
        }
        System.out.println(result);
    }
    public static int divide(int a,int b){
        int c=0;
        c=a/b;
        return c;
    }

57.finall用法

（1）发生了异常会向上的抛出，但是finally里面的代码永远会得到执行

（2）return后面可以通过finally来执行代码

（3） try …..catch …..finally，但是finally里面的代码永远会得到执行

public static int divide(int a,int b){
    int c=0;
    try {
        c=a/b;
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        System.out.println("被调用端后面的代码被执行了");
    }
    return c;
}

（4）笔试题，finally是唯一一个可以return一次之后还能return的代码块，可以修改方法的返回值

public static void main(String[] args) {
    int result=divide(20,0);
    System.out.println(result);
}
public static int divide(int a,int b){
    int c=0;
    try {
        c=a/b;
        return c;
    } catch (Exception e) {
        c=4;
        return c;//方法遇到return就形成返回值，后续再修改变量不会改变返回值。
    } finally {
        c=5;
        return c;//finally是唯一一个可以return一次之后还能return的代码块，可以修改方法的返回值
    }
}

58.编译期间异常

编译期异常：这个异常必须要处理，否则没法编译通过。

jdk可以准确的预测到这个代码可能发生异常，所以给开发者一个错误的警示，让我们来处理这种可能发生的异常。

运行时异常向上抛出不需要来声明的

编译期的异常如果想要向上抛出就必须要来声明

编译期的异常建议大家通过try…catch来处理

运行时的异常建议向上抛，最顶层来处理。

import java.io.IOException;
import java.net.ServerSocket;

public class AbnomalEditor {
    public static void main(String[] args) throws IOException {
        ServerSocket ss=new ServerSocket(8000);
    }
}

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

public class AbnomalRun {
    public static void main(String[] args) {
        try {
            method();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
    public static void method() throws FileNotFoundException {
        FileReader f = new FileReader("monica");
    }
}

59.自定义异常

（1）自定义规则

我们以后的项目中自定义的异常99%都是运行时的异常。我们定义的异常要继承RuntimeException

在类中继承RuntimeException的构造器即可。

//定义的异常要继承RuntimeException
public class StockException extends RuntimeException {
//    在类中继承RuntimeException的构造器即可
    public StockException() {
    }

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

    public StockException(String message, Throwable cause) {
        super(message, cause);
    }

    public StockException(Throwable cause) {
        super(cause);
    }

    public StockException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }
}

（2）自定义异常的使用

public class Self {
    public static void main(String[] args) {
        try {
            submitOrder(6);
        } catch (Exception e) {
            System.out.println("收到库存不足信息");
            submitOrder(5);
        }
    }
    public static void submitOrder(int stock){
        if (stock>5) {
            throw new StockException("库存不足"+stock);
        } else {
            System.out.println("自动跳转支付界面");
        }
    }
}

转载于:https://my.oschina.net/u/4110331/blog/3048111