重温JavaSE11、12

常⠀

已于 2024-01-23 21:28:30 修改

阅读量795

点赞数 17

分类专栏：重温JavaSE 文章标签： java

于 2024-01-11 19:06:01 首次发布

本文链接：https://blog.csdn.net/huichangzhe/article/details/135536741

版权

重温JavaSE 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

异常(重点)

目的：

为了保证程序运行出现异常时，能够解决并执行后续代码，不会因为异常报错而终止程序。(程序不停就行)

用if-else堵漏洞会很麻烦，可读性差。

要会看错误信息：
在这里插入图片描述

自己解决try catch finally：IDEA快捷键选中代码ctrl+alt+T

如果try语句块中的内容真的出现了异常，会new一个Exception对象，被catch后面的()中的那个异常对象接收，程序将执行catch语句块的内容（没异常正常执行），无论是否出现异常，finally语句块一定执行（善后）

try{
	可能出现异常的代码	出现异常直接跳到catch，不执行try语句块异常下的语句（只能处理一个异常）
} catch (异常类型1 e){
	异常类型1的处理代码，用来解决代码异常
} catch (异常类型2 e){
	异常类型2的处理代码
} catch (Exception e) {//异常的父类(多态)
            System.out.println("main的求商代码错误，出错位置：28~33行");
}finally {		//finally语句块可省略，只有System.exit();能跳过finally的执行
	无论是否出现异常语句块必须执行的语句，用来善后
}

注意：try中如果出现异常，执行第一个与异常类型匹配的catch语句，那么try中后续的代码是不会执行的。

在安排catch语句的顺序的时候，一般会先写子类异常，再写父类异常。

如果catch捕获异常成功，那么try-catch后面的代码该执行还是执行没有影响。

一旦执行其中一条catch语句之后，后面的catch语句就会被忽略了！

程序可以有0个或多个catch，没有catch时后要接finally

只要将必须执行的代码放入finally中，那么这个代码无论如何一定执行。(一般放关闭数据库、关闭IO流...)

只有System.exit();能跳过finally的执行

自己无法解决，向上抛出异常throws

throws：声明异常(抛出异常)

public void method() throws Exception{
}

throw：人为制造异常 int age = 450000;//程序没错，现实有错

throw new Exception("年龄不正确，应该在0~100之间");

注意：有throw的方法一定有throws，有throws不一定有throw

throw和throws的区别：

	throw	throws
位置不同	方法内部	方法的签名处，方法的声明处
内容不同	throw+异常对象(检查异常，运行时异常)	throws+异常的类型(可以多个类型(用逗号拼接))
作用不同	异常出现的源头，制造异常	在方法的声明处，告诉方法的调用者，这个方法中可能会出现我声明的这些异常。然后调用者对这个异常进行处理

自定义异常类

因为在手动抛出异常对象时，系统没提供对应的异常类，抛出父类Exception对象不合理，所有需要创建自定义异常类。

public class IllegalAgeException extends Exception  {
    public IllegalAgeException(String info){
        super(info);
    }
}

重载和重写的异常:

在这里插入图片描述

看下面干货分享

package com.jr.curriculum;

import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.Scanner;

