Java基础--＞异常

news2024/10/7 18:29:39

什么是异常？

异常：异常就是代表程序出现的问题

误区：不是让我们以后不出现异常，而是程序出了异常之后该如何处理

 Error

代表系统级别的错误（属于原重问题）

系统一旦出现问题，sun公司会把这些错误封装成Error对象。Error是给sun公司自己用的，不是给我们程序员用的。因此我们开发人员不用管它。

Excetion

代表程序可能出现问题

我们通常会用Exception以及它的子类类封装程序出现的问题。

运行时异常（RuntimeException)

RuntimeException及其子类，编译阶段不会出现异常提醒。运行时出现异常（数组越界异常)

package 异常;

public class 运行时异常 {
    public static void main(String[] args) {
        /*运行时异常*/
        int[] arr = {0,1,2};
        System.out.println(arr[10]);
        /*Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 10 out of bounds for length 3
	at 异常.运行时异常.main(运行时异常.java:7)*/
    }
}

编译时异常

编译阶段就会出现的异常提醒（日期解析异常）

package 异常;

import javax.xml.crypto.Data;
import java.text.ParseException;
import java.text.SimpleDateFormat;

public class 编译时异常 {
    public static void main(String[] args) throws ParseException {
        /*编译时异常
        * 在编译时期必须手动处理，否则代码报错*/
        String time = "2021年2月1日0";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");

        Data data = (Data) sdf.parse(time);

        System.out.println(data);
    }
}

小结：

  • 异常是什么？
    •  程序中可能出现的问题
  • 异常体系的最上层父类是谁？异常分为几类？
    • 父类：Exception
    • 异常分为两类：编译时异常、运行时异常
  • 编译时异常和运行时异常的区别：
    • 编译时异常：没有继承RuntimeException的异常，直接继承于Exception。编译阶段就会有错误提示
    • 运行时异常：RuntimeException本身和子类。编译时没有错误提示，运行时出现错误；

 运行时异常和编译时异常

编译时异常：编译阶段就要处理的异常（如：日期解析异常）

运行时异常：RuntimeException及其子类，编译阶段不需要处理。代码运行时出现的异常（如：数组越界异常）

 扩展：为什么不将异常归并为一个类？

  • 编译阶段：Java不会运行代码，自会检查语法是否错误，或做出一些性能优化
  • 运行遗产：代码出错导致程序出现的问题

编译时期异常的目的：提醒程序员检查本地信息！

运行时异常和编译时异常的区别

  • 编译时异常：除了RuntimeException和它的子类，其他的都是编译时异常。编译阶段需要进行处理，作用在于提醒程序员。
  • 运行时异常：RuntimeException本身和所有的子类都是运行时异常。【编译阶段不报错，程序运行时报错，是程序运行时出现的。一般是由于参数传递错误带来的问题】

异常的作用

  • 作用1：异常是用来查询bug的关键参考信息
  • 作用2：异常可以作为方法内部的一种特殊返回值，以便通知调用者底层的执行情况

异常是用来查询bug的关键参考信息

package 异常;

public class Student1 {
    private String name;
    private int age;

    public Student1() {
    }

    public Student1(String name, int age) {
        this.name = name;
        this.age = age;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Student1{name = " + name + ", age = " + age + "}";
    }
}


package 异常;

public class 异常的作用1 {
    public static void main(String[] args) {
        /*作用1：异常是用来查询bug的关键参考信息
          作用2：异常可以作为方法内部的一种特殊返回值，以便通知调用者底层的执行情况
          */
        Student1[] arr = new Student1[3];
        String name = arr[0].getName();
        System.out.println(name);
        /**Exception in thread "main" java.lang.NullPointerException: Cannot invoke "异常.Student1.getName()" because "arr[0]" is null
         at 异常.异常的作用.main(异常的作用.java:10)
         空指针异常*/


    }
}

package 异常;

public class Student2 {
    private String name;
    private int age;

