JAVASE9

最新推荐文章于 2023-06-01 08:14:00 发布

cnjss

最新推荐文章于 2023-06-01 08:14:00 发布

阅读量114

点赞数

分类专栏： java 后端文章标签： java

本文链接：https://blog.youkuaiyun.com/cnjss/article/details/115466827

版权

java 后端专栏收录该内容

20 篇文章

订阅专栏

JAVASE9

一、

可变参数:
形参与实参一一对应

在jdk1.7之后提出可变参数的新特性,使用…表示可变参数
可变参数的个数,可以为0~n个,个数不固定,数据类型要求一致,有实参决定
写法: 数据类型 …参数名
在方法的内部,默认为可变参数构建一个数组,存储这些实参,想要使用可变参数的数据,通过数组的使用方式操作
如果方法的参数列表中存在多个参数,可以参数要在参数列表的最后

public class ParamDemo01 {
    public static void main(String[] args) {
        test(2,3,4,5);

        test(new String(),new Student());
    }

    static void test(int... i){
        System.out.println(i.length);
        System.out.println(i);
        for(int j:i){
            System.out.println(j);
        }
    }

    static  void test(Object ... obj){

    }
}

二、

变量:
存储单个数据
数组:
存储多个数据
一段连续内存空间
相同数据类型数据的有序集合

特点:
是一个引用数据类型
存储的多个数据要求数据类型相同
数组的长度一旦确定,不可改变
有序的 :数组中的每一个空间的序号,从0开始,每次+1–>索引|下标

数组的声明:
数据类型变量名;–>变量
数据类型[] 数组名; -->数组 -->建议
数据类型数组名[];
数组中的每一个空间如果没有赋值,存在默认值,由数组的类型决定
引用数据类型:null 整数:0 小数:0.0 布尔:false 字符:’ ’

数组的初始化:
动态初始化 : 先创建数组,然后再赋值
数据类型[] 数组名 = new 数据类型[数组的长度];
数据类型: 可以为任意数据类型
数组的长度 : 必须为整数,0或者以上的正整数

静态初始化 : 创建数组的同时赋值
数据类型[] 数组名 = new 数据类型[]{数据1,数据2,数据3…};
数据类型[] 数组名 = {数据1,数据2,数据3…};

数组存在长度属性:
数组名.length --> 存储数据的个数(小空间的个数)

索引|下标:
从0开始,每次+1
所有数组如果有数据,第一个数据空间下标为0
数组的最后一个数据空间索引为: 数组的长度-1

操作数组中的数据:
根据索引操作数组名[索引]

注意:
数组的引用统一时刻只能指向一个地址

public class ArrayDemo01 {
    public static void main(String[] args) {
        //声明一个存储姓名的数组
        String[] arr ;
        int arr2[];

        //动态初始化
        arr = new String[3];

        System.out.println(arr);
        System.out.println(arr.length);

        //数组中的数据赋值
        arr[0] = "黄鹏";
        arr[1] = "汪健哥哥";
        arr[2] = "晨晨学长";


        //获取数组中数据
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);

        //静态初始化
        char[] arr3 = new char[]{'a','b','c','d'};
        System.out.println(arr3);
        System.out.println(arr3.length);
        System.out.println(arr3[0]);
        System.out.println(arr3[1]);
        System.out.println(arr3[2]);
        System.out.println(arr3[3]);

        //简化方法  -->不是所有地方都支持注意
        boolean[] arr4 = {false,false,true,true};
        System.out.println(arr4);
        System.out.println(arr4.length);
        System.out.println(arr4[0]);
        System.out.println(arr4[1]);
        System.out.println(arr4[2]);
        System.out.println(arr4[3]);

        arr3 = new char[0];
        arr4 = new boolean[]{false};
    }
}

数据的遍历:

获取数组中的所有数据

普通for循环
循环条件i作为数组的索引,确定索引变化的范围

增强for循环–foreach
for(数据类型变量名:数组名|容器名){
变量名 : 存放数据中的每一个数据,不是索引,是数据
}

foreach更简单,而for循环的遍历更强大

public class ArrayDemo02 {
    public static void main(String[] args) {
        int[] arr  = {1,2,3,4,5};

        //for遍历
        for(int i=0;i<=arr.length-1;i++){
            System.out.println(arr[i]);
        }

        //foreach
        for (int i:arr ) {
            System.out.println(i);
        }

    }
}

在使用数组时候，常遇到的一些异常：

1.空指针异常
NullPointerException
数组引用没有指向一个数组对象，指向为空null
2.数组索引越界异常
ArrayIndexOutOfBoundsException
索引为负数索引》=长度