public class Demo1 {
    public static void main(String[] args) {
        //if的方式排错：（麻烦，可读性差）
//        Scanner sc = new Scanner(System.in);
//        System.out.println("请录入第一个数：");
//        if(sc.hasNextInt()){
//            int num1 = sc.nextInt();
//            System.out.println("请录入第二个数：");
//            if(sc.hasNextInt()){
//                int num2 = sc.nextInt();
//                if(num2 == 0){
//                    System.out.println("对不起，除数不能为0");
//                }else{
//                    System.out.println("商："+num1/num2);
//                }
//            }else{
//               System.out.println("对不起，你录入的不是int类型的数据！");
//            }
//        }else{
//            System.out.println("对不起，你录入的不是int类型的数据！");
//        }
        try {
            Scanner sc = new Scanner(System.in);
            System.out.println("请录入第一个数：");
            int num1 = sc.nextInt();
            System.out.println("请录入第二个数：");
            int num2 = sc.nextInt();
            System.out.println("商：" + num1 / num2);
        } catch (InputMismatchException e) {//输入不匹配异常
            System.out.println("main的数字代码错误，出错位置：28~33行");
        } catch (Exception e) {//异常的父类(多态)
            System.out.println("main的求商代码错误，出错位置：28~33行");
        }finally {
            System.out.println("关闭资源");
        }
        System.out.println("程序来到后续，继续执行");
    }
    /*
【异常处理机制】为确保java程序的安全性
目的：异常处理机制可以保证java程序在运行的时候，不会因为异常报错而终止程序。(程序不停就行)
解决方案：1.自己解决try catch finally
         2.自己无法解决，向上抛出异常throws
    try：监控，有可能产生错误的代码
    catch(错误的类型){解救方法}
    catch(错误的类型){解救方法}
    catch(Exception e){解救方法}//父类异常一定放最后
    finally{善后的方法，肯定会执行}

    throw：人为制造错误    int age = 450000;//程序没错，现实有错
    throws：声明异常(抛出异常)
【try】--(监控)可能出现异常的代码
【catch】--(捕获)出现异常对象。
            --捕获成功，进到对应的catch块里执行程序，其他catch不执行，子类放前，父类放后
                1)解决问题
                2)记录问题
                    自定义提示信息
                    异常对象.toString();
                    异常对象.getMessage();
                    异常对象.printStackTrace();
            --捕获失败，程序终止
                准备多个catch块，同时父类异常捕获放在最后
【finally】--善后，关闭各种对象资源
    try没出现错误：try->执行finally
    try出现错误：try(没执行完)->catch->finally
    try出现错误：try(没执行完)->catch(捕获失败)->finally
只有System.exit();跳过finally的执行
     */
}

public class Demo3 {
    private int age;
    public int getAge() {
        return age;
    }
    public void setAge(int age) throws Exception {//向调用这个方法的地方抛出异常
        if (age >= 0 && age <= 150){
            this.age = age;
        }else {
//            System.out.println("年龄不正确，应该在0~100之间");
//            throw new Exception("年龄不正确，应该在0~100之间");//抛出异常不合理
            throw new IllegalAgeException("年龄不正确，应该在0~100之间");
        }
    }
    public static void main(String[] args) throws Exception {//在向上抛出异常
        Demo3 demo3 = new Demo3();
        demo3.setAge(999999);
    }
    /*
【throws】抛出(声明)异常:
    例子：public void method() throws ...Exception{
         }
【throw】抛出异常：
    人为制造抛出异常，本身不是异常，但是为了处于警告调用者，开发者可以手动制造异常，并用throws抛出异常
    例子：throw new Exception("年龄不正确，应该在0~100之间");
注意：有throw的方法一定有throws，有throws不一定有throw

区别：
【1】位置不同
throw：方法内部
throws: 方法的签名处，方法的声明处
【2】内容不同
throw+异常对象（检查异常，运行时异常）
throws+异常的类型（可以多个类型(用逗号拼接)）
【3】作用不同
throw：异常出现的源头，制造异常。
throws:在方法的声明处，告诉方法的调用者，这个方法中可能会出现我声明的这些异常。然后调用者对这个异常进行处理：
【自定义异常类】
因为在手动抛出异常对象时，系统没提供对应的异常类，抛出父类Exception对象不合理，所有需要创建自定义异常类。
*/
}

public class IllegalAgeException extends Exception  {
    public IllegalAgeException(String info){
        super(info);
    }
}

异常类型(记住结构图)

异常类型结构图：`(主要记名字Object、Throwable、Error、Exception)`

在这里插入图片描述

Error（了解）程序无法解决，程序员也无法解决 Error结尾的错误。

Exception(重点)运行时异常

看下面干货分享

public class Demo2 {
    public static void main(String[] args) throws ClassNotFoundException {//抛出异常
        try {
            Class.forName("com.jr.curriculum.Demo2");//检查异常
        }catch (ClassNotFoundException e){//找不到类异常
            e.printStackTrace();
        }
        Class.forName("com.jr.curriculum.Demo2");
        String str = null;
        System.out.println(str.equals("1"));
    }
    /*
【异常类型结构图】会背
                  Object
                Throwable
        Error                 Exception
               检查异常(必须做处理) 运行时异常(可以不处理)
     */
}

