JavaSe基础：数组+异常

JavaSe基础

1. 数组

数组是存储多个数据的一段连续的空间，是相同数据类型数据的有序集合。特点：

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

数组的属性：

• 长度：使用数组名.length，即存储数据的个数
• 索引/下标：所有的数组只要有数据，第一个数据空间的索引为0，最后一个数据空间的索引为数组的长度-1

1.1 一维数组的定义

一维数组的初始化分为以下两种：

• 动态初始化：先创建数组，然后再赋值，语法如下：

  数据类型[] 数组名 = new 数据类型[数组的长度];
  //数据类型：可以为任意数据类型
  //数组的长度：必须为整数，0或者以上的正整数
  

• 静态初始化：创建数组的同时赋值，语法如下：

  数据类型[] 数组名 = new 数据类型[]{数据1,数据2,数据3...};//第一种方式
  数据类型[] 数组名 = {数据1,数据2,数据3...};//第二种方式
  

例：

//测试数组的定义
public class ArrayDemo01 {
    public static void main(String[] args) {
        //动态初始化
        int[] arr1 = new int[5];
        arr1[0] = 10;
        arr1[1] = 20;
        arr1[2] = 30;
        arr1[3] = 40;
        arr1[4] = 50;
        System.out.println(arr1.length);
        System.out.println(arr1);
        //静态初始化
        String[] arr2 = new String[]{"张三","李四","王五","张四","张五"};
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);
        System.out.println(arr2[3]);
        System.out.println(arr2[4]);
        System.out.println(arr2.length);
        System.out.println(arr2);
    }
}

1.2 一维数组的遍历

数组的遍历即获取数组中的所有数据，一维数组的遍历有两种方式：

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

• 增强for循环–foreach：

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

  增强for循环简单但是普通for循环适用性更强

例：

//测试数组的遍历
public class ArrayDemo02 {
    public static void main(String[] args) {
        int[] arr1 = new int[]{10,20,30,40,50};
        //普通for循环
        for(int i=0;i<=arr1.length-1;i++){
            System.out.print(arr1[i]+" ");
        }
        System.out.println();
        //增强for循环（foreach）
        for (int i:arr1) {
            System.out.print(i+" ");
        }
    }
}

新建Student类的javabean(javabean的代码就不显示了)，模拟遍历存放对象数据的数组，代码如下：

public class ArrayDemo03 {
    public static void main(String[] args) {
        //新建student对象
        Student s1 = new Student(101,"张三",180.5);
        Student s2 = new Student(103,"李四",175.3);
        Student s3 = new Student(107,"王五",183.2);
        Student s4 = new Student(104,"李小龙",175.3);
        Student[] arr1 = {s1,s2,s3,s4};
        //定义数组存放学生对象的身高
        double[] arr2 = {s1.getHeight(),s2.getHeight(),s3.getHeight(),s4.getHeight()};
        //身高去重
        heightDistinct(arr2);
        //得到最高的学生的姓名
        for (int i=0;i<=arr1.length-1;i++){
            if (arr1[i].getHeight() == getMAxHeight(arr2)){
                System.out.println("身高最高的学生名字是："+arr1[i].getName());
            }
        }
    }
    //定义得到最高身高的方法
    public static double getMAxHeight(double[] arr){
        double maxHeight = arr[0];
        for (int i=1;i<=arr.length-1;i++){
            if(arr[i]>maxHeight){
                maxHeight = arr[i];
            }
        }
        return maxHeight;
    }
    //定义身高去重的方法
    public static void heightDistinct(double[] arr){
        boolean flag = false;
        for (int i=0;i<=arr.length-1;i++){
            for (int j=i+1;j<=arr.length-1;j++){
                if (arr[i]==arr[j]){
                    flag = true;
                    break;
                }
            }
            if (!flag){
                System.out.println(arr[i]);
            }else{
                flag = false;
            }
        }
    }
}

1.3 二维数组的定义

二维数组的初始化分为以下两种：

• 动态初始化：

  • 在构建外层数组对象之后，直接构建内层的每一个小数组

    数据类型[][] 数组名 = new 数据类型[整数n即外层数组长度][整数m即内层每一个小数组长度];
    

  • 先构建外层数组对象，再构建内层的每一个小数组

    数据类型[][] 数组名 = new 数据类型[整数n外层数组长度][];
    //构建内层的每一个小数组就是一维数组的构建方式
    

• 静态初始化：创建数组的同时赋值

  数据类型[][] 数组名 = new 数据类型[][]{{1,2,3},{4,5},{6}...};//第一种方式
  数据类型[][] 数组名 ={{1,2,3},{4,5},{6}...};//第二种方式
  