    public Student2() {
    }
    public Student2(String str) {
        String[] arr = str.split("-");
        this.name = arr[0];
        this.age = Integer.parseInt(arr[1]);
    }

    public Student2(String name, int age) {
        this.name = name;
        this.age = age;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Student2{name = " + name + ", age = " + age + "}";
    }
}

package 异常;

public class 异常的作用1_2 {
    public static void main(String[] args) {
          /*作用1：异常是用来查询bug的关键参考信息
          作用2：异常可以作为方法内部的一种特殊返回值，以便通知调用者底层的执行情况
          */
        Student2 stu = new Student2("张三,23");
        System.out.println(stu);
    }
}

异常可以作为方法内部的一种特殊返回值，以便通知调用者底层的执行情况

package 异常;

public class Student1 {
    private String name;
    private int age;

    public Student1() {
    }

    public Student1(String name, int age) {
        this.name = name;
        this.age = age;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        if (age < 18 || age > 40){
            throw new RuntimeException();
        } else
        this.age = age;
    }

    public String toString() {
        return "Student1{name = " + name + ", age = " + age + "}";
    }
}

package 异常;

public class 异常的作用2_1 {
    public static void main(String[] args) {
          /*
          作用1：异常是用来查询bug的关键参考信息
          作用2：异常可以作为方法内部的一种特殊返回值，以便通知调用者底层的执行情况
          */
        /*1、创建学生对象*/
        Student1 s1 = new Student1();
        //年龄：（同学）18-40岁
        s1.setAge(50);
        
        /**
            Exception in thread "main" java.lang.RuntimeException
	        at 异常.Student1.setAge(Student1.java:45)
	        at 异常.异常的作用2_1.main(异常的作用2_1.java:12)*/
    }
}

异常的处理方式

  1. jvm默认处理
  2. 自己处理
  3. 抛出处理

jvm默认处理方式

  • 把异常的名称，异常原因及异常的位置等信息输出在控制台
  • 程序停止执行，下面代码不会再执行
package 异常.异常的处理;

public class JVM默认处理 {
    public static void main(String[] args) {
        /*JVM默认处理异常的方式
        * 1、把异常的名称，异常原因及异常的位置等信息输出在控制台
          2、程序停止执行，下面代码不会再执行*/
        System.out.println("aaa");
        System.out.println("dd");
        System.out.println(1/0);
        System.out.println("vv");
        System.out.println("fdd");
    }
}

aaa
dd
Exception in thread "main" java.lang.ArithmeticException: / by zero
	at 异常.异常的处理.JVM默认处理.main(JVM默认处理.java:10)

自己处理（捕获异常）

目的：当代码出现异常时，程序可以继续执行。

格式：

try{

        可能出现异常的代码；

} catch（异常类名 变量名）{

        异常的处理代码；

}

package 异常.异常的处理;

public class 自己处理 {
    public static void main(String[] args) {
        /*格式：
        try{
            可能出现异常的代码；
        } catch（异常类名 变量名）{
             异常的处理代码；
        }*/

        int[] arr = {1,2,3,4,5};
        try {
            System.out.println(arr[10]);
        } catch (RuntimeException rs){
            System.out.println(rs);
        }
        System.out.println("执行了");

    }
}
java.lang.ArrayIndexOutOfBoundsException: Index 10 out of bounds for length 5
执行了

灵魂四问

  • 如果try中没有遇到问题，怎么执行？
    • 执行try中的全部代码
    • 不执行catch中的代码
package 异常.异常的处理;

public class 自己处理灵魂四问 {
    public static void main(String[] args) {
/*      如果try中没有遇到问题，怎么执行？
        如果try中可能会遇到多个问题，怎么执行？
        如果try中遇到的问题没有被捕获，怎么执行？
        如果try中遇到了问题，那么try下面的其他代码还会执行吗？*/
        int[] arr = {1,2,3,4,5,6} ;
        try {
            System.out.println(arr[0]);
        }catch (ArrayIndexOutOfBoundsException e){
            System.out.println("索引越界");
        }
        System.out.println("判断是否执行");
    }
}