包装类(重点)

为什么要学习包装类？

1.因为8个基本数据类型不符合面向对象开发，把8个基本数据类型进行了封装成包装类
2.集合类只能存储引用数据类型

包装类特有机制：

自动装箱、自动拆箱
是从JDK1.5以后新出的特性，可以将基本数据类型和包装类进行快速的类型转换。

java为8个基本数据类型都提供了对应的包装类(引用数据类型)

基本数据类型	对应的包装类	继承关系
byte	Byte	—》Number—》Object
short	Short	—》Number—》Object
`int`	`Integer`	`---》Number---》Object`
long	Long	—》Number—》Object
float	Float	—》Number—》Object
double	Double	—》Number—》Object
char	Character	Object
boolean	Boolean	Object

由于方法都大差不差只介绍Integer了

Integer(重点)

特点：

没有无参构造

类被final修饰，不能有子类，具有不可变性

`Integer的方法`

Integer.方法()	说明	返回值	例子
MAX_VALUE	能取到的最大值		int a = Integer.MAX_VALUE;
MIN_VALUE	能取到的最小值		int a = Integer.MIN_VALUE;
(整型或字符);	构造器，没有无参构造		Integer a = new Integer(12); Integer a = new Integer(“12”);
compare(整型x，整型y)	判断是否x<y，若true返回-1，反之判断是否x=y，若true返回0，反之返回1.	int	compare(int x, int y)
`valueOf(整型或字符)`	封装成一个Integer对象	Integer	Integer a = Integer.valueOf(“12”);
`.parseInt(字符串);`	字符转整型(int)	int	Integer.parseInt(“123”);

Integer对象.方法()	说明	返回值	例子
`intValue();`	转换成int型变量（自动拆箱）	int	int a = b.intValue();
toString();	返回一个字符串对象表现形式的int数据	String	String a = b.toString();
equals(Object i)	进行值的比较，i应该是整型的才为true	boolean	System.out.println(b.equals(90));
compare(Integer对象)	判断对象是否小于括号里的对象，若true返回-1，反之判断是否x=y，若true返回0，反之返回1.	int	x.compare(Integer y)

自己理解：包装类，包括String只要输入"包装类.valueOf(要转换的值)"即可转换成对应的包装类对象

`包装类和基本数据类型之间的转换`

包装类转基本数据类型：

基本数据类型变量 = 包装类.基本数据类型Value()

例如：
Integer integer = new Integer(2);
int a = integer.intValue();

基本数据类型转包装类：

包装类型.valueOf(基本类型);

int a = 15;
Integer integer = Integer.valueOf(a);//方法一，转字符串一样
Integer integer1 = new Integer(a);//方法二

`包装类实现基本类型变量和字符串之间的转换`

字符串转基本数据类型：

基本数据类型变量 = 包装类.parse包装类(字符串);

String str = "123.0";
double a = Double.parseDouble(str);

基本数据类型转字符串：(和基本数据类型转包装类一样)

int a = 15;
String str = String.valueOf(a);//方法一，转字符串一样
String str = new String(a+"");//方法二，不建议用

看下面干货分享