例：

//测试二维数据
public class ArrayDemo04 {
    public static void main(String[] args) {
        //动态初始化 方式一
        int[][] arr1 = new int[2][2];
        arr1[0][0] = 1;
        arr1[0][1] = 2;
        arr1[1][0] = 3;
        arr1[1][1] = 4;
        System.out.println(arr1[0][0]);
        System.out.println(arr1[0][1]);
        System.out.println(arr1[1][0]);
        System.out.println(arr1[1][1]);
        //动态初始化 方法二
        int[][] arr2 = new int[2][];
        arr2[0] = new int[2];

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

1.4 二维数组的遍历

二维数组的遍历方式即使用普通for循环和增强for循环任意嵌套。

例：

//测试二维数组的遍历
public class ArrayDemo05 {
    public static void main(String[] args) {
        int[][] arr = {{1,2,3},{4,5},{6}};
        //for--foreach嵌套
        for (int i=0;i<=arr.length-1;i++){
            for(int j:arr[i]){
                System.out.println(j);
            }
        }
        System.out.println("---------------");
        //for--for嵌套
        for (int i=0;i<=arr.length-1;i++){
            for(int j=0;j<=arr[i].length-1;j++){
                System.out.println(arr[i][j]);
            }
        }
        System.out.println("---------------");
        //foreach--for嵌套
        for(int[] i:arr){
            for(int j=0;j<=i.length-1;j++){
                System.out.println(i[j]);
            }
        }
        System.out.println("---------------");
        //foreach--foreach嵌套
        for(int[] i:arr){
            for(int j:i){
                System.out.println(j);
            }
        }
    }
}

1.5 可变参数

在jdk1.7后提出了可变参数的新特性，使用…表示可变参数，可变参数的个数可以为0~n个，个数不固定但数据类型要求一致，个数由实参决定。

语法：数据类型 … 参数名

在方法的内部默认为可变参数构建一个数组，存储这些实参，想要获得可变参数的数据可以使用数组的使用方式操作。如果方法的参数列表中存在多个参数，可变参数要在参数列表的最后。

例：

//测试可变参数
public class ParameterTest {
    public static void main(String[] args) {
        test("张三",1,2,3,4,5,6);
    }
    //定义方法，参数列表加入可变参数
    static void test(String str,int ... i){
        //遍历i数组
        for(int j:i){
            System.out.println(j);
        }
    }
}

2. 异常及处理

Throwable类分为Error（错误）和Exception（异常），而异常也可以分为CheckedException（检查时异常）和RuntimeException（运行时异常），其中常见的运行时异常有以下几类：

• 空指针异常 NullPointerException
• 索引越界异常 ArrayIndexOutOfBoundsException
• 数学异常 ArithmeticException
• 数据格式异常 NumberFormatException

2.1 异常处理

异常如果不进行处理，后面的程序都无法执行，处理好后之后的程序才可以继续执行。

异常的处理方案有两种方式：

• 异常抛出：使用throws关键字将异常抛出到上一层，谁调用谁解决

• 异常捕获：使用try catch语句捕获异常，具体语法：

  try{
      有可能出现异常的代码;
  }catch(异常类 e){
      执行的代码;//如果出现异常执行
  }finally{
      无论是否出现异常都会执行的代码;
  }
  

  注：

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

例：

//测试异常处理
public class ExceptionTest {
    public static void main(String[] args) {
        System.out.println("主方法开始");
        try {
            System.out.println(5/0);//放入异常语句
        }catch (ArithmeticException e){//捕获异常
            System.out.println("异常处理完毕");
        }finally {
            System.out.println("哈哈哈");
        }
        System.out.println("主方法结束");
    }
}

2.2 自定义异常

有时可以自定义一个异常类，使用throw关键字制造异常，throws关键字抛出异常。

例：

//测试自定义异常
public class DefinedException {
    public static void main(String[] args) {
        User user = new User();
        user.setName("张三");
        //使用try catch方法捕获自定义的年龄异常
        try {
            user.setAge(17);
        } catch (AgeException e) {
            e.printStackTrace();
        }
        System.out.println(user);
    }
}
//定义年龄异常类继承Exception类
class AgeException extends Exception{
    public AgeException() {
    }
    public AgeException(String message) {
        super(message);
    }
}
//定义用户类
class User {
    private String name;
    private int age;

    public User() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }
	//setAge方法中制造异常
    public void setAge(int age) throws AgeException {//方法处抛出年龄异常
        if (age>=18){
            this.age = age;
        }else{
            throw new AgeException("年龄不符合要求"+age);
        }
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}