1
判断是否执行
  • 如果try中可能会遇到多个问题，怎么执行？
    • try中遇到错误程序代码就跳转catch进行匹配
    • 当遇到多个异常时，可以写多个catch进行捕获
    • 当我们捕获多个异常时，如果异常中存在父子关系，父类写最后
package 异常.异常的处理;

public class 灵魂二问 {
    public static void main(String[] args) {
/*
        如果try中可能会遇到多个问题，怎么执行？
*/
        int[] arr = {1,2,3,4,5,6};
        try {
            System.out.println(arr[10]);
            System.out.println(2/0);

        } catch (ArrayIndexOutOfBoundsException e){
            System.out.println("索引越界");
        } catch (ArithmeticException e){
            System.out.println("除数不能为0");
        }
        System.out.println("判断是否执行");

    }
}

索引越界
判断是否执行
  • 如果try中遇到的问题没有被捕获，怎么执行？
    • 程序中断，try相当于没写，代码交给虚拟机处理
package 异常.异常的处理;

public class 灵魂三问 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6};
        try {
            System.out.println(arr[10]);//ArrayIndexOutOfBoundsException
        }catch (NullPointerException e){
            System.out.println("空指针异常");
        }

        System.out.println("检查是否执行");
    }
}
  • 如果try中遇到了问题，那么try下面的其他代码还会执行吗？
    • 不会！
    • 代码直接跳转到catch中进行匹配
    • catch中没有与之匹配将交给虚拟机
package 异常.异常的处理;

public class 灵魂四问 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6};
        try {
            System.out.println(arr[10]);//ArrayIndexOutOfBoundsException
            System.out.println("检查是否执行");
        }catch (ArrayIndexOutOfBoundsException e){
            System.out.println("空指针异常");
        }
    }
}
空指针异常

Throwable的成员方法

getMessage : 返回此throwable的详细消息字符串

package 异常.异常的处理.Throwable;

public class getMessage {
    public static void main(String[] args) {
        /*getMessage : 返回此throwable的详细消息字符串*/
        int[] arr = {1,2,3,4,5,6};

        try {
            System.out.println(arr[10]);
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        System.out.println("检查是否执行");
    }
}
Index 10 out of bounds for length 6
检查是否执行

toString : 返回可抛出的简短描述

package 异常.异常的处理.Throwable;

public class toString {
    public static void main(String[] args) {
        /*toString : 返回可抛出的简短描述*/
        int[] arr = {1,2,3,4,5,6};
        try {
            System.out.println(arr[10]);
        } catch (Exception e) {
            System.out.println(e.toString());
        }
        System.out.println("检查是否执行");
    }
}
java.lang.ArrayIndexOutOfBoundsException: Index 10 out of bounds for length 6

printStackTrace：把异常的信息输出在控制台

package 异常.异常的处理.Throwable;

public class printStackTrace {
    public static void main(String[] args) {
        /*toString : 返回可抛出的简短描述*/
        int[] arr = {1,2,3,4,5,6};
        try {
            System.out.println(arr[10]);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("检查是否执行");
    }
}
java.lang.ArrayIndexOutOfBoundsException: Index 10 out of bounds for length 6
	at 异常.异常的处理.Throwable.toString.main(toString.java:8)
检查是否执行

抛出处理

  • throws ：【编译时异常：必须写，运行时异常：可以不写】
    • 写在方法定义处，表示声明一个异常
    • 告诉调用者，使用本方法可能会有那些异常
  • throw：
    • 写在方法内，结束方法。
    • 手动抛出异常对象，交给调用者
    • 方法中下面的代码不再执行