public class Demo4 {
    public static void main(String[] args) {
        System.out.println("int的最大值："+Integer.MAX_VALUE);
        System.out.println("int的最小值："+Integer.MIN_VALUE);
        int i = new Integer(34);
        System.out.println(i);
        Integer j = new Integer(34);
        Integer k = new Integer("34");
        System.out.println(j);//默认调用toString方法

        int i1 = 9;
        Integer i2 = new Integer(90);
        i1 = i2;//基本和引用会自动拆箱(大转小)
//        i1 = i2.intValue();//相当于这条语句
        i2 = i1;//基本和引用会自动装箱(小转大)
//        i2 = Integer.valueOf(i);//相当于这条语句
        System.out.println("i1\t"+i1);
        System.out.println("i2\t"+i2);
        System.out.println(i2.equals(90));
    }
    /*
【包装类】(工具类)
java为8个基本数据类型都提供了对应的包装类(引用数据类型)
| byte      | Byte      | ---》Number---》Object  |
| -------------------   | ----------------------- |
| short     | Short     | ---》Number---》Object  |
| int       | Integer   | ---》Number---》Object  |
| long      | Long      | ---》Number---》Object  |
| float     | Float     | ---》Number---》Object  |
| double    | Double    | ---》Number---》Object  |
| char      | Character | Object                  |
| boolean   | Boolean   | Object                  |
为什么要学习包装类？
    1.因为8个基本数据类型不符合面向对象开发
    2.集合类只能存储引用数据类型
包装类特有的机制：自动装箱 自动拆箱
是从JDK1.5以后新出的特性
将基本数据类型和包装类进行快速的类型转换。
【Integer】
    1，常用方法：
        包装类型.valueOf(基本类型);
        compareTo();比较两个Integer对象谁大谁小。结果0表示相同，1前一个对象大，-1后一个大
        equals()
        intValue()......
     */
}

Math类(偏重点)

Math的特点：

直接使用无序导包

类是被final修饰的

私有构造器，单例模式(自己学)的一种，不可以创建对象

内部的属性和方法都是静态的，所以可以静态导入

静态导入包：import static java.lang.Math.*;

Math.方法名(参数)	说明
`random()`	`随机数[0.0,1.0)`
abs(double参数)	绝对值
ceil(double参数)	向上取值(取大)
floor(double参数)	向下取整(取小)
round(浮点参数)	四舍五入,double时返回long值，float时返回int值
max(double参数1,double参数2)	取最大值
min(double参数1,double参数2)	取最小值
sqrt(double参数)	取平方根
cbrt(double参数)	取立方根
pow(double参数1,double参数2)	取参数1的参数2平方
sin(double值)、cos(double值)、ten(double值)	取正弦、余弦、正切
PI	π值:3.141592653589793

看下面干货分享

public class Demo5 {
    public static void main(String[] args) {
        System.out.println(Math.PI);
        System.out.println("随机数："+Math.random());//[0.0,1.0)
        System.out.println("随机数："+(int)(Math.random()*10));//[0,10)要自己算
        System.out.println("绝对值："+Math.abs(-80));//80
        System.out.println("向上取值："+Math.ceil(9.1));//10.0
        System.out.println("向下取值："+Math.floor(9.9));//9.0
        System.out.println("四舍五入："+Math.round(3.5));//4
        System.out.println("取大的那个值："+Math.max(3, 6));//6
        System.out.println("取小的那个值："+Math.min(3, 6));//3
    }
    /*
【Math类】         【单例模式】面试必考，自学
特点：
    1.私有构造器，单例模式的一种，不可以创建对象
    2.内部的属性和方法都是静态的，所以可以静态导入
     */
}

Random随机数类(偏重点)

Random的特点：

更适合面向对象

Random类可以直接获取指定范围的整数，Math.Random()要自己计算

可以实例化，种子相同，随机数也会相同，

可通过Random random = new Random(System.currentTimeMillis());种子是当前系统时间的毫秒数,不会重复

import java.util.Random;
public class Demo5 {
    public static void main(String[] args) {
        Random random = new Random();
        System.out.println(random.nextInt());//随机数，包括负数
        System.out.println(random.nextInt(100));//随机0~100整数
        System.out.println(random.nextDouble());//随机0~1小数
        //随机数种子相同一样，随机数就相同
        Random random1 = new Random(System.currentTimeMillis());//种子为当前系统时间的毫秒数
        Random random2 = new Random(System.currentTimeMillis());
        System.out.println(random1.nextInt());
        System.out.println(random2.nextInt());
    }
}

面试题(重点)

Error和Exception的区别

在这里插入图片描述

Error类，表示仅靠程序本身无法恢复的严重错误，比如说内存溢出、动态链接异常、虚拟机错误。应用程序不应该抛出这种类型的对象。假如出现这种错误，除了尽力使程序安全退出外，在其他方面是无能为力的。所以在进行程序设计时，应该更关注Exception类。
Exception类，由Java应用程序抛出和处理的非严重错误，比如所需文件没有找到、零作除数，数组下标越界等。它的各种不同子类分别对应不同类型异常。可分为两类：Checked异常和Runtime异常