public class ArrayDemo04 {
    public static void main(String[] args) {
        int[] arr = {};

        //arr  = null;

        System.out.println(arr.length);

        System.out.println(arr[0]);

    }
}

二位数组(了解)

数组中放数组

声明:

数据类型[][] 数组名; -->推荐
数据类型数组名[][];
数据类型[] 数组名[];

初始化:
动态初始化:
在构建外层数组对象之后,直接构建内层的每一个小数组
数据类型[][] 数组名 = new 数据类型[整数n外层数组长度][整数m内层每一个小数组长度];
先构建外层数组对象,再构建内层的每一个小数组
数据类型[][] 数组名 = new 数据类型[整数n外层数组长度][];
构建内层的每一个小数组 : 就是一维数组的构建方式

静态初始化:
创建数组的同时赋值
数据类型[][] 数组名 = new 数据类型[][]{{1,2,3},{4,5},{6}…};
数据类型[][] 数组名 ={{1,2,3},{4,5},{6}…};

根据索引操作:

数组名 [一维索引] [二维索引]

public class ArrayDemo07 {
    public static void main(String[] args) {
        //声明
        int[][] arr ;

        //动态
        arr = new int[3][2];

        //赋值
        arr[0][0] = 1;
        arr[0][1] = 2;
        arr[1][0] = 3;
        arr[1][1] = 4;
        arr[2][0] = 5;
        arr[2][1] = 6;

        //先构建外层数组对象,再构建内层的每一个小数组
        double[][] arr2 = new double[2][];

        //构建内层的每一个小数组
        arr2[0] = new double[3];
        arr2[1] = new double[]{1.1,2.2};

        arr2[0][0] = 100;
        arr2[0][1] = 200;
        arr2[0][2] = 300;

        //静态初始化
        int[][] arr3 = new int[][]{{1,2,3},{4,5},{6}};
        //获取
        System.out.println(arr3[0][0]);
        System.out.println(arr3[0][1]);
        System.out.println(arr3[0][2]);
        System.out.println(arr3[1][0]);
        System.out.println(arr3[1][1]);
        System.out.println(arr3[2][0]);

        //简化写法
        int[][] arr4 = {{1,2,3},{4,5},{6}};

    }
}

三、

异常:

Throwable
/
Error Exception

Error: 错误,一般指代由虚拟机生成并脱出的问题,不由程序猿控制
Exception: 异常
CheckedException 检查时异常 | 编译时异常
RuntimeException 运行时异常
增强程序的健壮性决定(if…)

常见的运行时期异常:
1.空指针
2.索引越界 ArrayIndexOutOfBoundsException
3.数学异常 ArithmeticException
4.数据格式异常 NumberFormatException

public class ExceptionDemo01 {
    public static void main(String[] args) {
        //运行时期异常
        String s = null;
        if(s!=null){
            System.out.println(s.length());
        }

        int[] arr = new int[2];
        //System.out.println(arr[3]);

        //System.out.println(5/0);

       s = "123abc";
        System.out.println(Integer.valueOf(s));;
        System.out.println("main方法结束");

        //编译时异常
        //InputStream is = new FileInputStream("D://hahaha.txt");
    }
}

异常的处理方案:

1.异常抛出 throws
把异常抛出到上一层,谁调用谁解决
2.异常捕获
try{
有可能出现异常的代码;
}catch(NullPointerException e){
执行对应的代码…
}catch(Exception e){
e…;
//如果出现种异常,执行的代码
}finally{
无论是否出现异常,都会执行finally的代码
}

一个try后面可以跟一到多个catch…
范围大的catch一定要写在后面
如果try中的代码没有出现异常,try中的正常执行完毕
如果try中一旦遇到异常,try中后面的代码不会执行,直接执行catch进行判断,从上到下进行判断,找到能够接受当前出现异常对象的catch,直接执行对应的语句体
无论是否try中出现异常,无论异常是否能够捕获,都会在结束之前执行finally中的代码

注意:
一个异常出现如果不处理,后面程序无法执行
一个异常出现,如果通过异常处理方案进行处理,后面代码可能正常执行

public class ExceptionDemo02 {
    public static void main(String[] args) {
        try {
            System.out.println("try开始了");
            test();
            System.out.println(5/0);

            System.out.println("try结束了");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }finally {
            System.out.println("最后的最后我们都要离开....");
        }

        System.out.println("main方法结束了");
    }

    static void test() throws FileNotFoundException {
        //编译时异常
        InputStream is = new FileInputStream("D://hahaha.txt");
    }
}