 throw：写在方法内

package 异常.异常的处理;

public class Throw {
    public static void main(String[] args) {
/*      throw：
        写在方法内，结束方法。
        手动抛出异常对象，交给调用者
        方法中下面的代码不再执行
*/
        //需求：定义一个方法求数组的最大值
        int[] arr = null;
        System.out.println(getMax(arr));
        //方法中下面的代码不再执行
        System.out.println("检查是否执行");

    }
    public static int getMax(int[] arr){
        if(arr == null || arr.length == 0 ){
            //手动抛出异常对象，交给调用者
            throw new NullPointerException();
        }
        int max = arr[0];
        for (int a : arr){
            if(a > max){
                max = a;
            }
        }
        return max;
    }
}
Exception in thread "main" java.lang.NullPointerException
	at 异常.异常的处理.Throw.getMax(Throw.java:20)
	at 异常.异常的处理.Throw.main(Throw.java:12)

throws ：【编译时异常：必须写，运行时异常：可以不写】

package 异常.异常的处理;

public class Throws {
    public static void main(String[] args) {
/*        throws ：【编译时异常：必须写，运行时异常：可以不写】
        写在方法定义处，表示声明一个异常
        告诉调用者，使用本方法可能会有那些异常
*/
        //需求：定义一个方法求数组的最大值
        int[] arr = null;
        try {
            System.out.println(getMax(arr));
        } catch (NullPointerException e) {
            System.out.println("null");
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("数组越界");
        }
        //方法中下面的代码不再执行
        System.out.println("检查是否执行");

    }
    public static int getMax(int[] arr) throws NullPointerException,ArrayIndexOutOfBoundsException{
        int max = arr[0];
        for (int a : arr){
            if(a > max){
                max = a;
            }
        }
        return max;
    }
}
null
检查是否执行

总结：

  • 虚拟机默认处理异常的方式
    • 把异常的信息以红色字体打印在控制台，并结束程序
  • 捕获：try...catch
    • 一般用在调用出，让代码继续往下运行
  • 抛出：throw、throws
    • 在方法中出现异常，方法就没有继续运行的意义，采取抛出处理
    • 让该方法结束运行并告诉调用者出现的问题

 

综合练习

 无异常处理：

package 异常;

public class girlfriend {
    private String name;
    private int age;

    public girlfriend() {
    }

    public girlfriend(String name, int age) {
        this.name = name;
        this.age = age;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "girlfriend{name = " + name + ", age = " + age + "}";
    }
}


package 异常;

import java.util.Scanner;

public class 综合练习 {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        //创建女朋友的对象
        girlfriend gf = new girlfriend();
        System.out.println("请输入名字");
        //接收名字
        String name = sc.nextLine();
        gf.setName(name);
        //接受年龄
        System.out.println("输入年龄");
        String ageStr = sc.nextLine();
        int age = Integer.parseInt(ageStr);
        gf.setAge(age);
        //打印信息
        System.out.println(gf);
    }
}
请输入名字
sdgf
输入年龄
sdf
Exception in thread "main" java.lang.NumberFormatException: For input string: "sdf"
	at java.base/java.lang.NumberFormatException.forInputString(NumberFormatException.java:67)
	at java.base/java.lang.Integer.parseInt(Integer.java:665)
	at java.base/java.lang.Integer.parseInt(Integer.java:781)
	at 异常.综合练习.main(综合练习.java:18)

Process finished with exit code 1

 增加异常处理：

package 异常;

public class girlfriend {
    private String name;
    private int age;

    public girlfriend() {
    }

    public girlfriend(String name, int age) {
        this.name = name;
        this.age = age;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        int length = name.length();
        if (length < 3 || length > 10){
            throw new RuntimeException();
        }
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        if(age < 18 || age > 40){
            throw new RuntimeException();
        }
        this.age = age;
    }