Checked异常和Runtime异常的区别

运行时异常：包括RuntimeaException及其所有子类。不要求程序必须对它们作出处理，比如InputMismatchException、ArithmeticException、NullPointerException等。即使没有使用try-catch或throws进行处理，仍旧可以进行编译和运行。如果运行时发生异常，会输出异常的堆栈信息并中止程序执行。
Checked异常（非运行时异常）：除了运行时异常外的其他异常类都是Checked异常。程序必须捕获或者声明抛出这种异常，否则出现编译错误，无法通过编译。处理方式包括两种：通过try-catch捕获异常，通过throws声明抛出异常从而交给上一级调用方法处理。

Java异常处理try-catch-finally的执行过程

try-catch-finally程序块的执行流程以及执行结果比较复杂。基本执行过程如下：

程序首先执行可能发生异常的try语句块。如果try语句没有出现异常则执行完后跳至finally语句块执行；如果try语句出现异常，则中断执行并根据发生的异常类型跳至相应的catch语句块执行处理。catch语句块可以有多个，分别捕获不同类型的异常。catch语句块执行完后程序会继续执行finally语句块。finally语句是可选的，如果有的话，则不管是否发生异常，finally语句都会被执行。

需要注意的是即使try和catch块中存在return语句，finally语句也会执行。是在执行完finally语句后再通过return退出。

异常处理中throws和throw的区别

作用不同：throw用于程序员自行产生并抛出异常；throws用于声明在该方法内抛出了异常
使用的位置不同：throw位于方法体内部，可以作为单独语句使用；throws必须跟在方法参数列表的后面，不能单独使用。
内容不同：throw抛出一个异常对象，且只能是一个；throws后面跟异常类，而且可以有多个。

基本数据类型和包装类

1)八个基本数据类型的包装类

基本数据类型包装类

byte Byte

boolean Boolean

short Short

char Character

int Integer

long Long

float Float

double Double

2)为什么为基本类型引入包装类

基本数据类型有方便之处，简单、高效。

但是Java中的基本数据类型却是不面向对象的（没有属性、方法），这在实际使用时存在很多的不便（比如集合的元素只能是Object）。

为了解决这个不足，在设计类时为每个基本数据类型设计了一个对应的类进行包装，这样八个和基本数据类型对应的类统称为包装类(Wrapper Class)。

3)包装类和基本数据类型之间的转换

包装类------ wrapperInstance.xxxValue() ----------->基本数据类型

包装类<-----new WrapperClass(primitive) new WrapperClass(string)------基本数据类型

4)自动装箱和自动拆箱

JDK1.5提供了自动装箱（autoboxing）和自动拆箱（autounboxing）功能, 从而实现了包装类和基本数据类型之间的自动转换

5)、包装类还可以实现基本类型变量和字符串之间的转换

基本类型变量------------String.valueof()------------>字符串

基本类型变量<------------WrapperClass.parseXxx(string)------------字符串

Integer与int的区别

int是java提供的8种原始数据类型之一。Java为每个原始类型提供了封装类，Integer是java为int提供的封装类。int的默认值为0，而Integer的默认值为null，即Integer可以区分出未赋值和值为0的区别，int则无法表达出未赋值的情况，例如，要想表达出没有参加考试和考试成绩为0的区别，则只能使用Integer。在JSP开发中，Integer的默认为null，所以用el表达式在文本框中显示时，值为空白字符串，而int默认的默认值为0，所以用el表达式在文本框中显示时，结果为0，所以，int不适合作为web层的表单数据的类型。

在Hibernate中，如果将OID定义为Integer类型，那么Hibernate就可以根据其值是否为null而判断一个对象是否是临时的，如果将OID定义为了int类型，还需要在hbm映射文件中设置其unsaved-value属性为0。

另外，Integer提供了多个与整数相关的操作方法，例如，将一个字符串转换成整数，Integer中还定义了表示整数的最大值和最小值的常量。