    public String toString() {
        return "girlfriend{name = " + name + ", age = " + age + "}";
    }
}
package 异常;

import java.util.Scanner;

public class 综合练习 {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        //创建女朋友的对象
        girlfriend gf = new girlfriend();
        while (true) {
            try {
                System.out.println("请输入名字");
                //接收名字
                String name = sc.nextLine();
                gf.setName(name);
                //接受年龄
                System.out.println("输入年龄");
                String ageStr = sc.nextLine();
                int age = Integer.parseInt(ageStr);
                gf.setAge(age);
                break;
            } catch (NumberFormatException e) {
                System.out.println("年龄格式错误");
                continue;
            } catch (RuntimeException e){
                System.out.println("姓名长度 或 年龄范围有误");
            }
        }
        //打印信息
        System.out.println(gf);
    }
}

自定义异常

  1. 定义异常类
  2. 写继承关系
  3. 空参构造
  4. 带参构造

 定义异常类

  • 名字错误异常类
  • 年龄错误异常类

名字错误异常类

package 异常.自定义异常;

public class NameFormatException extends RuntimeException {
    //取名技巧
    //NameFormat ： 当前异常的名字，表示姓名格式化问题
    //Exception ： 表示当前类为异常类

    //运行时 ： RuntineEException 核心：表示参数错误导致的问题
    //编译时 ： Exception 核心：提醒程序员检查本地信息


    public NameFormatException() {
    }

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

}

年龄错误异常类

package 异常.自定义异常;

public class AgeOutOfBoundsException extends RuntimeException{
    public AgeOutOfBoundsException() {
    }

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

 综合练习修改

package 异常.自定义异常;

public class girlfriend {
    private String name;
    private int age;

    public girlfriend() {
    }

    public girlfriend(String name, int age) {
        this.name = name;
        this.age = age;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        int length = name.length();
        if (length < 3 || length > 10){
            throw new NameFormatException(name + "格式有误，length < 3 || length > 10");}
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        if(age < 18 || age > 40){
            throw new AgeOutOfBoundsException(age + "不在范围内");
        }
        this.age = age;
    }

    public String toString() {
        return "girlfriend{name = " + name + ", age = " + age + "}";
    }
}
package 异常.自定义异常;

import 异常.自定义异常.girlfriend;

import java.util.Scanner;

public class text {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        //创建女朋友的对象
        girlfriend gf = new girlfriend();
        while (true) {
            try {
                System.out.println("请输入名字");
                //接收名字
                String name = sc.nextLine();
                gf.setName(name);
                //接受年龄
                System.out.println("输入年龄");
                String ageStr = sc.nextLine();
                int age = Integer.parseInt(ageStr);
                gf.setAge(age);
                break;
            } catch (NumberFormatException e) {
                e.printStackTrace();
            } catch (NameFormatException e){
                e.printStackTrace();
            } catch (AgeOutOfBoundsException e){
                e.printStackTrace();
            }
        }
        //打印信息
        System.out.println(gf);
    }
}

 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/783699.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

数据库应用：Mycat实现读写分离

数据库应用：Mycat实现读写分离

目录 一、理论 1.Mycat 2.Mycat安装启动 3.Mycat搭建读写分离 4.垂直分库 5.水平分表 6.Mycat高可用 7.Mycat安全设置 8.Mycat监控工具 二、实验 1.Mycat读写分离 2.Mycat监控安装 三、问题 1.Mycat命令无法补全 2.Mycat启动失败 3.zookeeper启动报错 四、总结…
阅读更多...
基于SpringBoot+Vue的冬奥会科普平台设计与实现

基于SpringBoot+Vue的冬奥会科普平台设计与实现

博主介绍&#xff1a; 大家好&#xff0c;我是一名在Java圈混迹十余年的程序员&#xff0c;精通Java编程语言&#xff0c;同时也熟练掌握微信小程序、Python和Android等技术&#xff0c;能够为大家提供全方位的技术支持和交流。 我擅长在JavaWeb、SSH、SSM、SpringBoot等框架…
阅读更多...
Java通过URL对象实现简单爬虫功能

Java通过URL对象实现简单爬虫功能

目录 一、URL类 1. URL类基本概念 2. 构造器 3. 常用方法 二、爬虫实例 1. 爬取网络图片&#xff08;简易&#xff09; 2. 爬取网页源代码 3. 爬取网站所有图片 一、URL类 1. URL类基本概念 URL&#xff1a;Uniform Resource Locator 统一资源定位符 表示统一资源定位…
阅读更多...
动态规划--回文串问题

动态规划--回文串问题

一)回文子串: 647. 回文子串 - 力扣&#xff08;LeetCode&#xff09; 思路1:暴力枚举: for(int i0;i<array.length;i) for(int ji;j<array.length;j) 我们的中心思路就是枚举出所有的子字符串&#xff0c;然后进行判断所有的子串是否是回文串 思路2:中心扩散: 我们从左向…
阅读更多...
​MySQL高阶语句（三）

​MySQL高阶语句（三）

目录 1、内连接 2、左连接 3、右连接&#xff1a; 二、存储过程⭐⭐⭐ 4. 调用存储过程 5.查看存储过程 5.1 查看存储过程 5.2查看指定存储过程信息 三. 存储过程的参数 3.1存储过程的参数 3.2修改存储过程 四.删除存储过程 MySQL 的连接查询&#xff0c;通常都是将来…
阅读更多...
类型组-RFC调用

类型组-RFC调用

创建类型组
阅读更多...
ElasticSearch学习--RestClient及案例

ElasticSearch学习--RestClient及案例

目录 RestClient查询文档 快速入门 总结 全文检索&#xff08;match&#xff09;查询 精确查询 复合查询 查询总结 排序&#xff0c;分页 高亮 RestClient查询文档 快速入门 总结 全文检索&#xff08;match&#xff09;查询 多种查询的差异都在做类型和条件上&#x…
阅读更多...
JS 自定义的悬浮窗被浏览器遮挡问题解决方案

JS 自定义的悬浮窗被浏览器遮挡问题解决方案

遮挡问题解决思路&#xff0c;首先拿到外层的DOM元素div的宽高&#xff0c;然后根据鼠标悬浮事件的元素e e.clientX表距离页面窗口宽的位置 e.clientY代表距离页面窗口高的位置 然后设置这个悬浮窗为200px 那个这个div的宽高 dom.getElementById(xxxx).cliengHeight dom.g…
阅读更多...
FutureTask

FutureTask

Future接口 Future接口&#xff08;FutureTask实现类&#xff09;定义了操作异步任务执行一些方法&#xff0c;如获取异步任务执行的结果、取消任务的执行、判断任务是否取消、判断任务执行是否完成等。它提供了一种并行异步计算的功能。比如主线程让子线程去执行任务&#xff…
阅读更多...
C语言两种方法求证大小端存储

C语言两种方法求证大小端存储

目录 什么是大小端存储&#xff1f; 字节序的概念&#xff1a; 小端字节序存储&#xff1a; 大端字节序存储&#xff1a; 什么是低位字节、高位字节&#xff1f; 记忆技巧&#xff1a; C语言求证大小端存储 法一&#xff1a; 法二&#xff1a; 总结&#xff1a; 什么是…
阅读更多...
CAXA中.exb或者.dwg文件保存为PDF

CAXA中.exb或者.dwg文件保存为PDF

通常CAXAZ中的文件为.exb或者.dwg格式&#xff0c;我们想打印或者保存为PDF文件格式&#xff0c;那么就用一下的方法&#xff1a; CAXA文件如图所示&#xff1a; 框选出你要打印的图纸&#xff01;&#xff01;&#xff01;&#xff01; 我们选择"菜单"->"…
阅读更多...
用户订单信息案例

用户订单信息案例

需求: 用户输入商品价格和商品数量&#xff0c;以及收货地址&#xff0c;可以自动打印订单信息 分析: ① 需要输入3个数据&#xff0c;所以需要3个变量来存储price num address ② 需要计算总的价格total ③ 页面打印生成表格, 里面填充数据即可 ④ 记得最好使用模板字符串 【…
阅读更多...
java.io.InputStreamReader的read()函数返回值是字符对应的Unicode码点

java.io.InputStreamReader的read()函数返回值是字符对应的Unicode码点

java.io.InputStreamReader的read()函数定义&#xff1a; https://docs.oracle.com/en/java/javase/19/docs/api/java.base/java/io/InputStreamReader.html#read() 这个返回的值其实就是解码后的字符对应的Unicode码点&#xff08;Unicode code point&#xff09;。 举例 例如…
阅读更多...
MySQL表的管理

MySQL表的管理

目录 1.mysql中&#xff0c;数据存储过程分为四步 2.数据库命名规则 3.创建数据库 4.管理数据库的方法 5.修改数据库&#xff08;一般不改&#xff0c;最多改字符集&#xff09; 6.删除数据库 7.如何创建数据表 8.修改表 9.重命名表 10.删除表&#xff08;注意⚠️无…
阅读更多...
Java日志slf4j+logback

Java日志slf4j+logback

一、maven依赖 在pom文件增加slf4jlogback依赖 <!-- 版本配置 --> <properties><slf4j.version>1.7.21</slf4j.version><logback.version>1.1.7</logback.version> </properties><dependencies><!-- slf4j依赖包 -->&…
阅读更多...
JVM源码剖析之达到什么条件进行JIT优化

JVM源码剖析之达到什么条件进行JIT优化

版本信息&#xff1a; jdk版本&#xff1a;jdk8u40 思想至上 技术经过数百年的迭代&#xff0c;如今虚拟机中都存在JIT模块&#xff0c;JVM中Hotspot&#xff0c;Android虚拟机中dalvik、Art等等。并且存在一个共性&#xff0c;全部都是解释器和JIT共存。当然&#xff0c;如今…
阅读更多...
六、模型融合

六、模型融合

目录 1 构建模型多样性1.1 特征多样性1.2 样本多样性1.3 模型多样性 2. 训练过程融合2.1 Bagging2.2 Boosting 3. 训练结果融合3.1 加权法3.2 Stacking 融合3.3 Blending 融合 4. 实战案例 本章主要分为构建多样性、训练过程融合和训练结果融合三部分。模型融合常常是竞赛取得胜…
阅读更多...
神州通用数据库Linux安装

神州通用数据库Linux安装

神舟通用1.安装包下载地址 神舟通用 操作系统、数据库 1、官方下载链接 2、windows客户端下载链接 3、官方安装手册 4、安装前准备 3.1、创建安装用户 3.2、以root 用户修改神通数据库安装包的所有者为shentong 用户 3.3、以root 用户创建神通数据库主目录并修改所有者为shent…
阅读更多...
欧姆龙cx系列plc串门通讯设置串口转以太网通讯处理器

欧姆龙cx系列plc串门通讯设置串口转以太网通讯处理器

捷米特JM-ETH-CX 串口转以太网通讯处理器是为满足日益增多的工厂设备信息化需求&#xff08;设备网络监控和生产管理&#xff09;而设计&#xff0c;用于欧姆龙 CPM、CQM、C200、C1000、C2000 等多个系列 PLC 的以太网数据采集&#xff0c; 非常方便构建生产管理系统。 捷米特J…
阅读更多...
Linux内核--五大子系统

Linux内核--五大子系统

Linux内核有五大核心子系统&#xff0c;分别是进程调度系统、虚拟文件系统(VFS)、内存管理单元(MMU)、网络单元、进程间通信(IPC)。 在Linux内核中的主要组件中&#xff0c;五个核心子系统是最为重要的组成部分&#xff0c;它与系统调用接口&#xff08;System Call Interface&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023